Lines Matching defs:skge
38 #include "skge.h"
40 #define DRV_NAME "skge"
93 static void skge_phy_reset(struct skge_port *skge);
97 static void genesis_get_stats(struct skge_port *skge, u64 *data);
98 static void yukon_get_stats(struct skge_port *skge, u64 *data);
101 static void genesis_link_up(struct skge_port *skge);
135 const struct skge_port *skge = netdev_priv(dev);
136 const void __iomem *io = skge->hw->regs;
160 static void skge_wol_init(struct skge_port *skge)
162 struct skge_hw *hw = skge->hw;
163 int port = skge->port;
212 skge->netdev->dev_addr, ETH_ALEN);
217 if (skge->wol & WAKE_PHY)
222 if (skge->wol & WAKE_MAGIC)
236 struct skge_port *skge = netdev_priv(dev);
238 wol->supported = wol_supported(skge->hw);
239 wol->wolopts = skge->wol;
244 struct skge_port *skge = netdev_priv(dev);
245 struct skge_hw *hw = skge->hw;
251 skge->wol = wol->wolopts;
253 device_set_wakeup_enable(&hw->pdev->dev, skge->wol);
295 struct skge_port *skge = netdev_priv(dev);
296 struct skge_hw *hw = skge->hw;
307 advertising = skge->advertising;
308 cmd->base.autoneg = skge->autoneg;
309 cmd->base.speed = skge->speed;
310 cmd->base.duplex = skge->duplex;
323 struct skge_port *skge = netdev_priv(dev);
324 const struct skge_hw *hw = skge->hw;
334 skge->duplex = -1;
335 skge->speed = -1;
373 skge->speed = speed;
374 skge->duplex = cmd->base.duplex;
377 skge->autoneg = cmd->base.autoneg;
378 skge->advertising = advertising;
395 struct skge_port *skge = netdev_priv(dev);
399 strscpy(info->bus_info, pci_name(skge->hw->pdev),
447 struct skge_port *skge = netdev_priv(dev);
449 if (is_genesis(skge->hw))
450 genesis_get_stats(skge, data);
452 yukon_get_stats(skge, data);
461 struct skge_port *skge = netdev_priv(dev);
464 if (is_genesis(skge->hw))
465 genesis_get_stats(skge, data);
467 yukon_get_stats(skge, data);
498 struct skge_port *skge = netdev_priv(dev);
503 p->rx_pending = skge->rx_ring.count;
504 p->tx_pending = skge->tx_ring.count;
512 struct skge_port *skge = netdev_priv(dev);
519 skge->rx_ring.count = p->rx_pending;
520 skge->tx_ring.count = p->tx_pending;
534 struct skge_port *skge = netdev_priv(netdev);
535 return skge->msg_enable;
540 struct skge_port *skge = netdev_priv(netdev);
541 skge->msg_enable = value;
546 struct skge_port *skge = netdev_priv(dev);
548 if (skge->autoneg != AUTONEG_ENABLE || !netif_running(dev))
551 skge_phy_reset(skge);
558 struct skge_port *skge = netdev_priv(dev);
560 ecmd->rx_pause = ((skge->flow_control == FLOW_MODE_SYMMETRIC) ||
561 (skge->flow_control == FLOW_MODE_SYM_OR_REM));
563 (skge->flow_control == FLOW_MODE_LOC_SEND));
571 struct skge_port *skge = netdev_priv(dev);
578 skge->flow_control = ecmd->autoneg ? FLOW_MODE_NONE : FLOW_MODE_SYMMETRIC;
581 skge->flow_control = FLOW_MODE_SYMMETRIC;
583 skge->flow_control = FLOW_MODE_SYM_OR_REM;
585 skge->flow_control = FLOW_MODE_LOC_SEND;
587 skge->flow_control = FLOW_MODE_NONE;
625 struct skge_port *skge = netdev_priv(dev);
626 struct skge_hw *hw = skge->hw;
627 int port = skge->port;
651 struct skge_port *skge = netdev_priv(dev);
652 struct skge_hw *hw = skge->hw;
653 int port = skge->port;
688 static void skge_led(struct skge_port *skge, enum led_mode mode)
690 struct skge_hw *hw = skge->hw;
691 int port = skge->port;
751 (skge->speed == SPEED_100 ?
771 struct skge_port *skge = netdev_priv(dev);
778 skge_led(skge, LED_MODE_TST);
782 skge_led(skge, LED_MODE_OFF);
787 skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
795 struct skge_port *skge = netdev_priv(dev);
798 pci_read_config_dword(skge->hw->pdev, PCI_DEV_REG2, ®2);
830 struct skge_port *skge = netdev_priv(dev);
831 struct pci_dev *pdev = skge->hw->pdev;
856 struct skge_port *skge = netdev_priv(dev);
857 struct pci_dev *pdev = skge->hw->pdev;
943 static int skge_rx_setup(struct skge_port *skge, struct skge_element *e,
949 map = dma_map_single(&skge->hw->pdev->dev, skb->data, bufsize,
952 if (dma_mapping_error(&skge->hw->pdev->dev, map))
989 static void skge_rx_clean(struct skge_port *skge)
991 struct skge_hw *hw = skge->hw;
992 struct skge_ring *ring = &skge->rx_ring;
1016 struct skge_port *skge = netdev_priv(dev);
1017 struct skge_ring *ring = &skge->rx_ring;
1024 skb = __netdev_alloc_skb(dev, skge->rx_buf_size + NET_IP_ALIGN,
1030 if (skge_rx_setup(skge, e, skb, skge->rx_buf_size) < 0) {
1057 static void skge_link_up(struct skge_port *skge)
1059 skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG),
1062 netif_carrier_on(skge->netdev);
1063 netif_wake_queue(skge->netdev);
1065 netif_info(skge, link, skge->netdev,
1067 skge->speed,
1068 skge->duplex == DUPLEX_FULL ? "full" : "half",
1069 skge_pause(skge->flow_status));
1072 static void skge_link_down(struct skge_port *skge)
1074 skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_REG_OFF);
1075 netif_carrier_off(skge->netdev);
1076 netif_stop_queue(skge->netdev);
1078 netif_info(skge, link, skge->netdev, "Link is down\n");
1084 struct skge_port *skge = netdev_priv(dev);
1089 skge_link_down(skge);
1220 struct skge_port *skge = netdev_priv(dev);
1232 if (skge->autoneg == AUTONEG_ENABLE) {
1249 skge->duplex = DUPLEX_FULL;
1252 skge->duplex = DUPLEX_HALF;
1262 skge->flow_status = FLOW_STAT_SYMMETRIC;
1265 skge->flow_status = FLOW_STAT_REM_SEND;
1268 skge->flow_status = FLOW_STAT_LOC_SEND;
1271 skge->flow_status = FLOW_STAT_NONE;
1273 skge->speed = SPEED_1000;
1277 genesis_link_up(skge);
1283 static void bcom_phy_init(struct skge_port *skge)
1285 struct skge_hw *hw = skge->hw;
1286 int port = skge->port;
1348 if (skge->autoneg == AUTONEG_ENABLE) {
1355 if (skge->advertising & ADVERTISED_1000baseT_Half)
1357 if (skge->advertising & ADVERTISED_1000baseT_Full)
1363 if (skge->duplex == DUPLEX_FULL)
1371 phy_pause_map[skge->flow_control] | PHY_AN_CSMA);
1389 static void xm_phy_init(struct skge_port *skge)
1391 struct skge_hw *hw = skge->hw;
1392 int port = skge->port;
1395 if (skge->autoneg == AUTONEG_ENABLE) {
1396 if (skge->advertising & ADVERTISED_1000baseT_Half)
1398 if (skge->advertising & ADVERTISED_1000baseT_Full)
1401 ctrl |= fiber_pause_map[skge->flow_control];
1409 if (skge->duplex == DUPLEX_FULL)
1420 mod_timer(&skge->link_timer, jiffies + LINK_HZ);
1425 struct skge_port *skge = netdev_priv(dev);
1426 struct skge_hw *hw = skge->hw;
1427 int port = skge->port;
1439 if (skge->autoneg == AUTONEG_ENABLE) {
1456 skge->duplex = DUPLEX_FULL;
1459 skge->duplex = DUPLEX_HALF;
1467 if ((skge->flow_control == FLOW_MODE_SYMMETRIC ||
1468 skge->flow_control == FLOW_MODE_SYM_OR_REM) &&
1470 skge->flow_status = FLOW_STAT_SYMMETRIC;
1471 else if (skge->flow_control == FLOW_MODE_SYM_OR_REM &&
1474 skge->flow_status = FLOW_STAT_REM_SEND;
1475 else if (skge->flow_control == FLOW_MODE_LOC_SEND &&
1478 skge->flow_status = FLOW_STAT_LOC_SEND;
1480 skge->flow_status = FLOW_STAT_NONE;
1482 skge->speed = SPEED_1000;
1486 genesis_link_up(skge);
1498 struct skge_port *skge = from_timer(skge, t, link_timer);
1499 struct net_device *dev = skge->netdev;
1500 struct skge_hw *hw = skge->hw;
1501 int port = skge->port;
1527 mod_timer(&skge->link_timer,
1536 struct skge_port *skge = netdev_priv(dev);
1578 xm_phy_init(skge);
1581 bcom_phy_init(skge);
1607 if (skge->duplex == DUPLEX_HALF) {
1691 static void genesis_stop(struct skge_port *skge)
1693 struct skge_hw *hw = skge->hw;
1694 int port = skge->port;
1739 static void genesis_get_stats(struct skge_port *skge, u64 *data)
1741 struct skge_hw *hw = skge->hw;
1742 int port = skge->port;
1770 struct skge_port *skge = netdev_priv(dev);
1773 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
1778 mod_timer(&skge->link_timer, jiffies + 1);
1787 static void genesis_link_up(struct skge_port *skge)
1789 struct skge_hw *hw = skge->hw;
1790 int port = skge->port;
1800 if (skge->flow_status == FLOW_STAT_NONE ||
1801 skge->flow_status == FLOW_STAT_LOC_SEND)
1811 if (skge->flow_status == FLOW_STAT_SYMMETRIC ||
1812 skge->flow_status == FLOW_STAT_LOC_SEND) {
1850 if (hw->phy_type != SK_PHY_XMAC && skge->duplex == DUPLEX_FULL)
1867 skge_link_up(skge);
1871 static inline void bcom_phy_intr(struct skge_port *skge)
1873 struct skge_hw *hw = skge->hw;
1874 int port = skge->port;
1878 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
1950 struct skge_port *skge = netdev_priv(hw->dev[port]);
1953 if (skge->autoneg == AUTONEG_ENABLE) {
1966 if (skge->autoneg == AUTONEG_DISABLE)
1976 if (skge->autoneg == AUTONEG_ENABLE) {
1978 if (skge->advertising & ADVERTISED_1000baseT_Full)
1980 if (skge->advertising & ADVERTISED_1000baseT_Half)
1982 if (skge->advertising & ADVERTISED_100baseT_Full)
1984 if (skge->advertising & ADVERTISED_100baseT_Half)
1986 if (skge->advertising & ADVERTISED_10baseT_Full)
1988 if (skge->advertising & ADVERTISED_10baseT_Half)
1992 adv |= phy_pause_map[skge->flow_control];
1994 if (skge->advertising & ADVERTISED_1000baseT_Full)
1996 if (skge->advertising & ADVERTISED_1000baseT_Half)
1999 adv |= fiber_pause_map[skge->flow_control];
2008 if (skge->duplex == DUPLEX_FULL)
2011 switch (skge->speed) {
2029 if (skge->autoneg == AUTONEG_ENABLE)
2066 struct skge_port *skge = netdev_priv(hw->dev[port]);
2102 if (skge->autoneg == AUTONEG_DISABLE) {
2107 switch (skge->speed) {
2121 if (skge->duplex == DUPLEX_FULL)
2126 switch (skge->flow_control) {
2233 static void yukon_stop(struct skge_port *skge)
2235 struct skge_hw *hw = skge->hw;
2236 int port = skge->port;
2253 static void yukon_get_stats(struct skge_port *skge, u64 *data)
2255 struct skge_hw *hw = skge->hw;
2256 int port = skge->port;
2272 struct skge_port *skge = netdev_priv(dev);
2275 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
2302 static void yukon_link_up(struct skge_port *skge)
2304 struct skge_hw *hw = skge->hw;
2305 int port = skge->port;
2312 if (skge->duplex == DUPLEX_FULL || skge->autoneg == AUTONEG_ENABLE)
2320 skge_link_up(skge);
2323 static void yukon_link_down(struct skge_port *skge)
2325 struct skge_hw *hw = skge->hw;
2326 int port = skge->port;
2333 if (skge->flow_status == FLOW_STAT_REM_SEND) {
2340 skge_link_down(skge);
2345 static void yukon_phy_intr(struct skge_port *skge)
2347 struct skge_hw *hw = skge->hw;
2348 int port = skge->port;
2355 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
2375 skge->duplex = (phystat & PHY_M_PS_FULL_DUP)
2377 skge->speed = yukon_speed(hw, phystat);
2382 skge->flow_status = FLOW_STAT_SYMMETRIC;
2385 skge->flow_status = FLOW_STAT_REM_SEND;
2388 skge->flow_status = FLOW_STAT_LOC_SEND;
2391 skge->flow_status = FLOW_STAT_NONE;
2394 if (skge->flow_status == FLOW_STAT_NONE ||
2395 (skge->speed < SPEED_1000 && skge->duplex == DUPLEX_HALF))
2399 yukon_link_up(skge);
2404 skge->speed = yukon_speed(hw, phystat);
2407 skge->duplex = (phystat & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
2410 yukon_link_up(skge);
2412 yukon_link_down(skge);
2416 pr_err("%s: autonegotiation failed (%s)\n", skge->netdev->name, reason);
2421 static void skge_phy_reset(struct skge_port *skge)
2423 struct skge_hw *hw = skge->hw;
2424 int port = skge->port;
2427 netif_stop_queue(skge->netdev);
2428 netif_carrier_off(skge->netdev);
2447 struct skge_port *skge = netdev_priv(dev);
2448 struct skge_hw *hw = skge->hw;
2464 err = __xm_phy_read(hw, skge->port, data->reg_num & 0x1f, &val);
2466 err = __gm_phy_read(hw, skge->port, data->reg_num & 0x1f, &val);
2475 err = xm_phy_write(hw, skge->port, data->reg_num & 0x1f,
2478 err = gm_phy_write(hw, skge->port, data->reg_num & 0x1f,
2517 static void skge_qset(struct skge_port *skge, u16 q,
2520 struct skge_hw *hw = skge->hw;
2522 u64 base = skge->dma + (e->desc - skge->mem);
2536 struct skge_port *skge = netdev_priv(dev);
2537 struct skge_hw *hw = skge->hw;
2538 int port = skge->port;
2546 netif_info(skge, ifup, skge->netdev, "enabling interface\n");
2549 skge->rx_buf_size = dev->mtu + ETH_HLEN;
2551 skge->rx_buf_size = RX_BUF_SIZE;
2554 rx_size = skge->rx_ring.count * sizeof(struct skge_rx_desc);
2555 tx_size = skge->tx_ring.count * sizeof(struct skge_tx_desc);
2556 skge->mem_size = tx_size + rx_size;
2557 skge->mem = dma_alloc_coherent(&hw->pdev->dev, skge->mem_size,
2558 &skge->dma, GFP_KERNEL);
2559 if (!skge->mem)
2562 BUG_ON(skge->dma & 7);
2564 if (upper_32_bits(skge->dma) != upper_32_bits(skge->dma + skge->mem_size)) {
2570 err = skge_ring_alloc(&skge->rx_ring, skge->mem, skge->dma);
2578 err = skge_ring_alloc(&skge->tx_ring, skge->mem + rx_size,
2579 skge->dma + rx_size);
2607 skge_qset(skge, rxqaddr[port], skge->rx_ring.to_clean);
2609 BUG_ON(skge->tx_ring.to_use != skge->tx_ring.to_clean);
2611 skge_qset(skge, txqaddr[port], skge->tx_ring.to_use);
2616 skge_led(skge, LED_MODE_ON);
2624 napi_enable(&skge->napi);
2631 kfree(skge->tx_ring.start);
2633 skge_rx_clean(skge);
2634 kfree(skge->rx_ring.start);
2636 dma_free_coherent(&hw->pdev->dev, skge->mem_size, skge->mem,
2637 skge->dma);
2638 skge->mem = NULL;
2654 struct skge_port *skge = netdev_priv(dev);
2655 struct skge_hw *hw = skge->hw;
2656 int port = skge->port;
2658 if (!skge->mem)
2661 netif_info(skge, ifdown, skge->netdev, "disabling interface\n");
2666 del_timer_sync(&skge->link_timer);
2668 napi_disable(&skge->napi);
2680 skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_REG_OFF);
2682 genesis_stop(skge);
2684 yukon_stop(skge);
2717 skge_led(skge, LED_MODE_OFF);
2723 skge_rx_clean(skge);
2725 kfree(skge->rx_ring.start);
2726 kfree(skge->tx_ring.start);
2727 dma_free_coherent(&hw->pdev->dev, skge->mem_size, skge->mem,
2728 skge->dma);
2729 skge->mem = NULL;
2743 struct skge_port *skge = netdev_priv(dev);
2744 struct skge_hw *hw = skge->hw;
2754 if (unlikely(skge_avail(&skge->tx_ring) < skb_shinfo(skb)->nr_frags + 1))
2757 e = skge->tx_ring.to_use;
2825 skge_write8(hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_START);
2827 netif_printk(skge, tx_queued, KERN_DEBUG, skge->netdev,
2829 e - skge->tx_ring.start, skb->len);
2831 skge->tx_ring.to_use = e->next;
2834 if (skge_avail(&skge->tx_ring) <= TX_LOW_WATER) {
2842 e = skge->tx_ring.to_use;
2875 struct skge_port *skge = netdev_priv(dev);
2878 for (e = skge->tx_ring.to_clean; e != skge->tx_ring.to_use; e = e->next) {
2881 skge_tx_unmap(skge->hw->pdev, e, td->control);
2889 skge->tx_ring.to_clean = e;
2894 struct skge_port *skge = netdev_priv(dev);
2896 netif_printk(skge, timer, KERN_DEBUG, skge->netdev, "tx timeout\n");
2898 skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_STOP);
2936 struct skge_port *skge = netdev_priv(dev);
2937 struct skge_hw *hw = skge->hw;
2938 int port = skge->port;
2955 if (skge->flow_status == FLOW_STAT_REM_SEND ||
2956 skge->flow_status == FLOW_STAT_SYMMETRIC)
2976 struct skge_port *skge = netdev_priv(dev);
2977 struct skge_hw *hw = skge->hw;
2978 int port = skge->port;
2980 int rx_pause = (skge->flow_status == FLOW_STAT_REM_SEND ||
2981 skge->flow_status == FLOW_STAT_SYMMETRIC);
3038 struct skge_port *skge = netdev_priv(dev);
3040 if (is_genesis(skge->hw))
3055 struct skge_port *skge = netdev_priv(dev);
3059 netif_printk(skge, rx_status, KERN_DEBUG, skge->netdev,
3061 e - skge->rx_ring.start, status, len);
3063 if (len > skge->rx_buf_size)
3069 if (bad_phy_status(skge->hw, status))
3072 if (phy_length(skge->hw, status) != len)
3080 dma_sync_single_for_cpu(&skge->hw->pdev->dev,
3085 dma_sync_single_for_device(&skge->hw->pdev->dev,
3089 skge_rx_reuse(e, skge->rx_buf_size);
3094 nskb = netdev_alloc_skb_ip_align(dev, skge->rx_buf_size);
3103 if (skge_rx_setup(skge, e, nskb, skge->rx_buf_size) < 0) {
3108 dma_unmap_single(&skge->hw->pdev->dev,
3125 netif_printk(skge, rx_err, KERN_DEBUG, skge->netdev,
3127 e - skge->rx_ring.start, control, status);
3129 if (is_genesis(skge->hw)) {
3146 skge_rx_reuse(e, skge->rx_buf_size);
3153 struct skge_port *skge = netdev_priv(dev);
3154 struct skge_ring *ring = &skge->tx_ring;
3158 skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_IRQ_CL_F);
3166 skge_tx_unmap(skge->hw->pdev, e, control);
3169 netif_printk(skge, tx_done, KERN_DEBUG, skge->netdev,
3171 e - skge->tx_ring.start);
3180 skge->tx_ring.to_clean = e;
3186 skge_avail(&skge->tx_ring) > TX_LOW_WATER)) {
3189 skge_avail(&skge->tx_ring) > TX_LOW_WATER)) {
3199 struct skge_port *skge = container_of(napi, struct skge_port, napi);
3200 struct net_device *dev = skge->netdev;
3201 struct skge_hw *hw = skge->hw;
3202 struct skge_ring *ring = &skge->rx_ring;
3208 skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_IRQ_CL_F);
3230 skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_START);
3236 hw->intr_mask |= napimask[skge->port];
3358 struct skge_port *skge = netdev_priv(dev);
3362 yukon_phy_intr(skge);
3364 bcom_phy_intr(skge);
3396 struct skge_port *skge = netdev_priv(hw->dev[0]);
3398 napi_schedule(&skge->napi);
3414 struct skge_port *skge = netdev_priv(hw->dev[1]);
3418 napi_schedule(&skge->napi);
3446 struct skge_port *skge = netdev_priv(dev);
3449 skge_intr(dev->irq, skge->hw);
3456 struct skge_port *skge = netdev_priv(dev);
3457 struct skge_hw *hw = skge->hw;
3458 unsigned port = skge->port;
3696 const struct skge_port *skge = netdev_priv(dev);
3697 const struct skge_hw *hw = skge->hw;
3706 seq_printf(seq, "Tx Ring: (%d)\n", skge_avail(&skge->tx_ring));
3707 for (e = skge->tx_ring.to_clean; e != skge->tx_ring.to_use; e = e->next) {
3715 for (e = skge->rx_ring.to_clean; ; e = e->next) {
3738 struct skge_port *skge;
3743 skge = netdev_priv(dev);
3746 if (skge->debugfs)
3747 skge->debugfs = debugfs_rename(skge_debug,
3748 skge->debugfs,
3753 debugfs_remove(skge->debugfs);
3754 skge->debugfs = NULL;
3758 skge->debugfs = debugfs_create_file(dev->name, 0444, skge_debug,
3774 skge_debug = debugfs_create_dir("skge", NULL);
3814 struct skge_port *skge;
3815 struct net_device *dev = alloc_etherdev(sizeof(*skge));
3834 skge = netdev_priv(dev);
3835 netif_napi_add(dev, &skge->napi, skge_poll);
3836 skge->netdev = dev;
3837 skge->hw = hw;
3838 skge->msg_enable = netif_msg_init(debug, default_msg);
3840 skge->tx_ring.count = DEFAULT_TX_RING_SIZE;
3841 skge->rx_ring.count = DEFAULT_RX_RING_SIZE;
3844 skge->autoneg = AUTONEG_ENABLE;
3845 skge->flow_control = FLOW_MODE_SYM_OR_REM;
3846 skge->duplex = -1;
3847 skge->speed = -1;
3848 skge->advertising = skge_supported_modes(hw);
3851 skge->wol = wol_supported(hw) & WAKE_MAGIC;
3852 device_set_wakeup_enable(&hw->pdev->dev, skge->wol);
3857 skge->port = port;
3861 timer_setup(&skge->link_timer, xm_link_timer, 0);
3877 const struct skge_port *skge = netdev_priv(dev);
3879 netif_info(skge, probe, skge->netdev, "addr %pM\n", dev->dev_addr);
3929 /* space for skge@pci:0000:04:00.0 */
4075 struct skge_port *skge = netdev_priv(dev);
4080 if (skge->wol)
4081 skge_wol_init(skge);
4136 struct skge_port *skge = netdev_priv(dev);
4138 if (skge->wol)
4139 skge_wol_init(skge);