Lines Matching defs:mxfep
172 #define KIOIP KSTAT_INTR_PTR(mxfep->mxfe_intrstat)
304 mxfe_t *mxfep;
390 mxfep = kmem_zalloc(sizeof (mxfe_t), KM_SLEEP);
391 ddi_set_driver_private(dip, mxfep);
394 if (ddi_get_iblock_cookie(dip, 0, &mxfep->mxfe_icookie)
398 kmem_free(mxfep, sizeof (mxfe_t));
402 mxfep->mxfe_dip = dip;
403 mxfep->mxfe_cardp = cardp;
404 mxfep->mxfe_phyaddr = -1;
405 mxfep->mxfe_cachesize = cachesize;
408 mxfep->mxfe_adv_aneg = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
410 mxfep->mxfe_adv_100T4 = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
412 mxfep->mxfe_adv_100fdx = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
414 mxfep->mxfe_adv_100hdx = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
416 mxfep->mxfe_adv_10fdx = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
418 mxfep->mxfe_adv_10hdx = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
428 mutex_init(&mxfep->mxfe_xmtlock, NULL, MUTEX_DRIVER,
429 mxfep->mxfe_icookie);
430 mutex_init(&mxfep->mxfe_intrlock, NULL, MUTEX_DRIVER,
431 mxfep->mxfe_icookie);
448 mxfep->mxfe_intrstat = kstat_create("mxfe", inst, "intr", "controller",
450 if (mxfep->mxfe_intrstat == NULL) {
454 kstat_install(mxfep->mxfe_intrstat);
459 if (ddi_regs_map_setup(dip, 1, (caddr_t *)&mxfep->mxfe_regs,
460 0, 0, &mxfe_devattr, &mxfep->mxfe_regshandle)) {
468 if ((mxfe_allocrxring(mxfep) != DDI_SUCCESS) ||
469 (mxfe_alloctxring(mxfep) != DDI_SUCCESS)) {
475 mutex_enter(&mxfep->mxfe_intrlock);
476 mutex_enter(&mxfep->mxfe_xmtlock);
477 if (!mxfe_initialize(mxfep)) {
478 mutex_exit(&mxfep->mxfe_xmtlock);
479 mutex_exit(&mxfep->mxfe_intrlock);
482 mutex_exit(&mxfep->mxfe_xmtlock);
483 mutex_exit(&mxfep->mxfe_intrlock);
486 mxfep->mxfe_sromwidth = mxfe_sromwidth(mxfep);
492 mxfe_getfactaddr(mxfep, mxfep->mxfe_curraddr);
493 mxfep->mxfe_promisc = B_FALSE;
498 if (ddi_add_intr(dip, 0, NULL, NULL, mxfe_intr, (caddr_t)mxfep) !=
512 macp->m_driver = mxfep;
514 macp->m_src_addr = mxfep->mxfe_curraddr;
520 if (mac_register(macp, &mxfep->mxfe_mh) == DDI_SUCCESS) {
528 if (mxfep->mxfe_icookie != NULL) {
529 ddi_remove_intr(dip, 0, mxfep->mxfe_icookie);
531 if (mxfep->mxfe_intrstat) {
532 kstat_delete(mxfep->mxfe_intrstat);
534 mutex_destroy(&mxfep->mxfe_intrlock);
535 mutex_destroy(&mxfep->mxfe_xmtlock);
537 mxfe_freerxring(mxfep);
538 mxfe_freetxring(mxfep);
540 if (mxfep->mxfe_regshandle != NULL) {
541 ddi_regs_map_free(&mxfep->mxfe_regshandle);
543 kmem_free(mxfep, sizeof (mxfe_t));
550 mxfe_t *mxfep;
552 mxfep = ddi_get_driver_private(dip);
553 if (mxfep == NULL) {
561 if (mac_unregister(mxfep->mxfe_mh) != 0) {
566 mutex_enter(&mxfep->mxfe_intrlock);
567 mutex_enter(&mxfep->mxfe_xmtlock);
568 mxfep->mxfe_flags &= ~MXFE_RUNNING;
569 mxfe_stopall(mxfep);
570 mutex_exit(&mxfep->mxfe_xmtlock);
571 mutex_exit(&mxfep->mxfe_intrlock);
574 ddi_remove_intr(dip, 0, mxfep->mxfe_icookie);
577 kstat_delete(mxfep->mxfe_intrstat);
582 mxfe_freerxring(mxfep);
583 mxfe_freetxring(mxfep);
585 ddi_regs_map_free(&mxfep->mxfe_regshandle);
586 mutex_destroy(&mxfep->mxfe_intrlock);
587 mutex_destroy(&mxfep->mxfe_xmtlock);
589 kmem_free(mxfep, sizeof (mxfe_t));
594 mutex_enter(&mxfep->mxfe_intrlock);
595 mutex_enter(&mxfep->mxfe_xmtlock);
596 mxfep->mxfe_flags |= MXFE_SUSPENDED;
597 mxfe_stopall(mxfep);
598 mutex_exit(&mxfep->mxfe_xmtlock);
599 mutex_exit(&mxfep->mxfe_intrlock);
609 mxfe_t *mxfep;
611 if ((mxfep = ddi_get_driver_private(dip)) == NULL) {
615 mutex_enter(&mxfep->mxfe_intrlock);
616 mutex_enter(&mxfep->mxfe_xmtlock);
618 mxfep->mxfe_flags &= ~MXFE_SUSPENDED;
621 if (!mxfe_initialize(mxfep)) {
622 mxfe_error(mxfep->mxfe_dip, "unable to resume chip!");
623 mxfep->mxfe_flags |= MXFE_SUSPENDED;
624 mutex_exit(&mxfep->mxfe_intrlock);
625 mutex_exit(&mxfep->mxfe_xmtlock);
630 if (mxfep->mxfe_flags & MXFE_RUNNING) {
631 mxfe_startall(mxfep);
635 mutex_exit(&mxfep->mxfe_xmtlock);
636 mutex_exit(&mxfep->mxfe_intrlock);
644 mxfe_t *mxfep;
646 if ((mxfep = ddi_get_driver_private(dip)) == NULL) {
651 SETBIT(mxfep, CSR_PAR, PAR_RESET);
667 mxfe_t *mxfep = arg;
670 mutex_enter(&mxfep->mxfe_intrlock);
671 mutex_enter(&mxfep->mxfe_xmtlock);
673 mxfep->mxfe_promisc = on;
675 if ((mxfep->mxfe_flags & (MXFE_RUNNING|MXFE_SUSPENDED)) ==
678 SETBIT(mxfep, CSR_NAR, NAR_RX_PROMISC);
680 CLRBIT(mxfep, CSR_NAR, NAR_RX_PROMISC);
683 mutex_exit(&mxfep->mxfe_xmtlock);
684 mutex_exit(&mxfep->mxfe_intrlock);
692 mxfe_t *mxfep = arg;
694 mutex_enter(&mxfep->mxfe_intrlock);
695 mutex_enter(&mxfep->mxfe_xmtlock);
696 bcopy(macaddr, mxfep->mxfe_curraddr, ETHERADDRL);
698 mxfe_resetall(mxfep);
700 mutex_exit(&mxfep->mxfe_intrlock);
701 mutex_exit(&mxfep->mxfe_xmtlock);
709 mxfe_t *mxfep = arg;
712 mutex_enter(&mxfep->mxfe_xmtlock);
714 if (mxfep->mxfe_flags & MXFE_SUSPENDED) {
715 mutex_exit(&mxfep->mxfe_xmtlock);
723 if (!mxfe_send(mxfep, mp)) {
729 mutex_exit(&mxfep->mxfe_xmtlock);
738 mxfe_initialize(mxfe_t *mxfep)
744 ASSERT(mutex_owned(&mxfep->mxfe_intrlock));
745 ASSERT(mutex_owned(&mxfep->mxfe_xmtlock));
748 SETBIT(mxfep, CSR_PAR, PAR_RESET);
751 val = GETCSR(mxfep, CSR_PAR);
757 mxfe_error(mxfep->mxfe_dip, "timed out waiting for reset!");
765 switch (mxfep->mxfe_cachesize) {
780 PUTCSR(mxfep, CSR_PAR, par);
782 mxfe_resetrings(mxfep);
785 (void) GETCSR(mxfep, CSR_LPC);
788 nar = GETCSR(mxfep, CSR_NAR);
794 if (mxfep->mxfe_promisc) {
799 PUTCSR(mxfep, CSR_NAR, nar);
801 mxfe_send_setup(mxfep);
811 mxfe_sromwidth(mxfe_t *mxfep)
819 PUTCSR(mxfep, CSR_SPR, eeread & ~SPR_SROM_CHIP);
821 PUTCSR(mxfep, CSR_SPR, eeread);
826 PUTCSR(mxfep, CSR_SPR, eeread | val);
828 PUTCSR(mxfep, CSR_SPR, eeread | val | SPR_SROM_CLOCK);
832 PUTCSR(mxfep, CSR_SPR, eeread);
835 PUTCSR(mxfep, CSR_SPR, eeread | SPR_SROM_CLOCK);
837 if (!(GETCSR(mxfep, CSR_SPR) & SPR_SROM_DOUT)) {
838 PUTCSR(mxfep, CSR_SPR, eeread);
842 PUTCSR(mxfep, CSR_SPR, eeread);
847 PUTCSR(mxfep, CSR_SPR, eeread &~ SPR_SROM_CHIP);
860 mxfe_readsromword(mxfe_t *mxfep, unsigned romaddr)
871 addrlen = mxfep->mxfe_sromwidth;
879 PUTCSR(mxfep, CSR_SPR, eeread & ~SPR_SROM_CHIP);
880 PUTCSR(mxfep, CSR_SPR, eeread);
885 PUTCSR(mxfep, CSR_SPR, eeread | val);
887 PUTCSR(mxfep, CSR_SPR, eeread | val | SPR_SROM_CLOCK);
891 PUTCSR(mxfep, CSR_SPR, eeread);
894 PUTCSR(mxfep, CSR_SPR, eeread | SPR_SROM_CLOCK);
897 if (GETCSR(mxfep, CSR_SPR) & SPR_SROM_DOUT) {
900 PUTCSR(mxfep, CSR_SPR, eeread);
905 PUTCSR(mxfep, CSR_SPR, eeread &~ SPR_SROM_CHIP);
918 mxfe_readsrom(mxfe_t *mxfep, unsigned romaddr, unsigned len, void *dest)
925 word = mxfe_readsromword(mxfep, romaddr + i);
933 mxfe_getfactaddr(mxfe_t *mxfep, uchar_t *eaddr)
939 word = mxfe_readsromword(mxfep, SROM_ENADDR / 2);
944 mxfe_readsrom(mxfep, word / 2, ETHERADDRL / 2, eaddr);
951 mxfe_startphy(mxfe_t *mxfep)
953 switch (MXFE_MODEL(mxfep)) {
955 mxfe_startphymii(mxfep);
958 mxfe_startphynway(mxfep);
964 mxfe_stopphy(mxfe_t *mxfep)
970 PUTCSR(mxfep, CSR_TIMER, 0);
972 switch (MXFE_MODEL(mxfep)) {
975 mxfe_miiwrite(mxfep, mxfep->mxfe_phyaddr, MII_CONTROL,
981 PUTCSR(mxfep, CSR_SIA, SIA_RESET);
983 CLRBIT(mxfep, CSR_TCTL, TCTL_PWR | TCTL_ANE);
984 nar = GETCSR(mxfep, CSR_NAR);
987 PUTCSR(mxfep, CSR_NAR, nar);
994 if (!mxfep->mxfe_resetting) {
995 mxfep->mxfe_linkup = LINK_STATE_UNKNOWN;
996 mxfep->mxfe_ifspeed = 0;
997 mxfep->mxfe_duplex = LINK_DUPLEX_UNKNOWN;
998 if (mxfep->mxfe_flags & MXFE_RUNNING)
999 mxfe_reportlink(mxfep);
1007 mxfe_startnway(mxfe_t *mxfep)
1014 if (mxfep->mxfe_nwaystate != MXFE_NOLINK) {
1016 mxfep->mxfe_nwaystate);
1020 if (mxfep->mxfe_adv_aneg == 0) {
1025 nar = GETCSR(mxfep, CSR_NAR);
1030 mxfe_stopmac(mxfep);
1035 tctl = GETCSR(mxfep, CSR_TCTL);
1038 if (mxfep->mxfe_adv_100fdx) {
1041 if (mxfep->mxfe_adv_100hdx) {
1044 if (mxfep->mxfe_adv_10fdx) {
1047 if (mxfep->mxfe_adv_10hdx) {
1054 PUTCSR(mxfep, CSR_NAR, nar);
1057 PUTCSR(mxfep, CSR_TCTL, tctl);
1061 PUTCSR(mxfep, CSR_TSTAT, TSTAT_ANS_START);
1065 mxfe_startmac(mxfep);
1068 PUTCSR(mxfep, CSR_MXMAGIC, 0x0b2c0000);
1069 PUTCSR(mxfep, CSR_ACOMP, 0x11000);
1071 mxfep->mxfe_nwaystate = MXFE_NWAYCHECK;
1075 mxfe_checklinknway(mxfe_t *mxfep)
1080 DBG(DPHY, "NWay check, state %x", mxfep->mxfe_nwaystate);
1081 tstat = GETCSR(mxfep, CSR_TSTAT);
1084 mxfep->mxfe_anlpar = lpar;
1086 mxfep->mxfe_aner |= MII_AN_EXP_LPCANAN;
1088 mxfep->mxfe_aner &= ~(MII_AN_EXP_LPCANAN);
1096 mxfep->mxfe_bmsr &= ~MII_STATUS_ANDONE;
1098 mxfep->mxfe_bmsr |= ~MII_STATUS_ANDONE;
1102 mxfep->mxfe_linkup = LINK_STATE_DOWN;
1103 mxfep->mxfe_ifspeed = 0;
1104 mxfep->mxfe_duplex = LINK_DUPLEX_UNKNOWN;
1105 mxfep->mxfe_nwaystate = MXFE_NOLINK;
1106 mxfe_reportlink(mxfep);
1107 mxfe_startnway(mxfep);
1115 if (mxfep->mxfe_adv_aneg) {
1119 mxfep->mxfe_linkup = LINK_STATE_UP;
1120 anlpar = mxfep->mxfe_anlpar;
1126 mxfep->mxfe_adv_100fdx) {
1127 mxfep->mxfe_ifspeed = 100000000;
1128 mxfep->mxfe_duplex = LINK_DUPLEX_FULL;
1130 mxfep->mxfe_adv_100hdx) {
1131 mxfep->mxfe_ifspeed = 100000000;
1132 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1134 mxfep->mxfe_adv_10fdx) {
1135 mxfep->mxfe_ifspeed = 10000000;
1136 mxfep->mxfe_duplex = LINK_DUPLEX_FULL;
1138 mxfep->mxfe_adv_10hdx) {
1139 mxfep->mxfe_ifspeed = 10000000;
1140 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1142 mxfep->mxfe_ifspeed = 0;
1147 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1150 mxfep->mxfe_ifspeed = 100000000;
1152 mxfep->mxfe_ifspeed = 10000000;
1157 mxfep->mxfe_linkup = LINK_STATE_UP;
1158 if (mxfep->mxfe_adv_100fdx) {
1159 mxfep->mxfe_ifspeed = 100000000;
1160 mxfep->mxfe_duplex = LINK_DUPLEX_FULL;
1161 } else if (mxfep->mxfe_adv_100hdx) {
1162 mxfep->mxfe_ifspeed = 100000000;
1163 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1164 } else if (mxfep->mxfe_adv_10fdx) {
1165 mxfep->mxfe_ifspeed = 10000000;
1166 mxfep->mxfe_duplex = LINK_DUPLEX_FULL;
1167 } else if (mxfep->mxfe_adv_10hdx) {
1168 mxfep->mxfe_ifspeed = 10000000;
1169 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1171 mxfep->mxfe_ifspeed = 0;
1174 mxfe_reportlink(mxfep);
1175 mxfep->mxfe_nwaystate = MXFE_GOODLINK;
1179 mxfe_startphynway(mxfe_t *mxfep)
1182 PUTCSR(mxfep, CSR_SIA, SIA_NRESET);
1185 mxfep->mxfe_nwaystate = MXFE_NOLINK;
1186 mxfep->mxfe_bmsr = MII_STATUS_CANAUTONEG |
1189 mxfep->mxfe_cap_aneg =
1190 mxfep->mxfe_cap_100fdx = mxfep->mxfe_cap_100hdx =
1191 mxfep->mxfe_cap_10fdx = mxfep->mxfe_cap_10hdx = 1;
1194 mxfep->mxfe_phyaddr = 0;
1195 mxfep->mxfe_phyinuse = XCVR_100X;
1196 mxfep->mxfe_phyid = 0;
1199 mxfep->mxfe_adv_100T4 = 0;
1200 mxfep->mxfe_cap_100T4 = 0;
1203 if ((!mxfep->mxfe_adv_100fdx) &&
1204 (!mxfep->mxfe_adv_100hdx) &&
1205 (!mxfep->mxfe_adv_10fdx) &&
1206 (!mxfep->mxfe_adv_10hdx)) {
1207 mxfe_error(mxfep->mxfe_dip, "No valid link mode selected.");
1208 mxfe_error(mxfep->mxfe_dip, "Powering down PHY.");
1209 mxfe_stopphy(mxfep);
1210 mxfep->mxfe_linkup = LINK_STATE_DOWN;
1211 if (mxfep->mxfe_flags & MXFE_RUNNING)
1212 mxfe_reportlink(mxfep);
1216 if (mxfep->mxfe_adv_aneg == 0) {
1221 nar = GETCSR(mxfep, CSR_NAR);
1222 tctl = GETCSR(mxfep, CSR_TCTL);
1228 if (mxfep->mxfe_adv_100fdx) {
1230 } else if (mxfep->mxfe_adv_100hdx) {
1232 } else if (mxfep->mxfe_adv_10fdx) {
1234 } else { /* mxfep->mxfe_adv_10hdx */
1238 PUTCSR(mxfep, CSR_NAR, nar);
1239 PUTCSR(mxfep, CSR_TCTL, tctl);
1242 PUTCSR(mxfep, CSR_MXMAGIC, 0x0b2c0000);
1243 PUTCSR(mxfep, CSR_ACOMP, 0x11000);
1245 mxfe_startnway(mxfep);
1247 PUTCSR(mxfep, CSR_TIMER, TIMER_LOOP |
1255 mxfe_startphymii(mxfe_t *mxfep)
1266 mxfep->mxfe_phyaddr = -1;
1270 bmsr = mxfe_miiread(mxfep, phyaddr, MII_STATUS);
1272 mxfep->mxfe_phyaddr = phyaddr;
1277 phyidr1 = mxfe_miiread(mxfep, phyaddr, MII_PHYIDH);
1278 phyidr2 = mxfe_miiread(mxfep, phyaddr, MII_PHYIDL);
1279 mxfep->mxfe_phyid = (phyidr1 << 16) | (phyidr2);
1291 mxfep->mxfe_phyinuse = XCVR_100T4;
1293 mxfep->mxfe_phyinuse = XCVR_100X;
1297 mxfep->mxfe_cap_aneg = mxfep->mxfe_cap_100T4 =
1298 mxfep->mxfe_cap_100fdx = mxfep->mxfe_cap_100hdx =
1299 mxfep->mxfe_cap_10fdx = mxfep->mxfe_cap_10hdx = 1;
1302 DBG(DPHY, "bmsr = %x", mxfe_miiread(mxfep,
1303 mxfep->mxfe_phyaddr, MII_STATUS));
1304 DBG(DPHY, "anar = %x", mxfe_miiread(mxfep,
1305 mxfep->mxfe_phyaddr, MII_AN_ADVERT));
1306 DBG(DPHY, "anlpar = %x", mxfe_miiread(mxfep,
1307 mxfep->mxfe_phyaddr, MII_AN_LPABLE));
1308 DBG(DPHY, "aner = %x", mxfe_miiread(mxfep,
1309 mxfep->mxfe_phyaddr, MII_AN_EXPANSION));
1314 mxfe_miiwrite(mxfep, phyaddr, MII_CONTROL, MII_CONTROL_RESET);
1321 if (mxfe_miiread(mxfep, phyaddr, MII_CONTROL) &
1329 mxfe_error(mxfep->mxfe_dip, "timeout waiting on phy to reset");
1335 bmsr = mxfe_miiread(mxfep, phyaddr, MII_STATUS);
1336 bmcr = mxfe_miiread(mxfep, phyaddr, MII_CONTROL);
1337 anar = mxfe_miiread(mxfep, phyaddr, MII_AN_ADVERT);
1345 mxfep->mxfe_adv_100T4 = 0;
1346 mxfep->mxfe_cap_100T4 = 0;
1349 mxfep->mxfe_adv_100fdx = 0;
1350 mxfep->mxfe_cap_100fdx = 0;
1353 mxfep->mxfe_adv_100hdx = 0;
1354 mxfep->mxfe_cap_100hdx = 0;
1357 mxfep->mxfe_adv_10fdx = 0;
1358 mxfep->mxfe_cap_10fdx = 0;
1361 mxfep->mxfe_adv_10hdx = 0;
1362 mxfep->mxfe_cap_10hdx = 0;
1365 mxfep->mxfe_adv_aneg = 0;
1366 mxfep->mxfe_cap_aneg = 0;
1370 if (mxfep->mxfe_adv_100T4) {
1374 if (mxfep->mxfe_adv_100fdx) {
1378 if (mxfep->mxfe_adv_100hdx) {
1382 if (mxfep->mxfe_adv_10fdx) {
1386 if (mxfep->mxfe_adv_10hdx) {
1395 mxfe_error(mxfep->mxfe_dip, "No valid link mode selected.");
1396 mxfe_error(mxfep->mxfe_dip, "Powering down PHY.");
1397 mxfe_stopphy(mxfep);
1398 mxfep->mxfe_linkup = LINK_STATE_DOWN;
1399 if (mxfep->mxfe_flags & MXFE_RUNNING)
1400 mxfe_reportlink(mxfep);
1404 if ((mxfep->mxfe_adv_aneg) && (bmsr & MII_STATUS_CANAUTONEG)) {
1409 if (mxfep->mxfe_adv_100fdx) {
1411 } else if (mxfep->mxfe_adv_100hdx) {
1413 } else if (mxfep->mxfe_adv_10fdx) {
1422 mxfe_miiwrite(mxfep, phyaddr, MII_AN_ADVERT, anar);
1424 mxfe_miiwrite(mxfep, phyaddr, MII_CONTROL, bmcr);
1429 PUTCSR(mxfep, CSR_TIMER, TIMER_LOOP |
1434 mxfe_reportlink(mxfe_t *mxfep)
1438 if (mxfep->mxfe_ifspeed != mxfep->mxfe_lastifspeed) {
1439 mxfep->mxfe_lastifspeed = mxfep->mxfe_ifspeed;
1442 if (mxfep->mxfe_duplex != mxfep->mxfe_lastduplex) {
1443 mxfep->mxfe_lastduplex = mxfep->mxfe_duplex;
1446 if (mxfep->mxfe_linkup != mxfep->mxfe_lastlinkup) {
1447 mxfep->mxfe_lastlinkup = mxfep->mxfe_linkup;
1451 mac_link_update(mxfep->mxfe_mh, mxfep->mxfe_linkup);
1455 mxfe_checklink(mxfe_t *mxfep)
1457 if ((mxfep->mxfe_flags & MXFE_RUNNING) == 0)
1460 if ((mxfep->mxfe_txstall_time != 0) &&
1461 (gethrtime() > mxfep->mxfe_txstall_time) &&
1462 (mxfep->mxfe_txavail != MXFE_TXRING)) {
1463 mxfep->mxfe_txstall_time = 0;
1464 mxfe_error(mxfep->mxfe_dip, "TX stall detected!");
1465 mxfe_resetall(mxfep);
1469 switch (MXFE_MODEL(mxfep)) {
1471 mxfe_checklinkmii(mxfep);
1474 mxfe_checklinknway(mxfep);
1479 mxfe_checklinkmii(mxfe_t *mxfep)
1489 bmsr = mxfe_miiread(mxfep, mxfep->mxfe_phyaddr, MII_STATUS);
1490 bmsr = mxfe_miiread(mxfep, mxfep->mxfe_phyaddr, MII_STATUS);
1491 bmcr = mxfe_miiread(mxfep, mxfep->mxfe_phyaddr, MII_CONTROL);
1492 anar = mxfe_miiread(mxfep, mxfep->mxfe_phyaddr, MII_AN_ADVERT);
1493 anlpar = mxfe_miiread(mxfep, mxfep->mxfe_phyaddr, MII_AN_LPABLE);
1494 aner = mxfe_miiread(mxfep, mxfep->mxfe_phyaddr, MII_AN_EXPANSION);
1496 mxfep->mxfe_bmsr = bmsr;
1497 mxfep->mxfe_anlpar = anlpar;
1498 mxfep->mxfe_aner = aner;
1501 mxfe_error(mxfep->mxfe_dip, "Remote fault detected.");
1504 mxfe_error(mxfep->mxfe_dip, "Jabber condition detected.");
1508 mxfep->mxfe_ifspeed = 0;
1509 mxfep->mxfe_duplex = LINK_DUPLEX_UNKNOWN;
1510 mxfep->mxfe_linkup = LINK_STATE_DOWN;
1511 mxfe_reportlink(mxfep);
1516 mxfep->mxfe_linkup = LINK_STATE_UP;
1521 mxfep->mxfe_ifspeed = 100000000;
1523 mxfep->mxfe_ifspeed = 10000000;
1526 mxfep->mxfe_duplex = LINK_DUPLEX_FULL;
1528 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1532 mxfep->mxfe_ifspeed = 0;
1533 mxfep->mxfe_duplex = LINK_DUPLEX_UNKNOWN;
1535 mxfep->mxfe_ifspeed = 100000000;
1536 mxfep->mxfe_duplex = LINK_DUPLEX_FULL;
1538 mxfep->mxfe_ifspeed = 100000000;
1539 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1541 mxfep->mxfe_ifspeed = 100000000;
1542 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1544 mxfep->mxfe_ifspeed = 10000000;
1545 mxfep->mxfe_duplex = LINK_DUPLEX_FULL;
1547 mxfep->mxfe_ifspeed = 10000000;
1548 mxfep->mxfe_duplex = LINK_DUPLEX_HALF;
1550 mxfep->mxfe_ifspeed = 0;
1551 mxfep->mxfe_duplex = LINK_DUPLEX_UNKNOWN;
1554 mxfe_reportlink(mxfep);
1558 mxfe_miitristate(mxfe_t *mxfep)
1561 PUTCSR(mxfep, CSR_SPR, val);
1563 PUTCSR(mxfep, CSR_SPR, val | SPR_MII_CLOCK);
1568 mxfe_miiwritebit(mxfe_t *mxfep, uint8_t bit)
1571 PUTCSR(mxfep, CSR_SPR, val);
1573 PUTCSR(mxfep, CSR_SPR, val | SPR_MII_CLOCK);
1578 mxfe_miireadbit(mxfe_t *mxfep)
1582 PUTCSR(mxfep, CSR_SPR, val);
1584 bit = (GETCSR(mxfep, CSR_SPR) & SPR_MII_DIN) ? 1 : 0;
1585 PUTCSR(mxfep, CSR_SPR, val | SPR_MII_CLOCK);
1591 mxfe_miiread(mxfe_t *mxfep, int phy, int reg)
1593 switch (MXFE_MODEL(mxfep)) {
1595 return (mxfe_miiread98713(mxfep, phy, reg));
1602 mxfe_miireadgeneral(mxfe_t *mxfep, int phy, int reg)
1609 mxfe_miiwritebit(mxfep, 1);
1613 mxfe_miiwritebit(mxfep, 0);
1614 mxfe_miiwritebit(mxfep, 1);
1617 mxfe_miiwritebit(mxfep, 1);
1618 mxfe_miiwritebit(mxfep, 0);
1622 mxfe_miiwritebit(mxfep, (phy & i) ? 1 : 0);
1627 mxfe_miiwritebit(mxfep, (reg & i) ? 1 : 0);
1631 mxfe_miitristate(mxfep);
1632 mxfe_miiwritebit(mxfep, 0);
1637 value |= mxfe_miireadbit(mxfep);
1639 mxfe_miitristate(mxfep);
1644 mxfe_miiread98713(mxfe_t *mxfep, int phy, int reg)
1652 nar = GETCSR(mxfep, CSR_NAR);
1653 PUTCSR(mxfep, CSR_NAR, nar & ~NAR_PORTSEL);
1654 retval = mxfe_miireadgeneral(mxfep, phy, reg);
1655 PUTCSR(mxfep, CSR_NAR, nar);
1660 mxfe_miiwrite(mxfe_t *mxfep, int phy, int reg, uint16_t val)
1662 switch (MXFE_MODEL(mxfep)) {
1664 mxfe_miiwrite98713(mxfep, phy, reg, val);
1672 mxfe_miiwritegeneral(mxfe_t *mxfep, int phy, int reg, uint16_t val)
1678 mxfe_miiwritebit(mxfep, 1);
1682 mxfe_miiwritebit(mxfep, 0);
1683 mxfe_miiwritebit(mxfep, 1);
1686 mxfe_miiwritebit(mxfep, 0);
1687 mxfe_miiwritebit(mxfep, 1);
1691 mxfe_miiwritebit(mxfep, (phy & i) ? 1 : 0);
1696 mxfe_miiwritebit(mxfep, (reg & i) ? 1 : 0);
1700 mxfe_miitristate(mxfep);
1701 mxfe_miiwritebit(mxfep, 0);
1705 mxfe_miiwritebit(mxfep, (val & i) ? 1 : 0);
1709 mxfe_miitristate(mxfep);
1713 mxfe_miiwrite98713(mxfe_t *mxfep, int phy, int reg, uint16_t val)
1720 nar = GETCSR(mxfep, CSR_NAR);
1721 PUTCSR(mxfep, CSR_NAR, nar & ~NAR_PORTSEL);
1722 mxfe_miiwritegeneral(mxfep, phy, reg, val);
1723 PUTCSR(mxfep, CSR_NAR, nar);
1729 mxfe_t *mxfep = arg;
1732 mutex_enter(&mxfep->mxfe_intrlock);
1733 mutex_enter(&mxfep->mxfe_xmtlock);
1735 mxfe_startall(mxfep);
1736 mxfep->mxfe_flags |= MXFE_RUNNING;
1738 mutex_exit(&mxfep->mxfe_xmtlock);
1739 mutex_exit(&mxfep->mxfe_intrlock);
1746 mxfe_t *mxfep = arg;
1749 mutex_enter(&mxfep->mxfe_intrlock);
1750 mutex_enter(&mxfep->mxfe_xmtlock);
1752 mxfe_stopall(mxfep);
1753 mxfep->mxfe_flags &= ~MXFE_RUNNING;
1755 mutex_exit(&mxfep->mxfe_xmtlock);
1756 mutex_exit(&mxfep->mxfe_intrlock);
1760 mxfe_startmac(mxfe_t *mxfep)
1763 ASSERT(mutex_owned(&mxfep->mxfe_intrlock));
1764 ASSERT(mutex_owned(&mxfep->mxfe_xmtlock));
1767 SETBIT(mxfep, CSR_NAR, NAR_TX_ENABLE | NAR_RX_ENABLE);
1769 if (mxfep->mxfe_txavail != MXFE_TXRING)
1770 PUTCSR(mxfep, CSR_TDR, 0);
1773 if (mxfep->mxfe_flags & MXFE_RUNNING)
1774 mac_tx_update(mxfep->mxfe_mh);
1778 mxfe_stopmac(mxfe_t *mxfep)
1783 ASSERT(mutex_owned(&mxfep->mxfe_intrlock));
1784 ASSERT(mutex_owned(&mxfep->mxfe_xmtlock));
1786 CLRBIT(mxfep, CSR_NAR, NAR_TX_ENABLE | NAR_RX_ENABLE);
1798 if ((GETCSR(mxfep, CSR_SR) & (SR_TX_STATE | SR_RX_STATE)) == 0)
1804 PUTCSR(mxfep, CSR_SR, INT_RXSTOPPED | INT_TXSTOPPED);
1808 mxfe_resetrings(mxfe_t *mxfep)
1813 PUTCSR(mxfep, CSR_RDB, 0);
1814 PUTCSR(mxfep, CSR_TDB, 0);
1817 mxfep->mxfe_rxhead = 0;
1818 mxfep->mxfe_txreclaim = 0;
1819 mxfep->mxfe_txsend = 0;
1820 mxfep->mxfe_txavail = MXFE_TXRING;
1824 mxfe_desc_t *tmdp = &mxfep->mxfe_txdescp[i];
1829 PUTTXDESC(mxfep, tmdp->desc_status, 0);
1830 PUTTXDESC(mxfep, tmdp->desc_control, control);
1831 PUTTXDESC(mxfep, tmdp->desc_buffer1, 0);
1832 PUTTXDESC(mxfep, tmdp->desc_buffer2, 0);
1833 SYNCTXDESC(mxfep, i, DDI_DMA_SYNC_FORDEV);
1835 PUTCSR(mxfep, CSR_TDB, mxfep->mxfe_txdesc_paddr);
1839 mxfe_rxbuf_t *rxb = mxfep->mxfe_rxbufs[i];
1840 mxfe_desc_t *rmdp = &mxfep->mxfe_rxdescp[i];
1847 PUTRXDESC(mxfep, rmdp->desc_buffer1, rxb->rxb_paddr);
1848 PUTRXDESC(mxfep, rmdp->desc_buffer2, 0);
1849 PUTRXDESC(mxfep, rmdp->desc_control, control);
1850 PUTRXDESC(mxfep, rmdp->desc_status, RXSTAT_OWN);
1851 SYNCRXDESC(mxfep, i, DDI_DMA_SYNC_FORDEV);
1853 PUTCSR(mxfep, CSR_RDB, mxfep->mxfe_rxdesc_paddr);
1857 mxfe_stopall(mxfe_t *mxfep)
1859 mxfe_disableinterrupts(mxfep);
1861 mxfe_stopmac(mxfep);
1864 mxfe_stopphy(mxfep);
1868 mxfe_startall(mxfe_t *mxfep)
1870 ASSERT(mutex_owned(&mxfep->mxfe_intrlock));
1871 ASSERT(mutex_owned(&mxfep->mxfe_xmtlock));
1874 mxfe_disableinterrupts(mxfep);
1877 (void) mxfe_initialize(mxfep);
1880 mxfe_enableinterrupts(mxfep);
1883 mxfe_startphy(mxfep);
1886 mxfe_startmac(mxfep);
1890 mxfe_resetall(mxfe_t *mxfep)
1892 mxfep->mxfe_resetting = B_TRUE;
1893 mxfe_stopall(mxfep);
1894 mxfep->mxfe_resetting = B_FALSE;
1895 mxfe_startall(mxfep);
1899 mxfe_alloctxbuf(mxfe_t *mxfep)
1908 if (ddi_dma_alloc_handle(mxfep->mxfe_dip, &mxfe_dma_txattr,
1943 mxfe_allocrxbuf(mxfe_t *mxfep)
1952 if (ddi_dma_alloc_handle(mxfep->mxfe_dip, &mxfe_dma_attr,
1992 mxfe_allocrxring(mxfe_t *mxfep)
2004 rval = ddi_dma_alloc_handle(mxfep->mxfe_dip, &mxfe_dma_attr,
2005 DDI_DMA_SLEEP, NULL, &mxfep->mxfe_rxdesc_dmah);
2007 mxfe_error(mxfep->mxfe_dip,
2012 rval = ddi_dma_mem_alloc(mxfep->mxfe_rxdesc_dmah, size, &mxfe_devattr,
2014 &mxfep->mxfe_rxdesc_acch);
2016 mxfe_error(mxfep->mxfe_dip,
2021 rval = ddi_dma_addr_bind_handle(mxfep->mxfe_rxdesc_dmah, NULL, kaddr,
2025 mxfe_error(mxfep->mxfe_dip,
2034 mxfep->mxfe_rxdesc_paddr = dmac.dmac_address;
2035 mxfep->mxfe_rxdescp = (void *)kaddr;
2038 mxfep->mxfe_rxbufs = kmem_zalloc(MXFE_RXRING * sizeof (mxfe_rxbuf_t *),
2043 mxfe_rxbuf_t *rxb = mxfe_allocrxbuf(mxfep);
2046 mxfep->mxfe_rxbufs[i] = rxb;
2056 mxfe_alloctxring(mxfe_t *mxfep)
2068 rval = ddi_dma_alloc_handle(mxfep->mxfe_dip, &mxfe_dma_attr,
2069 DDI_DMA_SLEEP, NULL, &mxfep->mxfe_txdesc_dmah);
2071 mxfe_error(mxfep->mxfe_dip,
2076 rval = ddi_dma_mem_alloc(mxfep->mxfe_txdesc_dmah, size, &mxfe_devattr,
2078 &mxfep->mxfe_txdesc_acch);
2080 mxfe_error(mxfep->mxfe_dip,
2085 rval = ddi_dma_addr_bind_handle(mxfep->mxfe_txdesc_dmah, NULL, kaddr,
2089 mxfe_error(mxfep->mxfe_dip,
2098 mxfep->mxfe_txdesc_paddr = dmac.dmac_address;
2099 mxfep->mxfe_txdescp = (void *)kaddr;
2102 mxfep->mxfe_txbufs = kmem_zalloc(MXFE_TXRING * sizeof (mxfe_txbuf_t *),
2107 mxfe_txbuf_t *txb = mxfe_alloctxbuf(mxfep);
2111 mxfep->mxfe_txbufs[i] = txb;
2118 mxfe_freerxring(mxfe_t *mxfep)
2123 mxfe_destroyrxbuf(mxfep->mxfe_rxbufs[i]);
2126 if (mxfep->mxfe_rxbufs) {
2127 kmem_free(mxfep->mxfe_rxbufs,
2131 if (mxfep->mxfe_rxdesc_paddr)
2132 (void) ddi_dma_unbind_handle(mxfep->mxfe_rxdesc_dmah);
2133 if (mxfep->mxfe_rxdesc_acch)
2134 ddi_dma_mem_free(&mxfep->mxfe_rxdesc_acch);
2135 if (mxfep->mxfe_rxdesc_dmah)
2136 ddi_dma_free_handle(&mxfep->mxfe_rxdesc_dmah);
2140 mxfe_freetxring(mxfe_t *mxfep)
2145 mxfe_destroytxbuf(mxfep->mxfe_txbufs[i]);
2148 if (mxfep->mxfe_txbufs) {
2149 kmem_free(mxfep->mxfe_txbufs,
2152 if (mxfep->mxfe_txdesc_paddr)
2153 (void) ddi_dma_unbind_handle(mxfep->mxfe_txdesc_dmah);
2154 if (mxfep->mxfe_txdesc_acch)
2155 ddi_dma_mem_free(&mxfep->mxfe_txdesc_acch);
2156 if (mxfep->mxfe_txdesc_dmah)
2157 ddi_dma_free_handle(&mxfep->mxfe_txdesc_dmah);
2166 mxfe_t *mxfep = (void *)arg;
2171 mutex_enter(&mxfep->mxfe_intrlock);
2173 if (mxfep->mxfe_flags & MXFE_SUSPENDED) {
2175 mutex_exit(&mxfep->mxfe_intrlock);
2180 status = GETCSR(mxfep, CSR_SR) & INT_ALL;
2184 mutex_exit(&mxfep->mxfe_intrlock);
2188 PUTCSR(mxfep, CSR_SR, status);
2191 if (!(mxfep->mxfe_flags & MXFE_RUNNING)) {
2193 mutex_exit(&mxfep->mxfe_intrlock);
2199 if (mxfe_receive(mxfep, &mp)) {
2206 mutex_enter(&mxfep->mxfe_xmtlock);
2207 mxfe_reclaim(mxfep);
2208 mutex_exit(&mxfep->mxfe_xmtlock);
2212 ((mxfep->mxfe_linkup == LINK_STATE_UP) &&
2215 mutex_enter(&mxfep->mxfe_xmtlock);
2216 mxfe_checklink(mxfep);
2217 mutex_exit(&mxfep->mxfe_xmtlock);
2224 mxfep->mxfe_jabber++;
2233 mxfe_error(mxfep->mxfe_dip, "PCI parity error");
2236 mxfe_error(mxfep->mxfe_dip, "PCI target abort");
2239 mxfe_error(mxfep->mxfe_dip, "PCI master abort");
2242 mxfe_error(mxfep->mxfe_dip, "Unknown PCI error");
2251 mutex_enter(&mxfep->mxfe_xmtlock);
2252 mxfe_resetall(mxfep);
2253 mutex_exit(&mxfep->mxfe_xmtlock);
2256 mutex_exit(&mxfep->mxfe_intrlock);
2262 mac_rx(mxfep->mxfe_mh, NULL, mp);
2269 mxfe_enableinterrupts(mxfe_t *mxfep)
2273 if (mxfep->mxfe_wantw)
2276 if (MXFE_MODEL(mxfep) != MXFE_98713A)
2280 PUTCSR(mxfep, CSR_IER, mask);
2284 mxfe_disableinterrupts(mxfe_t *mxfep)
2287 PUTCSR(mxfep, CSR_IER, 0);
2290 PUTCSR(mxfep, CSR_SR, INT_ALL);
2294 mxfe_send_setup(mxfe_t *mxfep)
2299 ASSERT(mutex_owned(&mxfep->mxfe_xmtlock));
2302 ASSERT(mxfep->mxfe_txsend == 0);
2304 txb = mxfep->mxfe_txbufs[0];
2305 tmdp = &mxfep->mxfe_txdescp[0];
2310 txb->txb_buf[156] = mxfep->mxfe_curraddr[0];
2311 txb->txb_buf[157] = mxfep->mxfe_curraddr[1];
2312 txb->txb_buf[160] = mxfep->mxfe_curraddr[2];
2313 txb->txb_buf[161] = mxfep->mxfe_curraddr[3];
2314 txb->txb_buf[164] = mxfep->mxfe_curraddr[4];
2315 txb->txb_buf[165] = mxfep->mxfe_curraddr[5];
2320 PUTTXDESC(mxfep, tmdp->desc_control,
2324 PUTTXDESC(mxfep, tmdp->desc_buffer1, txb->txb_paddr);
2325 PUTTXDESC(mxfep, tmdp->desc_buffer2, 0);
2326 PUTTXDESC(mxfep, tmdp->desc_status, TXSTAT_OWN);
2329 SYNCTXDESC(mxfep, 0, DDI_DMA_SYNC_FORDEV);
2335 PUTCSR(mxfep, CSR_TDR, 0);
2336 mxfep->mxfe_txsend++;
2337 mxfep->mxfe_txavail--;
2342 if (mxfep->mxfe_promisc) {
2343 SETBIT(mxfep, CSR_NAR, NAR_RX_PROMISC);
2345 CLRBIT(mxfep, CSR_NAR, NAR_RX_PROMISC);
2350 mxfe_send(mxfe_t *mxfep, mblk_t *mp)
2358 ASSERT(mutex_owned(&mxfep->mxfe_xmtlock));
2364 mxfep->mxfe_macxmt_errors++;
2369 if (mxfep->mxfe_txavail < MXFE_TXRECLAIM)
2370 mxfe_reclaim(mxfep);
2372 if (mxfep->mxfe_txavail == 0) {
2374 mxfep->mxfe_wantw = B_TRUE;
2376 mxfe_enableinterrupts(mxfep);
2380 txsend = mxfep->mxfe_txsend;
2387 txb = mxfep->mxfe_txbufs[txsend];
2393 mxfep->mxfe_opackets++;
2394 mxfep->mxfe_obytes += len;
2397 mxfep->mxfe_multixmt++;
2399 mxfep->mxfe_brdcstxmt++;
2408 tmd = &mxfep->mxfe_txdescp[txsend];
2411 PUTTXDESC(mxfep, tmd->desc_control, control);
2412 PUTTXDESC(mxfep, tmd->desc_buffer1, txb->txb_paddr);
2413 PUTTXDESC(mxfep, tmd->desc_buffer2, 0);
2414 PUTTXDESC(mxfep, tmd->desc_status, TXSTAT_OWN);
2416 SYNCTXDESC(mxfep, txsend, DDI_DMA_SYNC_FORDEV);
2421 mxfep->mxfe_txavail--;
2422 mxfep->mxfe_txsend = (txsend + 1) % MXFE_TXRING;
2428 mxfep->mxfe_txstall_time = gethrtime() + (5 * 1000000000ULL);
2434 PUTCSR(mxfep, CSR_TDR, 0);
2443 mxfe_reclaim(mxfe_t *mxfep)
2447 while (mxfep->mxfe_txavail != MXFE_TXRING) {
2450 int index = mxfep->mxfe_txreclaim;
2452 tmdp = &mxfep->mxfe_txdescp[index];
2455 SYNCTXDESC(mxfep, index, DDI_DMA_SYNC_FORKERNEL);
2457 control = GETTXDESC(mxfep, tmdp->desc_control);
2458 status = GETTXDESC(mxfep, tmdp->desc_status);
2465 mxfep->mxfe_txavail++;
2466 mxfep->mxfe_txreclaim = (index + 1) % MXFE_TXRING;
2479 mxfep->mxfe_errxmt++;
2483 mxfep->mxfe_macxmt_errors++;
2486 mxfep->mxfe_carrier_errors++;
2489 mxfep->mxfe_underflow++;
2492 mxfep->mxfe_tx_late_collisions++;
2495 mxfep->mxfe_ex_collisions++;
2496 mxfep->mxfe_collisions += 16;
2501 mxfep->mxfe_defer_xmts++;
2506 mxfep->mxfe_collisions++;
2507 mxfep->mxfe_first_collisions++;
2509 mxfep->mxfe_collisions += TXCOLLCNT(status);
2510 mxfep->mxfe_multi_collisions += TXCOLLCNT(status);
2514 if (mxfep->mxfe_txavail >= MXFE_TXRESCHED) {
2515 if (mxfep->mxfe_wantw) {
2520 mxfep->mxfe_wantw = B_FALSE;
2521 mxfe_enableinterrupts(mxfep);
2522 mac_tx_update(mxfep->mxfe_mh);
2528 mxfe_receive(mxfe_t *mxfep, mblk_t **rxchain)
2540 head = mxfep->mxfe_rxhead;
2547 rmd = &mxfep->mxfe_rxdescp[head];
2548 rxb = mxfep->mxfe_rxbufs[head];
2550 SYNCRXDESC(mxfep, head, DDI_DMA_SYNC_FORKERNEL);
2551 status = GETRXDESC(mxfep, rmd->desc_status);
2565 mxfep->mxfe_errrcv++;
2575 mxfep->mxfe_toolong_errors++;
2579 mxfep->mxfe_macrcv_errors++;
2583 mxfep->mxfe_runt++;
2587 mxfep->mxfe_macrcv_errors++;
2590 mxfep->mxfe_align_errors++;
2593 mxfep->mxfe_fcs_errors++;
2597 mxfep->mxfe_overflow++;
2603 mxfep->mxfe_errrcv++;
2604 mxfep->mxfe_toolong_errors++;
2613 mxfep->mxfe_errrcv++;
2614 mxfep->mxfe_norcvbuf++;
2624 mxfep->mxfe_ipackets++;
2625 mxfep->mxfe_rbytes += len;
2629 mxfep->mxfe_brdcstrcv++;
2631 mxfep->mxfe_multircv++;
2639 PUTRXDESC(mxfep, rmd->desc_status, RXSTAT_OWN);
2640 SYNCRXDESC(mxfep, head, DDI_DMA_SYNC_FORDEV);
2646 mxfep->mxfe_rxhead = head;
2655 mxfe_t *mxfep = arg;
2657 mutex_enter(&mxfep->mxfe_xmtlock);
2658 if ((mxfep->mxfe_flags & (MXFE_RUNNING|MXFE_SUSPENDED)) == MXFE_RUNNING)
2659 mxfe_reclaim(mxfep);
2660 mutex_exit(&mxfep->mxfe_xmtlock);
2664 *val = mxfep->mxfe_ifspeed;
2668 *val = mxfep->mxfe_multircv;
2672 *val = mxfep->mxfe_brdcstrcv;
2676 *val = mxfep->mxfe_multixmt;
2680 *val = mxfep->mxfe_brdcstxmt;
2684 *val = mxfep->mxfe_ipackets;
2688 *val = mxfep->mxfe_rbytes;
2692 *val = mxfep->mxfe_opackets;
2696 *val = mxfep->mxfe_obytes;
2700 *val = mxfep->mxfe_norcvbuf;
2704 *val = mxfep->mxfe_noxmtbuf;
2708 *val = mxfep->mxfe_collisions;
2712 *val = mxfep->mxfe_errrcv;
2716 *val = mxfep->mxfe_errxmt;
2720 *val = mxfep->mxfe_duplex;
2724 *val = mxfep->mxfe_align_errors;
2728 *val = mxfep->mxfe_fcs_errors;
2732 *val = mxfep->mxfe_sqe_errors;
2736 *val = mxfep->mxfe_defer_xmts;
2740 *val = mxfep->mxfe_first_collisions;
2744 *val = mxfep->mxfe_multi_collisions;
2748 *val = mxfep->mxfe_tx_late_collisions;
2752 *val = mxfep->mxfe_ex_collisions;
2756 *val = mxfep->mxfe_macxmt_errors;
2760 *val = mxfep->mxfe_carrier_errors;
2764 *val = mxfep->mxfe_toolong_errors;
2768 *val = mxfep->mxfe_macrcv_errors;
2772 *val = mxfep->mxfe_overflow;
2776 *val = mxfep->mxfe_underflow;
2780 *val = mxfep->mxfe_runt;
2784 *val = mxfep->mxfe_jabber;
2788 *val = mxfep->mxfe_adv_100T4;
2792 *val = (mxfep->mxfe_anlpar & MII_ABILITY_100BASE_T4) ? 1 : 0;
2796 *val = mxfep->mxfe_cap_100T4;
2800 *val = mxfep->mxfe_cap_100fdx;
2804 *val = mxfep->mxfe_cap_100hdx;
2808 *val = mxfep->mxfe_cap_10fdx;
2812 *val = mxfep->mxfe_cap_10hdx;
2816 *val = mxfep->mxfe_cap_aneg;
2820 *val = ((mxfep->mxfe_adv_aneg != 0) &&
2821 ((mxfep->mxfe_aner & MII_AN_EXP_LPCANAN) != 0));
2825 *val = mxfep->mxfe_adv_100fdx;
2829 *val = mxfep->mxfe_adv_100hdx;
2833 *val = mxfep->mxfe_adv_10fdx;
2837 *val = mxfep->mxfe_adv_10hdx;
2841 *val = mxfep->mxfe_adv_aneg;
2845 *val = (mxfep->mxfe_anlpar & MII_ABILITY_100BASE_TX_FD) ? 1 : 0;
2849 *val = (mxfep->mxfe_anlpar & MII_ABILITY_100BASE_TX) ? 1 : 0;
2853 *val = (mxfep->mxfe_anlpar & MII_ABILITY_10BASE_T_FD) ? 1 : 0;
2857 *val = (mxfep->mxfe_anlpar & MII_ABILITY_10BASE_T) ? 1 : 0;
2861 *val = (mxfep->mxfe_aner & MII_AN_EXP_LPCANAN) ? 1 : 0;
2865 *val = mxfep->mxfe_phyaddr;
2869 *val = mxfep->mxfe_phyid;
2873 *val = mxfep->mxfe_phyinuse;
2887 mxfe_t *mxfep = arg;
2893 bcopy(&mxfep->mxfe_duplex, val, sizeof (link_duplex_t));
2898 bcopy(&mxfep->mxfe_ifspeed, val, sizeof (uint64_t));
2902 *(uint8_t *)val = mxfep->mxfe_adv_aneg;
2907 *(uint8_t *)val = mxfep->mxfe_adv_100fdx;
2912 *(uint8_t *)val = mxfep->mxfe_adv_100hdx;
2917 *(uint8_t *)val = mxfep->mxfe_adv_10fdx;
2922 *(uint8_t *)val = mxfep->mxfe_adv_10hdx;
2927 *(uint8_t *)val = mxfep->mxfe_adv_100T4;
2942 mxfe_t *mxfep = arg;
2948 advp = &mxfep->mxfe_adv_100fdx;
2949 capp = &mxfep->mxfe_cap_100fdx;
2953 advp = &mxfep->mxfe_adv_100hdx;
2954 capp = &mxfep->mxfe_cap_100hdx;
2958 advp = &mxfep->mxfe_adv_10fdx;
2959 capp = &mxfep->mxfe_cap_10fdx;
2963 advp = &mxfep->mxfe_adv_10hdx;
2964 capp = &mxfep->mxfe_cap_10hdx;
2968 advp = &mxfep->mxfe_adv_100T4;
2969 capp = &mxfep->mxfe_cap_100T4;
2973 advp = &mxfep->mxfe_adv_aneg;
2974 capp = &mxfep->mxfe_cap_aneg;
2984 mutex_enter(&mxfep->mxfe_intrlock);
2985 mutex_enter(&mxfep->mxfe_xmtlock);
2990 if ((mxfep->mxfe_flags & (MXFE_RUNNING|MXFE_SUSPENDED)) ==
2999 mxfe_resetall(mxfep);
3002 mutex_exit(&mxfep->mxfe_xmtlock);
3003 mutex_exit(&mxfep->mxfe_intrlock);
3012 mxfe_t *mxfep = arg;
3028 mac_prop_info_set_default_uint8(mph, mxfep->mxfe_cap_aneg);
3032 mac_prop_info_set_default_uint8(mph, mxfep->mxfe_cap_100fdx);
3036 mac_prop_info_set_default_uint8(mph, mxfep->mxfe_cap_100hdx);
3040 mac_prop_info_set_default_uint8(mph, mxfep->mxfe_cap_10fdx);
3044 mac_prop_info_set_default_uint8(mph, mxfep->mxfe_cap_10hdx);
3048 mac_prop_info_set_default_uint8(mph, mxfep->mxfe_cap_100T4);
3077 mxfe_dprintf(mxfe_t *mxfep, const char *func, int level, char *fmt, ...)
3086 if (mxfep && mxfep->mxfe_dip) {
3088 "%s%d", ddi_driver_name(mxfep->mxfe_dip),
3089 ddi_get_instance(mxfep->mxfe_dip));