Lines Matching defs:skge
38 #include "skge.h"
40 #define DRV_NAME "skge"
94 static void skge_phy_reset(struct skge_port *skge);
98 static void genesis_get_stats(struct skge_port *skge, u64 *data);
99 static void yukon_get_stats(struct skge_port *skge, u64 *data);
102 static void genesis_link_up(struct skge_port *skge);
136 const struct skge_port *skge = netdev_priv(dev);
137 const void __iomem *io = skge->hw->regs;
161 static void skge_wol_init(struct skge_port *skge)
163 struct skge_hw *hw = skge->hw;
164 int port = skge->port;
213 skge->netdev->dev_addr, ETH_ALEN);
218 if (skge->wol & WAKE_PHY)
223 if (skge->wol & WAKE_MAGIC)
237 struct skge_port *skge = netdev_priv(dev);
239 wol->supported = wol_supported(skge->hw);
240 wol->wolopts = skge->wol;
245 struct skge_port *skge = netdev_priv(dev);
246 struct skge_hw *hw = skge->hw;
252 skge->wol = wol->wolopts;
254 device_set_wakeup_enable(&hw->pdev->dev, skge->wol);
296 struct skge_port *skge = netdev_priv(dev);
297 struct skge_hw *hw = skge->hw;
308 advertising = skge->advertising;
309 cmd->base.autoneg = skge->autoneg;
310 cmd->base.speed = skge->speed;
311 cmd->base.duplex = skge->duplex;
324 struct skge_port *skge = netdev_priv(dev);
325 const struct skge_hw *hw = skge->hw;
335 skge->duplex = -1;
336 skge->speed = -1;
374 skge->speed = speed;
375 skge->duplex = cmd->base.duplex;
378 skge->autoneg = cmd->base.autoneg;
379 skge->advertising = advertising;
396 struct skge_port *skge = netdev_priv(dev);
400 strlcpy(info->bus_info, pci_name(skge->hw->pdev),
448 struct skge_port *skge = netdev_priv(dev);
450 if (is_genesis(skge->hw))
451 genesis_get_stats(skge, data);
453 yukon_get_stats(skge, data);
462 struct skge_port *skge = netdev_priv(dev);
465 if (is_genesis(skge->hw))
466 genesis_get_stats(skge, data);
468 yukon_get_stats(skge, data);
497 struct skge_port *skge = netdev_priv(dev);
502 p->rx_pending = skge->rx_ring.count;
503 p->tx_pending = skge->tx_ring.count;
509 struct skge_port *skge = netdev_priv(dev);
516 skge->rx_ring.count = p->rx_pending;
517 skge->tx_ring.count = p->tx_pending;
531 struct skge_port *skge = netdev_priv(netdev);
532 return skge->msg_enable;
537 struct skge_port *skge = netdev_priv(netdev);
538 skge->msg_enable = value;
543 struct skge_port *skge = netdev_priv(dev);
545 if (skge->autoneg != AUTONEG_ENABLE || !netif_running(dev))
548 skge_phy_reset(skge);
555 struct skge_port *skge = netdev_priv(dev);
557 ecmd->rx_pause = ((skge->flow_control == FLOW_MODE_SYMMETRIC) ||
558 (skge->flow_control == FLOW_MODE_SYM_OR_REM));
560 (skge->flow_control == FLOW_MODE_LOC_SEND));
568 struct skge_port *skge = netdev_priv(dev);
575 skge->flow_control = ecmd->autoneg ? FLOW_MODE_NONE : FLOW_MODE_SYMMETRIC;
578 skge->flow_control = FLOW_MODE_SYMMETRIC;
580 skge->flow_control = FLOW_MODE_SYM_OR_REM;
582 skge->flow_control = FLOW_MODE_LOC_SEND;
584 skge->flow_control = FLOW_MODE_NONE;
620 struct skge_port *skge = netdev_priv(dev);
621 struct skge_hw *hw = skge->hw;
622 int port = skge->port;
644 struct skge_port *skge = netdev_priv(dev);
645 struct skge_hw *hw = skge->hw;
646 int port = skge->port;
681 static void skge_led(struct skge_port *skge, enum led_mode mode)
683 struct skge_hw *hw = skge->hw;
684 int port = skge->port;
744 (skge->speed == SPEED_100 ?
764 struct skge_port *skge = netdev_priv(dev);
771 skge_led(skge, LED_MODE_TST);
775 skge_led(skge, LED_MODE_OFF);
780 skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
788 struct skge_port *skge = netdev_priv(dev);
791 pci_read_config_dword(skge->hw->pdev, PCI_DEV_REG2, ®2);
823 struct skge_port *skge = netdev_priv(dev);
824 struct pci_dev *pdev = skge->hw->pdev;
849 struct skge_port *skge = netdev_priv(dev);
850 struct pci_dev *pdev = skge->hw->pdev;
936 static int skge_rx_setup(struct skge_port *skge, struct skge_element *e,
942 map = dma_map_single(&skge->hw->pdev->dev, skb->data, bufsize,
945 if (dma_mapping_error(&skge->hw->pdev->dev, map))
982 static void skge_rx_clean(struct skge_port *skge)
984 struct skge_hw *hw = skge->hw;
985 struct skge_ring *ring = &skge->rx_ring;
1009 struct skge_port *skge = netdev_priv(dev);
1010 struct skge_ring *ring = &skge->rx_ring;
1017 skb = __netdev_alloc_skb(dev, skge->rx_buf_size + NET_IP_ALIGN,
1023 if (skge_rx_setup(skge, e, skb, skge->rx_buf_size) < 0) {
1050 static void skge_link_up(struct skge_port *skge)
1052 skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG),
1055 netif_carrier_on(skge->netdev);
1056 netif_wake_queue(skge->netdev);
1058 netif_info(skge, link, skge->netdev,
1060 skge->speed,
1061 skge->duplex == DUPLEX_FULL ? "full" : "half",
1062 skge_pause(skge->flow_status));
1065 static void skge_link_down(struct skge_port *skge)
1067 skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_REG_OFF);
1068 netif_carrier_off(skge->netdev);
1069 netif_stop_queue(skge->netdev);
1071 netif_info(skge, link, skge->netdev, "Link is down\n");
1077 struct skge_port *skge = netdev_priv(dev);
1082 skge_link_down(skge);
1213 struct skge_port *skge = netdev_priv(dev);
1225 if (skge->autoneg == AUTONEG_ENABLE) {
1242 skge->duplex = DUPLEX_FULL;
1245 skge->duplex = DUPLEX_HALF;
1255 skge->flow_status = FLOW_STAT_SYMMETRIC;
1258 skge->flow_status = FLOW_STAT_REM_SEND;
1261 skge->flow_status = FLOW_STAT_LOC_SEND;
1264 skge->flow_status = FLOW_STAT_NONE;
1266 skge->speed = SPEED_1000;
1270 genesis_link_up(skge);
1276 static void bcom_phy_init(struct skge_port *skge)
1278 struct skge_hw *hw = skge->hw;
1279 int port = skge->port;
1341 if (skge->autoneg == AUTONEG_ENABLE) {
1348 if (skge->advertising & ADVERTISED_1000baseT_Half)
1350 if (skge->advertising & ADVERTISED_1000baseT_Full)
1356 if (skge->duplex == DUPLEX_FULL)
1364 phy_pause_map[skge->flow_control] | PHY_AN_CSMA);
1382 static void xm_phy_init(struct skge_port *skge)
1384 struct skge_hw *hw = skge->hw;
1385 int port = skge->port;
1388 if (skge->autoneg == AUTONEG_ENABLE) {
1389 if (skge->advertising & ADVERTISED_1000baseT_Half)
1391 if (skge->advertising & ADVERTISED_1000baseT_Full)
1394 ctrl |= fiber_pause_map[skge->flow_control];
1402 if (skge->duplex == DUPLEX_FULL)
1413 mod_timer(&skge->link_timer, jiffies + LINK_HZ);
1418 struct skge_port *skge = netdev_priv(dev);
1419 struct skge_hw *hw = skge->hw;
1420 int port = skge->port;
1432 if (skge->autoneg == AUTONEG_ENABLE) {
1449 skge->duplex = DUPLEX_FULL;
1452 skge->duplex = DUPLEX_HALF;
1460 if ((skge->flow_control == FLOW_MODE_SYMMETRIC ||
1461 skge->flow_control == FLOW_MODE_SYM_OR_REM) &&
1463 skge->flow_status = FLOW_STAT_SYMMETRIC;
1464 else if (skge->flow_control == FLOW_MODE_SYM_OR_REM &&
1467 skge->flow_status = FLOW_STAT_REM_SEND;
1468 else if (skge->flow_control == FLOW_MODE_LOC_SEND &&
1471 skge->flow_status = FLOW_STAT_LOC_SEND;
1473 skge->flow_status = FLOW_STAT_NONE;
1475 skge->speed = SPEED_1000;
1479 genesis_link_up(skge);
1491 struct skge_port *skge = from_timer(skge, t, link_timer);
1492 struct net_device *dev = skge->netdev;
1493 struct skge_hw *hw = skge->hw;
1494 int port = skge->port;
1520 mod_timer(&skge->link_timer,
1529 struct skge_port *skge = netdev_priv(dev);
1571 xm_phy_init(skge);
1574 bcom_phy_init(skge);
1600 if (skge->duplex == DUPLEX_HALF) {
1684 static void genesis_stop(struct skge_port *skge)
1686 struct skge_hw *hw = skge->hw;
1687 int port = skge->port;
1732 static void genesis_get_stats(struct skge_port *skge, u64 *data)
1734 struct skge_hw *hw = skge->hw;
1735 int port = skge->port;
1763 struct skge_port *skge = netdev_priv(dev);
1766 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
1771 mod_timer(&skge->link_timer, jiffies + 1);
1780 static void genesis_link_up(struct skge_port *skge)
1782 struct skge_hw *hw = skge->hw;
1783 int port = skge->port;
1793 if (skge->flow_status == FLOW_STAT_NONE ||
1794 skge->flow_status == FLOW_STAT_LOC_SEND)
1804 if (skge->flow_status == FLOW_STAT_SYMMETRIC ||
1805 skge->flow_status == FLOW_STAT_LOC_SEND) {
1843 if (hw->phy_type != SK_PHY_XMAC && skge->duplex == DUPLEX_FULL)
1860 skge_link_up(skge);
1864 static inline void bcom_phy_intr(struct skge_port *skge)
1866 struct skge_hw *hw = skge->hw;
1867 int port = skge->port;
1871 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
1943 struct skge_port *skge = netdev_priv(hw->dev[port]);
1946 if (skge->autoneg == AUTONEG_ENABLE) {
1959 if (skge->autoneg == AUTONEG_DISABLE)
1969 if (skge->autoneg == AUTONEG_ENABLE) {
1971 if (skge->advertising & ADVERTISED_1000baseT_Full)
1973 if (skge->advertising & ADVERTISED_1000baseT_Half)
1975 if (skge->advertising & ADVERTISED_100baseT_Full)
1977 if (skge->advertising & ADVERTISED_100baseT_Half)
1979 if (skge->advertising & ADVERTISED_10baseT_Full)
1981 if (skge->advertising & ADVERTISED_10baseT_Half)
1985 adv |= phy_pause_map[skge->flow_control];
1987 if (skge->advertising & ADVERTISED_1000baseT_Full)
1989 if (skge->advertising & ADVERTISED_1000baseT_Half)
1992 adv |= fiber_pause_map[skge->flow_control];
2001 if (skge->duplex == DUPLEX_FULL)
2004 switch (skge->speed) {
2022 if (skge->autoneg == AUTONEG_ENABLE)
2059 struct skge_port *skge = netdev_priv(hw->dev[port]);
2095 if (skge->autoneg == AUTONEG_DISABLE) {
2100 switch (skge->speed) {
2114 if (skge->duplex == DUPLEX_FULL)
2119 switch (skge->flow_control) {
2226 static void yukon_stop(struct skge_port *skge)
2228 struct skge_hw *hw = skge->hw;
2229 int port = skge->port;
2246 static void yukon_get_stats(struct skge_port *skge, u64 *data)
2248 struct skge_hw *hw = skge->hw;
2249 int port = skge->port;
2265 struct skge_port *skge = netdev_priv(dev);
2268 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
2295 static void yukon_link_up(struct skge_port *skge)
2297 struct skge_hw *hw = skge->hw;
2298 int port = skge->port;
2305 if (skge->duplex == DUPLEX_FULL || skge->autoneg == AUTONEG_ENABLE)
2313 skge_link_up(skge);
2316 static void yukon_link_down(struct skge_port *skge)
2318 struct skge_hw *hw = skge->hw;
2319 int port = skge->port;
2326 if (skge->flow_status == FLOW_STAT_REM_SEND) {
2333 skge_link_down(skge);
2338 static void yukon_phy_intr(struct skge_port *skge)
2340 struct skge_hw *hw = skge->hw;
2341 int port = skge->port;
2348 netif_printk(skge, intr, KERN_DEBUG, skge->netdev,
2368 skge->duplex = (phystat & PHY_M_PS_FULL_DUP)
2370 skge->speed = yukon_speed(hw, phystat);
2375 skge->flow_status = FLOW_STAT_SYMMETRIC;
2378 skge->flow_status = FLOW_STAT_REM_SEND;
2381 skge->flow_status = FLOW_STAT_LOC_SEND;
2384 skge->flow_status = FLOW_STAT_NONE;
2387 if (skge->flow_status == FLOW_STAT_NONE ||
2388 (skge->speed < SPEED_1000 && skge->duplex == DUPLEX_HALF))
2392 yukon_link_up(skge);
2397 skge->speed = yukon_speed(hw, phystat);
2400 skge->duplex = (phystat & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
2403 yukon_link_up(skge);
2405 yukon_link_down(skge);
2409 pr_err("%s: autonegotiation failed (%s)\n", skge->netdev->name, reason);
2414 static void skge_phy_reset(struct skge_port *skge)
2416 struct skge_hw *hw = skge->hw;
2417 int port = skge->port;
2420 netif_stop_queue(skge->netdev);
2421 netif_carrier_off(skge->netdev);
2440 struct skge_port *skge = netdev_priv(dev);
2441 struct skge_hw *hw = skge->hw;
2457 err = __xm_phy_read(hw, skge->port, data->reg_num & 0x1f, &val);
2459 err = __gm_phy_read(hw, skge->port, data->reg_num & 0x1f, &val);
2468 err = xm_phy_write(hw, skge->port, data->reg_num & 0x1f,
2471 err = gm_phy_write(hw, skge->port, data->reg_num & 0x1f,
2510 static void skge_qset(struct skge_port *skge, u16 q,
2513 struct skge_hw *hw = skge->hw;
2515 u64 base = skge->dma + (e->desc - skge->mem);
2529 struct skge_port *skge = netdev_priv(dev);
2530 struct skge_hw *hw = skge->hw;
2531 int port = skge->port;
2539 netif_info(skge, ifup, skge->netdev, "enabling interface\n");
2542 skge->rx_buf_size = dev->mtu + ETH_HLEN;
2544 skge->rx_buf_size = RX_BUF_SIZE;
2547 rx_size = skge->rx_ring.count * sizeof(struct skge_rx_desc);
2548 tx_size = skge->tx_ring.count * sizeof(struct skge_tx_desc);
2549 skge->mem_size = tx_size + rx_size;
2550 skge->mem = dma_alloc_coherent(&hw->pdev->dev, skge->mem_size,
2551 &skge->dma, GFP_KERNEL);
2552 if (!skge->mem)
2555 BUG_ON(skge->dma & 7);
2557 if (upper_32_bits(skge->dma) != upper_32_bits(skge->dma + skge->mem_size)) {
2563 err = skge_ring_alloc(&skge->rx_ring, skge->mem, skge->dma);
2571 err = skge_ring_alloc(&skge->tx_ring, skge->mem + rx_size,
2572 skge->dma + rx_size);
2600 skge_qset(skge, rxqaddr[port], skge->rx_ring.to_clean);
2602 BUG_ON(skge->tx_ring.to_use != skge->tx_ring.to_clean);
2604 skge_qset(skge, txqaddr[port], skge->tx_ring.to_use);
2609 skge_led(skge, LED_MODE_ON);
2617 napi_enable(&skge->napi);
2624 kfree(skge->tx_ring.start);
2626 skge_rx_clean(skge);
2627 kfree(skge->rx_ring.start);
2629 dma_free_coherent(&hw->pdev->dev, skge->mem_size, skge->mem,
2630 skge->dma);
2631 skge->mem = NULL;
2647 struct skge_port *skge = netdev_priv(dev);
2648 struct skge_hw *hw = skge->hw;
2649 int port = skge->port;
2651 if (!skge->mem)
2654 netif_info(skge, ifdown, skge->netdev, "disabling interface\n");
2659 del_timer_sync(&skge->link_timer);
2661 napi_disable(&skge->napi);
2673 skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_REG_OFF);
2675 genesis_stop(skge);
2677 yukon_stop(skge);
2710 skge_led(skge, LED_MODE_OFF);
2716 skge_rx_clean(skge);
2718 kfree(skge->rx_ring.start);
2719 kfree(skge->tx_ring.start);
2720 dma_free_coherent(&hw->pdev->dev, skge->mem_size, skge->mem,
2721 skge->dma);
2722 skge->mem = NULL;
2736 struct skge_port *skge = netdev_priv(dev);
2737 struct skge_hw *hw = skge->hw;
2747 if (unlikely(skge_avail(&skge->tx_ring) < skb_shinfo(skb)->nr_frags + 1))
2750 e = skge->tx_ring.to_use;
2818 skge_write8(hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_START);
2820 netif_printk(skge, tx_queued, KERN_DEBUG, skge->netdev,
2822 e - skge->tx_ring.start, skb->len);
2824 skge->tx_ring.to_use = e->next;
2827 if (skge_avail(&skge->tx_ring) <= TX_LOW_WATER) {
2835 e = skge->tx_ring.to_use;
2868 struct skge_port *skge = netdev_priv(dev);
2871 for (e = skge->tx_ring.to_clean; e != skge->tx_ring.to_use; e = e->next) {
2874 skge_tx_unmap(skge->hw->pdev, e, td->control);
2882 skge->tx_ring.to_clean = e;
2887 struct skge_port *skge = netdev_priv(dev);
2889 netif_printk(skge, timer, KERN_DEBUG, skge->netdev, "tx timeout\n");
2891 skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_STOP);
2929 struct skge_port *skge = netdev_priv(dev);
2930 struct skge_hw *hw = skge->hw;
2931 int port = skge->port;
2948 if (skge->flow_status == FLOW_STAT_REM_SEND ||
2949 skge->flow_status == FLOW_STAT_SYMMETRIC)
2968 struct skge_port *skge = netdev_priv(dev);
2969 struct skge_hw *hw = skge->hw;
2970 int port = skge->port;
2972 int rx_pause = (skge->flow_status == FLOW_STAT_REM_SEND ||
2973 skge->flow_status == FLOW_STAT_SYMMETRIC);
3030 struct skge_port *skge = netdev_priv(dev);
3032 if (is_genesis(skge->hw))
3047 struct skge_port *skge = netdev_priv(dev);
3051 netif_printk(skge, rx_status, KERN_DEBUG, skge->netdev,
3053 e - skge->rx_ring.start, status, len);
3055 if (len > skge->rx_buf_size)
3061 if (bad_phy_status(skge->hw, status))
3064 if (phy_length(skge->hw, status) != len)
3072 dma_sync_single_for_cpu(&skge->hw->pdev->dev,
3077 dma_sync_single_for_device(&skge->hw->pdev->dev,
3081 skge_rx_reuse(e, skge->rx_buf_size);
3086 nskb = netdev_alloc_skb_ip_align(dev, skge->rx_buf_size);
3095 if (skge_rx_setup(skge, e, nskb, skge->rx_buf_size) < 0) {
3100 dma_unmap_single(&skge->hw->pdev->dev,
3117 netif_printk(skge, rx_err, KERN_DEBUG, skge->netdev,
3119 e - skge->rx_ring.start, control, status);
3121 if (is_genesis(skge->hw)) {
3138 skge_rx_reuse(e, skge->rx_buf_size);
3145 struct skge_port *skge = netdev_priv(dev);
3146 struct skge_ring *ring = &skge->tx_ring;
3150 skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_IRQ_CL_F);
3158 skge_tx_unmap(skge->hw->pdev, e, control);
3161 netif_printk(skge, tx_done, KERN_DEBUG, skge->netdev,
3163 e - skge->tx_ring.start);
3172 skge->tx_ring.to_clean = e;
3178 skge_avail(&skge->tx_ring) > TX_LOW_WATER)) {
3181 skge_avail(&skge->tx_ring) > TX_LOW_WATER)) {
3191 struct skge_port *skge = container_of(napi, struct skge_port, napi);
3192 struct net_device *dev = skge->netdev;
3193 struct skge_hw *hw = skge->hw;
3194 struct skge_ring *ring = &skge->rx_ring;
3200 skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_IRQ_CL_F);
3222 skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_START);
3228 hw->intr_mask |= napimask[skge->port];
3350 struct skge_port *skge = netdev_priv(dev);
3354 yukon_phy_intr(skge);
3356 bcom_phy_intr(skge);
3388 struct skge_port *skge = netdev_priv(hw->dev[0]);
3390 napi_schedule(&skge->napi);
3406 struct skge_port *skge = netdev_priv(hw->dev[1]);
3410 napi_schedule(&skge->napi);
3438 struct skge_port *skge = netdev_priv(dev);
3441 skge_intr(dev->irq, skge->hw);
3448 struct skge_port *skge = netdev_priv(dev);
3449 struct skge_hw *hw = skge->hw;
3450 unsigned port = skge->port;
3688 const struct skge_port *skge = netdev_priv(dev);
3689 const struct skge_hw *hw = skge->hw;
3698 seq_printf(seq, "Tx Ring: (%d)\n", skge_avail(&skge->tx_ring));
3699 for (e = skge->tx_ring.to_clean; e != skge->tx_ring.to_use; e = e->next) {
3707 for (e = skge->rx_ring.to_clean; ; e = e->next) {
3730 struct skge_port *skge;
3735 skge = netdev_priv(dev);
3738 if (skge->debugfs)
3739 skge->debugfs = debugfs_rename(skge_debug,
3740 skge->debugfs,
3745 debugfs_remove(skge->debugfs);
3746 skge->debugfs = NULL;
3750 skge->debugfs = debugfs_create_file(dev->name, 0444, skge_debug,
3766 skge_debug = debugfs_create_dir("skge", NULL);
3806 struct skge_port *skge;
3807 struct net_device *dev = alloc_etherdev(sizeof(*skge));
3825 skge = netdev_priv(dev);
3826 netif_napi_add(dev, &skge->napi, skge_poll, NAPI_WEIGHT);
3827 skge->netdev = dev;
3828 skge->hw = hw;
3829 skge->msg_enable = netif_msg_init(debug, default_msg);
3831 skge->tx_ring.count = DEFAULT_TX_RING_SIZE;
3832 skge->rx_ring.count = DEFAULT_RX_RING_SIZE;
3835 skge->autoneg = AUTONEG_ENABLE;
3836 skge->flow_control = FLOW_MODE_SYM_OR_REM;
3837 skge->duplex = -1;
3838 skge->speed = -1;
3839 skge->advertising = skge_supported_modes(hw);
3842 skge->wol = wol_supported(hw) & WAKE_MAGIC;
3843 device_set_wakeup_enable(&hw->pdev->dev, skge->wol);
3848 skge->port = port;
3852 timer_setup(&skge->link_timer, xm_link_timer, 0);
3867 const struct skge_port *skge = netdev_priv(dev);
3869 netif_info(skge, probe, skge->netdev, "addr %pM\n", dev->dev_addr);
3919 /* space for skge@pci:0000:04:00.0 */
4065 struct skge_port *skge = netdev_priv(dev);
4070 if (skge->wol)
4071 skge_wol_init(skge);
4126 struct skge_port *skge = netdev_priv(dev);
4128 if (skge->wol)
4129 skge_wol_init(skge);