Lines Matching defs:sky2
41 #include "sky2.h"
43 #define DRV_NAME "sky2"
327 struct sky2_port *sky2 = netdev_priv(hw->dev[port]);
330 if ( (sky2->flags & SKY2_FLAG_AUTO_SPEED) &&
372 if ( (sky2->flags & SKY2_FLAG_AUTO_SPEED) &&
417 if (sky2->flags & SKY2_FLAG_AUTO_SPEED) {
419 if (sky2->advertising & ADVERTISED_1000baseT_Full)
421 if (sky2->advertising & ADVERTISED_1000baseT_Half)
423 if (sky2->advertising & ADVERTISED_100baseT_Full)
425 if (sky2->advertising & ADVERTISED_100baseT_Half)
427 if (sky2->advertising & ADVERTISED_10baseT_Full)
429 if (sky2->advertising & ADVERTISED_10baseT_Half)
433 if (sky2->advertising & ADVERTISED_1000baseT_Full)
435 if (sky2->advertising & ADVERTISED_1000baseT_Half)
448 switch (sky2->speed) {
459 if (sky2->duplex == DUPLEX_FULL) {
462 } else if (sky2->speed < SPEED_1000)
463 sky2->flow_mode = FC_NONE;
466 if (sky2->flags & SKY2_FLAG_AUTO_PAUSE) {
468 adv |= copper_fc_adv[sky2->flow_mode];
470 adv |= fiber_fc_adv[sky2->flow_mode];
473 reg |= gm_fc_disable[sky2->flow_mode];
476 if (sky2->flow_mode & FC_RX)
617 if (!(sky2->flags & SKY2_FLAG_AUTO_SPEED) ||
618 sky2->speed == SPEED_100) {
686 if (sky2->flags & SKY2_FLAG_AUTO_SPEED)
772 static void sky2_set_ipg(struct sky2_port *sky2)
776 reg = gma_read16(sky2->hw, sky2->port, GM_SERIAL_MODE);
778 if (sky2->speed > SPEED_100)
782 gma_write16(sky2->hw, sky2->port, GM_SERIAL_MODE, reg);
786 static void sky2_enable_rx_tx(struct sky2_port *sky2)
788 struct sky2_hw *hw = sky2->hw;
789 unsigned port = sky2->port;
798 static void sky2_phy_reinit(struct sky2_port *sky2)
800 spin_lock_bh(&sky2->phy_lock);
801 sky2_phy_init(sky2->hw, sky2->port);
802 sky2_enable_rx_tx(sky2);
803 spin_unlock_bh(&sky2->phy_lock);
807 static void sky2_wol_init(struct sky2_port *sky2)
809 struct sky2_hw *hw = sky2->hw;
810 unsigned port = sky2->port;
824 save_mode = sky2->flow_mode;
825 ctrl = sky2->advertising;
827 sky2->advertising &= ~(ADVERTISED_1000baseT_Half|ADVERTISED_1000baseT_Full);
828 sky2->flow_mode = FC_NONE;
830 spin_lock_bh(&sky2->phy_lock);
833 spin_unlock_bh(&sky2->phy_lock);
835 sky2->flow_mode = save_mode;
836 sky2->advertising = ctrl;
845 sky2->netdev->dev_addr, ETH_ALEN);
850 if (sky2->wol & WAKE_PHY)
855 if (sky2->wol & WAKE_MAGIC)
899 struct sky2_port *sky2 = netdev_priv(hw->dev[port]);
929 spin_lock_bh(&sky2->phy_lock);
932 spin_unlock_bh(&sky2->phy_lock);
1100 static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2, u16 *slot)
1102 struct sky2_tx_le *le = sky2->tx_le + *slot;
1104 *slot = RING_NEXT(*slot, sky2->tx_ring_size);
1109 static void tx_init(struct sky2_port *sky2)
1113 sky2->tx_prod = sky2->tx_cons = 0;
1114 sky2->tx_tcpsum = 0;
1115 sky2->tx_last_mss = 0;
1116 netdev_reset_queue(sky2->netdev);
1118 le = get_tx_le(sky2, &sky2->tx_prod);
1121 sky2->tx_last_upper = 0;
1133 static inline struct sky2_rx_le *sky2_next_rx(struct sky2_port *sky2)
1135 struct sky2_rx_le *le = sky2->rx_le + sky2->rx_put;
1136 sky2->rx_put = RING_NEXT(sky2->rx_put, RX_LE_SIZE);
1141 static unsigned sky2_get_rx_threshold(struct sky2_port *sky2)
1146 size = roundup(sky2->netdev->mtu + ETH_HLEN + VLAN_HLEN, 8);
1152 static unsigned sky2_get_rx_data_size(struct sky2_port *sky2)
1158 size = roundup(sky2->netdev->mtu + ETH_HLEN + VLAN_HLEN, 8);
1160 sky2->rx_nfrags = size >> PAGE_SHIFT;
1161 BUG_ON(sky2->rx_nfrags > ARRAY_SIZE(re->frag_addr));
1164 size -= sky2->rx_nfrags << PAGE_SHIFT;
1176 static void sky2_rx_add(struct sky2_port *sky2, u8 op,
1182 le = sky2_next_rx(sky2);
1187 le = sky2_next_rx(sky2);
1194 static void sky2_rx_submit(struct sky2_port *sky2,
1199 sky2_rx_add(sky2, OP_PACKET, re->data_addr, sky2->rx_data_size);
1202 sky2_rx_add(sky2, OP_BUFFER, re->frag_addr[i], PAGE_SIZE);
1266 static void rx_set_checksum(struct sky2_port *sky2)
1268 struct sky2_rx_le *le = sky2_next_rx(sky2);
1274 sky2_write32(sky2->hw,
1275 Q_ADDR(rxqaddr[sky2->port], Q_CSR),
1276 (sky2->netdev->features & NETIF_F_RXCSUM)
1283 struct sky2_port *sky2 = netdev_priv(dev);
1284 struct sky2_hw *hw = sky2->hw;
1290 sky2_write32(hw, SK_REG(sky2->port, RSS_CFG), HASH_ALL);
1299 sky2_write32(hw, SK_REG(sky2->port, RSS_KEY + i * 4),
1303 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T),
1306 sky2_write32(hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR),
1309 sky2_write32(hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR),
1323 static void sky2_rx_stop(struct sky2_port *sky2)
1325 struct sky2_hw *hw = sky2->hw;
1326 unsigned rxq = rxqaddr[sky2->port];
1337 netdev_warn(sky2->netdev, "receiver stop failed\n");
1346 static void sky2_rx_clean(struct sky2_port *sky2)
1350 if (sky2->rx_le)
1351 memset(sky2->rx_le, 0, RX_LE_BYTES);
1353 for (i = 0; i < sky2->rx_pending; i++) {
1354 struct rx_ring_info *re = sky2->rx_ring + i;
1357 sky2_rx_unmap_skb(sky2->hw->pdev, re);
1368 struct sky2_port *sky2 = netdev_priv(dev);
1369 struct sky2_hw *hw = sky2->hw;
1383 spin_lock_bh(&sky2->phy_lock);
1384 err = __gm_phy_read(hw, sky2->port, data->reg_num & 0x1f, &val);
1385 spin_unlock_bh(&sky2->phy_lock);
1392 spin_lock_bh(&sky2->phy_lock);
1393 err = gm_phy_write(hw, sky2->port, data->reg_num & 0x1f,
1395 spin_unlock_bh(&sky2->phy_lock);
1405 struct sky2_port *sky2 = netdev_priv(dev);
1406 struct sky2_hw *hw = sky2->hw;
1407 u16 port = sky2->port;
1440 static struct sk_buff *sky2_rx_alloc(struct sky2_port *sky2, gfp_t gfp)
1445 skb = __netdev_alloc_skb(sky2->netdev,
1446 sky2->rx_data_size + sky2_rx_pad(sky2->hw),
1451 if (sky2->hw->flags & SKY2_HW_RAM_BUFFER) {
1464 for (i = 0; i < sky2->rx_nfrags; i++) {
1479 static inline void sky2_rx_update(struct sky2_port *sky2, unsigned rxq)
1481 sky2_put_idx(sky2->hw, rxq, sky2->rx_put);
1484 static int sky2_alloc_rx_skbs(struct sky2_port *sky2)
1486 struct sky2_hw *hw = sky2->hw;
1489 sky2->rx_data_size = sky2_get_rx_data_size(sky2);
1492 for (i = 0; i < sky2->rx_pending; i++) {
1493 struct rx_ring_info *re = sky2->rx_ring + i;
1495 re->skb = sky2_rx_alloc(sky2, GFP_KERNEL);
1499 if (sky2_rx_map_skb(hw->pdev, re, sky2->rx_data_size)) {
1517 static void sky2_rx_start(struct sky2_port *sky2)
1519 struct sky2_hw *hw = sky2->hw;
1521 unsigned rxq = rxqaddr[sky2->port];
1524 sky2->rx_put = sky2->rx_next = 0;
1537 sky2_prefetch_init(hw, rxq, sky2->rx_le_map, RX_LE_SIZE - 1);
1540 rx_set_checksum(sky2);
1543 rx_set_rss(sky2->netdev, sky2->netdev->features);
1546 for (i = 0; i < sky2->rx_pending; i++) {
1547 re = sky2->rx_ring + i;
1548 sky2_rx_submit(sky2, re);
1557 thresh = sky2_get_rx_threshold(sky2);
1559 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_OFF);
1561 sky2_write16(hw, SK_REG(sky2->port, RX_GMF_TR_THR), thresh);
1562 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_TRUNC_ON);
1566 sky2_rx_update(sky2, rxq);
1577 sky2_write32(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), RX_MACSEC_FLUSH_OFF);
1582 sky2_write16(hw, SK_REG(sky2->port, RX_GMF_FL_CTRL),
1586 sky2_write32(hw, Q_ADDR(txqaddr[sky2->port], Q_TEST),
1591 static int sky2_alloc_buffers(struct sky2_port *sky2)
1593 struct sky2_hw *hw = sky2->hw;
1596 sky2->tx_le = dma_alloc_coherent(&hw->pdev->dev,
1597 sky2->tx_ring_size * sizeof(struct sky2_tx_le),
1598 &sky2->tx_le_map, GFP_KERNEL);
1599 if (!sky2->tx_le)
1602 sky2->tx_ring = kcalloc(sky2->tx_ring_size, sizeof(struct tx_ring_info),
1604 if (!sky2->tx_ring)
1607 sky2->rx_le = dma_alloc_coherent(&hw->pdev->dev, RX_LE_BYTES,
1608 &sky2->rx_le_map, GFP_KERNEL);
1609 if (!sky2->rx_le)
1612 sky2->rx_ring = kcalloc(sky2->rx_pending, sizeof(struct rx_ring_info),
1614 if (!sky2->rx_ring)
1617 return sky2_alloc_rx_skbs(sky2);
1622 static void sky2_free_buffers(struct sky2_port *sky2)
1624 struct sky2_hw *hw = sky2->hw;
1626 sky2_rx_clean(sky2);
1628 if (sky2->rx_le) {
1629 dma_free_coherent(&hw->pdev->dev, RX_LE_BYTES, sky2->rx_le,
1630 sky2->rx_le_map);
1631 sky2->rx_le = NULL;
1633 if (sky2->tx_le) {
1635 sky2->tx_ring_size * sizeof(struct sky2_tx_le),
1636 sky2->tx_le, sky2->tx_le_map);
1637 sky2->tx_le = NULL;
1639 kfree(sky2->tx_ring);
1640 kfree(sky2->rx_ring);
1642 sky2->tx_ring = NULL;
1643 sky2->rx_ring = NULL;
1646 static void sky2_hw_up(struct sky2_port *sky2)
1648 struct sky2_hw *hw = sky2->hw;
1649 unsigned port = sky2->port;
1652 struct net_device *otherdev = hw->dev[sky2->port^1];
1654 tx_init(sky2);
1676 netdev_dbg(sky2->netdev, "ram buffer %dK\n", ramsize);
1701 sky2_prefetch_init(hw, txqaddr[port], sky2->tx_le_map,
1702 sky2->tx_ring_size - 1);
1704 sky2_vlan_mode(sky2->netdev, sky2->netdev->features);
1705 netdev_update_features(sky2->netdev);
1707 sky2_rx_start(sky2);
1736 struct sky2_port *sky2 = netdev_priv(dev);
1737 struct sky2_hw *hw = sky2->hw;
1738 unsigned port = sky2->port;
1744 err = sky2_alloc_buffers(sky2);
1752 sky2_hw_up(sky2);
1766 netif_info(sky2, ifup, dev, "enabling interface\n");
1771 sky2_free_buffers(sky2);
1776 static inline int tx_inuse(const struct sky2_port *sky2)
1778 return (sky2->tx_prod - sky2->tx_cons) & (sky2->tx_ring_size - 1);
1782 static inline int tx_avail(const struct sky2_port *sky2)
1784 return sky2->tx_pending - tx_inuse(sky2);
1826 struct sky2_port *sky2 = netdev_priv(dev);
1827 struct sky2_hw *hw = sky2->hw;
1837 if (unlikely(tx_avail(sky2) < tx_le_req(skb)))
1847 slot = sky2->tx_prod;
1848 netif_printk(sky2, tx_queued, KERN_DEBUG, dev,
1853 if (upper != sky2->tx_last_upper) {
1854 le = get_tx_le(sky2, &slot);
1856 sky2->tx_last_upper = upper;
1867 if (mss != sky2->tx_last_mss) {
1868 le = get_tx_le(sky2, &slot);
1875 sky2->tx_last_mss = mss;
1884 le = get_tx_le(sky2, &slot);
1909 if (tcpsum != sky2->tx_tcpsum) {
1910 sky2->tx_tcpsum = tcpsum;
1912 le = get_tx_le(sky2, &slot);
1921 re = sky2->tx_ring + slot;
1926 le = get_tx_le(sky2, &slot);
1943 if (upper != sky2->tx_last_upper) {
1944 le = get_tx_le(sky2, &slot);
1946 sky2->tx_last_upper = upper;
1950 re = sky2->tx_ring + slot;
1955 le = get_tx_le(sky2, &slot);
1965 sky2->tx_prod = slot;
1967 if (tx_avail(sky2) <= MAX_SKB_TX_LE)
1971 sky2_put_idx(hw, txqaddr[sky2->port], sky2->tx_prod);
1976 for (i = sky2->tx_prod; i != slot; i = RING_NEXT(i, sky2->tx_ring_size)) {
1977 re = sky2->tx_ring + i;
1999 static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
2001 struct net_device *dev = sky2->netdev;
2005 BUG_ON(done >= sky2->tx_ring_size);
2007 for (idx = sky2->tx_cons; idx != done;
2008 idx = RING_NEXT(idx, sky2->tx_ring_size)) {
2009 struct tx_ring_info *re = sky2->tx_ring + idx;
2012 sky2_tx_unmap(sky2->hw->pdev, re);
2015 netif_printk(sky2, tx_done, KERN_DEBUG, dev,
2024 sky2->tx_next = RING_NEXT(idx, sky2->tx_ring_size);
2028 sky2->tx_cons = idx;
2033 u64_stats_update_begin(&sky2->tx_stats.syncp);
2034 sky2->tx_stats.packets += pkts_compl;
2035 sky2->tx_stats.bytes += bytes_compl;
2036 u64_stats_update_end(&sky2->tx_stats.syncp);
2063 static void sky2_hw_down(struct sky2_port *sky2)
2065 struct sky2_hw *hw = sky2->hw;
2066 unsigned port = sky2->port;
2098 sky2_rx_stop(sky2);
2100 spin_lock_bh(&sky2->phy_lock);
2102 spin_unlock_bh(&sky2->phy_lock);
2107 sky2_tx_complete(sky2, sky2->tx_prod);
2113 struct sky2_port *sky2 = netdev_priv(dev);
2114 struct sky2_hw *hw = sky2->hw;
2117 if (!sky2->tx_le)
2120 netif_info(sky2, ifdown, dev, "disabling interface\n");
2134 imask &= ~portirq_msk[sky2->port];
2142 sky2_hw_down(sky2);
2144 sky2_free_buffers(sky2);
2171 static void sky2_link_up(struct sky2_port *sky2)
2173 struct sky2_hw *hw = sky2->hw;
2174 unsigned port = sky2->port;
2182 sky2_set_ipg(sky2);
2184 sky2_enable_rx_tx(sky2);
2188 netif_carrier_on(sky2->netdev);
2196 netif_info(sky2, link, sky2->netdev,
2198 sky2->speed,
2199 sky2->duplex == DUPLEX_FULL ? "full" : "half",
2200 fc_name[sky2->flow_status]);
2203 static void sky2_link_down(struct sky2_port *sky2)
2205 struct sky2_hw *hw = sky2->hw;
2206 unsigned port = sky2->port;
2215 netif_carrier_off(sky2->netdev);
2220 netif_info(sky2, link, sky2->netdev, "Link is down\n");
2233 static int sky2_autoneg_done(struct sky2_port *sky2, u16 aux)
2235 struct sky2_hw *hw = sky2->hw;
2236 unsigned port = sky2->port;
2242 netdev_err(sky2->netdev, "remote fault\n");
2247 netdev_err(sky2->netdev, "speed/duplex mismatch\n");
2251 sky2->speed = sky2_phy_speed(hw, aux);
2252 sky2->duplex = (aux & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
2272 sky2->flow_status = FC_NONE;
2275 sky2->flow_status = FC_BOTH;
2277 sky2->flow_status = FC_RX;
2280 sky2->flow_status = FC_TX;
2283 if (sky2->duplex == DUPLEX_HALF && sky2->speed < SPEED_1000 &&
2285 sky2->flow_status = FC_NONE;
2287 if (sky2->flow_status & FC_TX)
2299 struct sky2_port *sky2 = netdev_priv(dev);
2305 spin_lock(&sky2->phy_lock);
2309 netif_info(sky2, intr, sky2->netdev, "phy interrupt status 0x%x 0x%x\n",
2313 if (sky2_autoneg_done(sky2, phystat) == 0 &&
2315 sky2_link_up(sky2);
2320 sky2->speed = sky2_phy_speed(hw, phystat);
2323 sky2->duplex =
2328 sky2_link_up(sky2);
2330 sky2_link_down(sky2);
2333 spin_unlock(&sky2->phy_lock);
2339 struct sky2_port *sky2 = netdev_priv(hw->dev[0]);
2354 sky2_link_up(sky2);
2362 struct sky2_port *sky2 = netdev_priv(dev);
2363 struct sky2_hw *hw = sky2->hw;
2365 netif_err(sky2, timer, dev, "tx timeout\n");
2368 sky2->tx_cons, sky2->tx_prod,
2369 sky2_read16(hw, sky2->port == 0 ? STAT_TXA1_RIDX : STAT_TXA2_RIDX),
2370 sky2_read16(hw, Q_ADDR(txqaddr[sky2->port], Q_DONE)));
2378 struct sky2_port *sky2 = netdev_priv(dev);
2379 struct sky2_hw *hw = sky2->hw;
2380 unsigned port = sky2->port;
2406 sky2_rx_stop(sky2);
2407 sky2_rx_clean(sky2);
2413 if (sky2->speed > SPEED_100)
2425 err = sky2_alloc_rx_skbs(sky2);
2427 sky2_rx_start(sky2);
2429 sky2_rx_clean(sky2);
2458 static struct sk_buff *receive_copy(struct sky2_port *sky2,
2464 skb = netdev_alloc_skb_ip_align(sky2->netdev, length);
2466 dma_sync_single_for_cpu(&sky2->hw->pdev->dev, re->data_addr,
2474 dma_sync_single_for_device(&sky2->hw->pdev->dev,
2519 static struct sk_buff *receive_new(struct sky2_port *sky2,
2525 unsigned hdr_space = sky2->rx_data_size;
2527 nre.skb = sky2_rx_alloc(sky2, GFP_ATOMIC);
2531 if (sky2_rx_map_skb(sky2->hw->pdev, &nre, hdr_space))
2535 sky2_rx_unmap_skb(sky2->hw->pdev, re);
2558 struct sky2_port *sky2 = netdev_priv(dev);
2559 struct rx_ring_info *re = sky2->rx_ring + sky2->rx_next;
2563 netif_printk(sky2, rx_status, KERN_DEBUG, dev,
2565 sky2->rx_next, status, length);
2567 sky2->rx_next = (sky2->rx_next + 1) % sky2->rx_pending;
2568 prefetch(sky2->rx_ring + sky2->rx_next);
2577 if (sky2->hw->chip_id == CHIP_ID_YUKON_FE_P &&
2578 sky2->hw->chip_rev == CHIP_REV_YU_FE2_A0 &&
2594 skb = receive_copy(sky2, re, length);
2596 skb = receive_new(sky2, re, length);
2601 sky2_rx_submit(sky2, re);
2609 netif_info(sky2, rx_err, dev,
2618 struct sky2_port *sky2 = netdev_priv(dev);
2621 sky2_tx_complete(sky2, last);
2624 if (tx_avail(sky2) > MAX_SKB_TX_LE + 4)
2629 static inline void sky2_skb_rx(const struct sky2_port *sky2,
2635 napi_gro_receive(&sky2->hw->napi, skb);
2642 struct sky2_port *sky2 = netdev_priv(dev);
2647 u64_stats_update_begin(&sky2->rx_stats.syncp);
2648 sky2->rx_stats.packets += packets;
2649 sky2->rx_stats.bytes += bytes;
2650 u64_stats_update_end(&sky2->rx_stats.syncp);
2652 sky2->last_rx = jiffies;
2656 static void sky2_rx_checksum(struct sky2_port *sky2, u32 status)
2659 BUG_ON(sky2->hw->flags & SKY2_HW_NEW_LE);
2667 struct sk_buff *skb = sky2->rx_ring[sky2->rx_next].skb;
2671 dev_notice(&sky2->hw->pdev->dev,
2673 sky2->netdev->name, status);
2679 sky2->netdev->features &= ~NETIF_F_RXCSUM;
2680 sky2_write32(sky2->hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR),
2685 static void sky2_rx_tag(struct sky2_port *sky2, u16 length)
2689 skb = sky2->rx_ring[sky2->rx_next].skb;
2693 static void sky2_rx_hash(struct sky2_port *sky2, u32 status)
2697 skb = sky2->rx_ring[sky2->rx_next].skb;
2713 struct sky2_port *sky2;
2729 sky2 = netdev_priv(dev);
2754 sky2_skb_rx(sky2, skb);
2762 sky2_rx_tag(sky2, length);
2766 sky2_rx_tag(sky2, length);
2770 sky2_rx_checksum(sky2, status);
2774 sky2_rx_hash(sky2, status);
2892 struct sky2_port *sky2 = netdev_priv(dev);
2895 netif_info(sky2, intr, dev, "mac interrupt status 0x%x\n", status);
2929 struct sky2_port *sky2 = netdev_priv(dev);
2930 struct sky2_hw *hw = sky2->hw;
2931 unsigned port = sky2->port;
2939 if (sky2->check.last == sky2->last_rx &&
2940 ((mac_rp == sky2->check.mac_rp &&
2941 mac_lev != 0 && mac_lev >= sky2->check.mac_lev) ||
2943 (fifo_rp == sky2->check.fifo_rp &&
2944 fifo_lev != 0 && fifo_lev >= sky2->check.fifo_lev))) {
2951 sky2->check.last = sky2->last_rx;
2952 sky2->check.mac_rp = mac_rp;
2953 sky2->check.mac_lev = mac_lev;
2954 sky2->check.fifo_rp = fifo_rp;
2955 sky2->check.fifo_lev = fifo_lev;
3075 struct sky2_port *sky2 = netdev_priv(dev);
3077 napi_schedule(&sky2->hw->napi);
3470 struct sky2_port *sky2 = netdev_priv(dev);
3477 sky2_hw_down(sky2);
3488 struct sky2_port *sky2 = netdev_priv(dev);
3493 sky2_hw_up(sky2);
3527 const struct sky2_port *sky2 = netdev_priv(dev);
3529 wol->supported = sky2_wol_supported(sky2->hw);
3530 wol->wolopts = sky2->wol;
3535 struct sky2_port *sky2 = netdev_priv(dev);
3536 struct sky2_hw *hw = sky2->hw;
3540 if ((wol->wolopts & ~sky2_wol_supported(sky2->hw)) ||
3544 sky2->wol = wol->wolopts;
3548 struct sky2_port *sky2 = netdev_priv(dev);
3550 if (sky2->wol)
3578 struct sky2_port *sky2 = netdev_priv(dev);
3579 struct sky2_hw *hw = sky2->hw;
3586 cmd->base.speed = sky2->speed;
3594 advertising = sky2->advertising;
3595 cmd->base.autoneg = (sky2->flags & SKY2_FLAG_AUTO_SPEED)
3597 cmd->base.duplex = sky2->duplex;
3610 struct sky2_port *sky2 = netdev_priv(dev);
3611 const struct sky2_hw *hw = sky2->hw;
3623 sky2->advertising = new_advertising |
3627 sky2->advertising = new_advertising |
3631 sky2->flags |= SKY2_FLAG_AUTO_SPEED;
3632 sky2->duplex = -1;
3633 sky2->speed = -1;
3671 sky2->speed = speed;
3672 sky2->duplex = cmd->base.duplex;
3673 sky2->flags &= ~SKY2_FLAG_AUTO_SPEED;
3677 sky2_phy_reinit(sky2);
3687 struct sky2_port *sky2 = netdev_priv(dev);
3691 strlcpy(info->bus_info, pci_name(sky2->hw->pdev),
3741 struct sky2_port *sky2 = netdev_priv(netdev);
3742 return sky2->msg_enable;
3747 struct sky2_port *sky2 = netdev_priv(dev);
3749 if (!netif_running(dev) || !(sky2->flags & SKY2_FLAG_AUTO_SPEED))
3752 sky2_phy_reinit(sky2);
3758 static void sky2_phy_stats(struct sky2_port *sky2, u64 * data, unsigned count)
3760 struct sky2_hw *hw = sky2->hw;
3761 unsigned port = sky2->port;
3773 struct sky2_port *sky2 = netdev_priv(netdev);
3774 sky2->msg_enable = value;
3790 struct sky2_port *sky2 = netdev_priv(dev);
3792 sky2_phy_stats(sky2, data, ARRAY_SIZE(sky2_stats));
3810 struct sky2_port *sky2 = netdev_priv(dev);
3811 struct sky2_hw *hw = sky2->hw;
3812 unsigned port = sky2->port;
3843 struct sky2_port *sky2 = netdev_priv(dev);
3844 struct sky2_hw *hw = sky2->hw;
3845 unsigned port = sky2->port;
3852 rx_pause = (sky2->flow_status == FC_RX || sky2->flow_status == FC_BOTH);
3889 struct sky2_port *sky2 = netdev_priv(dev);
3890 struct sky2_hw *hw = sky2->hw;
3891 unsigned port = sky2->port;
3896 start = u64_stats_fetch_begin_irq(&sky2->rx_stats.syncp);
3897 _bytes = sky2->rx_stats.bytes;
3898 _packets = sky2->rx_stats.packets;
3899 } while (u64_stats_fetch_retry_irq(&sky2->rx_stats.syncp, start));
3905 start = u64_stats_fetch_begin_irq(&sky2->tx_stats.syncp);
3906 _bytes = sky2->tx_stats.bytes;
3907 _packets = sky2->tx_stats.packets;
3908 } while (u64_stats_fetch_retry_irq(&sky2->tx_stats.syncp, start));
3932 static void sky2_led(struct sky2_port *sky2, enum led_mode mode)
3934 struct sky2_hw *hw = sky2->hw;
3935 unsigned port = sky2->port;
3937 spin_lock_bh(&sky2->phy_lock);
3985 spin_unlock_bh(&sky2->phy_lock);
3992 struct sky2_port *sky2 = netdev_priv(dev);
3998 sky2_led(sky2, MO_LED_NORM);
4001 sky2_led(sky2, MO_LED_ON);
4004 sky2_led(sky2, MO_LED_OFF);
4014 struct sky2_port *sky2 = netdev_priv(dev);
4016 switch (sky2->flow_mode) {
4030 ecmd->autoneg = (sky2->flags & SKY2_FLAG_AUTO_PAUSE)
4037 struct sky2_port *sky2 = netdev_priv(dev);
4040 sky2->flags |= SKY2_FLAG_AUTO_PAUSE;
4042 sky2->flags &= ~SKY2_FLAG_AUTO_PAUSE;
4044 sky2->flow_mode = sky2_flow(ecmd->rx_pause, ecmd->tx_pause);
4047 sky2_phy_reinit(sky2);
4055 struct sky2_port *sky2 = netdev_priv(dev);
4056 struct sky2_hw *hw = sky2->hw;
4090 struct sky2_port *sky2 = netdev_priv(dev);
4091 struct sky2_hw *hw = sky2->hw;
4099 if (ecmd->tx_max_coalesced_frames >= sky2->tx_ring_size-1)
4148 struct sky2_port *sky2 = netdev_priv(dev);
4153 ering->rx_pending = sky2->rx_pending;
4154 ering->tx_pending = sky2->tx_pending;
4160 struct sky2_port *sky2 = netdev_priv(dev);
4170 sky2->rx_pending = ering->rx_pending;
4171 sky2->tx_pending = ering->tx_pending;
4172 sky2->tx_ring_size = roundup_ring_size(sky2->tx_pending);
4233 const struct sky2_port *sky2 = netdev_priv(dev);
4234 const void __iomem *io = sky2->hw->regs;
4243 else if (sky2_reg_access_ok(sky2->hw, b))
4255 struct sky2_port *sky2 = netdev_priv(dev);
4256 struct sky2_hw *hw = sky2->hw;
4325 struct sky2_port *sky2 = netdev_priv(dev);
4326 int cap = pci_find_capability(sky2->hw->pdev, PCI_CAP_ID_VPD);
4333 return sky2_vpd_read(sky2->hw, cap, data, eeprom->offset, eeprom->len);
4339 struct sky2_port *sky2 = netdev_priv(dev);
4340 int cap = pci_find_capability(sky2->hw->pdev, PCI_CAP_ID_VPD);
4352 return sky2_vpd_write(sky2->hw, cap, data, eeprom->offset, eeprom->len);
4358 const struct sky2_port *sky2 = netdev_priv(dev);
4359 const struct sky2_hw *hw = sky2->hw;
4372 (sky2->hw->flags & SKY2_HW_RSS_CHKSUM)) {
4382 struct sky2_port *sky2 = netdev_priv(dev);
4386 !(sky2->hw->flags & SKY2_HW_NEW_LE)) {
4387 sky2_write32(sky2->hw,
4388 Q_ADDR(rxqaddr[sky2->port], Q_CSR),
4520 const struct sky2_port *sky2 = netdev_priv(dev);
4521 struct sky2_hw *hw = sky2->hw;
4522 unsigned port = sky2->port;
4556 sky2->tx_cons, sky2->tx_prod,
4562 for (idx = sky2->tx_next; idx != sky2->tx_prod && idx < sky2->tx_ring_size;
4563 idx = RING_NEXT(idx, sky2->tx_ring_size)) {
4564 const struct sky2_tx_le *le = sky2->tx_le + idx;
4623 struct sky2_port *sky2 = netdev_priv(dev);
4630 if (sky2->debugfs) {
4631 sky2->debugfs = debugfs_rename(sky2_debug, sky2->debugfs,
4637 if (sky2->debugfs) {
4639 debugfs_remove(sky2->debugfs);
4640 sky2->debugfs = NULL;
4645 sky2->debugfs = debugfs_create_file(dev->name, 0444,
4648 if (IS_ERR(sky2->debugfs))
4649 sky2->debugfs = NULL;
4664 ent = debugfs_create_dir("sky2", NULL);
4726 struct sky2_port *sky2;
4727 struct net_device *dev = alloc_etherdev(sizeof(*sky2));
4739 sky2 = netdev_priv(dev);
4740 sky2->netdev = dev;
4741 sky2->hw = hw;
4742 sky2->msg_enable = netif_msg_init(debug, default_msg);
4744 u64_stats_init(&sky2->tx_stats.syncp);
4745 u64_stats_init(&sky2->rx_stats.syncp);
4748 sky2->flags = SKY2_FLAG_AUTO_SPEED | SKY2_FLAG_AUTO_PAUSE;
4752 sky2->flow_mode = FC_BOTH;
4754 sky2->duplex = -1;
4755 sky2->speed = -1;
4756 sky2->advertising = sky2_supported_modes(hw);
4757 sky2->wol = wol;
4759 spin_lock_init(&sky2->phy_lock);
4761 sky2->tx_pending = TX_DEF_PENDING;
4762 sky2->tx_ring_size = roundup_ring_size(TX_DEF_PENDING);
4763 sky2->rx_pending = RX_DEF_PENDING;
4767 sky2->port = port;
4822 const struct sky2_port *sky2 = netdev_priv(dev);
4824 netif_info(sky2, probe, dev, "addr %pM\n", dev->dev_addr);
5198 struct sky2_port *sky2 = netdev_priv(dev);
5200 if (sky2->wol)
5201 sky2_wol_init(sky2);