Lines Matching defs:nxgep
120 static nxge_status_t nxge_get_tn1010_speed(p_nxge_t nxgep, uint16_t *speed);
121 static nxge_status_t nxge_set_tn1010_param(p_nxge_t nxgep);
122 static nxge_status_t nxge_tn1010_check(p_nxge_t nxgep,
124 static boolean_t nxge_is_tn1010_phy(p_nxge_t nxgep);
125 static nxge_status_t nxge_tn1010_xcvr_init(p_nxge_t nxgep);
132 static nxge_status_t nxge_tn1010_reset(p_nxge_t nxgep);
133 static void nxge_dump_tn1010_status_regs(p_nxge_t nxgep);
253 * This function partitions nxgep->nxge_hw_p->niu_type (which may have
257 static boolean_t nxge_is_tn1010_phy(p_nxge_t nxgep)
259 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
261 if (((nxgep->nxge_hw_p->niu_type >> (NXGE_PORT_TYPE_SHIFT * portn))
271 * Figure out nxgep->mac.portmode from nxge.conf, OBP's device properties,
278 nxge_get_xcvr_type(p_nxge_t nxgep)
283 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
288 if (nxgep->mac.portmode == PORT_10G_SERDES &&
289 nxgep->statsp->mac_stats.link_up) {
290 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
294 nxgep->mac.portmode = 0;
295 nxgep->xcvr_addr = 0;
300 if (nxgep->hot_swappable_phy == B_TRUE) {
301 nxgep->statsp->mac_stats.xcvr_inuse = HSP_XCVR;
302 nxgep->mac.portmode = PORT_HSP_MODE;
303 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "Other: Hot Swappable"));
304 } else if (ddi_prop_exists(DDI_DEV_T_ANY, nxgep->dip,
307 nxgep->statsp->mac_stats.xcvr_inuse = HSP_XCVR;
308 nxgep->mac.portmode = PORT_HSP_MODE;
309 NXGE_DEBUG_MSG((nxgep, MAC_CTL, ".conf: Hot Swappable"));
310 } else if (nxgep->niu_type == N2_NIU &&
311 ddi_prop_exists(DDI_DEV_T_ANY, nxgep->dip, 0,
313 nxgep->statsp->mac_stats.xcvr_inuse = HSP_XCVR;
314 nxgep->mac.portmode = PORT_HSP_MODE;
315 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "OBP: Hot Swappable"));
321 if (nxgep->mac.portmode == PORT_HSP_MODE) {
322 nxgep->hot_swappable_phy = B_TRUE;
327 if (nxge_hswap_phy_present(nxgep, portn))
330 nxgep->phy_absent = B_TRUE;
333 rs = npi_xmac_xpcs_read(nxgep->npi_handle, nxgep->mac.portnum,
337 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
338 nxgep->mac.portmode = PORT_10G_SERDES;
339 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
344 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
345 nxgep->mac.portmode = PORT_10G_FIBER;
346 nxgep->phy_absent = B_FALSE;
347 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "10G Fiber Xcvr "
354 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, nxgep->dip,
357 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
360 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
361 nxgep->mac.portmode = PORT_10G_SERDES;
362 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
365 nxgep->statsp->mac_stats.xcvr_inuse = PCS_XCVR;
366 nxgep->mac.portmode = PORT_1G_SERDES;
367 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "1G Serdes"));
369 nxgep->statsp->mac_stats.xcvr_inuse = INT_MII_XCVR;
370 nxgep->mac.portmode = PORT_1G_COPPER;
371 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "1G Copper Xcvr"));
373 nxgep->statsp->mac_stats.xcvr_inuse = PCS_XCVR;
374 nxgep->mac.portmode = PORT_1G_FIBER;
375 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "1G FIBER Xcvr"));
385 if (nxge_is_tn1010_phy(nxgep)) {
386 if ((status = nxge_set_tn1010_param(nxgep))
390 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "TN1010 Xcvr"));
392 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
393 nxgep->mac.portmode = PORT_10G_FIBER;
394 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
398 if ((status = nxge_set_tn1010_param(nxgep)) != NXGE_OK)
400 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "TN1010 Xcvr"));
403 (void) ddi_prop_update_string(DDI_DEV_T_NONE, nxgep->dip,
407 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_get_xcvr_type: "
409 nxgep->mac.portmode));
415 if (nxgep->niu_type == N2_NIU) {
416 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, nxgep->dip, 0,
427 if (nxge_is_tn1010_phy(nxgep)) {
429 nxge_set_tn1010_param(nxgep))
433 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
435 } else if (nxge_is_nlp2020_phy(nxgep)) {
437 nxge_set_nlp2020_param(nxgep))
441 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
444 nxgep->statsp->mac_stats.xcvr_inuse
446 nxgep->mac.portmode = PORT_10G_FIBER;
447 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
451 nxgep->statsp->mac_stats.xcvr_inuse =
453 nxgep->mac.portmode = PORT_1G_COPPER;
454 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
457 nxgep->statsp->mac_stats.xcvr_inuse = PCS_XCVR;
458 nxgep->mac.portmode = PORT_1G_FIBER;
459 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
462 status = nxge_set_tn1010_param(nxgep);
465 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "TN1010 Xcvr"));
467 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
468 nxgep->mac.portmode = PORT_10G_SERDES;
469 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
472 nxgep->statsp->mac_stats.xcvr_inuse = PCS_XCVR;
473 nxgep->mac.portmode = PORT_1G_SERDES;
474 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
477 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
484 nxgep->dip, "phy-type", prop_val);
487 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_get_xcvr_type: "
489 nxgep->mac.portmode));
493 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
500 if (!nxgep->vpd_info.present) {
504 if (!nxgep->vpd_info.ver_valid) {
508 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
514 phy_type = nxgep->vpd_info.phy_type;
517 nxgep->mac.portmode = PORT_1G_COPPER;
518 nxgep->statsp->mac_stats.xcvr_inuse = INT_MII_XCVR;
520 nxgep->mac.portmode = PORT_10G_FIBER;
521 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
523 nxgep->mac.portmode = PORT_1G_FIBER;
524 nxgep->statsp->mac_stats.xcvr_inuse = PCS_XCVR;
526 status = nxge_set_tn1010_param(nxgep);
528 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
533 nxgep->mac.portmode = PORT_10G_SERDES;
534 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
536 nxgep->mac.portmode = PORT_1G_SERDES;
537 nxgep->statsp->mac_stats.xcvr_inuse = PCS_XCVR;
539 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
545 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_get_xcvr_type: "
546 "Got phy type [0x%x] from VPD", nxgep->mac.portmode));
548 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_get_xcvr_type"));
555 status = nxge_espc_phy_type_get(nxgep);
557 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
559 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "EEPROM version "
560 "[%s] invalid...please update", nxgep->vpd_info.ver));
570 nxge_setup_xcvr_table(p_nxge_t nxgep)
574 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
580 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_setup_xcvr_table: port<%d>",
583 switch (nxgep->niu_type) {
585 switch (nxgep->mac.portmode) {
588 nxgep->xcvr = nxge_n2_1G_table;
589 nxgep->xcvr_addr = portn;
590 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "NIU 1G %s Xcvr",
591 (nxgep->mac.portmode == PORT_1G_FIBER) ? "Fiber" :
597 nxgep->xcvr = nxge_n2_10G_table;
598 if (nxgep->nxge_hw_p->xcvr_addr[portn]) {
599 nxgep->xcvr_addr =
600 nxgep->nxge_hw_p->xcvr_addr[portn];
602 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "NIU 10G %s Xcvr",
603 (nxgep->mac.portmode == PORT_10G_FIBER) ? "Fiber" :
604 ((nxgep->mac.portmode == PORT_10G_COPPER) ?
608 nxgep->xcvr = nxge_n2_1G_tn1010_table;
609 nxgep->xcvr_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
610 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
614 nxgep->xcvr = nxge_n2_10G_tn1010_table;
615 nxgep->xcvr_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
616 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
620 nxgep->xcvr = nxge_n2_10G_table;
621 nxgep->xcvr.xcvr_inuse = HSP_XCVR;
622 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "NIU 10G Hot "
626 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
633 if (nxgep->mac.portmode == 0) {
639 if (!NXGE_IS_VALID_NEPTUNE_TYPE(nxgep)) {
640 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
643 nxgep->niu_type));
647 port_type = nxgep->niu_type >>
654 nxgep->mac.portmode = PORT_1G_COPPER;
657 nxgep->mac.portmode = PORT_10G_COPPER;
660 nxgep->mac.portmode = PORT_1G_FIBER;
663 nxgep->mac.portmode = PORT_10G_FIBER;
666 nxgep->mac.portmode = PORT_1G_SERDES;
669 nxgep->mac.portmode = PORT_10G_SERDES;
673 nxgep->mac.portmode = PORT_1G_RGMII_FIBER;
685 if ((status = nxge_set_tn1010_param(nxgep))
687 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
693 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
702 * nxgep->xcvr (the table) and nxgep->xcvr_addr according
705 switch (nxgep->mac.portmode) {
708 nxgep->xcvr = nxge_1G_copper_table;
709 nxgep->xcvr_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
718 switch (nxgep->platform_type) {
724 nxgep->xcvr_addr += 3;
727 nxgep->xcvr_addr += 1;
730 nxgep->xcvr_addr -= 1;
733 nxgep->xcvr_addr -= 3;
743 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "1G %s Xcvr",
744 (nxgep->mac.portmode == PORT_1G_COPPER) ?
749 nxgep->xcvr = nxge_10G_copper_table;
750 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "10G Copper Xcvr"));
754 nxgep->xcvr = nxge_1G_tn1010_table;
755 nxgep->xcvr_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
756 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
761 nxgep->xcvr = nxge_10G_tn1010_table;
762 nxgep->xcvr_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
763 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
769 nxgep->xcvr = nxge_1G_fiber_table;
770 nxgep->xcvr_addr = portn;
771 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "1G %s Xcvr",
772 (nxgep->mac.portmode == PORT_1G_FIBER) ?
777 nxgep->xcvr = nxge_10G_fiber_table;
778 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "10G xcvr "
779 "nxgep->nxge_hw_p->xcvr_addr[portn] = [%d] "
780 "nxgep->xcvr_addr = [%d]",
781 nxgep->nxge_hw_p->xcvr_addr[portn],
782 nxgep->xcvr_addr));
783 if (nxgep->nxge_hw_p->xcvr_addr[portn]) {
784 nxgep->xcvr_addr =
785 nxgep->nxge_hw_p->xcvr_addr[portn];
787 switch (nxgep->platform_type) {
794 nxge_bcm5464_link_led_off(nxgep);
799 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "10G %s Xcvr",
800 (nxgep->mac.portmode == PORT_10G_FIBER) ?
805 nxgep->xcvr = nxge_10G_fiber_table;
806 nxgep->xcvr.xcvr_inuse = HSP_XCVR;
807 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "Neptune 10G Hot "
811 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
817 if (nxgep->mac.portmode == PORT_10G_FIBER ||
818 nxgep->mac.portmode == PORT_10G_COPPER) {
820 pma_pmd_id = nxge_get_cl45_pma_pmd_id(nxgep,
821 nxgep->xcvr_addr);
824 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
830 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
833 } else if ((status = nxge_mdio_read(nxgep, nxgep->xcvr_addr,
839 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
845 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
851 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
860 nxgep->statsp->mac_stats.xcvr_inuse = nxgep->xcvr.xcvr_inuse;
861 nxgep->statsp->mac_stats.xcvr_portn = nxgep->xcvr_addr;
862 nxgep->chip_id = chip_id;
867 nxgep->statsp->mac_stats.xcvr_id = 0;
869 pma_pmd_id = nxge_get_cl45_pma_pmd_id(nxgep, nxgep->xcvr_addr);
871 nxgep->statsp->mac_stats.xcvr_id = pma_pmd_id;
873 pcs_id = nxge_get_cl45_pcs_id(nxgep, nxgep->xcvr_addr);
875 nxgep->statsp->mac_stats.xcvr_id = pcs_id;
877 phy_id = nxge_get_cl22_phy_id(nxgep,
878 nxgep->xcvr_addr);
880 nxgep->statsp->mac_stats.xcvr_id = phy_id;
885 nxgep->mac.linkchkmode = LINKCHK_TIMER;
887 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_setup_xcvr_table: niu_type"
888 "[0x%x] platform type[0x%x] xcvr_addr[%d]", nxgep->niu_type,
889 nxgep->platform_type, nxgep->xcvr_addr));
897 nxge_mac_init(p_nxge_t nxgep)
901 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
903 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mac_init: port<%d>", portn));
905 nxgep->mac.portnum = portn;
906 nxgep->mac.porttype = PORT_TYPE_XMAC;
909 nxgep->mac.porttype = PORT_TYPE_BMAC;
913 if ((status = nxge_xif_init(nxgep)) != NXGE_OK) {
917 if ((status = nxge_pcs_init(nxgep)) != NXGE_OK) {
925 if ((status = nxge_tx_mac_reset(nxgep)) != NXGE_OK)
928 if ((status = nxge_tx_mac_init(nxgep)) != NXGE_OK)
931 if ((status = nxge_rx_mac_reset(nxgep)) != NXGE_OK)
934 if ((status = nxge_rx_mac_init(nxgep)) != NXGE_OK)
937 if ((status = nxge_tx_mac_enable(nxgep)) != NXGE_OK)
940 if (nxgep->nxge_mac_state == NXGE_MAC_STARTED) {
941 if ((status = nxge_rx_mac_enable(nxgep)) != NXGE_OK)
946 if ((status = nxge_mac_ctrl_init(nxgep)) != NXGE_OK) {
950 nxgep->statsp->mac_stats.mac_mtu = nxgep->mac.maxframesize;
953 if ((NXGE_IS_VALID_NEPTUNE_TYPE(nxgep)) &&
954 ((nxgep->mac.portmode == PORT_1G_SERDES) ||
955 (nxgep->mac.portmode == PORT_1G_TN1010) ||
956 (nxgep->mac.portmode == PORT_1G_FIBER)) &&
958 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
960 if ((status = nxge_1G_serdes_init(nxgep)) != NXGE_OK) {
966 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_mac_init: port<%d>", portn));
970 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
978 nxge_link_init(p_nxge_t nxgep)
985 portn = nxgep->mac.portnum;
987 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_link_init: port<%d>", portn));
991 portmode = nxgep->mac.portmode;
998 if (nxgep->niu_type == N2_NIU && (portmode != PORT_10G_SERDES) &&
1002 if ((status = nxge_xcvr_init(nxgep)) != NXGE_OK) {
1009 if ((status = nxge_serdes_init(nxgep)) != NXGE_OK)
1012 if ((status = nxge_xcvr_init(nxgep)) != NXGE_OK)
1015 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_link_init: port<%d>", portn));
1020 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_link_init: ",
1030 nxge_xif_init(p_nxge_t nxgep)
1041 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
1043 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_xif_init: port<%d>", portn));
1045 handle = nxgep->npi_handle;
1046 portmode = nxgep->mac.portmode;
1047 portt = nxgep->mac.porttype;
1048 statsp = nxgep->statsp;
1050 if ((NXGE_IS_VALID_NEPTUNE_TYPE(nxgep)) &&
1051 ((nxgep->mac.portmode == PORT_1G_SERDES) ||
1052 (nxgep->mac.portmode == PORT_1G_TN1010) ||
1053 (nxgep->mac.portmode == PORT_1G_FIBER)) &&
1055 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1057 npi_mac_mif_set_atca_mode(nxgep->npi_handle, B_TRUE);
1103 nxgep->mac.xif_config = xif_cfg;
1116 if (nxge_10g_link_led_on(nxgep) != NXGE_OK)
1119 if (nxge_10g_link_led_off(nxgep) != NXGE_OK)
1127 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1140 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1169 nxgep->mac.xif_config = xif_cfg;
1171 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_xif_init: port<%d>", portn));
1174 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1185 nxge_pcs_init(p_nxge_t nxgep)
1197 handle = nxgep->npi_handle;
1198 portmode = nxgep->mac.portmode;
1199 portn = nxgep->mac.portnum;
1200 statsp = nxgep->statsp;
1202 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_pcs_init: port<%d>", portn));
1228 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1284 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1297 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_pcs_init: port<%d>", portn));
1300 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1310 nxge_mac_ctrl_init(p_nxge_t nxgep)
1318 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
1320 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mac_ctrl_init: port<%d>",
1323 handle = nxgep->npi_handle;
1324 portt = nxgep->mac.porttype;
1325 statsp = nxgep->statsp;
1351 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1355 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1369 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1419 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_mac_ctrl_init: port<%d>",
1428 nxge_serdes_init(p_nxge_t nxgep)
1437 portn = nxgep->mac.portnum;
1438 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1442 if (nxgep->xcvr.serdes_init) {
1443 statsp = nxgep->statsp;
1444 status = nxgep->xcvr.serdes_init(nxgep);
1450 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_serdes_init port<%d>",
1456 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1466 nxge_n2_serdes_init(p_nxge_t nxgep)
1482 portn = nxgep->mac.portnum;
1484 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_n2_serdes_init port<%d>",
1486 if (nxgep->niu_hw_type == NIU_HW_TYPE_RF) {
1487 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1489 return (nxge_n2_kt_serdes_init(nxgep));
1510 if (nxgep->mac.portmode == PORT_1G_TN1010 ||
1511 nxgep->mac.portmode == PORT_10G_TN1010) {
1512 if (nxge_set_tn1010_param(nxgep) != NXGE_OK) {
1517 if (nxgep->mac.portmode == PORT_10G_FIBER ||
1518 nxgep->mac.portmode == PORT_10G_COPPER ||
1519 nxgep->mac.portmode == PORT_10G_TN1010 ||
1520 nxgep->mac.portmode == PORT_HSP_MODE ||
1521 nxgep->mac.portmode == PORT_10G_SERDES) {
1536 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes10g) {
1540 if ((status = nxge_mdio_write(nxgep, portn,
1550 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1554 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1559 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1561 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1565 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1567 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1571 } else if (nxgep->mac.portmode == PORT_1G_FIBER ||
1572 nxgep->mac.portmode == PORT_1G_TN1010 ||
1573 nxgep->mac.portmode == PORT_1G_SERDES) {
1595 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1599 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1604 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1606 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1610 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1612 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1618 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes1000) {
1622 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1625 if ((status = nxge_mdio_write(nxgep, portn,
1641 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1645 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1649 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1652 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1659 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1663 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1667 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1671 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1676 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_n2_serdes_init port<%d>",
1681 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
1692 nxge_n2_kt_serdes_init(p_nxge_t nxgep)
1710 portn = nxgep->mac.portnum;
1712 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1714 handle = nxgep->npi_handle;
1737 if (nxgep->mac.portmode == PORT_1G_TN1010 ||
1738 nxgep->mac.portmode == PORT_10G_TN1010) {
1739 if (nxge_set_tn1010_param(nxgep) != NXGE_OK) {
1743 if (nxgep->mac.portmode == PORT_10G_FIBER ||
1744 nxgep->mac.portmode == PORT_10G_COPPER ||
1745 nxgep->mac.portmode == PORT_10G_TN1010 ||
1746 nxgep->mac.portmode == PORT_10G_SERDES) {
1749 if (nxgep->srds_prop.prop_set & NXGE_SRDS_TXCFGL) {
1750 tx_cfg_l.value = nxgep->srds_prop.tx_cfg_l;
1757 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1761 if (nxgep->srds_prop.prop_set & NXGE_SRDS_TXCFGH) {
1762 tx_cfg_h.value = nxgep->srds_prop.tx_cfg_h;
1768 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1772 if (nxgep->srds_prop.prop_set & NXGE_SRDS_RXCFGL) {
1773 rx_cfg_l.value = nxgep->srds_prop.rx_cfg_l;
1781 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1785 if (nxgep->srds_prop.prop_set & NXGE_SRDS_RXCFGH) {
1786 rx_cfg_h.value = nxgep->srds_prop.rx_cfg_h;
1792 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1796 if (nxgep->srds_prop.prop_set & NXGE_SRDS_PLLCFGL) {
1797 pll_cfg_l.value = nxgep->srds_prop.pll_cfg_l;
1804 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1808 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1811 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1816 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes10g) {
1821 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1826 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1828 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
1833 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1835 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
1839 } else if (nxgep->mac.portmode == PORT_1G_FIBER ||
1840 nxgep->mac.portmode == PORT_1G_TN1010 ||
1841 nxgep->mac.portmode == PORT_1G_SERDES) {
1848 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1855 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1866 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1873 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1881 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1885 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1892 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1894 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
1898 nxge_mdio_read(nxgep, portn, ESR_N2_DEV_ADDR,
1900 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
1906 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes1000) {
1909 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1912 if ((status = nxge_mdio_write(nxgep, portn,
1920 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
1923 portn, nxgep->mac.portmode));
1929 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1939 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1943 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1947 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1951 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1959 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1964 if ((status = nxge_mdio_write(nxgep, portn, ESR_N2_DEV_ADDR,
1969 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
1973 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2002 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2031 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2039 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2044 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2054 nxge_neptune_10G_serdes_init(p_nxge_t nxgep)
2068 portn = nxgep->mac.portnum;
2073 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2075 handle = nxgep->npi_handle;
2102 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes10g) {
2138 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes10g) {
2153 if ((status = nxge_mdio_read(nxgep, portn,
2157 if ((status = nxge_mdio_read(nxgep, portn,
2161 if ((status = nxge_mdio_read(nxgep, portn,
2165 if ((status = nxge_mdio_read(nxgep, portn,
2176 if ((status = nxge_mdio_write(nxgep, portn,
2180 if ((status = nxge_mdio_write(nxgep, portn,
2184 if ((status = nxge_mdio_write(nxgep, portn,
2188 if ((status = nxge_mdio_write(nxgep, portn,
2195 if ((status = nxge_mdio_write(nxgep, portn,
2200 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2208 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2214 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2219 if ((status = nxge_mdio_read(nxgep, portn,
2223 if ((status = nxge_mdio_read(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2227 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2257 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2286 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2294 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2299 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2309 nxge_1G_serdes_init(p_nxge_t nxgep)
2323 portn = nxgep->mac.portnum;
2325 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2328 handle = nxgep->npi_handle;
2345 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes1000) {
2373 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_serdes1000) {
2394 if ((status = nxge_mdio_read(nxgep, portn,
2399 if ((status = nxge_mdio_read(nxgep, portn,
2404 if ((status = nxge_mdio_read(nxgep, portn,
2409 if ((status = nxge_mdio_read(nxgep, portn,
2422 if ((status = nxge_mdio_write(nxgep, portn,
2427 if ((status = nxge_mdio_write(nxgep, portn,
2432 if ((status = nxge_mdio_write(nxgep, portn,
2437 if ((status = nxge_mdio_write(nxgep, portn,
2444 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2448 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2452 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2456 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2462 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2467 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2476 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2483 if ((status = nxge_mdio_write(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2489 if ((status = nxge_mdio_read(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2493 if ((status = nxge_mdio_read(nxgep, portn, ESR_NEPTUNE_DEV_ADDR,
2498 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2507 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2519 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2533 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2542 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2546 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2554 #define NXGE_SET_PHY_TUNABLES(nxgep, phy_port, stat) \
2558 if (nxgep->phy_prop.cnt > 0) { \
2559 for (i = 0; i < nxgep->phy_prop.cnt; i++) { \
2560 if ((stat = nxge_mdio_write(nxgep, phy_port, \
2561 nxgep->phy_prop.arr[i].dev, \
2562 nxgep->phy_prop.arr[i].reg, \
2563 nxgep->phy_prop.arr[i].val)) != NXGE_OK) { \
2566 NXGE_DEBUG_MSG((nxgep, MAC_CTL, \
2569 nxgep->phy_prop.arr[i].dev, \
2570 nxgep->phy_prop.arr[i].reg, \
2571 nxgep->phy_prop.arr[i].val)); \
2579 nxge_BCM8704_xcvr_init(p_nxge_t nxgep)
2595 portn = nxgep->mac.portnum;
2598 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_BCM8704_xcvr_init: port<%d>",
2601 phy_port_addr = nxgep->statsp->mac_stats.xcvr_portn;
2604 if ((status = nxge_mdio_read(nxgep, phy_port_addr, BCM8704_PHYXS_ADDR,
2609 if ((status = nxge_mdio_write(nxgep, phy_port_addr, BCM8704_PHYXS_ADDR,
2615 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2622 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_xcvr_init: "
2639 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
2650 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
2658 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2663 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2668 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2673 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2679 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2683 if (NXGE_IS_XAUI_PLATFORM(nxgep)) {
2688 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
2698 NXGE_SET_PHY_TUNABLES(nxgep, phy_port_addr, status);
2700 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2706 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2710 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_phy10g)
2714 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
2719 status = nxge_mdio_read(nxgep, phy_port_addr, 0x1, 0xA, &val);
2722 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2724 status = nxge_mdio_read(nxgep, phy_port_addr, 0x3, 0x20, &val);
2727 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2729 status = nxge_mdio_read(nxgep, phy_port_addr, 0x4, 0x18, &val);
2732 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2737 status = nxge_mdio_read(nxgep, phy_port_addr, BCM8704_USER_DEV3_ADDR,
2743 status = nxge_mdio_read(nxgep, phy_port_addr,
2748 status = nxge_mdio_read(nxgep, phy_port_addr,
2753 status = nxge_mdio_read(nxgep, phy_port_addr,
2760 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
2764 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2771 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_BCM8704_xcvr_init: port<%d>",
2776 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2778 "port<%d>", nxgep->mac.portnum));
2785 nxge_BCM8706_xcvr_init(p_nxge_t nxgep)
2794 uint8_t portn = nxgep->mac.portnum;
2797 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_BCM8706_xcvr_init: port<%d>",
2800 phy_port_addr = nxgep->statsp->mac_stats.xcvr_portn;
2803 if ((status = nxge_mdio_read(nxgep, phy_port_addr, BCM8704_PHYXS_ADDR,
2808 if ((status = nxge_mdio_write(nxgep, phy_port_addr, BCM8704_PHYXS_ADDR,
2813 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2821 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_xcvr_init: "
2832 NXGE_SET_PHY_TUNABLES(nxgep, phy_port_addr, status);
2834 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2840 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2844 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_phy10g)
2848 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
2854 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
2861 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
2866 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_BCM8706_xcvr_init: port<%d>",
2871 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
2873 "port<%d>", nxgep->mac.portnum));
2878 nxge_nlp2020_i2c_read(p_nxge_t nxgep, uint8_t ctrl_port, uint16_t address,
2893 if (nxge_mdio_write(nxgep, ctrl_port,
2898 (void) nxge_mdio_read(nxgep, ctrl_port, phy_dev, phy_reg, &stat);
2900 (void) nxge_mdio_read(nxgep, ctrl_port, phy_dev, phy_reg,
2905 (void) nxge_mdio_read(nxgep, ctrl_port, phy_dev, phy_reg,
2911 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
3404 nxge_nlp2020_xcvr_init(p_nxge_t nxgep)
3415 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_nlp2020_xcvr_init: "
3416 "port<%d>, phyaddr[0x%x]", nxgep->mac.portnum,
3417 nxgep->statsp->mac_stats.xcvr_portn));
3419 phy_port_addr = nxgep->statsp->mac_stats.xcvr_portn;
3423 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
3429 (void) nxge_mdio_read(nxgep, phy_port_addr,
3433 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_nlp2020_xcvr_init: "
3440 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
3445 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_phy10g)
3449 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
3454 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_nlp2020_xcvr_init: "
3458 if (nxge_nlp2020_i2c_read(nxgep, phy_port_addr, NLP2020_XCVR_I2C_ADDR,
3465 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3468 nxgep->nlp_conn = NXGE_NLP_CONN_FIBER;
3471 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3474 nxgep->nlp_conn = NXGE_NLP_CONN_FIBER;
3477 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3482 nxgep->nlp_conn = NXGE_NLP_CONN_COPPER_LT_7M;
3485 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
3490 nxgep->nlp_conn = NXGE_NLP_CONN_FIBER;
3503 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
3510 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
3516 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
3520 if (nxge_nlp2020_i2c_read(nxgep, phy_port_addr, NLP2020_XCVR_I2C_ADDR,
3525 if (nxge_nlp2020_i2c_read(nxgep, phy_port_addr, NLP2020_XCVR_I2C_ADDR,
3529 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3534 nxgep->nlp_conn = NXGE_NLP_CONN_COPPER_7M_ABOVE;
3536 (void) nxge_mdio_write(nxgep, phy_port_addr,
3540 (void) nxge_mdio_write(nxgep, phy_port_addr,
3544 (void) nxge_mdio_write(nxgep, phy_port_addr,
3548 (void) nxge_mdio_write(nxgep, phy_port_addr,
3552 (void) nxge_mdio_write(nxgep, phy_port_addr,
3559 (void) nxge_mdio_write(nxgep, phy_port_addr,
3564 (void) nxge_mdio_write(nxgep, phy_port_addr,
3572 NXGE_SET_PHY_TUNABLES(nxgep, phy_port_addr, status);
3574 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
3582 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_nlp2020_xcvr_init: "
3583 "port<%d> phyaddr[0x%x]", nxgep->mac.portnum, phy_port_addr));
3588 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
3590 "port<%d>", nxgep->mac.portnum));
3594 static boolean_t nxge_is_nlp2020_phy(p_nxge_t nxgep)
3596 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
3599 uint8_t xcvr_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
3601 pma_pmd_id = nxge_get_cl45_pma_pmd_id(nxgep, xcvr_addr);
3602 pcs_id = nxge_get_cl45_pcs_id(nxgep, xcvr_addr);
3612 static uint8_t nxge_get_nlp2020_connector_type(p_nxge_t nxgep)
3614 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
3615 uint8_t xcvr_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
3618 (void) nxge_nlp2020_i2c_read(nxgep, xcvr_addr, NLP2020_XCVR_I2C_ADDR,
3624 static nxge_status_t nxge_set_nlp2020_param(p_nxge_t nxgep)
3628 connector = nxge_get_nlp2020_connector_type(nxgep);
3632 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3634 nxgep->mac.portmode = PORT_10G_FIBER;
3635 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
3638 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3640 nxgep->mac.portmode = PORT_10G_FIBER;
3641 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
3644 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3647 nxgep->mac.portmode = PORT_10G_COPPER;
3648 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
3651 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
3655 nxgep->mac.portmode = PORT_10G_FIBER;
3656 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
3665 #define MRVL88X2011_RD(nxgep, port, d, r, p) \
3666 CHK_STAT(nxge_mdio_read(nxgep, port, d, r, p))
3668 #define MRVL88X2011_WR(nxgep, port, d, r, p) \
3669 CHK_STAT(nxge_mdio_write(nxgep, port, d, r, p))
3673 nxge_mrvl88x2011_led_blink_rate(p_nxge_t nxgep, uint16_t rate)
3676 uint8_t phy = nxgep->statsp->mac_stats.xcvr_portn;
3678 if (nxge_mdio_read(nxgep, phy, MRVL_88X2011_USER_DEV2_ADDR,
3682 (void) nxge_mdio_write(nxgep, phy,
3689 nxge_mrvl88x2011_setup_lb(p_nxge_t nxgep)
3693 uint8_t phy = nxgep->statsp->mac_stats.xcvr_portn;
3695 MRVL88X2011_RD(nxgep, phy, MRVL_88X2011_USER_DEV3_ADDR,
3698 if (nxgep->statsp->port_stats.lb_mode == nxge_lb_phy10g)
3703 MRVL88X2011_WR(nxgep, phy, MRVL_88X2011_USER_DEV3_ADDR,
3712 nxge_mrvl88x2011_led(p_nxge_t nxgep, uint16_t val)
3715 uint8_t phy = nxgep->statsp->mac_stats.xcvr_portn;
3722 if (nxge_mdio_write(nxgep, phy, MRVL_88X2011_USER_DEV2_ADDR,
3724 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
3731 nxge_mrvl88x2011_xcvr_init(p_nxge_t nxgep)
3737 phy = nxgep->statsp->mac_stats.xcvr_portn;
3739 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
3741 nxgep->mac.portnum, phy));
3744 nxge_mrvl88x2011_led_blink_rate(nxgep, MRVL_88X2011_LED_BLK134MS);
3746 nxge_mrvl88x2011_led(nxgep, MRVL_88X2011_LED_ACT);
3748 MRVL88X2011_RD(nxgep, phy, MRVL_88X2011_USER_DEV3_ADDR,
3751 MRVL88X2011_WR(nxgep, phy, MRVL_88X2011_USER_DEV3_ADDR,
3756 CHK_STAT(nxge_mrvl88x2011_setup_lb(nxgep));
3759 MRVL88X2011_WR(nxgep, phy, MRVL_88X2011_USER_DEV1_ADDR,
3762 NXGE_DEBUG_MSG((nxgep, MAC_CTL, " nxge_mrvl88x2011_reset: OK"));
3773 nxge_10G_xcvr_init(p_nxge_t nxgep)
3776 p_nxge_param_t param_arr = nxgep->param_arr;
3779 uint8_t portn = nxgep->mac.portnum;
3781 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_10G_xcvr_init: port<%d>",
3784 statsp = nxgep->statsp;
3787 if (nxge_10g_link_led_off(nxgep) != NXGE_OK)
3791 if (nxgep->mac.portmode == PORT_10G_SERDES || nxgep->phy_absent) {
3796 npi_mac_mif_set_indirect_mode(nxgep->npi_handle, B_TRUE);
3798 switch (nxgep->chip_id) {
3800 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_10G_xcvr_init: "
3801 "Chip ID 8704 [0x%x] for 10G xcvr", nxgep->chip_id));
3802 status = nxge_BCM8704_xcvr_init(nxgep);
3805 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_10G_xcvr_init: "
3806 "Chip ID 8706 [0x%x] for 10G xcvr", nxgep->chip_id));
3807 status = nxge_BCM8706_xcvr_init(nxgep);
3810 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_10G_xcvr_init: "
3811 "Chip ID MRVL [0x%x] for 10G xcvr", nxgep->chip_id));
3812 status = nxge_mrvl88x2011_xcvr_init(nxgep);
3815 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "nxge_10G_xcvr_init: "
3816 "Chip ID NL2020 [0x%x] for 10G xcvr", nxgep->chip_id));
3817 status = nxge_nlp2020_xcvr_init(nxgep);
3820 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_xcvr_init: "
3822 nxgep->chip_id, nxgep->statsp->mac_stats.xcvr_portn));
3836 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_10G_xcvr_init: port<%d>",
3841 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
3843 "port<%d>", nxgep->mac.portnum));
3850 nxge_1G_xcvr_init(p_nxge_t nxgep)
3852 p_nxge_param_t param_arr = nxgep->param_arr;
3853 p_nxge_stats_t statsp = nxgep->statsp;
3856 if (nxgep->mac.portmode == PORT_1G_SERDES) {
3863 npi_mac_mif_set_indirect_mode(nxgep->npi_handle, B_FALSE);
3867 if ((nxgep->mac.portmode == PORT_1G_COPPER) ||
3868 (nxgep->mac.portmode == PORT_1G_FIBER)) {
3875 status = nxge_mii_xcvr_init(nxgep);
3883 * initializes the members of nxgep->statsp->mac_stats struct for
3884 * kstat based on the value of nxgep->statsp->ports_stats.lb_mode.
3905 nxge_tn1010_xcvr_init(p_nxge_t nxgep)
3912 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
3915 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_1G_tn1010_xcvr_init"));
3917 param_arr = nxgep->param_arr;
3918 statsp = nxgep->statsp;
3931 if (nxge_get_tn1010_speed(nxgep, &speed) != NXGE_OK) {
4057 npi_mac_mif_set_indirect_mode(nxgep->npi_handle, B_TRUE);
4058 phy_port_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
4060 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
4071 if ((status = nxge_mdio_write(nxgep, phy_port_addr,
4079 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
4083 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4091 nxge_xcvr_init(p_nxge_t nxgep)
4100 portn = nxgep->mac.portnum;
4102 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_xcvr_init: port<%d>", portn));
4103 statsp = nxgep->statsp;
4106 * Initialize the xcvr statistics. nxgep->xcvr.xcvr_init will
4129 if (nxgep->xcvr.xcvr_init) {
4130 status = nxgep->xcvr.xcvr_init(nxgep);
4136 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_xcvr_init: port<%d>",
4141 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
4150 nxge_xcvr_find(p_nxge_t nxgep)
4152 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_xcvr_find: port<%d>",
4153 nxgep->mac.portnum));
4155 if (nxge_get_xcvr_type(nxgep) != NXGE_OK)
4158 if (nxge_setup_xcvr_table(nxgep) != NXGE_OK)
4161 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_xcvr_find: xcvr_inuse = %d",
4162 nxgep->statsp->mac_stats.xcvr_inuse));
4169 nxge_tx_mac_init(p_nxge_t nxgep)
4178 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
4179 portt = nxgep->mac.porttype;
4180 handle = nxgep->npi_handle;
4181 portmode = nxgep->mac.portmode;
4183 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_tx_mac_init: port<%d>",
4190 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
4193 nxgep->mac.minframesize,
4194 nxgep->mac.maxframesize,
4199 nxgep->mac.minframesize,
4200 nxgep->mac.maxframesize,
4209 nxgep->mac.tx_iconfig = NXGE_XMAC_TX_INTRS;
4219 nxgep->mac.ipg[0] = XGMII_IPG_12_15;
4225 nxgep->mac.ipg[0] = MII_GMII_IPG_12;
4230 nxgep->mac.tx_config = CFG_XMAC_TX_CRC | CFG_XMAC_TX;
4231 nxgep->mac.maxburstsize = 0; /* not programmable */
4232 nxgep->mac.ctrltype = 0; /* not programmable */
4233 nxgep->mac.pa_size = 0; /* not programmable */
4243 nxgep->mac.tx_iconfig = NXGE_BMAC_TX_INTRS;
4249 nxgep->mac.ctrltype = 0x8808;
4254 nxgep->mac.pa_size = 0x7;
4259 nxgep->mac.tx_config = CFG_BMAC_TX_CRC | CFG_BMAC_TX;
4262 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_tx_mac_init: port<%d>",
4267 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
4274 nxge_rx_mac_mcast_hash_table(p_nxge_t nxgep)
4283 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
4284 handle = nxgep->npi_handle;
4289 hash_filter = nxgep->hash_filter;
4310 nxge_rx_mac_init(p_nxge_t nxgep)
4322 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
4324 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_rx_mac_init: port<%d>\n",
4326 handle = nxgep->npi_handle;
4327 portt = nxgep->mac.porttype;
4329 addr16p = (uint16_t *)nxgep->ouraddr.ether_addr_octet;
4344 rs = nxge_rx_mac_mcast_hash_table(nxgep);
4352 nxgep->mac.rx_iconfig = NXGE_XMAC_RX_INTRS;
4354 (void) nxge_fflp_init_hostinfo(nxgep);
4360 if (nxgep->filter.all_phys_cnt != 0)
4362 if (nxgep->filter.all_multicast_cnt != 0)
4370 nxgep->mac.rx_config = xconfig;
4380 if (npi_bmac_rx_iconfig(nxgep->npi_handle, INIT, portn,
4384 nxgep->mac.rx_iconfig = NXGE_BMAC_RX_INTRS;
4386 (void) nxge_fflp_init_hostinfo(nxgep);
4391 if (nxgep->filter.all_phys_cnt != 0)
4393 if (nxgep->filter.all_multicast_cnt != 0)
4400 nxgep->mac.rx_config = bconfig;
4410 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_rx_mac_init: port<%d>\n",
4416 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4425 nxge_tx_mac_enable(p_nxge_t nxgep)
4431 handle = nxgep->npi_handle;
4433 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_tx_mac_enable: port<%d>",
4434 nxgep->mac.portnum));
4436 if ((status = nxge_tx_mac_init(nxgep)) != NXGE_OK)
4440 nxgep->msg_min = ETHERMIN;
4442 if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
4443 if ((rs = npi_xmac_tx_config(handle, ENABLE, nxgep->mac.portnum,
4447 if ((rs = npi_bmac_tx_config(handle, ENABLE, nxgep->mac.portnum,
4452 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_tx_mac_enable: port<%d>",
4453 nxgep->mac.portnum));
4457 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4459 nxgep->mac.portnum));
4469 nxge_tx_mac_disable(p_nxge_t nxgep)
4474 if (isLDOMguest(nxgep))
4477 handle = nxgep->npi_handle;
4479 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_tx_mac_disable: port<%d>",
4480 nxgep->mac.portnum));
4482 if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
4484 nxgep->mac.portnum, CFG_XMAC_TX)) != NPI_SUCCESS)
4488 nxgep->mac.portnum, CFG_BMAC_TX)) != NPI_SUCCESS)
4492 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_tx_mac_disable: port<%d>",
4493 nxgep->mac.portnum));
4496 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4498 nxgep->mac.portnum));
4505 nxge_rx_mac_enable(p_nxge_t nxgep)
4513 if (isLDOMguest(nxgep))
4516 handle = nxgep->npi_handle;
4517 portn = nxgep->mac.portnum;
4519 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_rx_mac_enable: port<%d>",
4522 if ((status = nxge_rx_mac_init(nxgep)) != NXGE_OK)
4525 if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
4535 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
4540 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4552 nxge_rx_mac_disable(p_nxge_t nxgep)
4559 if (isLDOMguest(nxgep))
4562 handle = nxgep->npi_handle;
4563 portn = nxgep->mac.portnum;
4565 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_rx_mac_disable: port<%d>",
4568 if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
4578 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_rx_mac_disable: port<%d>",
4582 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4591 nxge_tx_mac_reset(p_nxge_t nxgep)
4597 handle = nxgep->npi_handle;
4598 portn = nxgep->mac.portnum;
4600 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_tx_mac_reset: port<%d>",
4603 if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
4613 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_tx_mac_reset: port<%d>",
4618 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4627 nxge_rx_mac_reset(p_nxge_t nxgep)
4633 handle = nxgep->npi_handle;
4634 portn = nxgep->mac.portnum;
4636 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_rx_mac_reset: port<%d>",
4639 if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
4649 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_rx_mac_reset: port<%d>",
4654 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4662 nxge_10G_link_intr_start(p_nxge_t nxgep)
4665 uint8_t portn = nxgep->mac.portnum;
4667 rs = npi_xmac_xpcs_link_intr_enable(nxgep->npi_handle, portn);
4678 nxge_10G_link_intr_stop(p_nxge_t nxgep)
4681 uint8_t portn = nxgep->mac.portnum;
4683 rs = npi_xmac_xpcs_link_intr_disable(nxgep->npi_handle, portn);
4694 nxge_1G_fiber_link_intr_start(p_nxge_t nxgep)
4697 uint8_t portn = nxgep->mac.portnum;
4699 rs = npi_mac_pcs_link_intr_enable(nxgep->npi_handle, portn);
4709 nxge_1G_fiber_link_intr_stop(p_nxge_t nxgep)
4712 uint8_t portn = nxgep->mac.portnum;
4714 rs = npi_mac_pcs_link_intr_disable(nxgep->npi_handle, portn);
4725 nxge_1G_copper_link_intr_start(p_nxge_t nxgep)
4728 uint8_t portn = nxgep->mac.portnum;
4730 rs = npi_mac_mif_link_intr_enable(nxgep->npi_handle, portn,
4742 nxge_1G_copper_link_intr_stop(p_nxge_t nxgep)
4745 uint8_t portn = nxgep->mac.portnum;
4747 rs = npi_mac_mif_link_intr_disable(nxgep->npi_handle, portn);
4758 nxge_link_intr(p_nxge_t nxgep, link_intr_enable_t enable)
4763 portn = nxgep->mac.portnum;
4765 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_link_intr: port<%d>", portn));
4766 if (!nxgep->xcvr.link_intr_stop || !nxgep->xcvr.link_intr_start)
4770 status = nxgep->xcvr.link_intr_start(nxgep);
4772 status = nxgep->xcvr.link_intr_stop(nxgep);
4776 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_link_intr: port<%d>", portn));
4780 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
4789 nxge_mii_xcvr_init(p_nxge_t nxgep)
4805 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mii_xcvr_init"));
4807 param_arr = nxgep->param_arr;
4808 statsp = nxgep->statsp;
4813 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
4821 (void) nxge_mii_get_link_mode(nxgep);
4822 if (nxgep->mac.portmode == PORT_1G_RGMII_FIBER) {
4823 return (nxge_mii_xcvr_fiber_init(nxgep));
4832 if ((status = nxge_mii_write(nxgep, xcvr_portn,
4842 if ((status = nxge_mii_read(nxgep, xcvr_portn,
4853 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "Xcvr reset failed."));
4857 if ((status = nxge_mii_read(nxgep, xcvr_portn,
4906 if ((status = nxge_mii_read(nxgep, xcvr_portn,
4945 if ((status = nxge_mii_write(nxgep, xcvr_portn,
4973 if ((status = nxge_mii_write(nxgep, xcvr_portn,
4980 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5002 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5020 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5034 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "Going into forced mode."));
5050 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5097 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5125 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5134 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5142 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "bmcr = 0x%04X", bmcr.value));
5147 nxgep->soft_bmsr.value = 0;
5149 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5155 &nxgep->bmsr.value)) != NXGE_OK)
5159 nxgep->bmsr.value = 0;
5162 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5168 nxge_mii_xcvr_fiber_init(p_nxge_t nxgep)
5183 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mii_xcvr_fiber_init"));
5185 param_arr = nxgep->param_arr;
5186 statsp = nxgep->statsp;
5191 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5204 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5208 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5215 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5220 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5228 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "Xcvr reset failed."));
5233 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5237 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5282 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5287 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5325 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5329 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5351 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5356 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "Going into forced mode."));
5369 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5374 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5385 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5390 if ((status = nxge_mii_write(nxgep, xcvr_portn,
5396 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5401 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5405 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5410 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5416 nxgep->soft_bmsr.value = 0;
5418 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5420 &nxgep->bmsr.value)) != NXGE_OK)
5423 if ((status = nxge_mii_read(nxgep, xcvr_portn,
5425 &nxgep->bmsr.value)) != NXGE_OK)
5430 nxgep->bmsr.value = 0;
5432 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5437 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
5445 nxge_mii_read(p_nxge_t nxgep, uint8_t xcvr_portn, uint8_t xcvr_reg,
5450 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "==> nxge_mii_read: xcvr_port<%d>"
5453 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
5455 if ((nxgep->mac.portmode == PORT_1G_COPPER) ||
5456 (nxgep->mac.portmode == PORT_1G_RGMII_FIBER)) {
5457 if ((rs = npi_mac_mif_mii_read(nxgep->npi_handle,
5460 } else if ((nxgep->mac.portmode == PORT_1G_FIBER) ||
5461 (nxgep->mac.portmode == PORT_1G_SERDES)) {
5462 if ((rs = npi_mac_pcs_mii_read(nxgep->npi_handle,
5468 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5470 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "<== nxge_mii_read: xcvr_port<%d>"
5474 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5475 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
5484 nxge_mii_write(p_nxge_t nxgep, uint8_t xcvr_portn, uint8_t xcvr_reg,
5489 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "==> nxge_mii_write: xcvr_port<%d>"
5492 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
5494 if ((nxgep->mac.portmode == PORT_1G_COPPER) ||
5495 (nxgep->mac.portmode == PORT_1G_RGMII_FIBER)) {
5496 if ((rs = npi_mac_mif_mii_write(nxgep->npi_handle,
5499 } else if ((nxgep->mac.portmode == PORT_1G_FIBER) ||
5500 (nxgep->mac.portmode == PORT_1G_SERDES)) {
5501 if ((rs = npi_mac_pcs_mii_write(nxgep->npi_handle,
5507 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5509 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "<== nxge_mii_write: xcvr_port<%d>"
5513 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5515 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
5536 nxge_mdio_read(p_nxge_t nxgep, uint8_t xcvr_portn, uint8_t device,
5541 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "==> nxge_mdio_read: xcvr_port<%d>",
5544 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
5546 if ((rs = npi_mac_mif_mdio_read(nxgep->npi_handle,
5550 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5552 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "<== nxge_mdio_read: xcvr_port<%d>",
5556 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5558 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
5567 nxge_mdio_write(p_nxge_t nxgep, uint8_t xcvr_portn, uint8_t device,
5572 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "==> nxge_mdio_write: xcvr_port<%d>",
5575 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
5577 if ((rs = npi_mac_mif_mdio_write(nxgep->npi_handle,
5581 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5583 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "<== nxge_mdio_write: xcvr_port<%d>",
5587 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
5589 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
5599 nxge_mii_check(p_nxge_t nxgep, mii_bmsr_t bmsr, mii_bmsr_t bmsr_ints,
5613 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mii_check"));
5616 param_arr = nxgep->param_arr;
5617 statsp = nxgep->statsp;
5618 soft_bmsr = &nxgep->soft_bmsr;
5621 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5626 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5631 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5639 nxgep->link_notify = B_FALSE;
5643 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5648 if (nxgep->mac.portmode == PORT_1G_COPPER &&
5684 nxgep->link_notify = B_FALSE;
5688 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
5694 if (nxgep->mac.portmode == PORT_1G_COPPER &&
5696 if ((status = nxge_mii_read(nxgep,
5705 if ((status = nxge_mii_read(nxgep,
5714 if ((status = nxge_mii_read(nxgep,
5737 if ((status = nxge_mii_read(nxgep,
5802 } else if (nxgep->mac.portmode == PORT_1G_RGMII_FIBER) {
5808 if (nxgep->link_notify && nxgep->nxge_mac_state == NXGE_MAC_STARTED &&
5809 (statsp->mac_stats.link_up == 1 || nxgep->link_check_count > 3)) {
5812 nxgep->link_notify = B_FALSE;
5814 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_mii_check"));
5817 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
5827 nxge_pcs_check(p_nxge_t nxgep, uint8_t portn, nxge_link_state_t *link_up)
5832 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_pcs_check"));
5834 statsp = nxgep->statsp;
5837 (void) npi_mac_get_link_status(nxgep->npi_handle, portn, &linkup);
5839 if ((nxgep->link_notify &&
5840 nxgep->nxge_mac_state == NXGE_MAC_STARTED) ||
5841 nxgep->statsp->mac_stats.link_up == 0) {
5846 nxgep->link_notify = B_FALSE;
5849 if ((nxgep->link_notify && nxgep->link_check_count > 3 &&
5850 nxgep->nxge_mac_state == NXGE_MAC_STARTED) ||
5851 nxgep->statsp->mac_stats.link_up == 1) {
5856 nxgep->link_notify = B_FALSE;
5860 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_pcs_check"));
5866 nxge_add_mcast_addr(p_nxge_t nxgep, struct ether_addr *addrp)
5875 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_add_mcast_addr"));
5877 RW_ENTER_WRITER(&nxgep->filter_lock);
5879 if (nxgep->hash_filter == NULL) {
5882 nxgep->hash_filter = KMEM_ZALLOC(sizeof (hash_filter_t),
5886 hash_filter = nxgep->hash_filter;
5895 rs = nxge_rx_mac_mcast_hash_table(nxgep);
5899 RW_EXIT(&nxgep->filter_lock);
5900 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_add_mcast_addr"));
5903 RW_EXIT(&nxgep->filter_lock);
5904 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_add_mcast_addr: "
5912 nxge_del_mcast_addr(p_nxge_t nxgep, struct ether_addr *addrp)
5921 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_del_mcast_addr"));
5922 RW_ENTER_WRITER(&nxgep->filter_lock);
5924 if (nxgep->hash_filter == NULL) {
5927 RW_EXIT(&nxgep->filter_lock);
5928 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_del_mcast_addr"));
5931 hash_filter = nxgep->hash_filter;
5944 nxgep->hash_filter = NULL;
5947 rs = nxge_rx_mac_mcast_hash_table(nxgep);
5951 RW_EXIT(&nxgep->filter_lock);
5952 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_del_mcast_addr"));
5956 RW_EXIT(&nxgep->filter_lock);
5957 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_del_mcast_addr: "
5966 nxge_set_mac_addr(p_nxge_t nxgep, struct ether_addr *addrp)
5970 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_set_mac_addr"));
5972 MUTEX_ENTER(&nxgep->ouraddr_lock);
5978 (ether_cmp(addrp, &nxgep->ouraddr) == 0)) {
5981 nxgep->ouraddr = *addrp;
5987 RW_ENTER_WRITER(&nxgep->filter_lock);
5988 if ((status = nxge_rx_mac_disable(nxgep)) != NXGE_OK)
5990 if ((status = nxge_rx_mac_enable(nxgep)) != NXGE_OK)
5993 RW_EXIT(&nxgep->filter_lock);
5994 MUTEX_EXIT(&nxgep->ouraddr_lock);
5997 MUTEX_EXIT(&nxgep->ouraddr_lock);
5999 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_set_mac_addr"));
6003 MUTEX_EXIT(&nxgep->ouraddr_lock);
6004 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_set_mac_addr: "
6039 nxge_check_mii_link(p_nxge_t nxgep)
6049 if (nxgep->nxge_magic != NXGE_MAGIC)
6052 if (nxge_check_link_stop(nxgep) == CHECK_LINK_STOP)
6055 portn = nxgep->mac.portnum;
6057 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_check_mii_link port<%d>",
6062 RW_ENTER_WRITER(&nxgep->filter_lock);
6064 if (nxgep->statsp->port_stats.lb_mode > nxge_lb_ext10)
6067 switch (nxgep->mac.portmode) {
6070 if ((status = nxge_mii_read(nxgep,
6071 nxgep->statsp->mac_stats.xcvr_portn,
6081 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6083 "RIGHT AFTER READ bmsr_data 0x%x (nxgep->bmsr 0x%x ",
6084 portn, bmsr_data.value, nxgep->bmsr.value));
6086 if (nxgep->param_arr[param_autoneg].value) {
6087 if ((status = nxge_mii_read(nxgep,
6088 nxgep->statsp->mac_stats.xcvr_portn,
6096 if ((status = nxge_mii_read(nxgep,
6097 nxgep->statsp->mac_stats.xcvr_portn,
6105 if (nxgep->mac.portmode != PORT_1G_RGMII_FIBER) {
6107 if (nxgep->statsp->mac_stats.link_up &&
6108 ((nxgep->statsp->mac_stats.lp_cap_1000fdx ^
6110 (nxgep->statsp->mac_stats.lp_cap_1000hdx ^
6112 (nxgep->statsp->mac_stats.lp_cap_100T4 ^
6114 (nxgep->statsp->mac_stats.lp_cap_100fdx ^
6116 (nxgep->statsp->mac_stats.lp_cap_100hdx ^
6118 (nxgep->statsp->mac_stats.lp_cap_10fdx ^
6120 (nxgep->statsp->mac_stats.lp_cap_10hdx ^
6133 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6135 "BEFORE BMSR ^ nxgep->bmsr 0x%x bmsr_data 0x%x",
6136 portn, nxgep->bmsr.value, bmsr_data.value));
6138 bmsr_ints.value = nxgep->bmsr.value ^ bmsr_data.value;
6139 nxgep->bmsr.value = bmsr_data.value;
6141 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6146 if ((status = nxge_mii_check(nxgep, bmsr_data, bmsr_ints,
6159 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6161 nxge_pcs_check(nxgep, portn, &link_up);
6166 RW_EXIT(&nxgep->filter_lock);
6168 nxge_link_is_up(nxgep);
6170 nxge_link_is_down(nxgep);
6172 (void) nxge_link_monitor(nxgep, LINK_MONITOR_START);
6174 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_check_mii_link port<%d>",
6179 RW_EXIT(&nxgep->filter_lock);
6181 (void) nxge_link_monitor(nxgep, LINK_MONITOR_START);
6182 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
6189 nxge_check_10g_link(p_nxge_t nxgep)
6197 if (nxgep->nxge_magic != NXGE_MAGIC)
6200 if (nxge_check_link_stop(nxgep) == CHECK_LINK_STOP)
6203 portn = nxgep->mac.portnum;
6207 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_check_10g_link port<%d>",
6210 switch (nxgep->mac.portmode) {
6215 if (nxgep->hot_swappable_phy) {
6218 if (nxge_hswap_phy_present(nxgep, portn))
6222 rs = npi_xmac_xpcs_read(nxgep->npi_handle,
6223 nxgep->mac.portnum, XPCS_REG_STATUS, &val);
6232 if (nxgep->phy_absent) {
6238 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6240 nxgep->phy_absent = B_FALSE;
6241 (void) nxge_xcvr_find(nxgep);
6242 (void) nxge_link_init(nxgep);
6243 if (!(nxgep->drv_state &
6245 status = nxge_init(nxgep);
6247 NXGE_ERROR_MSG((nxgep,
6261 nxgep->statsp->mac_stats.xcvr_inuse =
6263 nxgep->mac.portmode = PORT_10G_SERDES;
6264 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6269 if (nxgep->link_notify &&
6270 nxgep->link_check_count > 3 &&
6271 nxgep->nxge_mac_state == NXGE_MAC_STARTED ||
6272 nxgep->statsp->mac_stats.link_up == 1) {
6273 nxgep->statsp->mac_stats.link_up = 0;
6274 nxgep->statsp->mac_stats.link_speed = 0;
6275 nxgep->statsp->mac_stats.link_duplex =
6278 nxge_link_is_down(nxgep);
6279 nxgep->link_notify = B_FALSE;
6288 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6290 nxgep->phy_absent = B_TRUE;
6291 nxgep->statsp->mac_stats.link_up = 0;
6292 nxgep->statsp->mac_stats.link_speed = 0;
6293 nxgep->statsp->mac_stats.link_duplex = 0;
6294 nxge_link_is_down(nxgep);
6295 nxgep->link_notify = B_FALSE;
6297 (void) nxge_xcvr_find(nxgep);
6304 switch (nxgep->chip_id) {
6306 status = nxge_check_mrvl88x2011_link(nxgep, &link_up);
6309 status = nxge_check_nlp2020_link(nxgep, &link_up);
6312 status = nxge_check_bcm8704_link(nxgep, &link_up);
6320 rs = npi_xmac_xpcs_read(nxgep->npi_handle, nxgep->mac.portnum,
6330 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6339 if ((nxgep->link_notify &&
6340 nxgep->nxge_mac_state == NXGE_MAC_STARTED) ||
6341 nxgep->statsp->mac_stats.link_up == 0) {
6342 if (nxge_10g_link_led_on(nxgep) != NXGE_OK)
6344 nxgep->statsp->mac_stats.link_up = 1;
6345 nxgep->statsp->mac_stats.link_speed = 10000;
6346 nxgep->statsp->mac_stats.link_duplex = 2;
6348 nxge_link_is_up(nxgep);
6349 nxgep->link_notify = B_FALSE;
6352 if ((nxgep->link_notify && nxgep->link_check_count > 3 &&
6353 nxgep->nxge_mac_state == NXGE_MAC_STARTED) ||
6354 nxgep->statsp->mac_stats.link_up == 1) {
6355 if (nxge_10g_link_led_off(nxgep) != NXGE_OK)
6357 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6359 nxgep->statsp->mac_stats.link_up = 0;
6360 nxgep->statsp->mac_stats.link_speed = 0;
6361 nxgep->statsp->mac_stats.link_duplex = 0;
6363 nxge_link_is_down(nxgep);
6364 nxgep->link_notify = B_FALSE;
6366 if (nxgep->mac.portmode == PORT_10G_SERDES) {
6371 (void) nxge_xcvr_find(nxgep);
6377 (void) nxge_link_monitor(nxgep, LINK_MONITOR_START);
6378 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_check_10g_link port<%d>",
6383 (void) nxge_check_link_stop(nxgep);
6385 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
6395 nxge_link_is_down(p_nxge_t nxgep)
6400 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_link_is_down"));
6402 statsp = nxgep->statsp;
6407 NXGE_ERROR_MSG((nxgep, NXGE_NOTE, "%s", link_stat_msg));
6410 mac_link_update(nxgep->mach, LINK_STATE_DOWN);
6412 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_link_is_down"));
6418 nxge_link_is_up(p_nxge_t nxgep)
6424 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_link_is_up"));
6426 statsp = nxgep->statsp;
6440 if ((nxgep->mac.portmode == PORT_10G_FIBER) ||
6441 (nxgep->mac.portmode == PORT_10G_COPPER) ||
6442 (nxgep->mac.portmode == PORT_10G_SERDES)) {
6443 (void) npi_xmac_xpcs_read(nxgep->npi_handle, nxgep->mac.portnum,
6445 (void) npi_xmac_xpcs_read(nxgep->npi_handle, nxgep->mac.portnum,
6459 if (nxgep->mac.portmode == PORT_1G_TN1010 ||
6460 nxgep->mac.portmode == PORT_10G_TN1010) {
6462 (void) nxge_set_tn1010_param(nxgep);
6466 * nxgep->portmode) and nxge_setup_xcvr_table (which sets
6467 * the nxgep->xcvr to the proper nxge_xcvr_table_t struct).
6469 if (nxge_xcvr_find(nxgep) != NXGE_OK) {
6470 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
6475 if (nxge_link_init(nxgep) != NXGE_OK) {
6476 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
6484 if (nxge_mac_init(nxgep) != NXGE_OK) {
6485 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
6489 (void) nxge_xif_init(nxgep);
6493 NXGE_ERROR_MSG((nxgep, NXGE_NOTE, "%s", link_stat_msg));
6496 mac_link_update(nxgep->mach, LINK_STATE_UP);
6498 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_link_is_up"));
6504 nxge_dump_tn1010_status_regs(p_nxge_t nxgep)
6508 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6512 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6516 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6520 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6524 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6528 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6532 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6536 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6540 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6544 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6548 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6552 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6556 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6560 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6564 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6568 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6572 nxge_mdio_read(nxgep, nxgep->xcvr_addr,
6611 nxge_serdes_reset(p_nxge_t nxgep)
6615 handle = nxgep->npi_handle;
6626 * It calls nxgep->xcvr.check_link, a member function of
6627 * nxge_xcvr_table_t. But nxgep->xcvr.check_link calls this
6632 nxge_link_monitor(p_nxge_t nxgep, link_mon_enable_t enable)
6637 if (isLDOMguest(nxgep))
6644 if ((nxgep->mac.portmode == PORT_10G_FIBER ||
6645 nxgep->mac.portmode == PORT_10G_COPPER ||
6646 nxgep->mac.portmode == PORT_10G_SERDES) &&
6647 (nxgep->mac.portnum > 1))
6650 if (nxgep->statsp == NULL) {
6655 if (nxgep->statsp->port_stats.lb_mode >= nxge_lb_serdes10g)
6658 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6660 nxgep->mac.portnum, enable));
6662 if (nxgep->mac.linkchkmode == LINKCHK_INTR) {
6663 if ((status = nxge_link_intr(nxgep, LINK_INTR_START))
6672 if (nxge_check_link_stop(nxgep) == CHECK_LINK_STOP)
6678 * of the nxge_xcvr_table and pass "nxgep" as the
6681 if (nxgep->xcvr.check_link) {
6683 (fptrv_t)(nxgep->xcvr.check_link),
6684 nxgep,
6686 MUTEX_ENTER(&nxgep->poll_lock);
6687 nxgep->nxge_link_poll_timerid = timerid;
6688 MUTEX_EXIT(&nxgep->poll_lock);
6689 nxgep->link_check_count ++;
6695 if (nxgep->mac.linkchkmode == LINKCHK_INTR) {
6696 if ((status = nxge_link_intr(nxgep, LINK_INTR_STOP))
6702 MUTEX_ENTER(&nxgep->poll_lock);
6706 if (nxgep->nxge_link_poll_timerid == 0) {
6707 MUTEX_EXIT(&nxgep->poll_lock);
6711 nxgep->poll_state = LINK_MONITOR_STOPPING;
6712 rv = cv_reltimedwait(&nxgep->poll_cv, &nxgep->poll_lock,
6716 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6719 nxgep->mac.portnum, nxgep->poll_state));
6720 nxgep->poll_state = LINK_MONITOR_STOP;
6721 nxgep->nxge_link_poll_timerid = 0;
6724 MUTEX_EXIT(&nxgep->poll_lock);
6727 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
6729 nxgep->mac.portnum, enable));
6738 nxge_check_tn1010_link(p_nxge_t nxgep)
6743 if (nxgep->nxge_magic != NXGE_MAGIC) {
6749 if (nxge_check_link_stop(nxgep) == CHECK_LINK_STOP) {
6753 if (nxgep->statsp->port_stats.lb_mode > nxge_lb_ext10)
6756 if ((status = nxge_tn1010_check(nxgep, &link_up)) != NXGE_OK)
6761 nxge_link_is_up(nxgep);
6763 nxge_link_is_down(nxgep);
6766 * nxge_link_monitor will call (nxgep->xcvr.check_link)
6769 (void) nxge_link_monitor(nxgep, LINK_MONITOR_START);
6774 (void) nxge_link_monitor(nxgep, LINK_MONITOR_START);
6776 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
6786 nxge_tn1010_check(p_nxge_t nxgep, nxge_link_state_t *link_up)
6795 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
6796 phy_port_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
6797 statsp = nxgep->statsp;
6800 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
6810 if ((nxgep->link_notify &&
6811 nxgep->nxge_mac_state == NXGE_MAC_STARTED) ||
6812 nxgep->statsp->mac_stats.link_up == 0) {
6816 nxgep->link_notify = B_FALSE;
6819 if ((nxgep->link_notify && nxgep->link_check_count > 3 &&
6820 nxgep->nxge_mac_state == NXGE_MAC_STARTED) ||
6821 nxgep->statsp->mac_stats.link_up == 1) {
6826 nxgep->link_notify = B_FALSE;
6832 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
6841 nxge_set_promisc(p_nxge_t nxgep, boolean_t on)
6845 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_set_promisc: on %d", on));
6847 nxgep->filter.all_phys_cnt = ((on) ? 1 : 0);
6849 RW_ENTER_WRITER(&nxgep->filter_lock);
6851 if ((status = nxge_rx_mac_disable(nxgep)) != NXGE_OK) {
6854 if ((status = nxge_rx_mac_enable(nxgep)) != NXGE_OK) {
6858 RW_EXIT(&nxgep->filter_lock);
6861 nxgep->statsp->mac_stats.promisc = B_TRUE;
6863 nxgep->statsp->mac_stats.promisc = B_FALSE;
6865 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_set_promisc"));
6869 RW_EXIT(&nxgep->filter_lock);
6870 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_set_promisc: "
6881 p_nxge_t nxgep = (p_nxge_t)arg2;
6892 if (arg2 == NULL || (void *)ldvp->nxgep != arg2) {
6893 nxgep = ldvp->nxgep;
6895 nxgep = ldvp->nxgep;
6897 NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_mif_intr"));
6899 NXGE_DEBUG_MSG((nxgep, INT_CTL, "<== nxge_mif_intr"));
6903 NXGE_DEBUG_MSG((nxgep, INT_CTL, "<== nxge_mif_intr"));
6911 p_nxge_t nxgep = (p_nxge_t)arg2;
6920 if (arg2 == NULL || (void *)ldvp->nxgep != arg2) {
6921 nxgep = ldvp->nxgep;
6925 NXGE_DEBUG_MSG((nxgep, INT_CTL, "==> nxge_mac_intr: "
6928 handle = NXGE_DEV_NPI_HANDLE(nxgep);
6933 statsp = (p_nxge_stats_t)nxgep->statsp;
6934 portn = nxgep->mac.portnum;
6936 NXGE_DEBUG_MSG((nxgep, INT_CTL,
6939 if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
6947 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
6959 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
6964 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
6986 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
7077 } else if (nxgep->mac.porttype == PORT_TYPE_BMAC) {
7085 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
7090 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
7118 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
7124 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
7130 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
7140 NXGE_FM_REPORT_ERROR(nxgep, portn, NULL,
7164 NXGE_DEBUG_MSG((nxgep, INT_CTL, "<== nxge_mac_intr"));
7168 NXGE_ERROR_MSG((nxgep, INT_CTL, "<== nxge_mac_intr"));
7173 nxge_check_bcm8704_link(p_nxge_t nxgep, boolean_t *link_up)
7186 phy_port_addr = nxgep->statsp->mac_stats.xcvr_portn;
7190 (void) nxge_mdio_read(nxgep, phy_port_addr, 0x3, 0xC809, &val_debug);
7193 nxgep->mac.portnum, val_debug);
7194 (void) nxge_mdio_read(nxgep, phy_port_addr, 0x4, 0x18,
7197 nxgep->mac.portnum, val_debug);
7200 (void) npi_xmac_xpcs_read(nxgep->npi_handle, nxgep->mac.portnum,
7205 (void) npi_xmac_xpcs_read(nxgep->npi_handle, nxgep->mac.portnum,
7210 (void) npi_xmac_xpcs_read(nxgep->npi_handle, nxgep->mac.portnum,
7219 status = nxge_mdio_read(nxgep, phy_port_addr, BCM8704_PMA_PMD_DEV_ADDR,
7226 if ((status = nxge_mdio_read(nxgep, phy_port_addr, BCM8704_PCS_DEV_ADDR,
7232 status = nxge_mdio_read(nxgep, phy_port_addr, BCM8704_PHYXS_ADDR,
7237 switch (nxgep->chip_id) {
7250 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "nxge_check_bcm8704_link:"
7251 "Unknown chip ID [0x%x]", nxgep->chip_id));
7261 "Reg 0x20 = 0x%x\n", nxgep->mac.portnum, val2);
7269 "Reg 0x18 = 0x%x\n", nxgep->mac.portnum, val3);
7278 nxgep->mac.portnum);
7292 nxge_check_mrvl88x2011_link(p_nxge_t nxgep, boolean_t *link_up)
7301 phy = nxgep->statsp->mac_stats.xcvr_portn;
7303 MRVL88X2011_RD(nxgep, phy, MRVL_88X2011_USER_DEV1_ADDR,
7311 MRVL88X2011_RD(nxgep, phy, MRVL_88X2011_USER_DEV1_ADDR,
7314 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7320 MRVL88X2011_RD(nxgep, phy, MRVL_88X2011_USER_DEV3_ADDR,
7322 MRVL88X2011_RD(nxgep, phy, MRVL_88X2011_USER_DEV3_ADDR,
7325 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7331 MRVL88X2011_RD(nxgep, phy, MRVL_88X2011_USER_DEV4_ADDR,
7334 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7349 nxge_mrvl88x2011_led(nxgep, MRVL_88X2011_LED_CTL_OFF);
7352 nxge_mrvl88x2011_led(nxgep, MRVL_88X2011_LED_CTL_PCS_ACT);
7355 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7362 nxge_check_nlp2020_link(p_nxge_t nxgep, boolean_t *link_up)
7369 phy = nxgep->statsp->mac_stats.xcvr_portn;
7374 status = nxge_mdio_read(nxgep, phy, NLP2020_PMA_PMD_ADDR,
7379 status = nxge_mdio_read(nxgep, phy, NLP2020_PHY_PCS_ADDR,
7384 status = nxge_mdio_read(nxgep, phy, NLP2020_PHY_XS_ADDR,
7397 if (nxgep->statsp->mac_stats.link_up == 0) {
7398 (void) nxge_nlp2020_i2c_read(nxgep, phy,
7403 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7405 if (nxgep->mac.portmode != PORT_10G_FIBER) {
7406 nxgep->mac.portmode = PORT_10G_FIBER;
7407 (void) nxge_nlp2020_xcvr_init(nxgep);
7411 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7413 if (nxgep->mac.portmode != PORT_10G_FIBER) {
7414 nxgep->mac.portmode = PORT_10G_FIBER;
7415 (void) nxge_nlp2020_xcvr_init(nxgep);
7419 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7423 if (nxgep->mac.portmode != PORT_10G_COPPER) {
7424 nxgep->mac.portmode = PORT_10G_COPPER;
7425 (void) nxge_nlp2020_xcvr_init(nxgep);
7428 (void) nxge_nlp2020_i2c_read(nxgep, phy,
7432 (nxgep->nlp_conn ==
7435 (nxgep->nlp_conn ==
7437 (void) nxge_nlp2020_xcvr_init(nxgep);
7442 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7446 if (nxgep->mac.portmode != PORT_10G_FIBER) {
7447 nxgep->mac.portmode = PORT_10G_FIBER;
7448 (void) nxge_nlp2020_xcvr_init(nxgep);
7454 if (*link_up == B_FALSE && nxgep->statsp->mac_stats.link_up == 1) {
7456 (void) nxge_mdio_write(nxgep, phy,
7458 (void) nxge_mdio_write(nxgep, phy,
7461 nxgep->statsp->mac_stats.link_up == 0) {
7463 (void) nxge_mdio_write(nxgep, phy,
7465 (void) nxge_mdio_write(nxgep, phy,
7467 (void) nxge_mdio_write(nxgep, phy,
7471 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7478 nxge_10g_link_led_on(p_nxge_t nxgep)
7480 if (npi_xmac_xif_led(nxgep->npi_handle, nxgep->mac.portnum, B_TRUE)
7488 nxge_10g_link_led_off(p_nxge_t nxgep)
7490 if (npi_xmac_xif_led(nxgep->npi_handle, nxgep->mac.portnum, B_FALSE)
7498 nxge_hswap_phy_present(p_nxge_t nxgep, uint8_t portn)
7509 if (nxge_is_phy_present(nxgep, ALT_GOA_CLAUSE45_PORT1_ADDR,
7511 nxgep->xcvr_addr = ALT_GOA_CLAUSE45_PORT1_ADDR;
7515 if (nxge_is_phy_present(nxgep, GOA_CLAUSE45_PORT_ADDR_BASE + portn,
7517 nxgep->xcvr_addr = GOA_CLAUSE45_PORT_ADDR_BASE + portn;
7526 if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT0_ADDR0,
7528 nxgep->xcvr_addr = NLP2020_CL45_PORT0_ADDR0;
7530 } else if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT0_ADDR1,
7532 nxgep->xcvr_addr = NLP2020_CL45_PORT0_ADDR1;
7534 } else if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT0_ADDR2,
7536 nxgep->xcvr_addr = NLP2020_CL45_PORT0_ADDR2;
7538 } else if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT0_ADDR3,
7540 nxgep->xcvr_addr = NLP2020_CL45_PORT0_ADDR3;
7546 if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT1_ADDR0,
7548 nxgep->xcvr_addr = NLP2020_CL45_PORT1_ADDR0;
7550 } else if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT1_ADDR1,
7552 nxgep->xcvr_addr = NLP2020_CL45_PORT1_ADDR1;
7554 } else if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT1_ADDR2,
7556 nxgep->xcvr_addr = NLP2020_CL45_PORT1_ADDR2;
7558 } else if (nxge_is_phy_present(nxgep, NLP2020_CL45_PORT1_ADDR3,
7560 nxgep->xcvr_addr = NLP2020_CL45_PORT1_ADDR3;
7575 nxge_is_phy_present(p_nxge_t nxgep, int addr, uint32_t id, uint32_t mask)
7581 pma_pmd_id = nxge_get_cl45_pma_pmd_id(nxgep, addr);
7582 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7586 pcs_id = nxge_get_cl45_pcs_id(nxgep, addr);
7587 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7591 phy_id = nxge_get_cl22_phy_id(nxgep, addr);
7592 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7640 nxge_get_cl45_pma_pmd_id(p_nxge_t nxgep, int phy_port)
7645 npi_handle_t handle = NXGE_DEV_NPI_HANDLE(nxgep);
7647 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
7652 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
7659 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] PMA/PMD "
7666 nxge_get_cl45_pcs_id(p_nxge_t nxgep, int phy_port)
7671 npi_handle_t handle = NXGE_DEV_NPI_HANDLE(nxgep);
7673 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
7678 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
7684 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] PCS "
7691 nxge_get_cl22_phy_id(p_nxge_t nxgep, int phy_port)
7696 npi_handle_t handle = NXGE_DEV_NPI_HANDLE(nxgep);
7699 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
7703 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] "
7710 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] "
7719 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
7720 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] PHY ID [0x%llx]",
7733 * hw_p->niu_type for each nxge instance to figure out nxgep->mac.portmode
7738 nxge_scan_ports_phy(p_nxge_t nxgep, p_nxge_hw_list_t hw_p)
7755 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_scan_ports_phy: "));
7756 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7758 nxgep->niu_type));
7760 if (isLDOMguest(nxgep)) {
7774 pma_pmd_dev_id = nxge_get_cl45_pma_pmd_id(nxgep, i);
7778 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] "
7799 pcs_dev_id = nxge_get_cl45_pcs_id(nxgep, i);
7803 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] PCS "
7847 phy_id = nxge_get_cl22_phy_id(nxgep, i);
7850 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "port[%d] PHY ID"
7889 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7902 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7911 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
7919 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
7967 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
7987 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8029 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8061 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8097 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8103 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8116 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8125 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8134 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8170 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8190 hw_p->xcvr_addr[nxgep->function_num] =
8223 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8241 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8246 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8267 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8271 hw_p->xcvr_addr[nxgep->function_num]
8275 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8289 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8309 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8355 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8359 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8363 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8391 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8401 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8408 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8420 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8424 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8430 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8434 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8441 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8448 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "<== nxge_scan_ports_phy, "
8468 nxge_bcm5464_link_led_off(p_nxge_t nxgep) {
8472 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
8474 NXGE_DEBUG_MSG((nxgep, MIF_CTL, "==> nxge_bcm5464_link_led_off"));
8476 if (nxgep->nxge_hw_p->platform_type == P_NEPTUNE_MARAMBA_P1) {
8478 } else if (nxgep->nxge_hw_p->platform_type == P_NEPTUNE_MARAMBA_P0) {
8501 MUTEX_ENTER(&nxgep->nxge_hw_p->nxge_mdio_lock);
8502 rs = npi_mac_mif_mii_write(nxgep->npi_handle,
8505 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8508 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
8512 rs = npi_mac_mif_mii_write(nxgep->npi_handle,
8515 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8520 MUTEX_EXIT(&nxgep->nxge_hw_p->nxge_mdio_lock);
8524 nxge_mii_get_link_mode(p_nxge_t nxgep)
8532 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mii_get_link_mode"));
8534 statsp = nxgep->statsp;
8540 if ((status = nxge_mii_write(nxgep, xcvr_portn,
8545 if ((status = nxge_mii_write(nxgep, xcvr_portn,
8552 if ((status = nxge_mii_read(nxgep, xcvr_portn,
8558 if ((status = nxge_mii_read(nxgep, xcvr_portn,
8566 nxgep->mac.portmode = PORT_1G_RGMII_FIBER;
8567 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8571 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8575 mode.value, nxgep->mac.portmode));
8577 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8581 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8587 nxge_mac_set_framesize(p_nxge_t nxgep)
8594 NXGE_DEBUG_MSG((nxgep, MAC_CTL, "==> nxge_mac_set_framesize"));
8596 portn = NXGE_GET_PORT_NUM(nxgep->function_num);
8597 handle = nxgep->npi_handle;
8599 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8603 nxgep->mac.minframesize,
8604 nxgep->mac.maxframesize));
8608 nxgep->mac.minframesize,
8609 nxgep->mac.maxframesize,
8612 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8619 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8671 nxge_get_tn1010_speed(p_nxge_t nxgep, uint16_t *speed)
8676 uint8_t portn = NXGE_GET_PORT_NUM(nxgep->function_num);
8682 npi_mac_mif_set_indirect_mode(nxgep->npi_handle, B_TRUE);
8684 phy_port_addr = nxgep->nxge_hw_p->xcvr_addr[portn];
8687 status = nxge_mdio_read(nxgep, phy_port_addr,
8695 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8700 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
8716 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8720 if ((status = nxge_mdio_read(nxgep, phy_port_addr,
8730 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8734 NXGE_DEBUG_MSG((nxgep, MAC_CTL,
8751 * nxgep->mac.portmode
8752 * nxgep->statsp->mac_stats.link_speed
8753 * nxgep->statsp->mac_stats.xcvr_inuse
8756 nxge_set_tn1010_param(p_nxge_t nxgep)
8760 if (nxge_get_tn1010_speed(nxgep, &speed) != NXGE_OK) {
8761 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8767 nxgep->mac.portmode = PORT_1G_TN1010;
8768 nxgep->statsp->mac_stats.link_speed = 1000;
8769 nxgep->statsp->mac_stats.xcvr_inuse = PCS_XCVR;
8771 nxgep->mac.portmode = PORT_10G_TN1010;
8772 nxgep->statsp->mac_stats.link_speed = 10000;
8773 nxgep->statsp->mac_stats.xcvr_inuse = XPCS_XCVR;
8780 nxge_mii_dump(p_nxge_t nxgep)
8792 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL, "==> nxge_mii_dump"));
8794 statsp = nxgep->statsp;
8800 (void) nxge_mii_read(nxgep, nxgep->statsp->mac_stats.xcvr_portn,
8803 (void) nxge_mii_read(nxgep, nxgep->statsp->mac_stats.xcvr_portn,
8806 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8811 (void) nxge_mii_read(nxgep,
8812 nxgep->statsp->mac_stats.xcvr_portn,
8815 (void) nxge_mii_read(nxgep,
8816 nxgep->statsp->mac_stats.xcvr_portn,
8819 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8824 (void) nxge_mii_read(nxgep,
8825 nxgep->statsp->mac_stats.xcvr_portn,
8828 (void) nxge_mii_read(nxgep,
8829 nxgep->statsp->mac_stats.xcvr_portn,
8835 (void) nxge_mii_read(nxgep,
8836 nxgep->statsp->mac_stats.xcvr_portn,
8839 (void) nxge_mii_read(nxgep,
8840 nxgep->statsp->mac_stats.xcvr_portn,
8844 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8848 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,
8856 (void) nxge_mii_write(nxgep, xcvr_portn,
8859 (void) nxge_mii_read(nxgep, xcvr_portn,
8862 (void) nxge_mii_write(nxgep, xcvr_portn,
8865 (void) nxge_mii_read(nxgep, xcvr_portn,
8869 NXGE_ERROR_MSG((nxgep, NXGE_ERR_CTL,