Lines Matching +full:eee +full:- +full:broken +full:- +full:1000 +full:t
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
98 * enable MSI-X in alc_attach() depending on the card type. The operator can
248 nitems(alc_ident_table) - 1);
253 { -1, 0, 0 }
258 { -1, 0, 0 }
263 { -1, 0, 0 }
268 { -1, 0, 0 }
280 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
294 * For AR8132 fast ethernet controller, do not report 1000baseT
297 * ability to establish 1000baseT link.
299 if ((sc->alc_flags & ALC_FLAG_FASTETHER) != 0 &&
305 for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
313 device_printf(sc->alc_dev, "phy read timeout : %d\n", reg);
326 if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
332 for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
340 device_printf(sc->alc_dev, "phy read timeout : %d\n", reg);
354 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
370 for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
378 device_printf(sc->alc_dev, "phy write timeout : %d\n", reg);
389 if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
396 for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
404 device_printf(sc->alc_dev, "phy write timeout : %d\n", reg);
419 mii = device_get_softc(sc->alc_miibus);
420 ifp = sc->alc_ifp;
425 sc->alc_flags &= ~ALC_FLAG_LINK;
426 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
428 switch (IFM_SUBTYPE(mii->mii_media_active)) {
431 sc->alc_flags |= ALC_FLAG_LINK;
434 if ((sc->alc_flags & ALC_FLAG_FASTETHER) == 0)
435 sc->alc_flags |= ALC_FLAG_LINK;
444 /* Program MACs with resolved speed/duplex/flow-control. */
445 if ((sc->alc_flags & ALC_FLAG_LINK) != 0) {
448 /* Re-enable Tx/Rx MACs. */
453 alc_aspm(sc, 0, IFM_SUBTYPE(mii->mii_media_active));
454 alc_dsp_fixup(sc, IFM_SUBTYPE(mii->mii_media_active));
461 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_ADDR,
463 return (alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
471 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_ADDR,
473 return (alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
485 if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
491 for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
499 device_printf(sc->alc_dev, "phy ext read timeout : %d, %d\n",
515 if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
522 for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
530 device_printf(sc->alc_dev, "phy ext write timeout : %d, %d\n",
541 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
543 if (AR816X_REV(sc->alc_rev) >= AR816X_REV_C0)
548 * 1000BT/AZ, wrong cable length
550 if ((sc->alc_flags & ALC_FLAG_LINK) != 0) {
576 if ((sc->alc_flags & ALC_FLAG_LINK_WAR) != 0 &&
577 AR816X_REV(sc->alc_rev) == AR816X_REV_B0) {
596 if ((sc->alc_flags & ALC_FLAG_LINK_WAR) != 0 &&
597 AR816X_REV(sc->alc_rev) == AR816X_REV_B0) {
620 mii = device_get_softc(sc->alc_miibus);
623 ifmr->ifm_status = mii->mii_media_status;
624 ifmr->ifm_active = mii->mii_media_active;
651 mii = device_get_softc(sc->alc_miibus);
652 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
667 for (ident = alc_ident_table; ident->name != NULL; ident++) {
668 if (vendor == ident->vendorid && devid == ident->deviceid)
682 device_set_desc(dev, ident->name);
693 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
715 switch (sc->alc_ident->deviceid) {
722 DELAY(1000);
729 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
731 val = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
733 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
735 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
737 val = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
739 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
752 for (i = 100; i > 0; i--) {
753 DELAY(1000);
759 device_printf(sc->alc_dev,
763 device_printf(sc->alc_dev, "EEPROM not found!\n");
766 switch (sc->alc_ident->deviceid) {
773 DELAY(1000);
780 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
782 val = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
784 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
786 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
788 val = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
790 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
808 for (i = 100; i > 0; i--) {
812 DELAY(1000);
816 for (i = 100; i > 0; i--) {
817 DELAY(1000);
825 device_printf(sc->alc_dev,
834 for (i = 100; i > 0; i--) {
839 DELAY(1000);
844 for (i = 100; i > 0; i--) {
845 DELAY(1000);
851 device_printf(sc->alc_dev,
866 sc->alc_eaddr[0] = (ea[1] >> 8) & 0xFF;
867 sc->alc_eaddr[1] = (ea[1] >> 0) & 0xFF;
868 sc->alc_eaddr[2] = (ea[0] >> 24) & 0xFF;
869 sc->alc_eaddr[3] = (ea[0] >> 16) & 0xFF;
870 sc->alc_eaddr[4] = (ea[0] >> 8) & 0xFF;
871 sc->alc_eaddr[5] = (ea[0] >> 0) & 0xFF;
879 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
895 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
909 DELAY(10 * 1000);
914 DELAY(10 * 1000);
917 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B) {
918 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
920 data = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
922 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
925 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151 ||
926 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2 ||
927 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B ||
928 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B2) {
929 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
931 data = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
933 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
935 DELAY(20 * 1000);
937 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151) {
938 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
940 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
943 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8131 ||
944 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8132 ||
945 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2 ||
946 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B2) {
947 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
949 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
956 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
958 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
964 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
966 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
974 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
976 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
983 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
985 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
991 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
993 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
995 DELAY(1000);
998 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_ADDR,
1000 data = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
1003 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_DATA,
1006 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_ADDR,
1008 data = alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
1011 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_DATA,
1051 /* XXX Disable EEE. */
1072 if ((sc->alc_flags & ALC_FLAG_LINK_WAR) != 0) {
1093 switch (sc->alc_ident->deviceid) {
1118 * AR8151 v1.0 also requires this one though. I don't
1124 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
1132 DELAY(1000);
1141 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
1153 if ((sc->alc_flags & ALC_FLAG_LINK) == 0)
1157 if ((sc->alc_flags & (ALC_FLAG_APS | ALC_FLAG_PCIE)) ==
1159 linkcfg = CSR_READ_2(sc, sc->alc_expcap +
1169 if ((sc->alc_flags & ALC_FLAG_APS) != 0) {
1172 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B &&
1173 sc->alc_rev == ATHEROS_AR8152_B_V10)
1175 CSR_WRITE_2(sc, sc->alc_expcap + PCIER_LINK_CTL,
1187 if ((sc->alc_flags & ALC_FLAG_LINK) != 0) {
1188 if ((sc->alc_flags & ALC_FLAG_L0S) != 0)
1190 if ((sc->alc_flags & ALC_FLAG_L1S) != 0)
1192 if ((sc->alc_flags & ALC_FLAG_APS) != 0) {
1193 if (sc->alc_ident->deviceid ==
1202 switch (sc->alc_ident->deviceid) {
1229 if ((sc->alc_flags & ALC_FLAG_L1S) != 0)
1253 if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
1254 (sc->alc_rev & 0x01) != 0)
1256 if ((sc->alc_flags & ALC_FLAG_LINK) != 0) {
1264 else if ((if_getdrvflags(sc->alc_ifp) & IFF_DRV_RUNNING) != 0)
1277 /* Clear data link and flow-control protocol error. */
1282 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
1288 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B &&
1289 sc->alc_rev == ATHEROS_AR8152_B_V10) {
1298 cap = CSR_READ_2(sc, sc->alc_expcap + PCIER_LINK_CAP);
1300 ctl = CSR_READ_2(sc, sc->alc_expcap + PCIER_LINK_CTL);
1302 sc->alc_rcb = DMA_CFG_RCB_128;
1304 device_printf(sc->alc_dev, "RCB %u bytes\n",
1305 sc->alc_rcb == DMA_CFG_RCB_64 ? 64 : 128);
1308 sc->alc_flags |= ALC_FLAG_L0S;
1310 sc->alc_flags |= ALC_FLAG_L1S;
1312 device_printf(sc->alc_dev, "ASPM %s %s\n",
1318 device_printf(sc->alc_dev,
1326 if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
1327 (sc->alc_rev & 0x01) != 0) {
1350 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
1360 mod = ALC_USECS(sc->alc_int_rx_mod);
1364 if ((sc->alc_flags & ALC_FLAG_MSIX) != 0)
1367 else if ((sc->alc_flags & ALC_FLAG_MSI) != 0)
1385 sc->alc_dev = dev;
1386 sc->alc_rev = pci_get_revid(dev);
1388 mtx_init(&sc->alc_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
1390 callout_init_mtx(&sc->alc_tick_ch, &sc->alc_mtx, 0);
1391 NET_TASK_INIT(&sc->alc_int_task, 0, alc_int_task, sc);
1392 sc->alc_ident = alc_find_ident(dev);
1396 sc->alc_res_spec = alc_res_spec_mem;
1397 sc->alc_irq_spec = alc_irq_spec_legacy;
1398 error = bus_alloc_resources(dev, sc->alc_res_spec, sc->alc_res);
1405 sc->alc_phyaddr = ALC_PHY_ADDR;
1410 * the PHY supports 1000Mbps but that's not true. The PHY
1411 * used in AR8132 can't establish gigabit link even if it
1414 switch (sc->alc_ident->deviceid) {
1418 sc->alc_flags |= ALC_FLAG_E2X00;
1421 * Disable MSI-X by default on Killer devices, since this is
1430 pci_get_subdevice(dev) == 0x0091 && sc->alc_rev == 0)
1431 sc->alc_flags |= ALC_FLAG_LINK_WAR;
1434 sc->alc_flags |= ALC_FLAG_AR816X_FAMILY;
1438 sc->alc_flags |= ALC_FLAG_FASTETHER | ALC_FLAG_AR816X_FAMILY;
1442 sc->alc_flags |= ALC_FLAG_APS;
1445 sc->alc_flags |= ALC_FLAG_FASTETHER;
1449 sc->alc_flags |= ALC_FLAG_APS;
1451 sc->alc_flags |= ALC_FLAG_MT;
1458 * The default value of msix_disable is 2, which means auto-detect. If
1459 * we didn't auto-detect it, default to enabling it.
1464 sc->alc_flags |= ALC_FLAG_JUMBO;
1468 * addition, Atheros said that enabling SMB wouldn't improve
1472 sc->alc_flags |= ALC_FLAG_SMB_BUG;
1474 * Don't use Tx CMB. It is known to have silicon bug.
1476 sc->alc_flags |= ALC_FLAG_CMB_BUG;
1477 sc->alc_chip_rev = CSR_READ_4(sc, ALC_MASTER_CFG) >>
1481 sc->alc_rev);
1483 sc->alc_chip_rev);
1484 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
1486 AR816X_REV(sc->alc_rev));
1493 sc->alc_dma_rd_burst = 0;
1494 sc->alc_dma_wr_burst = 0;
1495 sc->alc_rcb = DMA_CFG_RCB_64;
1497 sc->alc_flags |= ALC_FLAG_PCIE;
1498 sc->alc_expcap = base;
1500 sc->alc_dma_rd_burst =
1502 sc->alc_dma_wr_burst = (burst & PCIEM_CTL_MAX_PAYLOAD) >> 5;
1505 alc_dma_burst[sc->alc_dma_rd_burst]);
1507 alc_dma_burst[sc->alc_dma_wr_burst]);
1509 if (alc_dma_burst[sc->alc_dma_rd_burst] > 1024)
1510 sc->alc_dma_rd_burst = 3;
1511 if (alc_dma_burst[sc->alc_dma_wr_burst] > 1024)
1512 sc->alc_dma_wr_burst = 3;
1518 if ((sc->alc_flags &
1520 sc->alc_dma_wr_burst = 0;
1554 sc->alc_flags |= ALC_FLAG_MSIX;
1555 sc->alc_irq_spec = alc_irq_spec_msix;
1559 if (msi_disable == 0 && (sc->alc_flags & ALC_FLAG_MSIX) == 0 &&
1564 sc->alc_flags |= ALC_FLAG_MSI;
1565 sc->alc_irq_spec = alc_irq_spec_msi;
1571 error = bus_alloc_resources(dev, sc->alc_irq_spec, sc->alc_irq);
1586 ifp = sc->alc_ifp = if_alloc(IFT_ETHER);
1593 if_setsendqlen(ifp, ALC_TX_RING_CNT - 1);
1599 sc->alc_flags |= ALC_FLAG_PM;
1600 sc->alc_pmcap = base;
1605 error = mii_attach(dev, &sc->alc_miibus, ifp, alc_mediachange,
1606 alc_mediastatus, BMSR_DEFCAPMASK, sc->alc_phyaddr, MII_OFFSET_ANY,
1613 ether_ifattach(ifp, sc->alc_eaddr);
1624 * is a bug in Tx checksum offloading logic or I got broken
1625 * sample boards. To safety, don't enable Tx checksum offloading
1631 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
1640 sc->alc_tq = taskqueue_create_fast("alc_taskq", M_WAITOK,
1641 taskqueue_thread_enqueue, &sc->alc_tq);
1642 taskqueue_start_threads(&sc->alc_tq, 1, PI_NET, "%s taskq",
1643 device_get_nameunit(sc->alc_dev));
1646 if ((sc->alc_flags & ALC_FLAG_MSIX) != 0)
1648 else if ((sc->alc_flags & ALC_FLAG_MSI) != 0)
1653 error = bus_setup_intr(dev, sc->alc_irq[i],
1655 &sc->alc_intrhand[i]);
1661 taskqueue_free(sc->alc_tq);
1662 sc->alc_tq = NULL;
1686 ifp = sc->alc_ifp;
1692 callout_drain(&sc->alc_tick_ch);
1693 taskqueue_drain(sc->alc_tq, &sc->alc_int_task);
1696 if (sc->alc_tq != NULL) {
1697 taskqueue_drain(sc->alc_tq, &sc->alc_int_task);
1698 taskqueue_free(sc->alc_tq);
1699 sc->alc_tq = NULL;
1707 sc->alc_ifp = NULL;
1710 if ((sc->alc_flags & ALC_FLAG_MSIX) != 0)
1712 else if ((sc->alc_flags & ALC_FLAG_MSI) != 0)
1717 if (sc->alc_intrhand[i] != NULL) {
1718 bus_teardown_intr(dev, sc->alc_irq[i],
1719 sc->alc_intrhand[i]);
1720 sc->alc_intrhand[i] = NULL;
1723 if (sc->alc_res[0] != NULL)
1725 bus_release_resources(dev, sc->alc_irq_spec, sc->alc_irq);
1726 if ((sc->alc_flags & (ALC_FLAG_MSI | ALC_FLAG_MSIX)) != 0)
1728 bus_release_resources(dev, sc->alc_res_spec, sc->alc_res);
1729 mtx_destroy(&sc->alc_mtx);
1748 stats = &sc->alc_stats;
1749 ctx = device_get_sysctl_ctx(sc->alc_dev);
1750 child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->alc_dev));
1753 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->alc_int_rx_mod,
1756 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, &sc->alc_int_tx_mod,
1759 sc->alc_int_rx_mod = ALC_IM_RX_TIMER_DEFAULT;
1760 error = resource_int_value(device_get_name(sc->alc_dev),
1761 device_get_unit(sc->alc_dev), "int_rx_mod", &sc->alc_int_rx_mod);
1763 if (sc->alc_int_rx_mod < ALC_IM_TIMER_MIN ||
1764 sc->alc_int_rx_mod > ALC_IM_TIMER_MAX) {
1765 device_printf(sc->alc_dev, "int_rx_mod value out of "
1768 sc->alc_int_rx_mod = ALC_IM_RX_TIMER_DEFAULT;
1771 sc->alc_int_tx_mod = ALC_IM_TX_TIMER_DEFAULT;
1772 error = resource_int_value(device_get_name(sc->alc_dev),
1773 device_get_unit(sc->alc_dev), "int_tx_mod", &sc->alc_int_tx_mod);
1775 if (sc->alc_int_tx_mod < ALC_IM_TIMER_MIN ||
1776 sc->alc_int_tx_mod > ALC_IM_TIMER_MAX) {
1777 device_printf(sc->alc_dev, "int_tx_mod value out of "
1780 sc->alc_int_tx_mod = ALC_IM_TX_TIMER_DEFAULT;
1785 &sc->alc_process_limit, 0, sysctl_hw_alc_proc_limit, "I",
1788 sc->alc_process_limit = ALC_PROC_DEFAULT;
1789 error = resource_int_value(device_get_name(sc->alc_dev),
1790 device_get_unit(sc->alc_dev), "process_limit",
1791 &sc->alc_process_limit);
1793 if (sc->alc_process_limit < ALC_PROC_MIN ||
1794 sc->alc_process_limit > ALC_PROC_MAX) {
1795 device_printf(sc->alc_dev,
1798 sc->alc_process_limit = ALC_PROC_DEFAULT;
1811 &stats->rx_frames, "Good frames");
1813 &stats->rx_bcast_frames, "Good broadcast frames");
1815 &stats->rx_mcast_frames, "Good multicast frames");
1817 &stats->rx_pause_frames, "Pause control frames");
1819 &stats->rx_control_frames, "Control frames");
1821 &stats->rx_crcerrs, "CRC errors");
1823 &stats->rx_lenerrs, "Frames with length mismatched");
1825 &stats->rx_bytes, "Good octets");
1827 &stats->rx_bcast_bytes, "Good broadcast octets");
1829 &stats->rx_mcast_bytes, "Good multicast octets");
1831 &stats->rx_runts, "Too short frames");
1833 &stats->rx_fragments, "Fragmented frames");
1835 &stats->rx_pkts_64, "64 bytes frames");
1837 &stats->rx_pkts_65_127, "65 to 127 bytes frames");
1839 &stats->rx_pkts_128_255, "128 to 255 bytes frames");
1841 &stats->rx_pkts_256_511, "256 to 511 bytes frames");
1843 &stats->rx_pkts_512_1023, "512 to 1023 bytes frames");
1845 &stats->rx_pkts_1024_1518, "1024 to 1518 bytes frames");
1847 &stats->rx_pkts_1519_max, "1519 to max frames");
1849 &stats->rx_pkts_truncated, "Truncated frames due to MTU size");
1851 &stats->rx_fifo_oflows, "FIFO overflows");
1853 &stats->rx_rrs_errs, "Return status write-back errors");
1855 &stats->rx_alignerrs, "Alignment errors");
1857 &stats->rx_pkts_filtered,
1865 &stats->tx_frames, "Good frames");
1867 &stats->tx_bcast_frames, "Good broadcast frames");
1869 &stats->tx_mcast_frames, "Good multicast frames");
1871 &stats->tx_pause_frames, "Pause control frames");
1873 &stats->tx_control_frames, "Control frames");
1875 &stats->tx_excess_defer, "Frames with excessive derferrals");
1877 &stats->tx_excess_defer, "Frames with derferrals");
1879 &stats->tx_bytes, "Good octets");
1881 &stats->tx_bcast_bytes, "Good broadcast octets");
1883 &stats->tx_mcast_bytes, "Good multicast octets");
1885 &stats->tx_pkts_64, "64 bytes frames");
1887 &stats->tx_pkts_65_127, "65 to 127 bytes frames");
1889 &stats->tx_pkts_128_255, "128 to 255 bytes frames");
1891 &stats->tx_pkts_256_511, "256 to 511 bytes frames");
1893 &stats->tx_pkts_512_1023, "512 to 1023 bytes frames");
1895 &stats->tx_pkts_1024_1518, "1024 to 1518 bytes frames");
1897 &stats->tx_pkts_1519_max, "1519 to max frames");
1899 &stats->tx_single_colls, "Single collisions");
1901 &stats->tx_multi_colls, "Multiple collisions");
1903 &stats->tx_late_colls, "Late collisions");
1905 &stats->tx_excess_colls, "Excessive collisions");
1907 &stats->tx_underrun, "FIFO underruns");
1909 &stats->tx_desc_underrun, "Descriptor write-back errors");
1911 &stats->tx_lenerrs, "Frames with length mismatched");
1913 &stats->tx_pkts_truncated, "Truncated frames due to MTU size");
1934 ctx->alc_busaddr = segs[0].ds_addr;
1947 rx_ring_end = sc->alc_rdata.alc_rx_ring_paddr + ALC_RX_RING_SZ;
1948 rr_ring_end = sc->alc_rdata.alc_rr_ring_paddr + ALC_RR_RING_SZ;
1949 cmb_end = sc->alc_rdata.alc_cmb_paddr + ALC_CMB_SZ;
1950 tx_ring_end = sc->alc_rdata.alc_tx_ring_paddr + ALC_TX_RING_SZ;
1954 ALC_ADDR_HI(sc->alc_rdata.alc_rx_ring_paddr)) ||
1956 ALC_ADDR_HI(sc->alc_rdata.alc_rr_ring_paddr)) ||
1958 ALC_ADDR_HI(sc->alc_rdata.alc_cmb_paddr)) ||
1960 ALC_ADDR_HI(sc->alc_rdata.alc_tx_ring_paddr)))
1983 if (sc->alc_flags & ALC_FLAG_MT)
1988 bus_get_dma_tag(sc->alc_dev), /* parent */
1998 &sc->alc_cdata.alc_parent_tag);
2000 device_printf(sc->alc_dev,
2007 sc->alc_cdata.alc_parent_tag, /* parent */
2017 &sc->alc_cdata.alc_tx_ring_tag);
2019 device_printf(sc->alc_dev,
2026 sc->alc_cdata.alc_parent_tag, /* parent */
2036 &sc->alc_cdata.alc_rx_ring_tag);
2038 device_printf(sc->alc_dev,
2044 sc->alc_cdata.alc_parent_tag, /* parent */
2054 &sc->alc_cdata.alc_rr_ring_tag);
2056 device_printf(sc->alc_dev,
2063 sc->alc_cdata.alc_parent_tag, /* parent */
2073 &sc->alc_cdata.alc_cmb_tag);
2075 device_printf(sc->alc_dev,
2081 sc->alc_cdata.alc_parent_tag, /* parent */
2091 &sc->alc_cdata.alc_smb_tag);
2093 device_printf(sc->alc_dev,
2099 error = bus_dmamem_alloc(sc->alc_cdata.alc_tx_ring_tag,
2100 (void **)&sc->alc_rdata.alc_tx_ring,
2102 &sc->alc_cdata.alc_tx_ring_map);
2104 device_printf(sc->alc_dev,
2109 error = bus_dmamap_load(sc->alc_cdata.alc_tx_ring_tag,
2110 sc->alc_cdata.alc_tx_ring_map, sc->alc_rdata.alc_tx_ring,
2113 device_printf(sc->alc_dev,
2117 sc->alc_rdata.alc_tx_ring_paddr = ctx.alc_busaddr;
2120 error = bus_dmamem_alloc(sc->alc_cdata.alc_rx_ring_tag,
2121 (void **)&sc->alc_rdata.alc_rx_ring,
2123 &sc->alc_cdata.alc_rx_ring_map);
2125 device_printf(sc->alc_dev,
2130 error = bus_dmamap_load(sc->alc_cdata.alc_rx_ring_tag,
2131 sc->alc_cdata.alc_rx_ring_map, sc->alc_rdata.alc_rx_ring,
2134 device_printf(sc->alc_dev,
2138 sc->alc_rdata.alc_rx_ring_paddr = ctx.alc_busaddr;
2141 error = bus_dmamem_alloc(sc->alc_cdata.alc_rr_ring_tag,
2142 (void **)&sc->alc_rdata.alc_rr_ring,
2144 &sc->alc_cdata.alc_rr_ring_map);
2146 device_printf(sc->alc_dev,
2151 error = bus_dmamap_load(sc->alc_cdata.alc_rr_ring_tag,
2152 sc->alc_cdata.alc_rr_ring_map, sc->alc_rdata.alc_rr_ring,
2155 device_printf(sc->alc_dev,
2159 sc->alc_rdata.alc_rr_ring_paddr = ctx.alc_busaddr;
2162 error = bus_dmamem_alloc(sc->alc_cdata.alc_cmb_tag,
2163 (void **)&sc->alc_rdata.alc_cmb,
2165 &sc->alc_cdata.alc_cmb_map);
2167 device_printf(sc->alc_dev,
2172 error = bus_dmamap_load(sc->alc_cdata.alc_cmb_tag,
2173 sc->alc_cdata.alc_cmb_map, sc->alc_rdata.alc_cmb,
2176 device_printf(sc->alc_dev,
2180 sc->alc_rdata.alc_cmb_paddr = ctx.alc_busaddr;
2183 error = bus_dmamem_alloc(sc->alc_cdata.alc_smb_tag,
2184 (void **)&sc->alc_rdata.alc_smb,
2186 &sc->alc_cdata.alc_smb_map);
2188 device_printf(sc->alc_dev,
2193 error = bus_dmamap_load(sc->alc_cdata.alc_smb_tag,
2194 sc->alc_cdata.alc_smb_map, sc->alc_rdata.alc_smb,
2197 device_printf(sc->alc_dev,
2201 sc->alc_rdata.alc_smb_paddr = ctx.alc_busaddr;
2206 device_printf(sc->alc_dev, "4GB boundary crossed, "
2225 bus_get_dma_tag(sc->alc_dev), /* parent */
2235 &sc->alc_cdata.alc_buffer_tag);
2237 device_printf(sc->alc_dev,
2244 sc->alc_cdata.alc_buffer_tag, /* parent */
2254 &sc->alc_cdata.alc_tx_tag);
2256 device_printf(sc->alc_dev, "could not create Tx DMA tag.\n");
2262 sc->alc_cdata.alc_buffer_tag, /* parent */
2272 &sc->alc_cdata.alc_rx_tag);
2274 device_printf(sc->alc_dev, "could not create Rx DMA tag.\n");
2279 txd = &sc->alc_cdata.alc_txdesc[i];
2280 txd->tx_m = NULL;
2281 txd->tx_dmamap = NULL;
2282 error = bus_dmamap_create(sc->alc_cdata.alc_tx_tag, 0,
2283 &txd->tx_dmamap);
2285 device_printf(sc->alc_dev,
2291 if ((error = bus_dmamap_create(sc->alc_cdata.alc_rx_tag, 0,
2292 &sc->alc_cdata.alc_rx_sparemap)) != 0) {
2293 device_printf(sc->alc_dev,
2298 rxd = &sc->alc_cdata.alc_rxdesc[i];
2299 rxd->rx_m = NULL;
2300 rxd->rx_dmamap = NULL;
2301 error = bus_dmamap_create(sc->alc_cdata.alc_rx_tag, 0,
2302 &rxd->rx_dmamap);
2304 device_printf(sc->alc_dev,
2322 if (sc->alc_cdata.alc_tx_tag != NULL) {
2324 txd = &sc->alc_cdata.alc_txdesc[i];
2325 if (txd->tx_dmamap != NULL) {
2326 bus_dmamap_destroy(sc->alc_cdata.alc_tx_tag,
2327 txd->tx_dmamap);
2328 txd->tx_dmamap = NULL;
2331 bus_dma_tag_destroy(sc->alc_cdata.alc_tx_tag);
2332 sc->alc_cdata.alc_tx_tag = NULL;
2335 if (sc->alc_cdata.alc_rx_tag != NULL) {
2337 rxd = &sc->alc_cdata.alc_rxdesc[i];
2338 if (rxd->rx_dmamap != NULL) {
2339 bus_dmamap_destroy(sc->alc_cdata.alc_rx_tag,
2340 rxd->rx_dmamap);
2341 rxd->rx_dmamap = NULL;
2344 if (sc->alc_cdata.alc_rx_sparemap != NULL) {
2345 bus_dmamap_destroy(sc->alc_cdata.alc_rx_tag,
2346 sc->alc_cdata.alc_rx_sparemap);
2347 sc->alc_cdata.alc_rx_sparemap = NULL;
2349 bus_dma_tag_destroy(sc->alc_cdata.alc_rx_tag);
2350 sc->alc_cdata.alc_rx_tag = NULL;
2353 if (sc->alc_cdata.alc_tx_ring_tag != NULL) {
2354 if (sc->alc_rdata.alc_tx_ring_paddr != 0)
2355 bus_dmamap_unload(sc->alc_cdata.alc_tx_ring_tag,
2356 sc->alc_cdata.alc_tx_ring_map);
2357 if (sc->alc_rdata.alc_tx_ring != NULL)
2358 bus_dmamem_free(sc->alc_cdata.alc_tx_ring_tag,
2359 sc->alc_rdata.alc_tx_ring,
2360 sc->alc_cdata.alc_tx_ring_map);
2361 sc->alc_rdata.alc_tx_ring_paddr = 0;
2362 sc->alc_rdata.alc_tx_ring = NULL;
2363 bus_dma_tag_destroy(sc->alc_cdata.alc_tx_ring_tag);
2364 sc->alc_cdata.alc_tx_ring_tag = NULL;
2367 if (sc->alc_cdata.alc_rx_ring_tag != NULL) {
2368 if (sc->alc_rdata.alc_rx_ring_paddr != 0)
2369 bus_dmamap_unload(sc->alc_cdata.alc_rx_ring_tag,
2370 sc->alc_cdata.alc_rx_ring_map);
2371 if (sc->alc_rdata.alc_rx_ring != NULL)
2372 bus_dmamem_free(sc->alc_cdata.alc_rx_ring_tag,
2373 sc->alc_rdata.alc_rx_ring,
2374 sc->alc_cdata.alc_rx_ring_map);
2375 sc->alc_rdata.alc_rx_ring_paddr = 0;
2376 sc->alc_rdata.alc_rx_ring = NULL;
2377 bus_dma_tag_destroy(sc->alc_cdata.alc_rx_ring_tag);
2378 sc->alc_cdata.alc_rx_ring_tag = NULL;
2381 if (sc->alc_cdata.alc_rr_ring_tag != NULL) {
2382 if (sc->alc_rdata.alc_rr_ring_paddr != 0)
2383 bus_dmamap_unload(sc->alc_cdata.alc_rr_ring_tag,
2384 sc->alc_cdata.alc_rr_ring_map);
2385 if (sc->alc_rdata.alc_rr_ring != NULL)
2386 bus_dmamem_free(sc->alc_cdata.alc_rr_ring_tag,
2387 sc->alc_rdata.alc_rr_ring,
2388 sc->alc_cdata.alc_rr_ring_map);
2389 sc->alc_rdata.alc_rr_ring_paddr = 0;
2390 sc->alc_rdata.alc_rr_ring = NULL;
2391 bus_dma_tag_destroy(sc->alc_cdata.alc_rr_ring_tag);
2392 sc->alc_cdata.alc_rr_ring_tag = NULL;
2395 if (sc->alc_cdata.alc_cmb_tag != NULL) {
2396 if (sc->alc_rdata.alc_cmb_paddr != 0)
2397 bus_dmamap_unload(sc->alc_cdata.alc_cmb_tag,
2398 sc->alc_cdata.alc_cmb_map);
2399 if (sc->alc_rdata.alc_cmb != NULL)
2400 bus_dmamem_free(sc->alc_cdata.alc_cmb_tag,
2401 sc->alc_rdata.alc_cmb,
2402 sc->alc_cdata.alc_cmb_map);
2403 sc->alc_rdata.alc_cmb_paddr = 0;
2404 sc->alc_rdata.alc_cmb = NULL;
2405 bus_dma_tag_destroy(sc->alc_cdata.alc_cmb_tag);
2406 sc->alc_cdata.alc_cmb_tag = NULL;
2409 if (sc->alc_cdata.alc_smb_tag != NULL) {
2410 if (sc->alc_rdata.alc_smb_paddr != 0)
2411 bus_dmamap_unload(sc->alc_cdata.alc_smb_tag,
2412 sc->alc_cdata.alc_smb_map);
2413 if (sc->alc_rdata.alc_smb != NULL)
2414 bus_dmamem_free(sc->alc_cdata.alc_smb_tag,
2415 sc->alc_rdata.alc_smb,
2416 sc->alc_cdata.alc_smb_map);
2417 sc->alc_rdata.alc_smb_paddr = 0;
2418 sc->alc_rdata.alc_smb = NULL;
2419 bus_dma_tag_destroy(sc->alc_cdata.alc_smb_tag);
2420 sc->alc_cdata.alc_smb_tag = NULL;
2422 if (sc->alc_cdata.alc_buffer_tag != NULL) {
2423 bus_dma_tag_destroy(sc->alc_cdata.alc_buffer_tag);
2424 sc->alc_cdata.alc_buffer_tag = NULL;
2426 if (sc->alc_cdata.alc_parent_tag != NULL) {
2427 bus_dma_tag_destroy(sc->alc_cdata.alc_parent_tag);
2428 sc->alc_cdata.alc_parent_tag = NULL;
2441 * restarting auto-negotiation in suspend/shutdown phase but we
2442 * don't know whether that auto-negotiation would succeed or not
2450 * Save current negotiated media speed/duplex/flow-control to
2461 mii = device_get_softc(sc->alc_miibus);
2464 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
2466 switch IFM_SUBTYPE(mii->mii_media_active) {
2477 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, MII_100T2CR, 0);
2478 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
2480 alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
2482 DELAY(1000);
2489 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID))
2492 mii->mii_media_active)) {
2506 device_printf(sc->alc_dev,
2510 * No link, force MAC to have 100Mbps, full-duplex link.
2513 mii->mii_media_status = IFM_AVALID | IFM_ACTIVE;
2514 mii->mii_media_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
2522 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
2538 ifp = sc->alc_ifp;
2539 if ((sc->alc_flags & ALC_FLAG_PM) == 0) {
2553 if ((sc->alc_flags & ALC_FLAG_FASTETHER) == 0)
2582 pmstat = pci_read_config(sc->alc_dev,
2583 sc->alc_pmcap + PCIR_POWER_STATUS, 2);
2587 pci_write_config(sc->alc_dev,
2588 sc->alc_pmcap + PCIR_POWER_STATUS, pmstat, 2);
2600 ifp = sc->alc_ifp;
2607 if ((sc->alc_flags & ALC_FLAG_PM) == 0) {
2614 if ((sc->alc_flags & ALC_FLAG_FASTETHER) == 0)
2645 if ((sc->alc_flags & ALC_FLAG_PM) != 0) {
2647 pmstat = pci_read_config(sc->alc_dev,
2648 sc->alc_pmcap + PCIR_POWER_STATUS, 2);
2652 pci_write_config(sc->alc_dev,
2653 sc->alc_pmcap + PCIR_POWER_STATUS, pmstat, 2);
2682 if ((sc->alc_flags & ALC_FLAG_PM) != 0) {
2684 pmstat = pci_read_config(sc->alc_dev,
2685 sc->alc_pmcap + PCIR_POWER_STATUS, 2);
2688 pci_write_config(sc->alc_dev,
2689 sc->alc_pmcap + PCIR_POWER_STATUS, pmstat, 2);
2694 ifp = sc->alc_ifp;
2725 if ((m->m_pkthdr.csum_flags & (ALC_CSUM_FEATURES | CSUM_TSO)) != 0) {
2759 if (eh->ether_type == htons(ETHERTYPE_VLAN)) {
2773 poff = ip_off + (ip->ip_hl << 2);
2774 if ((m->m_pkthdr.csum_flags & CSUM_TSO) != 0) {
2781 m = m_pullup(m, poff + (tcp->th_off << 2));
2794 * wouldn't be much burden on modern CPUs.
2801 ip->ip_sum = 0;
2802 tcp->th_sum = in_pseudo(ip->ip_src.s_addr,
2803 ip->ip_dst.s_addr, htons(IPPROTO_TCP));
2808 prod = sc->alc_cdata.alc_tx_prod;
2809 txd = &sc->alc_cdata.alc_txdesc[prod];
2811 map = txd->tx_dmamap;
2813 error = bus_dmamap_load_mbuf_sg(sc->alc_cdata.alc_tx_tag, map,
2823 error = bus_dmamap_load_mbuf_sg(sc->alc_cdata.alc_tx_tag, map,
2839 if (sc->alc_cdata.alc_tx_cnt + nsegs >= ALC_TX_RING_CNT - 3) {
2840 bus_dmamap_unload(sc->alc_cdata.alc_tx_tag, map);
2843 bus_dmamap_sync(sc->alc_cdata.alc_tx_tag, map, BUS_DMASYNC_PREWRITE);
2851 if ((m->m_flags & M_VLANTAG) != 0) {
2852 vtag = htons(m->m_pkthdr.ether_vtag);
2856 if ((m->m_pkthdr.csum_flags & CSUM_TSO) != 0) {
2859 cflags |= ((uint32_t)m->m_pkthdr.tso_segsz << TD_MSS_SHIFT) &
2869 hdrlen = poff + (tcp->th_off << 2);
2870 desc = &sc->alc_rdata.alc_tx_ring[prod];
2871 desc->len = htole32(TX_BYTES(hdrlen | vtag));
2872 desc->flags = htole32(cflags);
2873 desc->addr = htole64(txsegs[0].ds_addr);
2874 sc->alc_cdata.alc_tx_cnt++;
2876 if (m->m_len - hdrlen > 0) {
2878 desc = &sc->alc_rdata.alc_tx_ring[prod];
2879 desc->len = htole32(TX_BYTES((m->m_len - hdrlen) |
2881 desc->flags = htole32(cflags);
2882 desc->addr = htole64(txsegs[0].ds_addr + hdrlen);
2883 sc->alc_cdata.alc_tx_cnt++;
2888 } else if ((m->m_pkthdr.csum_flags & ALC_CSUM_FEATURES) != 0) {
2896 cflags |= (((poff + m->m_pkthdr.csum_data) >> 1) <<
2899 if ((m->m_pkthdr.csum_flags & CSUM_IP) != 0)
2901 if ((m->m_pkthdr.csum_flags & CSUM_TCP) != 0)
2903 if ((m->m_pkthdr.csum_flags & CSUM_UDP) != 0)
2911 desc = &sc->alc_rdata.alc_tx_ring[prod];
2912 desc->len = htole32(TX_BYTES(txsegs[idx].ds_len) | vtag);
2913 desc->flags = htole32(cflags);
2914 desc->addr = htole64(txsegs[idx].ds_addr);
2915 sc->alc_cdata.alc_tx_cnt++;
2919 sc->alc_cdata.alc_tx_prod = prod;
2922 prod = (prod + ALC_TX_RING_CNT - 1) % ALC_TX_RING_CNT;
2923 desc = &sc->alc_rdata.alc_tx_ring[prod];
2924 desc->flags |= htole32(TD_EOP);
2927 txd = &sc->alc_cdata.alc_txdesc[prod];
2928 map = txd_last->tx_dmamap;
2929 txd_last->tx_dmamap = txd->tx_dmamap;
2930 txd->tx_dmamap = map;
2931 txd->tx_m = m;
2959 if (sc->alc_cdata.alc_tx_cnt >= ALC_TX_DESC_HIWAT)
2963 IFF_DRV_RUNNING || (sc->alc_flags & ALC_FLAG_LINK) == 0)
2972 * don't have room, set the OACTIVE flag and wait
3000 bus_dmamap_sync(sc->alc_cdata.alc_tx_ring_tag,
3001 sc->alc_cdata.alc_tx_ring_map, BUS_DMASYNC_PREWRITE);
3003 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
3005 (uint16_t)sc->alc_cdata.alc_tx_prod);
3008 (sc->alc_cdata.alc_tx_prod <<
3012 sc->alc_watchdog_timer = ALC_TX_TIMEOUT;
3022 if (sc->alc_watchdog_timer == 0 || --sc->alc_watchdog_timer)
3025 ifp = sc->alc_ifp;
3026 if ((sc->alc_flags & ALC_FLAG_LINK) == 0) {
3027 if_printf(sc->alc_ifp, "watchdog timeout (lost link)\n");
3033 if_printf(sc->alc_ifp, "watchdog timeout -- resetting\n");
3054 if (ifr->ifr_mtu < ETHERMIN ||
3055 ifr->ifr_mtu > (sc->alc_ident->max_framelen -
3056 sizeof(struct ether_vlan_header) - ETHER_CRC_LEN) ||
3057 ((sc->alc_flags & ALC_FLAG_JUMBO) == 0 &&
3058 ifr->ifr_mtu > ETHERMTU))
3060 else if (if_getmtu(ifp) != ifr->ifr_mtu) {
3062 if_setmtu(ifp, ifr->ifr_mtu);
3077 ((if_getflags(ifp) ^ sc->alc_if_flags) &
3084 sc->alc_if_flags = if_getflags(ifp);
3096 mii = device_get_softc(sc->alc_miibus);
3097 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
3101 mask = ifr->ifr_reqcap ^ if_getcapenable(ifp);
3162 mii = device_get_softc(sc->alc_miibus);
3166 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0 ||
3167 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151 ||
3168 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2 ||
3169 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B2)
3172 switch (IFM_SUBTYPE(mii->mii_media_active)) {
3181 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
3183 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0)
3185 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0)
3198 if ((sc->alc_flags & ALC_FLAG_SMB_BUG) == 0) {
3199 bus_dmamap_sync(sc->alc_cdata.alc_smb_tag,
3200 sc->alc_cdata.alc_smb_map,
3202 smb = sc->alc_rdata.alc_smb;
3204 smb->updated = 0;
3205 bus_dmamap_sync(sc->alc_cdata.alc_smb_tag,
3206 sc->alc_cdata.alc_smb_map,
3234 ifp = sc->alc_ifp;
3235 stat = &sc->alc_stats;
3236 if ((sc->alc_flags & ALC_FLAG_SMB_BUG) == 0) {
3237 bus_dmamap_sync(sc->alc_cdata.alc_smb_tag,
3238 sc->alc_cdata.alc_smb_map,
3240 smb = sc->alc_rdata.alc_smb;
3241 if (smb->updated == 0)
3260 stat->rx_frames += smb->rx_frames;
3261 stat->rx_bcast_frames += smb->rx_bcast_frames;
3262 stat->rx_mcast_frames += smb->rx_mcast_frames;
3263 stat->rx_pause_frames += smb->rx_pause_frames;
3264 stat->rx_control_frames += smb->rx_control_frames;
3265 stat->rx_crcerrs += smb->rx_crcerrs;
3266 stat->rx_lenerrs += smb->rx_lenerrs;
3267 stat->rx_bytes += smb->rx_bytes;
3268 stat->rx_runts += smb->rx_runts;
3269 stat->rx_fragments += smb->rx_fragments;
3270 stat->rx_pkts_64 += smb->rx_pkts_64;
3271 stat->rx_pkts_65_127 += smb->rx_pkts_65_127;
3272 stat->rx_pkts_128_255 += smb->rx_pkts_128_255;
3273 stat->rx_pkts_256_511 += smb->rx_pkts_256_511;
3274 stat->rx_pkts_512_1023 += smb->rx_pkts_512_1023;
3275 stat->rx_pkts_1024_1518 += smb->rx_pkts_1024_1518;
3276 stat->rx_pkts_1519_max += smb->rx_pkts_1519_max;
3277 stat->rx_pkts_truncated += smb->rx_pkts_truncated;
3278 stat->rx_fifo_oflows += smb->rx_fifo_oflows;
3279 stat->rx_rrs_errs += smb->rx_rrs_errs;
3280 stat->rx_alignerrs += smb->rx_alignerrs;
3281 stat->rx_bcast_bytes += smb->rx_bcast_bytes;
3282 stat->rx_mcast_bytes += smb->rx_mcast_bytes;
3283 stat->rx_pkts_filtered += smb->rx_pkts_filtered;
3286 stat->tx_frames += smb->tx_frames;
3287 stat->tx_bcast_frames += smb->tx_bcast_frames;
3288 stat->tx_mcast_frames += smb->tx_mcast_frames;
3289 stat->tx_pause_frames += smb->tx_pause_frames;
3290 stat->tx_excess_defer += smb->tx_excess_defer;
3291 stat->tx_control_frames += smb->tx_control_frames;
3292 stat->tx_deferred += smb->tx_deferred;
3293 stat->tx_bytes += smb->tx_bytes;
3294 stat->tx_pkts_64 += smb->tx_pkts_64;
3295 stat->tx_pkts_65_127 += smb->tx_pkts_65_127;
3296 stat->tx_pkts_128_255 += smb->tx_pkts_128_255;
3297 stat->tx_pkts_256_511 += smb->tx_pkts_256_511;
3298 stat->tx_pkts_512_1023 += smb->tx_pkts_512_1023;
3299 stat->tx_pkts_1024_1518 += smb->tx_pkts_1024_1518;
3300 stat->tx_pkts_1519_max += smb->tx_pkts_1519_max;
3301 stat->tx_single_colls += smb->tx_single_colls;
3302 stat->tx_multi_colls += smb->tx_multi_colls;
3303 stat->tx_late_colls += smb->tx_late_colls;
3304 stat->tx_excess_colls += smb->tx_excess_colls;
3305 stat->tx_underrun += smb->tx_underrun;
3306 stat->tx_desc_underrun += smb->tx_desc_underrun;
3307 stat->tx_lenerrs += smb->tx_lenerrs;
3308 stat->tx_pkts_truncated += smb->tx_pkts_truncated;
3309 stat->tx_bcast_bytes += smb->tx_bcast_bytes;
3310 stat->tx_mcast_bytes += smb->tx_mcast_bytes;
3313 if_inc_counter(ifp, IFCOUNTER_OPACKETS, smb->tx_frames);
3315 if_inc_counter(ifp, IFCOUNTER_COLLISIONS, smb->tx_single_colls +
3316 smb->tx_multi_colls * 2 + smb->tx_late_colls +
3317 smb->tx_excess_colls * HDPX_CFG_RETRY_DEFAULT);
3319 if_inc_counter(ifp, IFCOUNTER_OERRORS, smb->tx_late_colls +
3320 smb->tx_excess_colls + smb->tx_underrun + smb->tx_pkts_truncated);
3322 if_inc_counter(ifp, IFCOUNTER_IPACKETS, smb->rx_frames);
3325 smb->rx_crcerrs + smb->rx_lenerrs +
3326 smb->rx_runts + smb->rx_pkts_truncated +
3327 smb->rx_fifo_oflows + smb->rx_rrs_errs +
3328 smb->rx_alignerrs);
3330 if ((sc->alc_flags & ALC_FLAG_SMB_BUG) == 0) {
3332 smb->updated = 0;
3333 bus_dmamap_sync(sc->alc_cdata.alc_smb_tag,
3334 sc->alc_cdata.alc_smb_map,
3347 if (sc->alc_flags & ALC_FLAG_MT) {
3348 taskqueue_enqueue(sc->alc_tq, &sc->alc_int_task);
3357 taskqueue_enqueue(sc->alc_tq, &sc->alc_int_task);
3371 ifp = sc->alc_ifp;
3375 if (sc->alc_morework != 0) {
3376 sc->alc_morework = 0;
3388 more = alc_rxintr(sc, sc->alc_process_limit);
3390 sc->alc_morework = 1;
3401 device_printf(sc->alc_dev,
3402 "DMA read error! -- resetting\n");
3404 device_printf(sc->alc_dev,
3405 "DMA write error! -- resetting\n");
3407 device_printf(sc->alc_dev,
3408 "TxQ reset! -- resetting\n");
3422 taskqueue_enqueue(sc->alc_tq, &sc->alc_int_task);
3428 /* Re-enable interrupts if we're running. */
3429 if (sc->alc_flags & ALC_FLAG_MT)
3446 ifp = sc->alc_ifp;
3448 if (sc->alc_cdata.alc_tx_cnt == 0)
3450 bus_dmamap_sync(sc->alc_cdata.alc_tx_ring_tag,
3451 sc->alc_cdata.alc_tx_ring_map, BUS_DMASYNC_POSTWRITE);
3452 if ((sc->alc_flags & ALC_FLAG_CMB_BUG) == 0) {
3453 bus_dmamap_sync(sc->alc_cdata.alc_cmb_tag,
3454 sc->alc_cdata.alc_cmb_map, BUS_DMASYNC_POSTREAD);
3455 prod = sc->alc_rdata.alc_cmb->cons;
3457 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
3466 cons = sc->alc_cdata.alc_tx_cons;
3472 if (sc->alc_cdata.alc_tx_cnt <= 0)
3475 sc->alc_cdata.alc_tx_cnt--;
3476 txd = &sc->alc_cdata.alc_txdesc[cons];
3477 if (txd->tx_m != NULL) {
3479 bus_dmamap_sync(sc->alc_cdata.alc_tx_tag,
3480 txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
3481 bus_dmamap_unload(sc->alc_cdata.alc_tx_tag,
3482 txd->tx_dmamap);
3483 m_freem(txd->tx_m);
3484 txd->tx_m = NULL;
3488 if ((sc->alc_flags & ALC_FLAG_CMB_BUG) == 0)
3489 bus_dmamap_sync(sc->alc_cdata.alc_cmb_tag,
3490 sc->alc_cdata.alc_cmb_map, BUS_DMASYNC_PREREAD);
3491 sc->alc_cdata.alc_tx_cons = cons;
3496 if (sc->alc_cdata.alc_tx_cnt == 0)
3497 sc->alc_watchdog_timer = 0;
3511 m->m_len = m->m_pkthdr.len = RX_BUF_SIZE_MAX;
3516 if (bus_dmamap_load_mbuf_sg(sc->alc_cdata.alc_rx_tag,
3517 sc->alc_cdata.alc_rx_sparemap, m, segs, &nsegs, 0) != 0) {
3523 if (rxd->rx_m != NULL) {
3524 bus_dmamap_sync(sc->alc_cdata.alc_rx_tag, rxd->rx_dmamap,
3526 bus_dmamap_unload(sc->alc_cdata.alc_rx_tag, rxd->rx_dmamap);
3528 map = rxd->rx_dmamap;
3529 rxd->rx_dmamap = sc->alc_cdata.alc_rx_sparemap;
3530 sc->alc_cdata.alc_rx_sparemap = map;
3531 bus_dmamap_sync(sc->alc_cdata.alc_rx_tag, rxd->rx_dmamap,
3533 rxd->rx_m = m;
3534 rxd->rx_desc->addr = htole64(segs[0].ds_addr);
3546 bus_dmamap_sync(sc->alc_cdata.alc_rr_ring_tag,
3547 sc->alc_cdata.alc_rr_ring_map,
3549 bus_dmamap_sync(sc->alc_cdata.alc_rx_ring_tag,
3550 sc->alc_cdata.alc_rx_ring_map, BUS_DMASYNC_POSTWRITE);
3551 rr_cons = sc->alc_cdata.alc_rr_cons;
3552 ifp = sc->alc_ifp;
3554 if (count-- <= 0)
3556 rrd = &sc->alc_rdata.alc_rr_ring[rr_cons];
3557 status = le32toh(rrd->status);
3560 nsegs = RRD_RD_CNT(le32toh(rrd->rdinfo));
3563 device_printf(sc->alc_dev,
3564 "unexpected segment count -- resetting\n");
3569 rrd->status = 0;
3571 sc->alc_cdata.alc_rx_cons += nsegs;
3572 sc->alc_cdata.alc_rx_cons %= ALC_RR_RING_CNT;
3578 sc->alc_cdata.alc_rr_cons = rr_cons;
3580 bus_dmamap_sync(sc->alc_cdata.alc_rr_ring_tag,
3581 sc->alc_cdata.alc_rr_ring_map,
3587 bus_dmamap_sync(sc->alc_cdata.alc_rx_ring_tag,
3588 sc->alc_cdata.alc_rx_ring_map, BUS_DMASYNC_PREWRITE);
3593 * only when Rx buffer pre-fetching is required. In
3596 * it still seems that pre-fetching needs more
3599 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
3601 (uint16_t)sc->alc_cdata.alc_rx_cons);
3604 sc->alc_cdata.alc_rx_cons);
3619 dst = src - 3;
3621 if (m->m_next == NULL) {
3622 for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++)
3624 m->m_data -= 6;
3638 bcopy(m->m_data, n->m_data, ETHER_HDR_LEN);
3639 m->m_data += ETHER_HDR_LEN;
3640 m->m_len -= ETHER_HDR_LEN;
3641 n->m_len = ETHER_HDR_LEN;
3643 n->m_next = m;
3658 ifp = sc->alc_ifp;
3659 status = le32toh(rrd->status);
3660 rdinfo = le32toh(rrd->rdinfo);
3664 sc->alc_cdata.alc_rxlen = RRD_BYTES(status);
3686 rxd = &sc->alc_cdata.alc_rxdesc[rx_cons];
3687 mp = rxd->rx_m;
3692 if (sc->alc_cdata.alc_rxhead != NULL)
3693 m_freem(sc->alc_cdata.alc_rxhead);
3700 * multi-segmented frame.
3702 mp->m_len = sc->alc_buf_size;
3705 if (sc->alc_cdata.alc_rxhead == NULL) {
3706 sc->alc_cdata.alc_rxhead = mp;
3707 sc->alc_cdata.alc_rxtail = mp;
3709 mp->m_flags &= ~M_PKTHDR;
3710 sc->alc_cdata.alc_rxprev_tail =
3711 sc->alc_cdata.alc_rxtail;
3712 sc->alc_cdata.alc_rxtail->m_next = mp;
3713 sc->alc_cdata.alc_rxtail = mp;
3716 if (count == nsegs - 1) {
3718 m = sc->alc_cdata.alc_rxhead;
3719 m->m_flags |= M_PKTHDR;
3724 m->m_pkthdr.len =
3725 sc->alc_cdata.alc_rxlen - ETHER_CRC_LEN;
3728 mp->m_len = sc->alc_cdata.alc_rxlen -
3729 (nsegs - 1) * sc->alc_buf_size;
3731 if (mp->m_len <= ETHER_CRC_LEN) {
3732 sc->alc_cdata.alc_rxtail =
3733 sc->alc_cdata.alc_rxprev_tail;
3734 sc->alc_cdata.alc_rxtail->m_len -=
3735 (ETHER_CRC_LEN - mp->m_len);
3736 sc->alc_cdata.alc_rxtail->m_next = NULL;
3739 mp->m_len -= ETHER_CRC_LEN;
3742 m->m_len = m->m_pkthdr.len;
3743 m->m_pkthdr.rcvif = ifp;
3750 vtag = RRD_VLAN(le32toh(rrd->vtag));
3751 m->m_pkthdr.ether_vtag = ntohs(vtag);
3752 m->m_flags |= M_VLANTAG;
3780 mii = device_get_softc(sc->alc_miibus);
3792 callout_reset(&sc->alc_tick_ch, hz, alc_tick, sc);
3806 if (AR816X_REV(sc->alc_rev) >= AR816X_REV_B0) {
3808 * Restore over-current protection default value.
3824 if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1)
3840 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
3843 if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
3844 (sc->alc_rev & 0x01) != 0) {
3859 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
3860 for (i = ALC_RESET_TIMEOUT; i > 0; i--) {
3866 device_printf(sc->alc_dev, "MAC reset timeout!\n");
3868 for (i = ALC_RESET_TIMEOUT; i > 0; i--) {
3874 device_printf(sc->alc_dev, "master reset timeout!\n");
3876 for (i = ALC_RESET_TIMEOUT; i > 0; i--) {
3884 device_printf(sc->alc_dev, "reset timeout(0x%08x)!\n", reg);
3886 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
3887 if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
3888 (sc->alc_rev & 0x01) != 0) {
3905 if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1)
3910 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0 ||
3911 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B ||
3912 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2)
3939 ifp = sc->alc_ifp;
3954 device_printf(sc->alc_dev, "no memory for Rx buffers.\n");
3964 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
3969 if (AR816X_REV(sc->alc_rev) >= AR816X_REV_B0)
3987 paddr = sc->alc_rdata.alc_tx_ring_paddr;
3990 /* We don't use high priority ring. */
3996 paddr = sc->alc_rdata.alc_rx_ring_paddr;
3999 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
4016 * For strict-alignment architectures make sure to reduce buffer
4020 sc->alc_buf_size = RX_BUF_SIZE_MAX - sizeof(uint64_t);
4022 sc->alc_buf_size = RX_BUF_SIZE_MAX;
4024 CSR_WRITE_4(sc, ALC_RX_BUF_SIZE, sc->alc_buf_size);
4026 paddr = sc->alc_rdata.alc_rr_ring_paddr;
4029 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
4038 paddr = sc->alc_rdata.alc_cmb_paddr;
4040 paddr = sc->alc_rdata.alc_smb_paddr;
4044 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B) {
4045 /* Reconfigure SRAM - Vendor magic. */
4060 reg = ALC_USECS(sc->alc_int_rx_mod) << IM_TIMER_RX_SHIFT;
4061 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0)
4062 reg |= ALC_USECS(sc->alc_int_tx_mod) << IM_TIMER_TX_SHIFT;
4065 * We don't want to automatic interrupt clear as task queue
4071 if (ALC_USECS(sc->alc_int_rx_mod) != 0)
4073 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0 &&
4074 ALC_USECS(sc->alc_int_tx_mod) != 0)
4078 * Disable interrupt re-trigger timer. We don't want automatic
4079 * re-triggering of un-ACKed interrupts.
4083 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
4086 ALC_USECS(sc->alc_int_tx_mod));
4088 if ((sc->alc_flags & ALC_FLAG_CMB_BUG) == 0) {
4108 * would make path-MTU discovery hard as sender wouldn't get
4110 * multi-fragmented frames on Rx path so it has no issue on
4116 * accept from others - RFC 793.
4118 CSR_WRITE_4(sc, ALC_FRAME_SIZE, sc->alc_ident->max_framelen);
4120 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
4134 /* Set parameters for half-duplex media. */
4148 * larger than this threshold, hardware wouldn't do
4151 reg = (sc->alc_ident->max_framelen >> TSO_OFFLOAD_THRESH_UNIT_SHIFT) &
4153 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
4157 reg = (alc_dma_burst[sc->alc_dma_rd_burst] <<
4159 if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B ||
4160 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B2)
4166 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
4179 /* Configure Rx free descriptor pre-fetching. */
4192 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
4197 reg -= RX_FIFO_PAUSE_816X_RSVD;
4199 reg -= RX_BUF_SIZE_MAX;
4207 } else if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8131 ||
4208 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8132) {
4219 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
4229 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
4233 if ((sc->alc_flags & ALC_FLAG_FASTETHER) == 0)
4236 if ((sc->alc_flags & ALC_FLAG_FASTETHER) == 0 &&
4237 sc->alc_ident->deviceid != DEVICEID_ATHEROS_AR8151_V2)
4244 reg |= sc->alc_rcb;
4245 if ((sc->alc_flags & ALC_FLAG_CMB_BUG) == 0)
4247 if ((sc->alc_flags & ALC_FLAG_SMB_BUG) == 0)
4251 reg |= (sc->alc_dma_rd_burst & DMA_CFG_RD_BURST_MASK) <<
4253 reg |= (sc->alc_dma_wr_burst & DMA_CFG_WR_BURST_MASK) <<
4259 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
4260 switch (AR816X_REV(sc->alc_rev)) {
4276 * - Auto-padding for short frames.
4277 * - Enable CRC generation.
4283 * these controllers can't handle fragmented frames. Disable
4290 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0 ||
4291 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151 ||
4292 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2 ||
4293 sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B2)
4295 if ((sc->alc_flags & ALC_FLAG_FASTETHER) != 0)
4313 sc->alc_flags &= ~ALC_FLAG_LINK;
4317 callout_reset(&sc->alc_tick_ch, hz, alc_tick, sc);
4333 ifp = sc->alc_ifp;
4335 sc->alc_flags &= ~ALC_FLAG_LINK;
4336 callout_stop(&sc->alc_tick_ch);
4337 sc->alc_watchdog_timer = 0;
4347 DELAY(1000);
4355 if (sc->alc_cdata.alc_rxhead != NULL)
4356 m_freem(sc->alc_cdata.alc_rxhead);
4362 rxd = &sc->alc_cdata.alc_rxdesc[i];
4363 if (rxd->rx_m != NULL) {
4364 bus_dmamap_sync(sc->alc_cdata.alc_rx_tag,
4365 rxd->rx_dmamap, BUS_DMASYNC_POSTREAD);
4366 bus_dmamap_unload(sc->alc_cdata.alc_rx_tag,
4367 rxd->rx_dmamap);
4368 m_freem(rxd->rx_m);
4369 rxd->rx_m = NULL;
4373 txd = &sc->alc_cdata.alc_txdesc[i];
4374 if (txd->tx_m != NULL) {
4375 bus_dmamap_sync(sc->alc_cdata.alc_tx_tag,
4376 txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
4377 bus_dmamap_unload(sc->alc_cdata.alc_tx_tag,
4378 txd->tx_dmamap);
4379 m_freem(txd->tx_m);
4380 txd->tx_m = NULL;
4398 for (i = ALC_TIMEOUT; i > 0; i--) {
4405 device_printf(sc->alc_dev,
4425 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
4445 if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
4463 for (i = ALC_TIMEOUT; i > 0; i--) {
4470 device_printf(sc->alc_dev,
4483 sc->alc_cdata.alc_tx_prod = 0;
4484 sc->alc_cdata.alc_tx_cons = 0;
4485 sc->alc_cdata.alc_tx_cnt = 0;
4487 rd = &sc->alc_rdata;
4488 bzero(rd->alc_tx_ring, ALC_TX_RING_SZ);
4490 txd = &sc->alc_cdata.alc_txdesc[i];
4491 txd->tx_m = NULL;
4494 bus_dmamap_sync(sc->alc_cdata.alc_tx_ring_tag,
4495 sc->alc_cdata.alc_tx_ring_map, BUS_DMASYNC_PREWRITE);
4507 sc->alc_cdata.alc_rx_cons = ALC_RX_RING_CNT - 1;
4508 sc->alc_morework = 0;
4509 rd = &sc->alc_rdata;
4510 bzero(rd->alc_rx_ring, ALC_RX_RING_SZ);
4512 rxd = &sc->alc_cdata.alc_rxdesc[i];
4513 rxd->rx_m = NULL;
4514 rxd->rx_desc = &rd->alc_rx_ring[i];
4524 bus_dmamap_sync(sc->alc_cdata.alc_rx_ring_tag,
4525 sc->alc_cdata.alc_rx_ring_map, BUS_DMASYNC_PREWRITE);
4527 CSR_WRITE_4(sc, ALC_MBOX_RD0_PROD_IDX, sc->alc_cdata.alc_rx_cons);
4539 sc->alc_cdata.alc_rr_cons = 0;
4542 rd = &sc->alc_rdata;
4543 bzero(rd->alc_rr_ring, ALC_RR_RING_SZ);
4544 bus_dmamap_sync(sc->alc_cdata.alc_rr_ring_tag,
4545 sc->alc_cdata.alc_rr_ring_map,
4556 rd = &sc->alc_rdata;
4557 bzero(rd->alc_cmb, ALC_CMB_SZ);
4558 bus_dmamap_sync(sc->alc_cdata.alc_cmb_tag, sc->alc_cdata.alc_cmb_map,
4569 rd = &sc->alc_rdata;
4570 bzero(rd->alc_smb, ALC_SMB_SZ);
4571 bus_dmamap_sync(sc->alc_cdata.alc_smb_tag, sc->alc_cdata.alc_smb_map,
4583 ifp = sc->alc_ifp;
4613 ifp = sc->alc_ifp;
4647 if (error || req->newptr == NULL)
4678 KASSERT(sc->alc_buf_size <= MCLBYTES, ("incorrect cluster size"));