Lines Matching +full:i2c +full:- +full:transfer +full:- +full:timeout +full:- +full:us
3 /*-
4 * SPDX-License-Identifier: BSD-4-Clause
20 * 4. Neither the name of the author nor the names of any co-contributors
36 /*-
54 * SysKonnect SK-NET gigabit ethernet driver for FreeBSD. Supports
55 * the SK-984x series adapters, both single port and dual port.
58 * https://www.freebsd.org/~wpaul/SysKonnect/xmacii_datasheet_rev_c_9-29.pdf
65 * https://people.freebsd.org/~wpaul/SysKonnect/xmacii_datasheet_rev_c_9-29.pdf
176 "D-Link DGE-530T Gigabit Ethernet"
181 "D-Link DGE-530T Gigabit Ethernet"
269 * It seems that SK-NET GENESIS supports very simple checksum offload
335 { -1, 0, 0 }
341 { -1, 0, 0 }
440 switch(sc_if->sk_softc->sk_type) {
467 switch(sc_if->sk_softc->sk_type) {
493 switch(sc_if->sk_softc->sk_type) {
515 if (sc_if->sk_phytype != SK_PHYTYPE_XMAC) {
524 if_printf(sc_if->sk_ifp, "phy failed to come ready\n");
546 if_printf(sc_if->sk_ifp, "phy failed to come ready\n");
557 if_printf(sc_if->sk_ifp, "phy write timed out\n");
567 mii = device_get_softc(sc_if->sk_miibus);
573 if (sc_if->sk_phytype != SK_PHYTYPE_XMAC) {
574 if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) {
588 if (sc_if->sk_phytype != SK_PHYTYPE_MARV_COPPER &&
589 sc_if->sk_phytype != SK_PHYTYPE_MARV_FIBER) {
604 if_printf(sc_if->sk_ifp, "phy failed to come ready\n");
628 if_printf(sc_if->sk_ifp, "phy write timeout\n");
649 return (~crc & ((1 << HASH_BITS) - 1));
673 sc = sc_if->sk_softc;
674 if (sc->sk_type == SK_GENESIS)
697 sk_setfilt(ctx->sc_if, (uint16_t *)LLADDR(sdl), cnt + 1);
698 ctx->mode |= XM_MODE_RX_USE_PERFECT;
703 ctx->hashes[0] |= (1 << h);
705 ctx->hashes[1] |= (1 << (h - 32));
706 ctx->mode |= XM_MODE_RX_USE_HASH;
714 if_t ifp = sc_if->sk_ifp;
767 ifp = sc_if->sk_ifp;
797 sc_if->sk_cdata.sk_rx_cons = 0;
801 rd = &sc_if->sk_rdata;
802 bzero(rd->sk_rx_ring, sizeof(struct sk_rx_desc) * SK_RX_RING_CNT);
806 if (i == (SK_RX_RING_CNT - 1))
810 rd->sk_rx_ring[i].sk_next = htole32(SK_ADDR_LO(addr));
811 rd->sk_rx_ring[i].sk_csum_start = htole32(csum_start);
814 bus_dmamap_sync(sc_if->sk_cdata.sk_rx_ring_tag,
815 sc_if->sk_cdata.sk_rx_ring_map,
829 sc_if->sk_cdata.sk_jumbo_rx_cons = 0;
833 rd = &sc_if->sk_rdata;
834 bzero(rd->sk_jumbo_rx_ring,
839 if (i == (SK_JUMBO_RX_RING_CNT - 1))
843 rd->sk_jumbo_rx_ring[i].sk_next = htole32(SK_ADDR_LO(addr));
844 rd->sk_jumbo_rx_ring[i].sk_csum_start = htole32(csum_start);
847 bus_dmamap_sync(sc_if->sk_cdata.sk_jumbo_rx_ring_tag,
848 sc_if->sk_cdata.sk_jumbo_rx_ring_map,
862 STAILQ_INIT(&sc_if->sk_cdata.sk_txfreeq);
863 STAILQ_INIT(&sc_if->sk_cdata.sk_txbusyq);
865 sc_if->sk_cdata.sk_tx_prod = 0;
866 sc_if->sk_cdata.sk_tx_cons = 0;
867 sc_if->sk_cdata.sk_tx_cnt = 0;
869 rd = &sc_if->sk_rdata;
870 bzero(rd->sk_tx_ring, sizeof(struct sk_tx_desc) * SK_TX_RING_CNT);
872 if (i == (SK_TX_RING_CNT - 1))
876 rd->sk_tx_ring[i].sk_next = htole32(SK_ADDR_LO(addr));
877 txd = &sc_if->sk_cdata.sk_txdesc[i];
878 STAILQ_INSERT_TAIL(&sc_if->sk_cdata.sk_txfreeq, txd, tx_q);
881 bus_dmamap_sync(sc_if->sk_cdata.sk_tx_ring_tag,
882 sc_if->sk_cdata.sk_tx_ring_map,
893 r = &sc_if->sk_rdata.sk_rx_ring[idx];
894 rxd = &sc_if->sk_cdata.sk_rxdesc[idx];
895 m = rxd->rx_m;
896 r->sk_ctl = htole32(m->m_len | SK_RXSTAT | SK_OPCODE_CSUM);
906 r = &sc_if->sk_rdata.sk_jumbo_rx_ring[idx];
907 rxd = &sc_if->sk_cdata.sk_jumbo_rxdesc[idx];
908 m = rxd->rx_m;
909 r->sk_ctl = htole32(m->m_len | SK_RXSTAT | SK_OPCODE_CSUM);
925 m->m_len = m->m_pkthdr.len = MCLBYTES;
928 if (bus_dmamap_load_mbuf_sg(sc_if->sk_cdata.sk_rx_tag,
929 sc_if->sk_cdata.sk_rx_sparemap, m, segs, &nsegs, 0) != 0) {
935 rxd = &sc_if->sk_cdata.sk_rxdesc[idx];
936 if (rxd->rx_m != NULL) {
937 bus_dmamap_sync(sc_if->sk_cdata.sk_rx_tag, rxd->rx_dmamap,
939 bus_dmamap_unload(sc_if->sk_cdata.sk_rx_tag, rxd->rx_dmamap);
941 map = rxd->rx_dmamap;
942 rxd->rx_dmamap = sc_if->sk_cdata.sk_rx_sparemap;
943 sc_if->sk_cdata.sk_rx_sparemap = map;
944 bus_dmamap_sync(sc_if->sk_cdata.sk_rx_tag, rxd->rx_dmamap,
946 rxd->rx_m = m;
947 r = &sc_if->sk_rdata.sk_rx_ring[idx];
948 r->sk_data_lo = htole32(SK_ADDR_LO(segs[0].ds_addr));
949 r->sk_data_hi = htole32(SK_ADDR_HI(segs[0].ds_addr));
950 r->sk_ctl = htole32(segs[0].ds_len | SK_RXSTAT | SK_OPCODE_CSUM);
968 m->m_pkthdr.len = m->m_len = MJUM9BYTES;
976 if (bus_dmamap_load_mbuf_sg(sc_if->sk_cdata.sk_jumbo_rx_tag,
977 sc_if->sk_cdata.sk_jumbo_rx_sparemap, m, segs, &nsegs, 0) != 0) {
983 rxd = &sc_if->sk_cdata.sk_jumbo_rxdesc[idx];
984 if (rxd->rx_m != NULL) {
985 bus_dmamap_sync(sc_if->sk_cdata.sk_jumbo_rx_tag, rxd->rx_dmamap,
987 bus_dmamap_unload(sc_if->sk_cdata.sk_jumbo_rx_tag,
988 rxd->rx_dmamap);
990 map = rxd->rx_dmamap;
991 rxd->rx_dmamap = sc_if->sk_cdata.sk_jumbo_rx_sparemap;
992 sc_if->sk_cdata.sk_jumbo_rx_sparemap = map;
993 bus_dmamap_sync(sc_if->sk_cdata.sk_jumbo_rx_tag, rxd->rx_dmamap,
995 rxd->rx_m = m;
996 r = &sc_if->sk_rdata.sk_jumbo_rx_ring[idx];
997 r->sk_data_lo = htole32(SK_ADDR_LO(segs[0].ds_addr));
998 r->sk_data_hi = htole32(SK_ADDR_HI(segs[0].ds_addr));
999 r->sk_ctl = htole32(segs[0].ds_len | SK_RXSTAT | SK_OPCODE_CSUM);
1013 mii = device_get_softc(sc_if->sk_miibus);
1030 mii = device_get_softc(sc_if->sk_miibus);
1033 ifmr->ifm_active = mii->mii_media_active;
1034 ifmr->ifm_status = mii->mii_media_status;
1050 if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > SK_JUMBO_MTU)
1052 else if (if_getmtu(ifp) != ifr->ifr_mtu) {
1053 if (sc_if->sk_jumbo_disable != 0 &&
1054 ifr->ifr_mtu > SK_MAX_FRAMELEN)
1058 if_setmtu(ifp, ifr->ifr_mtu);
1071 if ((if_getflags(ifp) ^ sc_if->sk_if_flags)
1080 sc_if->sk_if_flags = if_getflags(ifp);
1092 mii = device_get_softc(sc_if->sk_miibus);
1093 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
1097 if (sc_if->sk_softc->sk_type == SK_GENESIS) {
1101 mask = ifr->ifr_reqcap ^ if_getcapenable(ifp);
1132 while(t->sk_name != NULL) {
1133 if ((pci_get_vendor(dev) == t->sk_vid) &&
1134 (pci_get_device(dev) == t->sk_did)) {
1139 if ((t->sk_vid == VENDORID_LINKSYS) &&
1140 (t->sk_did == DEVICEID_LINKSYS_EG1032) &&
1146 device_set_desc(dev, t->sk_name);
1164 if (SK_YUKON_FAMILY(sc->sk_type))
1171 if (SK_YUKON_FAMILY(sc->sk_type))
1174 if (sc->sk_type == SK_GENESIS) {
1189 * timer mask based on the timeout specified in the interrupt
1191 * register represents one tick, so to specify a timeout in
1193 * ticks-per-microsecond.
1195 switch (sc->sk_type) {
1197 sc->sk_int_ticks = SK_IMTIMER_TICKS_GENESIS;
1200 sc->sk_int_ticks = SK_IMTIMER_TICKS_YUKON;
1204 device_printf(sc->sk_dev, "interrupt moderation is %d us\n",
1205 sc->sk_int_mod);
1206 sk_win_write_4(sc, SK_IMTIMERINIT, SK_IM_USECS(sc->sk_int_mod,
1207 sc->sk_int_ticks));
1226 * for us.
1228 switch (sc->sk_type) {
1265 sc_if->sk_if_dev = dev;
1266 sc_if->sk_port = port;
1267 sc_if->sk_softc = sc;
1268 sc->sk_if[port] = sc_if;
1270 sc_if->sk_tx_bmu = SK_BMU_TXS_CSR0;
1272 sc_if->sk_tx_bmu = SK_BMU_TXS_CSR1;
1274 callout_init_mtx(&sc_if->sk_tick_ch, &sc_if->sk_softc->sk_mtx, 0);
1275 callout_init_mtx(&sc_if->sk_watchdog_ch, &sc_if->sk_softc->sk_mtx, 0);
1283 ifp = sc_if->sk_ifp = if_alloc(IFT_ETHER);
1288 * SK_GENESIS has a bug in checksum offload - From linux.
1290 if (sc_if->sk_softc->sk_type != SK_GENESIS) {
1311 if_setsendqlen(ifp, SK_TX_RING_CNT - 1);
1330 device_printf(sc_if->sk_if_dev,
1359 chunk = sc->sk_ramsize / 2;
1360 val = sc->sk_rboff / sizeof(u_int64_t);
1361 sc_if->sk_rx_ramstart = val;
1363 sc_if->sk_rx_ramend = val - 1;
1364 sc_if->sk_tx_ramstart = val;
1366 sc_if->sk_tx_ramend = val - 1;
1370 chunk = sc->sk_ramsize / 4;
1371 val = (sc->sk_rboff + (chunk * 2 * sc_if->sk_port)) /
1373 sc_if->sk_rx_ramstart = val;
1375 sc_if->sk_rx_ramend = val - 1;
1376 sc_if->sk_tx_ramstart = val;
1378 sc_if->sk_tx_ramend = val - 1;
1382 sc_if->sk_phytype = sk_win_read_1(sc, SK_EPROM1) & 0xF;
1383 if (!SK_YUKON_FAMILY(sc->sk_type)) {
1384 switch(sc_if->sk_phytype) {
1386 sc_if->sk_phyaddr = SK_PHYADDR_XMAC;
1389 sc_if->sk_phyaddr = SK_PHYADDR_BCOM;
1392 device_printf(sc->sk_dev, "unsupported PHY type: %d\n",
1393 sc_if->sk_phytype);
1399 if (sc_if->sk_phytype < SK_PHYTYPE_MARV_COPPER &&
1400 sc->sk_pmd != 'S') {
1402 sc_if->sk_phytype = SK_PHYTYPE_MARV_COPPER;
1403 sc->sk_coppertype = 1;
1406 sc_if->sk_phyaddr = SK_PHYADDR_MARV;
1408 if (!(sc->sk_coppertype))
1409 sc_if->sk_phytype = SK_PHYTYPE_MARV_FIBER;
1438 switch (sc->sk_type) {
1441 if (sc_if->sk_phytype == SK_PHYTYPE_XMAC)
1453 error = mii_attach(dev, &sc_if->sk_miibus, ifp, sk_ifmedia_upd,
1456 device_printf(sc_if->sk_if_dev, "attaching PHYs failed\n");
1464 sc->sk_if[port] = NULL;
1485 sc->sk_dev = dev;
1487 mtx_init(&sc->sk_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
1489 mtx_init(&sc->sk_mii_mtx, "sk_mii_mutex", NULL, MTX_DEF);
1497 sc->sk_res_spec = sk_res_spec_io;
1499 sc->sk_res_spec = sk_res_spec_mem;
1501 error = bus_alloc_resources(dev, sc->sk_res_spec, sc->sk_res);
1503 if (sc->sk_res_spec == sk_res_spec_mem)
1504 sc->sk_res_spec = sk_res_spec_io;
1506 sc->sk_res_spec = sk_res_spec_mem;
1507 error = bus_alloc_resources(dev, sc->sk_res_spec, sc->sk_res);
1510 sc->sk_res_spec == sk_res_spec_mem ? "memory" :
1516 sc->sk_type = sk_win_read_1(sc, SK_CHIPVER);
1517 sc->sk_rev = (sk_win_read_1(sc, SK_CONFIG) >> 4) & 0xf;
1520 if (sc->sk_type != SK_GENESIS && !SK_YUKON_FAMILY(sc->sk_type)) {
1522 sc->sk_type, sc->sk_rev);
1531 &sc->sk_int_mod, 0, sysctl_hw_sk_int_mod, "I",
1535 sc->sk_int_mod = SK_IM_DEFAULT;
1537 "int_mod", &sc->sk_int_mod);
1539 if (sc->sk_int_mod < SK_IM_MIN ||
1540 sc->sk_int_mod > SK_IM_MAX) {
1543 sc->sk_int_mod = SK_IM_DEFAULT;
1551 if (sc->sk_type == SK_GENESIS) {
1555 sc->sk_ramsize = 0x80000;
1556 sc->sk_rboff = SK_RBOFF_0;
1559 sc->sk_ramsize = 0x100000;
1560 sc->sk_rboff = SK_RBOFF_80000;
1563 sc->sk_ramsize = 0x100000;
1564 sc->sk_rboff = SK_RBOFF_0;
1567 sc->sk_ramsize = 0x200000;
1568 sc->sk_rboff = SK_RBOFF_0;
1577 sc->sk_ramsize = 0x20000;
1579 sc->sk_ramsize = skrs * (1<<12);
1580 sc->sk_rboff = SK_RBOFF_0;
1584 sc->sk_pmd = sk_win_read_1(sc, SK_PMDTYPE);
1586 if (sc->sk_pmd == 'T' || sc->sk_pmd == '1')
1587 sc->sk_coppertype = 1;
1589 sc->sk_coppertype = 0;
1605 switch (sc->sk_type) {
1625 if (sc->sk_type == SK_YUKON || sc->sk_type == SK_YUKON_LP) {
1637 sc->sk_type = SK_YUKON_LITE;
1638 sc->sk_rev = SK_YUKON_LITE_REV_A0;
1648 sc->sk_type, sc->sk_rev);
1653 if (sc->sk_type == SK_YUKON_LITE) {
1654 switch (sc->sk_rev) {
1675 pname, revstr, sc->sk_rev);
1678 device_printf(dev, "chip ver = 0x%02x\n", sc->sk_type);
1679 device_printf(dev, "chip rev = 0x%02x\n", sc->sk_rev);
1681 device_printf(dev, "SRAM size = 0x%06x\n", sc->sk_ramsize);
1684 sc->sk_devs[SK_PORT_A] = device_add_child(dev, "sk", DEVICE_UNIT_ANY);
1685 if (sc->sk_devs[SK_PORT_A] == NULL) {
1698 device_set_ivars(sc->sk_devs[SK_PORT_A], port);
1701 sc->sk_devs[SK_PORT_B] = device_add_child(dev, "sk", DEVICE_UNIT_ANY);
1702 if (sc->sk_devs[SK_PORT_B] == NULL) {
1715 device_set_ivars(sc->sk_devs[SK_PORT_B], port);
1724 error = bus_setup_intr(dev, sc->sk_res[1], INTR_TYPE_NET|INTR_MPSAFE,
1725 NULL, sk_intr, sc, &sc->sk_intrhand);
1759 KASSERT(mtx_initialized(&sc_if->sk_softc->sk_mtx),
1763 ifp = sc_if->sk_ifp;
1769 callout_drain(&sc_if->sk_tick_ch);
1770 callout_drain(&sc_if->sk_watchdog_ch);
1790 KASSERT(mtx_initialized(&sc->sk_mtx), ("sk mutex not initialized"));
1794 if (sc->sk_intrhand)
1795 bus_teardown_intr(dev, sc->sk_res[1], sc->sk_intrhand);
1796 bus_release_resources(dev, sc->sk_res_spec, sc->sk_res);
1798 mtx_destroy(&sc->sk_mii_mtx);
1799 mtx_destroy(&sc->sk_mtx);
1824 ctx->sk_busaddr = segs[0].ds_addr;
1830 * use them in their drivers. In order for us to use them, we need
1854 bus_get_dma_tag(sc_if->sk_if_dev),/* parent */
1864 &sc_if->sk_cdata.sk_parent_tag);
1866 device_printf(sc_if->sk_if_dev,
1872 error = bus_dma_tag_create(sc_if->sk_cdata.sk_parent_tag,/* parent */
1882 &sc_if->sk_cdata.sk_tx_ring_tag);
1884 device_printf(sc_if->sk_if_dev,
1890 error = bus_dma_tag_create(sc_if->sk_cdata.sk_parent_tag,/* parent */
1900 &sc_if->sk_cdata.sk_rx_ring_tag);
1902 device_printf(sc_if->sk_if_dev,
1908 error = bus_dma_tag_create(sc_if->sk_cdata.sk_parent_tag,/* parent */
1918 &sc_if->sk_cdata.sk_tx_tag);
1920 device_printf(sc_if->sk_if_dev,
1926 error = bus_dma_tag_create(sc_if->sk_cdata.sk_parent_tag,/* parent */
1936 &sc_if->sk_cdata.sk_rx_tag);
1938 device_printf(sc_if->sk_if_dev,
1944 error = bus_dmamem_alloc(sc_if->sk_cdata.sk_tx_ring_tag,
1945 (void **)&sc_if->sk_rdata.sk_tx_ring, BUS_DMA_NOWAIT |
1946 BUS_DMA_COHERENT | BUS_DMA_ZERO, &sc_if->sk_cdata.sk_tx_ring_map);
1948 device_printf(sc_if->sk_if_dev,
1954 error = bus_dmamap_load(sc_if->sk_cdata.sk_tx_ring_tag,
1955 sc_if->sk_cdata.sk_tx_ring_map, sc_if->sk_rdata.sk_tx_ring,
1958 device_printf(sc_if->sk_if_dev,
1962 sc_if->sk_rdata.sk_tx_ring_paddr = ctx.sk_busaddr;
1965 error = bus_dmamem_alloc(sc_if->sk_cdata.sk_rx_ring_tag,
1966 (void **)&sc_if->sk_rdata.sk_rx_ring, BUS_DMA_NOWAIT |
1967 BUS_DMA_COHERENT | BUS_DMA_ZERO, &sc_if->sk_cdata.sk_rx_ring_map);
1969 device_printf(sc_if->sk_if_dev,
1975 error = bus_dmamap_load(sc_if->sk_cdata.sk_rx_ring_tag,
1976 sc_if->sk_cdata.sk_rx_ring_map, sc_if->sk_rdata.sk_rx_ring,
1979 device_printf(sc_if->sk_if_dev,
1983 sc_if->sk_rdata.sk_rx_ring_paddr = ctx.sk_busaddr;
1987 txd = &sc_if->sk_cdata.sk_txdesc[i];
1988 txd->tx_m = NULL;
1989 txd->tx_dmamap = NULL;
1990 error = bus_dmamap_create(sc_if->sk_cdata.sk_tx_tag, 0,
1991 &txd->tx_dmamap);
1993 device_printf(sc_if->sk_if_dev,
2000 if ((error = bus_dmamap_create(sc_if->sk_cdata.sk_rx_tag, 0,
2001 &sc_if->sk_cdata.sk_rx_sparemap)) != 0) {
2002 device_printf(sc_if->sk_if_dev,
2007 rxd = &sc_if->sk_cdata.sk_rxdesc[i];
2008 rxd->rx_m = NULL;
2009 rxd->rx_dmamap = NULL;
2010 error = bus_dmamap_create(sc_if->sk_cdata.sk_rx_tag, 0,
2011 &rxd->rx_dmamap);
2013 device_printf(sc_if->sk_if_dev,
2031 device_printf(sc_if->sk_if_dev, "disabling jumbo frame support\n");
2032 sc_if->sk_jumbo_disable = 1;
2036 error = bus_dma_tag_create(sc_if->sk_cdata.sk_parent_tag,/* parent */
2046 &sc_if->sk_cdata.sk_jumbo_rx_ring_tag);
2048 device_printf(sc_if->sk_if_dev,
2054 error = bus_dma_tag_create(sc_if->sk_cdata.sk_parent_tag,/* parent */
2064 &sc_if->sk_cdata.sk_jumbo_rx_tag);
2066 device_printf(sc_if->sk_if_dev,
2072 error = bus_dmamem_alloc(sc_if->sk_cdata.sk_jumbo_rx_ring_tag,
2073 (void **)&sc_if->sk_rdata.sk_jumbo_rx_ring, BUS_DMA_NOWAIT |
2075 &sc_if->sk_cdata.sk_jumbo_rx_ring_map);
2077 device_printf(sc_if->sk_if_dev,
2083 error = bus_dmamap_load(sc_if->sk_cdata.sk_jumbo_rx_ring_tag,
2084 sc_if->sk_cdata.sk_jumbo_rx_ring_map,
2085 sc_if->sk_rdata.sk_jumbo_rx_ring, SK_JUMBO_RX_RING_SZ, sk_dmamap_cb,
2088 device_printf(sc_if->sk_if_dev,
2092 sc_if->sk_rdata.sk_jumbo_rx_ring_paddr = ctx.sk_busaddr;
2095 if ((error = bus_dmamap_create(sc_if->sk_cdata.sk_jumbo_rx_tag, 0,
2096 &sc_if->sk_cdata.sk_jumbo_rx_sparemap)) != 0) {
2097 device_printf(sc_if->sk_if_dev,
2102 jrxd = &sc_if->sk_cdata.sk_jumbo_rxdesc[i];
2103 jrxd->rx_m = NULL;
2104 jrxd->rx_dmamap = NULL;
2105 error = bus_dmamap_create(sc_if->sk_cdata.sk_jumbo_rx_tag, 0,
2106 &jrxd->rx_dmamap);
2108 device_printf(sc_if->sk_if_dev,
2118 device_printf(sc_if->sk_if_dev, "disabling jumbo frame support due to "
2120 sc_if->sk_jumbo_disable = 1;
2132 if (sc_if->sk_cdata.sk_tx_ring_tag) {
2133 if (sc_if->sk_rdata.sk_tx_ring_paddr)
2134 bus_dmamap_unload(sc_if->sk_cdata.sk_tx_ring_tag,
2135 sc_if->sk_cdata.sk_tx_ring_map);
2136 if (sc_if->sk_rdata.sk_tx_ring)
2137 bus_dmamem_free(sc_if->sk_cdata.sk_tx_ring_tag,
2138 sc_if->sk_rdata.sk_tx_ring,
2139 sc_if->sk_cdata.sk_tx_ring_map);
2140 sc_if->sk_rdata.sk_tx_ring = NULL;
2141 sc_if->sk_rdata.sk_tx_ring_paddr = 0;
2142 bus_dma_tag_destroy(sc_if->sk_cdata.sk_tx_ring_tag);
2143 sc_if->sk_cdata.sk_tx_ring_tag = NULL;
2146 if (sc_if->sk_cdata.sk_rx_ring_tag) {
2147 if (sc_if->sk_rdata.sk_rx_ring_paddr)
2148 bus_dmamap_unload(sc_if->sk_cdata.sk_rx_ring_tag,
2149 sc_if->sk_cdata.sk_rx_ring_map);
2150 if (sc_if->sk_rdata.sk_rx_ring)
2151 bus_dmamem_free(sc_if->sk_cdata.sk_rx_ring_tag,
2152 sc_if->sk_rdata.sk_rx_ring,
2153 sc_if->sk_cdata.sk_rx_ring_map);
2154 sc_if->sk_rdata.sk_rx_ring = NULL;
2155 sc_if->sk_rdata.sk_rx_ring_paddr = 0;
2156 bus_dma_tag_destroy(sc_if->sk_cdata.sk_rx_ring_tag);
2157 sc_if->sk_cdata.sk_rx_ring_tag = NULL;
2160 if (sc_if->sk_cdata.sk_tx_tag) {
2162 txd = &sc_if->sk_cdata.sk_txdesc[i];
2163 if (txd->tx_dmamap) {
2164 bus_dmamap_destroy(sc_if->sk_cdata.sk_tx_tag,
2165 txd->tx_dmamap);
2166 txd->tx_dmamap = NULL;
2169 bus_dma_tag_destroy(sc_if->sk_cdata.sk_tx_tag);
2170 sc_if->sk_cdata.sk_tx_tag = NULL;
2173 if (sc_if->sk_cdata.sk_rx_tag) {
2175 rxd = &sc_if->sk_cdata.sk_rxdesc[i];
2176 if (rxd->rx_dmamap) {
2177 bus_dmamap_destroy(sc_if->sk_cdata.sk_rx_tag,
2178 rxd->rx_dmamap);
2179 rxd->rx_dmamap = NULL;
2182 if (sc_if->sk_cdata.sk_rx_sparemap) {
2183 bus_dmamap_destroy(sc_if->sk_cdata.sk_rx_tag,
2184 sc_if->sk_cdata.sk_rx_sparemap);
2185 sc_if->sk_cdata.sk_rx_sparemap = NULL;
2187 bus_dma_tag_destroy(sc_if->sk_cdata.sk_rx_tag);
2188 sc_if->sk_cdata.sk_rx_tag = NULL;
2191 if (sc_if->sk_cdata.sk_parent_tag) {
2192 bus_dma_tag_destroy(sc_if->sk_cdata.sk_parent_tag);
2193 sc_if->sk_cdata.sk_parent_tag = NULL;
2204 if (sc_if->sk_cdata.sk_jumbo_rx_ring_tag) {
2205 if (sc_if->sk_rdata.sk_jumbo_rx_ring_paddr)
2206 bus_dmamap_unload(sc_if->sk_cdata.sk_jumbo_rx_ring_tag,
2207 sc_if->sk_cdata.sk_jumbo_rx_ring_map);
2208 if (sc_if->sk_rdata.sk_jumbo_rx_ring)
2209 bus_dmamem_free(sc_if->sk_cdata.sk_jumbo_rx_ring_tag,
2210 sc_if->sk_rdata.sk_jumbo_rx_ring,
2211 sc_if->sk_cdata.sk_jumbo_rx_ring_map);
2212 sc_if->sk_rdata.sk_jumbo_rx_ring = NULL;
2213 sc_if->sk_rdata.sk_jumbo_rx_ring_paddr = 0;
2214 bus_dma_tag_destroy(sc_if->sk_cdata.sk_jumbo_rx_ring_tag);
2215 sc_if->sk_cdata.sk_jumbo_rx_ring_tag = NULL;
2219 if (sc_if->sk_cdata.sk_jumbo_rx_tag) {
2221 jrxd = &sc_if->sk_cdata.sk_jumbo_rxdesc[i];
2222 if (jrxd->rx_dmamap) {
2224 sc_if->sk_cdata.sk_jumbo_rx_tag,
2225 jrxd->rx_dmamap);
2226 jrxd->rx_dmamap = NULL;
2229 if (sc_if->sk_cdata.sk_jumbo_rx_sparemap) {
2230 bus_dmamap_destroy(sc_if->sk_cdata.sk_jumbo_rx_tag,
2231 sc_if->sk_cdata.sk_jumbo_rx_sparemap);
2232 sc_if->sk_cdata.sk_jumbo_rx_sparemap = NULL;
2234 bus_dma_tag_destroy(sc_if->sk_cdata.sk_jumbo_rx_tag);
2235 sc_if->sk_cdata.sk_jumbo_rx_tag = NULL;
2247 for(; m && m->m_len == 0; m = m->m_next)
2249 if (m == NULL || m->m_len < ETHER_HDR_LEN) {
2254 if (m->m_len < ETHER_HDR_LEN + sizeof(u_int32_t)) {
2255 if (m->m_len != ETHER_HDR_LEN) {
2261 for(m = m->m_next; m && m->m_len == 0; m = m->m_next)
2274 offset = (ip->ip_hl << 2) + ETHER_HDR_LEN;
2277 f->sk_csum_startval = 0;
2278 f->sk_csum_start = htole32(((offset + m->m_pkthdr.csum_data) & 0xffff) |
2294 if ((txd = STAILQ_FIRST(&sc_if->sk_cdata.sk_txfreeq)) == NULL)
2297 error = bus_dmamap_load_mbuf_sg(sc_if->sk_cdata.sk_tx_tag,
2298 txd->tx_dmamap, *m_head, txsegs, &nseg, 0);
2307 error = bus_dmamap_load_mbuf_sg(sc_if->sk_cdata.sk_tx_tag,
2308 txd->tx_dmamap, *m_head, txsegs, &nseg, 0);
2321 if (sc_if->sk_cdata.sk_tx_cnt + nseg >= SK_TX_RING_CNT) {
2322 bus_dmamap_unload(sc_if->sk_cdata.sk_tx_tag, txd->tx_dmamap);
2327 if ((m->m_pkthdr.csum_flags & if_gethwassist(sc_if->sk_ifp)) != 0)
2331 si = frag = sc_if->sk_cdata.sk_tx_prod;
2333 f = &sc_if->sk_rdata.sk_tx_ring[frag];
2334 f->sk_data_lo = htole32(SK_ADDR_LO(txsegs[i].ds_addr));
2335 f->sk_data_hi = htole32(SK_ADDR_HI(txsegs[i].ds_addr));
2339 sk_txcksum(sc_if->sk_ifp, m, f);
2343 f->sk_ctl = htole32(sk_ctl);
2344 sc_if->sk_cdata.sk_tx_cnt++;
2347 sc_if->sk_cdata.sk_tx_prod = frag;
2350 frag = (frag + SK_TX_RING_CNT - 1) % SK_TX_RING_CNT;
2351 f = &sc_if->sk_rdata.sk_tx_ring[frag];
2352 f->sk_ctl |= htole32(SK_TXCTL_LASTFRAG | SK_TXCTL_EOF_INTR);
2355 f = &sc_if->sk_rdata.sk_tx_ring[si];
2356 f->sk_ctl |= htole32(SK_TXCTL_OWN);
2358 STAILQ_REMOVE_HEAD(&sc_if->sk_cdata.sk_txfreeq, tx_q);
2359 STAILQ_INSERT_TAIL(&sc_if->sk_cdata.sk_txbusyq, txd, tx_q);
2360 txd->tx_m = m;
2363 bus_dmamap_sync(sc_if->sk_cdata.sk_tx_tag, txd->tx_dmamap,
2365 bus_dmamap_sync(sc_if->sk_cdata.sk_tx_ring_tag,
2366 sc_if->sk_cdata.sk_tx_ring_map,
2395 sc = sc_if->sk_softc;
2400 sc_if->sk_cdata.sk_tx_cnt < SK_TX_RING_CNT - 1; ) {
2428 CSR_WRITE_4(sc, sc_if->sk_tx_bmu, SK_TXBMU_TX_START);
2430 /* Set a timeout in case the chip goes out to lunch. */
2431 sc_if->sk_watchdog_timer = 5;
2446 if (sc_if->sk_watchdog_timer == 0 || --sc_if->sk_watchdog_timer)
2454 if (sc_if->sk_cdata.sk_tx_cnt != 0) {
2455 if_printf(sc_if->sk_ifp, "watchdog timeout\n");
2462 callout_reset(&sc_if->sk_watchdog_ch, hz, sk_watchdog, ifp);
2499 sc_if0 = sc->sk_if[SK_PORT_A];
2500 sc_if1 = sc->sk_if[SK_PORT_B];
2502 ifp0 = sc_if0->sk_ifp;
2504 ifp1 = sc_if1->sk_ifp;
2509 sc->sk_suspended = 1;
2527 sc_if0 = sc->sk_if[SK_PORT_A];
2528 sc_if1 = sc->sk_if[SK_PORT_B];
2530 ifp0 = sc_if0->sk_ifp;
2532 ifp1 = sc_if1->sk_ifp;
2537 sc->sk_suspended = 0;
2545 * According to the data sheet from SK-NET GENESIS the hardware can compute
2566 pktlen = m->m_pkthdr.len;
2570 if (eh->ether_type != htons(ETHERTYPE_IP))
2573 if (ip->ip_v != IPVERSION)
2575 hlen = ip->ip_hl << 2;
2576 pktlen -= sizeof(struct ether_header);
2579 if (ntohs(ip->ip_len) < hlen)
2581 if (ntohs(ip->ip_len) != pktlen)
2588 len = hlen - sizeof(struct ip);
2602 m->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
2604 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
2611 if (sc->sk_type == SK_GENESIS) {
2638 sc = sc_if->sk_softc;
2639 ifp = sc_if->sk_ifp;
2643 bus_dmamap_sync(sc_if->sk_cdata.sk_rx_ring_tag,
2644 sc_if->sk_cdata.sk_rx_ring_map, BUS_DMASYNC_POSTREAD);
2647 for (cons = sc_if->sk_cdata.sk_rx_cons; prog < SK_RX_RING_CNT;
2649 cur_rx = &sc_if->sk_rdata.sk_rx_ring[cons];
2650 sk_ctl = le32toh(cur_rx->sk_ctl);
2653 rxd = &sc_if->sk_cdata.sk_rxdesc[cons];
2654 rxstat = le32toh(cur_rx->sk_xmac_rxstat);
2667 m = rxd->rx_m;
2668 csum = le32toh(cur_rx->sk_csum);
2675 m->m_pkthdr.rcvif = ifp;
2676 m->m_pkthdr.len = m->m_len = SK_RXBYTES(sk_ctl);
2686 sc_if->sk_cdata.sk_rx_cons = cons;
2687 bus_dmamap_sync(sc_if->sk_cdata.sk_rx_ring_tag,
2688 sc_if->sk_cdata.sk_rx_ring_map,
2704 sc = sc_if->sk_softc;
2705 ifp = sc_if->sk_ifp;
2709 bus_dmamap_sync(sc_if->sk_cdata.sk_jumbo_rx_ring_tag,
2710 sc_if->sk_cdata.sk_jumbo_rx_ring_map, BUS_DMASYNC_POSTREAD);
2713 for (cons = sc_if->sk_cdata.sk_jumbo_rx_cons;
2716 cur_rx = &sc_if->sk_rdata.sk_jumbo_rx_ring[cons];
2717 sk_ctl = le32toh(cur_rx->sk_ctl);
2720 jrxd = &sc_if->sk_cdata.sk_jumbo_rxdesc[cons];
2721 rxstat = le32toh(cur_rx->sk_xmac_rxstat);
2734 m = jrxd->rx_m;
2735 csum = le32toh(cur_rx->sk_csum);
2742 m->m_pkthdr.rcvif = ifp;
2743 m->m_pkthdr.len = m->m_len = SK_RXBYTES(sk_ctl);
2753 sc_if->sk_cdata.sk_jumbo_rx_cons = cons;
2754 bus_dmamap_sync(sc_if->sk_cdata.sk_jumbo_rx_ring_tag,
2755 sc_if->sk_cdata.sk_jumbo_rx_ring_map,
2768 ifp = sc_if->sk_ifp;
2770 txd = STAILQ_FIRST(&sc_if->sk_cdata.sk_txbusyq);
2773 bus_dmamap_sync(sc_if->sk_cdata.sk_tx_ring_tag,
2774 sc_if->sk_cdata.sk_tx_ring_map, BUS_DMASYNC_POSTREAD);
2779 for (idx = sc_if->sk_cdata.sk_tx_cons;; SK_INC(idx, SK_TX_RING_CNT)) {
2780 if (sc_if->sk_cdata.sk_tx_cnt <= 0)
2782 cur_tx = &sc_if->sk_rdata.sk_tx_ring[idx];
2783 sk_ctl = le32toh(cur_tx->sk_ctl);
2786 sc_if->sk_cdata.sk_tx_cnt--;
2790 bus_dmamap_sync(sc_if->sk_cdata.sk_tx_tag, txd->tx_dmamap,
2792 bus_dmamap_unload(sc_if->sk_cdata.sk_tx_tag, txd->tx_dmamap);
2795 m_freem(txd->tx_m);
2796 txd->tx_m = NULL;
2797 STAILQ_REMOVE_HEAD(&sc_if->sk_cdata.sk_txbusyq, tx_q);
2798 STAILQ_INSERT_TAIL(&sc_if->sk_cdata.sk_txfreeq, txd, tx_q);
2799 txd = STAILQ_FIRST(&sc_if->sk_cdata.sk_txbusyq);
2801 sc_if->sk_cdata.sk_tx_cons = idx;
2802 sc_if->sk_watchdog_timer = sc_if->sk_cdata.sk_tx_cnt > 0 ? 5 : 0;
2804 bus_dmamap_sync(sc_if->sk_cdata.sk_tx_ring_tag,
2805 sc_if->sk_cdata.sk_tx_ring_map,
2818 ifp = sc_if->sk_ifp;
2819 mii = device_get_softc(sc_if->sk_miibus);
2824 if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
2842 callout_reset(&sc_if->sk_tick_ch, hz, sk_tick, sc_if);
2850 callout_stop(&sc_if->sk_tick_ch);
2860 mii = device_get_softc(sc_if->sk_miibus);
2863 callout_reset(&sc_if->sk_tick_ch, hz, sk_yukon_tick, sc_if);
2872 mii = device_get_softc(sc_if->sk_miibus);
2873 ifp = sc_if->sk_ifp;
2893 if (!(lstat & BRGPHY_AUXSTS_LINK) && sc_if->sk_link) {
2898 sc_if->sk_link = 0;
2903 sc_if->sk_link = 1;
2910 callout_reset(&sc_if->sk_tick_ch, hz, sk_tick, sc_if);
2927 * Link has gone down. Start MII tick timeout to
2930 if (sc_if->sk_phytype == SK_PHYTYPE_XMAC) {
2933 callout_reset(&sc_if->sk_tick_ch, hz, sk_tick, sc_if);
2937 callout_reset(&sc_if->sk_tick_ch, hz, sk_tick, sc_if);
2981 if (status == 0 || status == 0xffffffff || sc->sk_suspended)
2984 sc_if0 = sc->sk_if[SK_PORT_A];
2985 sc_if1 = sc->sk_if[SK_PORT_B];
2988 ifp0 = sc_if0->sk_ifp;
2990 ifp1 = sc_if1->sk_ifp;
2992 for (; (status &= sc->sk_intrmask) != 0;) {
3024 if (sc->sk_type == SK_GENESIS)
3032 if (sc->sk_type == SK_GENESIS)
3040 sc_if0->sk_phytype == SK_PHYTYPE_BCOM)
3043 sc_if1->sk_phytype == SK_PHYTYPE_BCOM)
3049 CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
3074 sc = sc_if->sk_softc;
3075 ifp = sc_if->sk_ifp;
3085 sc_if->sk_xmac_rev = XM_XMAC_REV(SK_XM_READ_4(sc_if, XM_DEVID));
3092 if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
3098 if (sc_if->sk_port == SK_PORT_A)
3130 bcopy(if_getlladdr(sc_if->sk_ifp), eaddr, ETHER_ADDR_LEN);
3181 if (sc_if->sk_phytype == SK_PHYTYPE_XMAC)
3187 switch(sc_if->sk_xmac_rev) {
3216 sc_if->sk_link = 1;
3233 sc = sc_if->sk_softc;
3234 ifp = sc_if->sk_ifp;
3236 if (sc->sk_type == SK_YUKON_LITE &&
3237 sc->sk_rev >= SK_YUKON_LITE_REV_A3) {
3253 if (sc->sk_type == SK_YUKON_LITE &&
3254 sc->sk_rev >= SK_YUKON_LITE_REV_A3) {
3267 if (sc->sk_coppertype)
3305 eaddr = if_getlladdr(sc_if->sk_ifp);
3332 /* Disable RX MAC FIFO Flush for YUKON-Lite Rev. A0 only */
3333 if (sc->sk_type == SK_YUKON_LITE && sc->sk_rev == SK_YUKON_LITE_REV_A0)
3378 ifp = sc_if->sk_ifp;
3379 sc = sc_if->sk_softc;
3380 mii = device_get_softc(sc_if->sk_miibus);
3388 if (sc->sk_type == SK_GENESIS) {
3406 * SK-NET GENESIS data sheet says that possibility of losing Start
3409 * mechanism to send a Start transmit command to initiate transfer
3422 /* Configure I2C registers */
3425 switch (sc->sk_type) {
3437 if (sc->sk_type == SK_GENESIS) {
3454 SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_START, sc_if->sk_rx_ramstart);
3455 SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_WR_PTR, sc_if->sk_rx_ramstart);
3456 SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_RD_PTR, sc_if->sk_rx_ramstart);
3457 SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_END, sc_if->sk_rx_ramend);
3462 SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_START, sc_if->sk_tx_ramstart);
3463 SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_WR_PTR, sc_if->sk_tx_ramstart);
3464 SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_RD_PTR, sc_if->sk_tx_ramstart);
3465 SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_END, sc_if->sk_tx_ramend);
3494 device_printf(sc_if->sk_if_dev,
3503 if (imr != SK_IM_USECS(sc->sk_int_mod, sc->sk_int_ticks)) {
3504 sk_win_write_4(sc, SK_IMTIMERINIT, SK_IM_USECS(sc->sk_int_mod,
3505 sc->sk_int_ticks));
3507 device_printf(sc_if->sk_if_dev,
3508 "interrupt moderation is %d us.\n",
3509 sc->sk_int_mod);
3514 if (sc_if->sk_port == SK_PORT_A)
3515 sc->sk_intrmask |= SK_INTRS1;
3517 sc->sk_intrmask |= SK_INTRS2;
3519 sc->sk_intrmask |= SK_ISR_EXTERNAL_REG;
3521 CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
3526 switch(sc->sk_type) {
3546 /* start transfer of Tx descriptors */
3547 CSR_WRITE_4(sc, sc_if->sk_tx_bmu, SK_TXBMU_TX_START);
3552 switch (sc->sk_type) {
3556 callout_reset(&sc_if->sk_tick_ch, hz, sk_yukon_tick, sc_if);
3560 callout_reset(&sc_if->sk_watchdog_ch, hz, sk_watchdog, ifp);
3577 sc = sc_if->sk_softc;
3578 ifp = sc_if->sk_ifp;
3580 callout_stop(&sc_if->sk_tick_ch);
3581 callout_stop(&sc_if->sk_watchdog_ch);
3585 /* stop transfer of Tx descriptors */
3586 CSR_WRITE_4(sc, sc_if->sk_tx_bmu, SK_TXBMU_TX_STOP);
3588 val = CSR_READ_4(sc, sc_if->sk_tx_bmu);
3594 device_printf(sc_if->sk_if_dev,
3595 "can not stop transfer of Tx descriptor\n");
3596 /* stop transfer of Rx descriptors */
3605 device_printf(sc_if->sk_if_dev,
3606 "can not stop transfer of Rx descriptor\n");
3608 if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
3611 if (sc_if->sk_port == SK_PORT_A) {
3623 switch (sc->sk_type) {
3646 if (sc_if->sk_port == SK_PORT_A)
3647 sc->sk_intrmask &= ~SK_INTRS1;
3649 sc->sk_intrmask &= ~SK_INTRS2;
3650 CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
3657 rxd = &sc_if->sk_cdata.sk_rxdesc[i];
3658 if (rxd->rx_m != NULL) {
3659 bus_dmamap_sync(sc_if->sk_cdata.sk_rx_tag,
3660 rxd->rx_dmamap, BUS_DMASYNC_POSTREAD);
3661 bus_dmamap_unload(sc_if->sk_cdata.sk_rx_tag,
3662 rxd->rx_dmamap);
3663 m_freem(rxd->rx_m);
3664 rxd->rx_m = NULL;
3668 jrxd = &sc_if->sk_cdata.sk_jumbo_rxdesc[i];
3669 if (jrxd->rx_m != NULL) {
3670 bus_dmamap_sync(sc_if->sk_cdata.sk_jumbo_rx_tag,
3671 jrxd->rx_dmamap, BUS_DMASYNC_POSTREAD);
3672 bus_dmamap_unload(sc_if->sk_cdata.sk_jumbo_rx_tag,
3673 jrxd->rx_dmamap);
3674 m_freem(jrxd->rx_m);
3675 jrxd->rx_m = NULL;
3679 txd = &sc_if->sk_cdata.sk_txdesc[i];
3680 if (txd->tx_m != NULL) {
3681 bus_dmamap_sync(sc_if->sk_cdata.sk_tx_tag,
3682 txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
3683 bus_dmamap_unload(sc_if->sk_cdata.sk_tx_tag,
3684 txd->tx_dmamap);
3685 m_freem(txd->tx_m);
3686 txd->tx_m = NULL;
3704 if (error || !req->newptr)