pastebin - r8168-ck - post number 2136202

/*

################################################################################

#

# r8168 is the Linux device driver released for RealTek RTL8168B/8111B,

# RTL8168C/8111C, RTL8168CP/8111CP, RTL8168D/8111D, RTL8168DP/8111DP, and

# RTL8168E/8111E Gigabit Ethernet controllers with PCI-Express interface.

#

# Copyright(c) 2012 Realtek Semiconductor Corp. All rights reserved.

#

# This program is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License as published by the Free

# Software Foundation; either version 2 of the License, or (at your option)

# any later version.

#

# This program is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

# more details.

#

# You should have received a copy of the GNU General Public License along with

# this program; if not, see <http://www.gnu.org/licenses/>.

#

# Author:

# Realtek NIC software team <nicfae@realtek.com>

# No. 2, Innovation Road II, Hsinchu Science Park, Hsinchu 300, Taiwan

#

################################################################################

*/

 

/*

 *  This product is covered by one or more of the following patents:

 *  US5,307,459, US5,434,872, US5,732,094, US6,570,884, US6,115,776, and US6,327,625.

 */

 

/*

 * This driver is modified from r8169.c in Linux kernel 2.6.18

 */

 

#include <linux/module.h>

#include <linux/version.h>

#include <linux/pci.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/delay.h>

#include <linux/ethtool.h>

#include <linux/mii.h>

#include <linux/if_vlan.h>

#include <linux/crc32.h>

#include <linux/interrupt.h>

#include <linux/in.h>

#include <linux/ip.h>

#include <linux/tcp.h>

#include <linux/init.h>

#include <linux/rtnetlink.h>

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)

#define dev_printk(A,B,fmt,args...)        printk(A fmt,##args)

#else

#include <linux/dma-mapping.h>

#include <linux/moduleparam.h>

#endif

 

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/uaccess.h>

 

#include "r8168.h"

#include "r8168_asf.h"

#include "rtl_eeprom.h"

#include "rtltool.h"

 

static int eee_enable = 0 ;

module_param(eee_enable, int, S_IRUGO);

 

#ifdef CONFIG_DOWN_SPEED_100

static int config_down_speed_100 = 1;

#else

static int config_down_speed_100 = 0;

#endif

 

/* Maximum events (Rx packets, etc.) to handle at each interrupt. */

static const int max_interrupt_work = 20;

 

/* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).

   The RTL chips use a 64 element hash table based on the Ethernet CRC. */

static const int multicast_filter_limit = 32;

 

#define _R(NAME,MAC,RCR,MASK, JumFrameSz) \

        { .name = NAME, .mcfg = MAC, .RCR_Cfg = RCR, .RxConfigMask = MASK, .jumbo_frame_sz

= JumFrameSz }

 

static const struct {

        const char *name;

        u8 mcfg;

        u32 RCR_Cfg;

        u32 RxConfigMask;        /* Clears the bits supported by this chip */

        u32 jumbo_frame_sz;

} rtl_chip_info[] = {

        _R("RTL8168B/8111B",

           CFG_METHOD_1,

           (Reserved2_data << Reserved2_shift) | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_4k),

 

        _R("RTL8168B/8111B",

           CFG_METHOD_2,

           (Reserved2_data << Reserved2_shift) | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_4k),

 

        _R("RTL8168B/8111B",

           CFG_METHOD_3,

           (Reserved2_data << Reserved2_shift) | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_4k),

 

        _R("RTL8168C/8111C",

           CFG_METHOD_4, RxCfg_128_int_en | RxCfg_fet_multi_en | (RX_DMA_BURST <<

RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_6k),

 

        _R("RTL8168C/8111C",

           CFG_METHOD_5,

           RxCfg_128_int_en | RxCfg_fet_multi_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_6k),

 

        _R("RTL8168C/8111C",

           CFG_METHOD_6,

           RxCfg_128_int_en | RxCfg_fet_multi_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_6k),

 

        _R("RTL8168CP/8111CP",

           CFG_METHOD_7,

           RxCfg_128_int_en | RxCfg_fet_multi_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_6k),

 

        _R("RTL8168CP/8111CP",

           CFG_METHOD_8,

           RxCfg_128_int_en | RxCfg_fet_multi_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_6k),

 

        _R("RTL8168D/8111D",

           CFG_METHOD_9,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168D/8111D",

           CFG_METHOD_10,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168DP/8111DP",

           CFG_METHOD_11,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168DP/8111DP",

           CFG_METHOD_12,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168DP/8111DP",

           CFG_METHOD_13,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168E/8111E",

           CFG_METHOD_14,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168E/8111E",

           CFG_METHOD_15,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168E-VL/8111E-VL",

           CFG_METHOD_16,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e0080,

           Jumbo_Frame_9k),

 

        _R("RTL8168E-VL/8111E-VL",

           CFG_METHOD_17,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168F/8111F",

           CFG_METHOD_18,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8168F/8111F",

           CFG_METHOD_19,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("RTL8411",

           CFG_METHOD_20,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           Jumbo_Frame_9k),

 

        _R("Unknown",

           CFG_METHOD_DEFAULT,

           RxCfg_128_int_en | (RX_DMA_BURST << RxCfgDMAShift),

           0xff7e1880,

           RX_BUF_SIZE)

};

#undef _R

 

#ifndef PCI_VENDOR_ID_DLINK

#define PCI_VENDOR_ID_DLINK        0x1186

#endif

 

static struct pci_device_id rtl8168_pci_tbl[] = {

        { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,        0x8168), },

        { PCI_VENDOR_ID_DLINK, 0x4300, 0x1186, 0x4b10,},

        {0,},

};

 

MODULE_DEVICE_TABLE(pci, rtl8168_pci_tbl);

 

static int rx_copybreak = 200;

static int use_dac;

static struct {

        u32 msg_enable;

} debug = { -1 };

 

/* media options */

#define MAX_UNITS 8

static int speed[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };

static int duplex[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };

static int autoneg[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };

 

MODULE_AUTHOR("Realtek and the Linux r8168 crew <netdev@vger.kernel.org>");

MODULE_DESCRIPTION("RealTek RTL-8168 Gigabit Ethernet driver");

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)

MODULE_PARM(speed, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");

MODULE_PARM(autoneg, "1-" __MODULE_STRING(MAX_UNITS) "i");

#else

static int num_speed = 0;

static int num_duplex = 0;

static int num_autoneg = 0;

 

module_param_array(speed, int, &num_speed, 0);

module_param_array(duplex, int, &num_duplex, 0);

module_param_array(autoneg, int, &num_autoneg, 0);

#endif

 

MODULE_PARM_DESC(speed, "force phy operation. Deprecated by ethtool (8).");

MODULE_PARM_DESC(duplex, "force phy operation. Deprecated by ethtool (8).");

MODULE_PARM_DESC(autoneg, "force phy operation. Deprecated by ethtool (8).");

 

module_param(rx_copybreak, int, 0);

MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");

module_param(use_dac, int, 0);

MODULE_PARM_DESC(use_dac, "Enable PCI DAC. Unsafe on 32 bit PCI slot.");

 

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)

module_param_named(debug, debug.msg_enable, int, 0);

MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)");

#endif//LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)

 

MODULE_LICENSE("GPL");

 

MODULE_VERSION(RTL8168_VERSION);

 

static void rtl8168_sleep_rx_enable(struct net_device *dev);

static void rtl8168_dsm(struct net_device *dev, int dev_state);

 

static void rtl8168_esd_timer(unsigned long __opaque);

static void rtl8168_link_timer(unsigned long __opaque);

static void rtl8168_tx_clear(struct rtl8168_private *tp);

static void rtl8168_rx_clear(struct rtl8168_private *tp);

 

static int rtl8168_open(struct net_device *dev);

static int rtl8168_start_xmit(struct sk_buff *skb, struct net_device *dev);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)

static irqreturn_t rtl8168_interrupt(int irq, void *dev_instance, struct pt_regs

*regs);

#else

static irqreturn_t rtl8168_interrupt(int irq, void *dev_instance);

#endif

static void rtl8168_rx_desc_offset0_init(struct rtl8168_private *, int);

static int rtl8168_init_ring(struct net_device *dev);

static void rtl8168_hw_start(struct net_device *dev);

static int rtl8168_close(struct net_device *dev);

static void rtl8168_set_rx_mode(struct net_device *dev);

static void rtl8168_tx_timeout(struct net_device *dev);

static struct net_device_stats *rtl8168_get_stats(struct net_device *dev);

static int rtl8168_rx_interrupt(struct net_device *, struct rtl8168_private *, void

__iomem *, u32 budget);

static int rtl8168_change_mtu(struct net_device *dev, int new_mtu);

static void rtl8168_down(struct net_device *dev);

 

static int rtl8168_set_mac_address(struct net_device *dev, void *p);

void rtl8168_rar_set(struct rtl8168_private *tp, uint8_t *addr);

static void rtl8168_tx_desc_init(struct rtl8168_private *tp);

static void rtl8168_rx_desc_init(struct rtl8168_private *tp);

 

static void rtl8168_nic_reset(struct net_device *dev);

 

static void rtl8168_phy_power_up (struct net_device *dev);

static void rtl8168_phy_power_down (struct net_device *dev);

static int rtl8168_set_speed(struct net_device *dev, u8 autoneg,  u16 speed, u8

duplex);

 

#ifdef CONFIG_R8168_NAPI

static int rtl8168_poll(napi_ptr napi, napi_budget budget);

#endif

 

static u16 rtl8168_intr_mask = SYSErr | LinkChg | RxDescUnavail | TxErr | TxOK |

RxErr | RxOK;

static const u16 rtl8168_napi_event =

        RxOK | RxDescUnavail | RxFIFOOver | TxOK | TxErr;

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)

#undef ethtool_ops

#define ethtool_ops _kc_ethtool_ops

 

struct _kc_ethtool_ops {

        int  (*get_settings)(struct net_device *, struct ethtool_cmd *);

        int  (*set_settings)(struct net_device *, struct ethtool_cmd *);

        void (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *);

        int  (*get_regs_len)(struct net_device *);

        void (*get_regs)(struct net_device *, struct ethtool_regs *, void *);

        void (*get_wol)(struct net_device *, struct ethtool_wolinfo *);

        int  (*set_wol)(struct net_device *, struct ethtool_wolinfo *);

        u32  (*get_msglevel)(struct net_device *);

        void (*set_msglevel)(struct net_device *, u32);

        int  (*nway_reset)(struct net_device *);

        u32  (*get_link)(struct net_device *);

        int  (*get_eeprom_len)(struct net_device *);

        int  (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);

        int  (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);

        int  (*get_coalesce)(struct net_device *, struct ethtool_coalesce *);

        int  (*set_coalesce)(struct net_device *, struct ethtool_coalesce *);

        void (*get_ringparam)(struct net_device *, struct ethtool_ringparam *);

        int  (*set_ringparam)(struct net_device *, struct ethtool_ringparam *);

        void (*get_pauseparam)(struct net_device *,

                               struct ethtool_pauseparam*);

        int  (*set_pauseparam)(struct net_device *,

                               struct ethtool_pauseparam*);

        u32  (*get_rx_csum)(struct net_device *);

        int  (*set_rx_csum)(struct net_device *, u32);

        u32  (*get_tx_csum)(struct net_device *);

        int  (*set_tx_csum)(struct net_device *, u32);

        u32  (*get_sg)(struct net_device *);

        int  (*set_sg)(struct net_device *, u32);

        u32  (*get_tso)(struct net_device *);

        int  (*set_tso)(struct net_device *, u32);

        int  (*self_test_count)(struct net_device *);

        void (*self_test)(struct net_device *, struct ethtool_test *, u64 *);

        void (*get_strings)(struct net_device *, u32 stringset, u8 *);

        int  (*phys_id)(struct net_device *, u32);

        int  (*get_stats_count)(struct net_device *);

        void (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *,

                                  u64 *);

} *ethtool_ops = NULL;

 

#undef SET_ETHTOOL_OPS

#define SET_ETHTOOL_OPS(netdev, ops) (ethtool_ops = (ops))

 

#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)

 

 

//#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5)

#ifndef netif_msg_init

#define netif_msg_init _kc_netif_msg_init

/* copied from linux kernel 2.6.20 include/linux/netdevice.h */

static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)

        /* use default */

        if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))

                return default_msg_enable_bits;

        if (debug_value == 0)        /* no output */

                return 0;

        /* set low N bits */

        return (1 << debug_value) - 1;

 

#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,5)

 

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)

static inline void eth_copy_and_sum (struct sk_buff *dest,

                                     const unsigned char *src,

                                     int len, int base)

        memcpy (dest->data, src, len);

#endif //LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22)

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7)

/* copied from linux kernel 2.6.20 /include/linux/time.h */

/* Parameters used to convert the timespec values: */

#define MSEC_PER_SEC        1000L

 

/* copied from linux kernel 2.6.20 /include/linux/jiffies.h */

/*

 * Change timeval to jiffies, trying to avoid the

 * most obvious overflows..

 *

 * And some not so obvious.

 *

 * Note that we don't want to return MAX_LONG, because

 * for various timeout reasons we often end up having

 * to wait "jiffies+1" in order to guarantee that we wait

 * at _least_ "jiffies" - so "jiffies+1" had better still

 * be positive.

 */

#define MAX_JIFFY_OFFSET ((~0UL >> 1)-1)

 

/*

 * Convert jiffies to milliseconds and back.

 *

 * Avoid unnecessary multiplications/divisions in the

 * two most common HZ cases:

 */

static inline unsigned int _kc_jiffies_to_msecs(const unsigned long j)

#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)

        return (MSEC_PER_SEC / HZ) * j;

#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)

        return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);

#else

        return (j * MSEC_PER_SEC) / HZ;

#endif

 

static inline unsigned long _kc_msecs_to_jiffies(const unsigned int m)

        if (m > _kc_jiffies_to_msecs(MAX_JIFFY_OFFSET))

                return MAX_JIFFY_OFFSET;

#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)

        return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);

#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)

        return m * (HZ / MSEC_PER_SEC);

#else

        return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;

#endif

#endif        //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7)

 

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)

 

/* copied from linux kernel 2.6.12.6 /include/linux/pm.h */

typedef int __bitwise pci_power_t;

 

/* copied from linux kernel 2.6.12.6 /include/linux/pci.h */

typedef u32 __bitwise pm_message_t;

 

#define PCI_D0        ((pci_power_t __force) 0)

#define PCI_D1        ((pci_power_t __force) 1)

#define PCI_D2        ((pci_power_t __force) 2)

#define PCI_D3hot        ((pci_power_t __force) 3)

#define PCI_D3cold        ((pci_power_t __force) 4)

#define PCI_POWER_ERROR        ((pci_power_t __force) -1)

 

/* copied from linux kernel 2.6.12.6 /drivers/pci/pci.c */

/**

 * pci_choose_state - Choose the power state of a PCI device

 * @dev: PCI device to be suspended

 * @state: target sleep state for the whole system. This is the value

 *        that is passed to suspend() function.

 *

 * Returns PCI power state suitable for given device and given system

 * message.

 */

 

pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state)

        if (!pci_find_capability(dev, PCI_CAP_ID_PM))

                return PCI_D0;

 

        switch (state) {

        case 0: return PCI_D0;

        case 3: return PCI_D3hot;

        default:

                printk("They asked me for state %d\n", state);

//                BUG();

        }

        return PCI_D0;

#endif        //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)

/**

 * msleep_interruptible - sleep waiting for waitqueue interruptions

 * @msecs: Time in milliseconds to sleep for

 */

#define msleep_interruptible _kc_msleep_interruptible

unsigned long _kc_msleep_interruptible(unsigned int msecs)

        unsigned long timeout = _kc_msecs_to_jiffies(msecs);

 

        while (timeout && !signal_pending(current)) {

                set_current_state(TASK_INTERRUPTIBLE);

                timeout = schedule_timeout(timeout);

        }

        return _kc_jiffies_to_msecs(timeout);

#endif        //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7)

/* copied from linux kernel 2.6.20 include/linux/sched.h */

#ifndef __sched

#define __sched                __attribute__((__section__(".sched.text")))

#endif

 

/* copied from linux kernel 2.6.20 kernel/timer.c */

signed long __sched schedule_timeout_uninterruptible(signed long timeout)

        __set_current_state(TASK_UNINTERRUPTIBLE);

        return schedule_timeout(timeout);

 

/* copied from linux kernel 2.6.20 include/linux/mii.h */

#undef if_mii

#define if_mii _kc_if_mii

static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)

        return (struct mii_ioctl_data *) &rq->ifr_ifru;

#endif        //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7)

 

void mdio_write(struct rtl8168_private *tp,

           u32 RegAddr,

           u32 value)

        void __iomem *ioaddr = tp->mmio_addr;

        int i;

 

        if (tp->mcfg==CFG_METHOD_11)

        {

                RTL_W32(OCPDR, OCPDR_Write |

                        (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift |

                        (value & OCPDR_Data_Mask));

                RTL_W32(OCPAR, OCPAR_GPHY_Write);

                RTL_W32(EPHY_RXER_NUM, 0);

 

                for (i = 0; i < 100; i++)

                {

                        mdelay(1);

                        if (!(RTL_R32(OCPAR) & OCPAR_Flag))

                                break;

                }

        }

        else

        {

                if (tp->mcfg == CFG_METHOD_12 || tp->mcfg == CFG_METHOD_13)

                        RTL_W32(0xD0, RTL_R32(0xD0) & ~0x00020000);

 

                RTL_W32(PHYAR, PHYAR_Write |

                        (RegAddr & PHYAR_Reg_Mask) << PHYAR_Reg_shift |

                        (value & PHYAR_Data_Mask));

 

                for (i = 0; i < 10; i++) {

                        udelay(100);

 

                        /* Check if the RTL8168 has completed writing to the specified MII register */

                        if (!(RTL_R32(PHYAR) & PHYAR_Flag))

                        {

                                udelay(20);

                                break;

                        }

                }

 

                if (tp->mcfg == CFG_METHOD_12 || tp->mcfg == CFG_METHOD_13)

                        RTL_W32(0xD0, RTL_R32(0xD0) | 0x00020000);

        }

 

u32 mdio_read(struct rtl8168_private *tp,

          u32 RegAddr)

        void __iomem *ioaddr = tp->mmio_addr;

        int i, value = -1;

 

        if (tp->mcfg==CFG_METHOD_11)

        {

                RTL_W32(OCPDR, OCPDR_Read |

                        (RegAddr & OCPDR_Reg_Mask) << OCPDR_GPHY_Reg_shift);

                RTL_W32(OCPAR, OCPAR_GPHY_Write);

                RTL_W32(EPHY_RXER_NUM, 0);

 

                for (i = 0; i < 100; i++)

                {

                        mdelay(1);

                        if (!(RTL_R32(OCPAR) & OCPAR_Flag))

                                break;

                }

 

                mdelay(1);

                RTL_W32(OCPAR, OCPAR_GPHY_Read);

                RTL_W32(EPHY_RXER_NUM, 0);

 

                for (i = 0; i < 100; i++)

                {

                        mdelay(1);

                        if (RTL_R32(OCPAR) & OCPAR_Flag)

                                break;

                }

 

                value = (int) (RTL_R32(OCPDR) & OCPDR_Data_Mask);

        }

        else

        {

                if (tp->mcfg == CFG_METHOD_12 || tp->mcfg == CFG_METHOD_13)

                        RTL_W32(0xD0, RTL_R32(0xD0) & ~0x00020000);

 

                RTL_W32(PHYAR,

                        PHYAR_Read | (RegAddr & PHYAR_Reg_Mask) << PHYAR_Reg_shift);

 

                for (i = 0; i < 10; i++) {

                        udelay(100);

 

                        /* Check if the RTL8168 has completed retrieving data from the specified MII

register */

                        if (RTL_R32(PHYAR) & PHYAR_Flag) {

                                value = (int) (RTL_R32(PHYAR) & PHYAR_Data_Mask);

                                udelay(20);

                                break;

                        }

                }

 

                if (tp->mcfg == CFG_METHOD_12 || tp->mcfg == CFG_METHOD_13)

                        RTL_W32(0xD0, RTL_R32(0xD0) | 0x00020000);

        }

 

        return value;

 

u32 OCP_read(struct rtl8168_private *tp, u8 mask, u16 Reg)

        void __iomem *ioaddr = tp->mmio_addr;

        int        i;

 

        RTL_W32(OCPAR, ((u32)mask&0xF)<<12 | (Reg&0xFFF));

        for (i=0;i<20;i++)

        {

                udelay(100);

                if (RTL_R32(OCPAR) & OCPAR_Flag)

                        break;

        }

        return RTL_R32(OCPDR);

 

void OCP_write(struct rtl8168_private *tp, u8 mask, u16 Reg, u32 data)

        void __iomem *ioaddr = tp->mmio_addr;

        int        i;

 

        RTL_W32(OCPDR, data);

        RTL_W32(OCPAR, OCPAR_Flag | ((u32)mask&0xF)<<12 | (Reg&0xFFF));

        for (i=0;i<20;i++)

        {

                udelay(100);

                if ( (RTL_R32(OCPAR)&OCPAR_Flag) == 0)

                        break;

        }

 

static void OOB_mutex_lock(struct rtl8168_private *tp)

        u32 reg;

 

        if (tp->mcfg == CFG_METHOD_13)

                reg = 0x04;

        else

                reg = 0x14;

 

        OCP_write(tp, 0x8, reg, 0x01000000);

 

        while (OCP_read(tp, 0xF, reg) & 0x00FF0000) {

                if (OCP_read(tp, 0xF, 0x09C) & 0x000000FF) {

                        OCP_write(tp, 0x8, reg, 0x00000000);

 

                        while (OCP_read(tp, 0xF, 0x09C) & 0x000000FF);

 

                        OCP_write(tp, 0x8, reg, 0x01000000);

                }

        }

 

static void OOB_mutex_unlock(struct rtl8168_private *tp)

        u32 reg;

 

        if (tp->mcfg == CFG_METHOD_13)

                reg = 0x04;

        else

                reg = 0x14;

 

        OCP_write(tp, 0x1, 0x9C, 0x00000001);

        OCP_write(tp, 0x8, reg, 0x00000000);

 

void OOB_notify(struct rtl8168_private *tp, u8 cmd)

        void __iomem *ioaddr = tp->mmio_addr;

        int        i;

 

        RTL_W8(ERIDR, cmd);

        RTL_W32(ERIAR, 0x800010E8);

        mdelay(2);

        for (i = 0; i < 5; i++) {

                udelay(100);

                if ( !(RTL_R32(ERIAR) & ERIAR_Flag))

                        break;

        }

 

        OCP_write(tp, 0x1, 0x30, 0x00000001);

 

static int rtl8168_check_dash(struct rtl8168_private *tp)

        u32 reg;

 

        if (tp->mcfg == CFG_METHOD_13)

                reg = 0xb8;

        else

                reg = 0x10;

 

        if (OCP_read(tp, 0xF, reg) & 0x00008000)

                return 1;

        else

                return 0;

 

static void rtl8168_mac_loopback_test(struct rtl8168_private *tp)

        void __iomem *ioaddr = tp->mmio_addr;

        struct net_device *dev = tp->dev;

        struct sk_buff *skb, *rx_skb;

        dma_addr_t mapping;

        struct TxDesc *txd;

        struct RxDesc *rxd;

        void *tmpAddr;

        u32 len, rx_len, rx_cmd;

        u16 type;

        u8 pattern;

        int i;

 

        if (rtl8168_check_dash(tp))

                return;

 

        pattern = 0x5A;

        len = 60;

        type = htons(ETH_P_IP);

        txd = tp->TxDescArray;

        rxd = tp->RxDescArray;

        rx_skb = tp->Rx_skbuff[0];

        RTL_W32(TxConfig, (RTL_R32(TxConfig) & ~0x00060000) | 0x00020000);

 

        do {

                skb = dev_alloc_skb(len + RTK_RX_ALIGN);

                if (unlikely(!skb))

                        dev_printk(KERN_NOTICE, &tp->pci_dev->dev, "-ENOMEM;\n");

        } while (unlikely(skb == NULL));

        skb_reserve(skb, RTK_RX_ALIGN);

 

        memcpy(skb_put(skb, dev->addr_len), dev->dev_addr, dev->addr_len);

        memcpy(skb_put(skb, dev->addr_len), dev->dev_addr, dev->addr_len);

        memcpy(skb_put(skb, sizeof(type)), &type, sizeof(type));

        tmpAddr = skb_put(skb, len - 14);

 

        mapping = pci_map_single(tp->pci_dev, skb->data, len, PCI_DMA_TODEVICE);

        pci_dma_sync_single_for_cpu(tp->pci_dev, le64_to_cpu(mapping),

                                    len, PCI_DMA_TODEVICE);

        txd->addr = cpu_to_le64(mapping);

        txd->opts2 = 0;

        while (1) {

                memset(tmpAddr, pattern++, len - 14);

                pci_dma_sync_single_for_device(tp->pci_dev,

                                               le64_to_cpu(mapping),

                                               len, PCI_DMA_TODEVICE);

                txd->opts1 = cpu_to_le32(DescOwn | FirstFrag | LastFrag | len);

 

                RTL_W32(RxConfig, RTL_R32(RxConfig)  | AcceptMyPhys);

 

                smp_wmb();

                RTL_W8(TxPoll, NPQ);        /* set polling bit */

 

                for (i = 0; i < 50; i++) {

                        udelay(200);

                        rx_cmd = le32_to_cpu(rxd->opts1);

                        if ((rx_cmd & DescOwn) == 0)

                                break;

                }

 

                RTL_W32(RxConfig, RTL_R32(RxConfig) & ~(AcceptErr | AcceptRunt | AcceptBroadcast |

AcceptMulticast | AcceptMyPhys |  AcceptAllPhys));

 

                rx_len = rx_cmd & 0x3FFF;

                rx_len -= 4;

                rxd->opts1 = cpu_to_le32(DescOwn | tp->rx_buf_sz);

 

                pci_dma_sync_single_for_cpu(tp->pci_dev, le64_to_cpu(mapping), len,

PCI_DMA_TODEVICE);

 

                if (rx_len == len) {

                        pci_dma_sync_single_for_cpu(tp->pci_dev, le64_to_cpu(rxd->addr), tp->rx_buf_sz,

PCI_DMA_FROMDEVICE);

                        i = memcmp(skb->data, rx_skb->data, rx_len);

                        pci_dma_sync_single_for_device(tp->pci_dev, le64_to_cpu(rxd->addr),

tp->rx_buf_sz, PCI_DMA_FROMDEVICE);

                        if (i == 0) {

//                                dev_printk(KERN_INFO, &tp->pci_dev->dev, "loopback test finished\n",rx_len,len);

                                break;

                        }

                }

 

                rtl8168_nic_reset(dev);

                RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);

        }

        tp->dirty_tx++;

        tp->dirty_rx++;

        tp->cur_tx++;

        tp->cur_rx++;

        pci_unmap_single(tp->pci_dev, le64_to_cpu(mapping),

                         len, PCI_DMA_TODEVICE);

        RTL_W32(TxConfig, RTL_R32(TxConfig) & ~0x00060000);

        dev_kfree_skb_any(skb);

        RTL_W16(IntrStatus, 0xFFBF);

 

static void rtl8168_driver_start(struct rtl8168_private *tp)

        int timeout;

        u32 reg;

 

        OOB_notify(tp, OOB_CMD_DRIVER_START);

 

        if (tp->mcfg == CFG_METHOD_13)

                reg = 0xB8;

        else

                reg = 0x10;

 

        for (timeout = 0; timeout < 10; timeout++) {

                mdelay(10);

                if (OCP_read(tp, 0xF, reg) & BIT_11)

                        break;

        }

 

static void rtl8168_driver_stop(struct rtl8168_private *tp)

        int timeout;

        u32 reg;

 

        OOB_notify(tp, OOB_CMD_DRIVER_STOP);

 

        if (tp->mcfg == CFG_METHOD_13)

                reg = 0xB8;

        else

                reg = 0x10;

 

        for (timeout = 0; timeout < 10; timeout++) {

                mdelay(10);

                if ((OCP_read(tp, 0xF, reg) & BIT_11) == 0)

                        break;

        }

 

void rtl8168_ephy_write(void __iomem *ioaddr, int RegAddr, int value)

        int i;

 

        RTL_W32(EPHYAR,

                EPHYAR_Write |

                (RegAddr & EPHYAR_Reg_Mask) << EPHYAR_Reg_shift |

                (value & EPHYAR_Data_Mask));

 

        for (i = 0; i < 10; i++) {

                udelay(100);

 

                /* Check if the RTL8168 has completed EPHY write */

                if (!(RTL_R32(EPHYAR) & EPHYAR_Flag))

                        break;

        }

 

        udelay(20);

 

u16 rtl8168_ephy_read(void __iomem *ioaddr, int RegAddr)

        int i;

        u16 value = 0xffff;

 

        RTL_W32(EPHYAR,

                EPHYAR_Read | (RegAddr & EPHYAR_Reg_Mask) << EPHYAR_Reg_shift);

 

        for (i = 0; i < 10; i++) {

                udelay(100);

 

                /* Check if the RTL8168 has completed EPHY read */

                if (RTL_R32(EPHYAR) & EPHYAR_Flag) {

                        value = (u16) (RTL_R32(EPHYAR) & EPHYAR_Data_Mask);

                        break;

                }

        }

 

        udelay(20);

 

        return value;

 

static void

rtl8168_csi_write(struct rtl8168_private *tp,

                   u32 addr,

                   u32 value)

        void __iomem *ioaddr = tp->mmio_addr;

        u32 cmd;

        int i;

 

        RTL_W32(CSIDR, value);

        cmd = CSIAR_Write | CSIAR_ByteEn << CSIAR_ByteEn_shift | (addr & CSIAR_Addr_Mask);

        if (tp->mcfg == CFG_METHOD_20)

                cmd |= 0x00020000;

        RTL_W32(CSIAR, cmd);

 

        for (i = 0; i < 10; i++) {

                udelay(100);

 

                /* Check if the RTL8168 has completed CSI write */

                if (!(RTL_R32(CSIAR) & CSIAR_Flag))

                        break;

        }

 

        udelay(20);

 

static int

rtl8168_csi_read(struct rtl8168_private *tp,

                 u32 addr)

        void __iomem *ioaddr = tp->mmio_addr;

        u32 cmd;

        int i, value = -1;

 

        cmd = CSIAR_Read | CSIAR_ByteEn << CSIAR_ByteEn_shift | (addr & CSIAR_Addr_Mask);

 

        if (tp->mcfg == CFG_METHOD_20)

                cmd |= 0x00020000;

 

        RTL_W32(CSIAR, cmd);

 

        for (i = 0; i < 10; i++) {

                udelay(100);

 

                /* Check if the RTL8168 has completed CSI read */

                if (RTL_R32(CSIAR) & CSIAR_Flag) {

                        value = (int)RTL_R32(CSIDR);

                        break;

                }

        }

 

        udelay(20);

 

        return value;

 

u32 rtl8168_eri_read(void __iomem *ioaddr, int addr, int len, int type)

        int i, val_shift, shift = 0;

        u32 value1 = 0, value2 = 0, mask;

 

        if (len > 4 || len <= 0)

                return -1;

 

        while (len > 0) {

                val_shift = addr % ERIAR_Addr_Align;

                addr = addr & ~0x3;

 

                RTL_W32(ERIAR,

                        ERIAR_Read |

                        type << ERIAR_Type_shift |

                        ERIAR_ByteEn << ERIAR_ByteEn_shift |

                        addr);

 

                for (i = 0; i < 10; i++) {

                        udelay(100);

 

                        /* Check if the RTL8168 has completed ERI read */

                        if (RTL_R32(ERIAR) & ERIAR_Flag)

                                break;

                }

 

                if (len == 1)                mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;

                else if (len == 2)        mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;

                else if (len == 3)        mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;

                else                        mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;

 

                value1 = RTL_R32(ERIDR) & mask;

                value2 |= (value1 >> val_shift * 8) << shift * 8;

 

                if (len <= 4 - val_shift)

                        len = 0;

                else {

                        len -= (4 - val_shift);

                        shift = 4 - val_shift;

                        addr += 4;

                }

        }

 

        return value2;

 

int rtl8168_eri_write(void __iomem *ioaddr, int addr, int len, u32 value, int type)

 

        int i, val_shift, shift = 0;

        u32 value1 = 0, mask;

 

        if (len > 4 || len <= 0)

                return -1;

 

        while (len > 0) {

                val_shift = addr % ERIAR_Addr_Align;

                addr = addr & ~0x3;

 

                if (len == 1)                mask = (0xFF << (val_shift * 8)) & 0xFFFFFFFF;

                else if (len == 2)        mask = (0xFFFF << (val_shift * 8)) & 0xFFFFFFFF;

                else if (len == 3)        mask = (0xFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;

                else                        mask = (0xFFFFFFFF << (val_shift * 8)) & 0xFFFFFFFF;

 

                value1 = rtl8168_eri_read(ioaddr, addr, 4, type) & ~mask;

                value1 |= ((value << val_shift * 8) >> shift * 8);

 

                RTL_W32(ERIDR, value1);

                RTL_W32(ERIAR,

                        ERIAR_Write |

                        type << ERIAR_Type_shift |

                        ERIAR_ByteEn << ERIAR_ByteEn_shift |

                        addr);

 

                for (i = 0; i < 10; i++) {

                        udelay(100);

 

                        /* Check if the RTL8168 has completed ERI write */

                        if (!(RTL_R32(ERIAR) & ERIAR_Flag))

                                break;

                }

 

                if (len <= 4 - val_shift)

                        len = 0;

                else {

                        len -= (4 - val_shift);

                        shift = 4 - val_shift;

                        addr += 4;

                }

        }

 

        return 0;

 

static void

rtl8168_irq_mask_and_ack(void __iomem *ioaddr)

        RTL_W16(IntrMask, 0x0000);

 

static void

rtl8168_asic_down(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

 

        rtl8168_irq_mask_and_ack(ioaddr);

        rtl8168_nic_reset(dev);

 

static void

rtl8168_nic_reset(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        int        i;

 

        RTL_W32(RxConfig, RTL_R32(RxConfig) &

                ~(AcceptErr | AcceptRunt | AcceptBroadcast | AcceptMulticast |

                  AcceptMyPhys |  AcceptAllPhys));

 

        switch (tp->mcfg) {

        case CFG_METHOD_1:

        case CFG_METHOD_2:

        case CFG_METHOD_3:

                break;

        case CFG_METHOD_4:

        case CFG_METHOD_5:

        case CFG_METHOD_6:

        case CFG_METHOD_7:

        case CFG_METHOD_8:

        case CFG_METHOD_9:

        case CFG_METHOD_10:

        case CFG_METHOD_14:

        case CFG_METHOD_15:

                RTL_W8(ChipCmd, StopReq | CmdRxEnb | CmdTxEnb);

                udelay(100);

                break;

        case CFG_METHOD_11:

        case CFG_METHOD_12:

        case CFG_METHOD_13:

                while (RTL_R8(TxPoll) & NPQ)

                        udelay(20);

                break;

        default:

                RTL_W8(ChipCmd, StopReq | CmdRxEnb | CmdTxEnb);

                while (!(RTL_R32(TxConfig) & BIT_11)) udelay(100);

                break;

        }

 

        /* Soft reset the chip. */

        RTL_W8(ChipCmd, CmdReset);

 

        /* Check that the chip has finished the reset. */

        for (i = 100; i > 0; i--) {

                udelay(100);

                if ((RTL_R8(ChipCmd) & CmdReset) == 0)

                        break;

        }

 

        if (tp->mcfg == CFG_METHOD_11)

        {

                OOB_mutex_lock(tp);

                OCP_write(tp, 0x3, 0x10, OCP_read(tp, 0xF, 0x010)&~0x00004000);

                OOB_mutex_unlock(tp);

 

                OOB_notify(tp, OOB_CMD_RESET);

 

                for (i=0;i<10;i++)

                {

                        mdelay(10);

                        if (OCP_read(tp, 0xF, 0x010)&0x00004000)

                                break;

                }

 

                for (i=0;i<5;i++)

                {

                        if ( (OCP_read(tp, 0xF, 0x034) & 0xFFFF) == 0)

                                break;

                }

        }

 

static unsigned int

rtl8168_xmii_reset_pending(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        unsigned long flags;

        unsigned int retval;

 

        spin_lock_irqsave(&tp->phy_lock, flags);

        mdio_write(tp, 0x1f, 0x0000);

        retval = mdio_read(tp, MII_BMCR) & BMCR_RESET;

        spin_unlock_irqrestore(&tp->phy_lock, flags);

 

        return retval;

 

static unsigned int

rtl8168_xmii_link_ok(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        unsigned int retval;

 

        retval = RTL_R8(PHYstatus) & LinkStatus;

 

        return retval;

 

static void

rtl8168_xmii_reset_enable(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        unsigned long flags;

        int i, val = 0;

 

        spin_lock_irqsave(&tp->phy_lock, flags);

        mdio_write(tp, 0x1f, 0x0000);

        mdio_write(tp, MII_BMCR, mdio_read(tp, MII_BMCR) | BMCR_RESET);

        spin_unlock_irqrestore(&tp->phy_lock, flags);

 

        for (i = 0; i < 2500; i++) {

                spin_lock_irqsave(&tp->phy_lock, flags);

                val = mdio_read(tp, MII_BMSR) & BMCR_RESET;

                spin_unlock_irqrestore(&tp->phy_lock, flags);

 

                if (!val)

                        return;

 

                mdelay(1);

        }

 

static void

rtl8168dp_10mbps_gphy_para(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        u8 status = RTL_R8(PHYstatus);

        unsigned long flags;

 

        spin_lock_irqsave(&tp->phy_lock, flags);

        if ((status & LinkStatus) && (status & _10bps)) {

                mdio_write(tp, 0x1f, 0x0000);

                mdio_write(tp, 0x10, 0x04EE);

        } else {

                mdio_write(tp, 0x1f, 0x0000);

                mdio_write(tp, 0x10, 0x01EE);

        }

        spin_unlock_irqrestore(&tp->phy_lock, flags);

 

void rtl8168_init_ring_indexes(struct rtl8168_private *tp);

static void

rtl8168_check_link_status(struct net_device *dev,

                          struct rtl8168_private *tp,

                          void __iomem *ioaddr)

        unsigned long flags;

 

        if (tp->mcfg == CFG_METHOD_11)

        {

                rtl8168dp_10mbps_gphy_para(dev);

        }

 

        spin_lock_irqsave(&tp->lock, flags);

        if (tp->link_ok(dev)) {

                if (tp->mcfg == CFG_METHOD_18 || tp->mcfg == CFG_METHOD_19 || tp->mcfg ==

CFG_METHOD_20) {

                        if (RTL_R8(PHYstatus) & _1000bpsF) {

                                rtl8168_eri_write(ioaddr, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);

                                rtl8168_eri_write(ioaddr, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);

                        } else {

                                rtl8168_eri_write(ioaddr, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);

                                rtl8168_eri_write(ioaddr, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);

                        }

                        if (netif_running(dev) && (RTL_R8(ChipCmd) & (CmdRxEnb | CmdTxEnb))==0) {

                                int timeout;

                                for (timeout = 0; timeout < 10; timeout++) {

                                        if ((rtl8168_eri_read(ioaddr, 0x1AE, 4, ERIAR_ExGMAC) & BIT_13)==0)

                                                break;

                                        mdelay(1);

                                }

                                rtl8168_init_ring_indexes(tp);

                                RTL_W8(ChipCmd, CmdRxEnb | CmdTxEnb);

                        }

                } else if ((tp->mcfg == CFG_METHOD_16 || tp->mcfg == CFG_METHOD_17) &&

netif_running(dev)) {

                        u32 eri_data;

                        if (tp->mcfg == CFG_METHOD_16 && (RTL_R8(PHYstatus) & _10bps))

                                RTL_W32(RxConfig, RTL_R32(RxConfig) | AcceptAllPhys);

                        else if (tp->mcfg == CFG_METHOD_17) {

                                if (RTL_R8(PHYstatus) & _1000bpsF) {

                                        rtl8168_eri_write(ioaddr, 0x1bc, 4, 0x00000011, ERIAR_ExGMAC);

                                        rtl8168_eri_write(ioaddr, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);

                                } else if (RTL_R8(PHYstatus) & _100bps) {

                                        rtl8168_eri_write(ioaddr, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);

                                        rtl8168_eri_write(ioaddr, 0x1dc, 4, 0x00000005, ERIAR_ExGMAC);

                                } else {

                                        rtl8168_eri_write(ioaddr, 0x1bc, 4, 0x0000001f, ERIAR_ExGMAC);

                                        rtl8168_eri_write(ioaddr, 0x1dc, 4, 0x0000003f, ERIAR_ExGMAC);

                                }

                        }

 

                        eri_data = rtl8168_eri_read(ioaddr, 0xDC, 1, ERIAR_ExGMAC);

                        eri_data &= ~BIT_0;

                        rtl8168_eri_write(ioaddr, 0xDC, 1, eri_data, ERIAR_ExGMAC);

                        eri_data |= BIT_0;

                        rtl8168_eri_write(ioaddr, 0xDC, 1, eri_data, ERIAR_ExGMAC);

                        if ((RTL_R8(ChipCmd) & (CmdRxEnb | CmdTxEnb))==0) {

                                int timeout;

                                for (timeout = 0; timeout < 10; timeout++) {

                                        if ((rtl8168_eri_read(ioaddr, 0x1AE, 4, ERIAR_ExGMAC) & BIT_13)==0)

                                                break;

                                        mdelay(1);

                                }

                                rtl8168_init_ring_indexes(tp);

                                RTL_W8(ChipCmd, CmdRxEnb | CmdTxEnb);

                        }

 

                } else if ((tp->mcfg == CFG_METHOD_14 || tp->mcfg == CFG_METHOD_15) && eee_enable

==1){

                        //Full -Duplex  mode

                        if (RTL_R8(PHYstatus)&FullDup){

                                mdio_write(tp, 0x1F, 0x0006);

                                mdio_write(tp, 0x00, 0x5a30);

                                mdio_write(tp, 0x1F, 0x0000);

                        }else{

                                mdio_write(tp, 0x1F, 0x0006);

                                mdio_write(tp, 0x00, 0x5a00);

                                mdio_write(tp, 0x1F, 0x0000);

                        }

                }

 

                netif_carrier_on(dev);

                if (netif_msg_ifup(tp))

                        printk(KERN_INFO PFX "%s: link up\n", dev->name);

        } else {

                if (netif_msg_ifdown(tp))

                        printk(KERN_INFO PFX "%s: link down\n", dev->name);

                netif_carrier_off(dev);

        }

        spin_unlock_irqrestore(&tp->lock, flags);

 

static void

rtl8168_link_option(int idx,

                    u8 *aut,

                    u16 *spd,

                    u8 *dup)

        unsigned char opt_speed;

        unsigned char opt_duplex;

        unsigned char opt_autoneg;

 

        opt_speed = ((idx < MAX_UNITS) && (idx >= 0)) ? speed[idx] : 0xff;

        opt_duplex = ((idx < MAX_UNITS) && (idx >= 0)) ? duplex[idx] : 0xff;

        opt_autoneg = ((idx < MAX_UNITS) && (idx >= 0)) ? autoneg[idx] : 0xff;

 

        if ((opt_speed == 0xff) |

            (opt_duplex == 0xff) |

            (opt_autoneg == 0xff)) {

                *spd = SPEED_1000;

                *dup = DUPLEX_FULL;

                *aut = AUTONEG_ENABLE;

        } else {

                *spd = speed[idx];

                *dup = duplex[idx];

                *aut = autoneg[idx];

        }

 

static void

rtl8168_powerdown_pll(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        unsigned long flags;

        int auto_nego = 0;

        int giga_ctrl = 0;

 

        if ((tp->mcfg == CFG_METHOD_11 || tp->mcfg == CFG_METHOD_12 ||

             tp->mcfg == CFG_METHOD_13) && rtl8168_check_dash(tp))

                return;

 

        if (((tp->mcfg == CFG_METHOD_7) || (tp->mcfg == CFG_METHOD_8)) &&

(RTL_R16(CPlusCmd) & ASF))

                return;

 

//        if (tp->mcfg == CFG_METHOD_17) {

//                void __iomem *ioaddr = tp->mmio_addr;

//                unsigned long flags;

//                u32 data;

 

//                spin_lock_irqsave(&tp->phy_lock, flags);

//                mdio_write(tp, 0x1f, 0x0000);

//                data = mdio_read(tp, MII_CTRL1000);

//                data &=        ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);

//                mdio_write(tp, MII_CTRL1000, data);

//                mdio_write(tp, MII_BMCR, BMCR_RESET | BMCR_ANENABLE | BMCR_ANRESTART);

//                spin_unlock_irqrestore(&tp->phy_lock, flags);

 

//                ssleep(3);

//                RTL_W16(IntrStatus, RTL_R16(IntrStatus));

//                RTL_W32(MAR0, 0);

//                RTL_W32(MAR0 + 4, 0);

//                RTL_W16(RxMaxSize, 0x05f3);

//                RTL_W8(0xD3, RTL_R8(0xD3) | BIT_7);

 

//                data = rtl8168_eri_read(ioaddr, 0xDC, 1, ERIAR_ExGMAC);

//                data &= ~BIT_0;

//                rtl8168_eri_write(ioaddr, 0xDC, 1, data, ERIAR_ExGMAC);

//                data |= BIT_0;

//                rtl8168_eri_write(ioaddr, 0xDC, 1, data, ERIAR_ExGMAC);

 

//                RTL_W32(RxConfig, RTL_R32(RxConfig) | AcceptBroadcast | AcceptMulticast |

AcceptMyPhys);

//                return;

//        }

 

        if (tp->wol_enabled == WOL_ENABLED) {

                spin_lock_irqsave(&tp->phy_lock, flags);

                mdio_write(tp, 0x1F, 0x0000);

                auto_nego = mdio_read(tp, MII_ADVERTISE);

                auto_nego &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL

                                | ADVERTISE_100HALF | ADVERTISE_100FULL);

                if (config_down_speed_100)

                        auto_nego |= ADVERTISE_100FULL;

                else

                        auto_nego |= ADVERTISE_10HALF;

 

                giga_ctrl = mdio_read(tp, MII_CTRL1000) & ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);

                mdio_write(tp, MII_ADVERTISE, auto_nego);

                mdio_write(tp, MII_CTRL1000, giga_ctrl);

                mdio_write(tp, MII_BMCR, BMCR_RESET | BMCR_ANENABLE | BMCR_ANRESTART);

                spin_unlock_irqrestore(&tp->phy_lock, flags);

                RTL_W32(RxConfig, RTL_R32(RxConfig) | AcceptBroadcast | AcceptMulticast |

AcceptMyPhys);

                return;

        }

 

        rtl8168_phy_power_down(dev);

 

        switch (tp->mcfg) {

        case CFG_METHOD_9:

        case CFG_METHOD_10:

        case CFG_METHOD_11:

        case CFG_METHOD_12:

        case CFG_METHOD_13:

        case CFG_METHOD_14:

        case CFG_METHOD_15:

                RTL_W8(PMCH, RTL_R8(PMCH) & ~BIT_7);

                break;

        }

 

static void rtl8168_powerup_pll(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

 

        switch (tp->mcfg) {

        case CFG_METHOD_9:

        case CFG_METHOD_10:

        case CFG_METHOD_11:

        case CFG_METHOD_12:

        case CFG_METHOD_13:

        case CFG_METHOD_14:

        case CFG_METHOD_15:

                RTL_W8(PMCH, RTL_R8(PMCH) | BIT_7);

                break;

        }

 

        rtl8168_phy_power_up(dev);

        rtl8168_set_speed(dev, tp->autoneg, tp->speed, tp->duplex);

 

static void

rtl8168_get_wol(struct net_device *dev,

                struct ethtool_wolinfo *wol)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        u8 options;

        u32 csi_tmp;

 

        wol->wolopts = 0;

 

#define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST)

        if (tp->mcfg == CFG_METHOD_DEFAULT) {

                wol->supported = 0;

                return;

        } else {

        wol->supported = WAKE_ANY;

        }

 

        spin_lock_irq(&tp->lock);

 

        options = RTL_R8(Config1);

        if (!(options & PMEnable))

                goto out_unlock;

 

        options = RTL_R8(Config3);

        if (options & LinkUp)

                wol->wolopts |= WAKE_PHY;

        if (tp->mcfg == CFG_METHOD_16 || tp->mcfg == CFG_METHOD_17) {

                csi_tmp = rtl8168_eri_read(ioaddr, 0xDE, 4, ERIAR_ExGMAC);

                if (csi_tmp & BIT_0)

                        wol->wolopts |= WAKE_MAGIC;

        } else {

                if (options & MagicPacket)

                        wol->wolopts |= WAKE_MAGIC;

        }

 

        options = RTL_R8(Config5);

        if (options & UWF)

                wol->wolopts |= WAKE_UCAST;

        if (options & BWF)

                wol->wolopts |= WAKE_BCAST;

        if (options & MWF)

                wol->wolopts |= WAKE_MCAST;

 

out_unlock:

        spin_unlock_irq(&tp->lock);

 

static int

rtl8168_set_wol(struct net_device *dev,

                struct ethtool_wolinfo *wol)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        int i,tmp;

        u32 csi_tmp;

        static struct {

                u32 opt;

                u16 reg;

                u8  mask;

        } cfg[] = {

                { WAKE_ANY,   Config1, PMEnable },

                { WAKE_PHY,   Config3, LinkUp },

                { WAKE_UCAST, Config5, UWF },

                { WAKE_BCAST, Config5, BWF },

                { WAKE_MCAST, Config5, MWF },

                { WAKE_ANY,   Config5, LanWake },

                { WAKE_MAGIC, Config3, MagicPacket },

        };

 

        if (tp->mcfg == CFG_METHOD_DEFAULT)

                return -EOPNOTSUPP;

 

        spin_lock_irq(&tp->lock);

 

        RTL_W8(Cfg9346, Cfg9346_Unlock);

 

        if (tp->mcfg == CFG_METHOD_16 || tp->mcfg == CFG_METHOD_17) {

                tmp = ARRAY_SIZE(cfg) - 1;

 

                csi_tmp = rtl8168_eri_read(ioaddr, 0xDE, 4, ERIAR_ExGMAC);

                if (wol->wolopts & WAKE_MAGIC)

                        csi_tmp |= BIT_0;

                else

                        csi_tmp &=~ BIT_0;

                rtl8168_eri_write(ioaddr, 0xDE, 4, csi_tmp, ERIAR_ExGMAC);

        } else {

                tmp = ARRAY_SIZE(cfg);

        }

 

        for (i = 0; i < tmp; i++) {

                u8 options = RTL_R8(cfg[i].reg) & ~cfg[i].mask;

                if (wol->wolopts & cfg[i].opt)

                        options |= cfg[i].mask;

                RTL_W8(cfg[i].reg, options);

        }

 

        RTL_W8(Cfg9346, Cfg9346_Lock);

 

        tp->wol_enabled = (wol->wolopts) ? WOL_ENABLED : WOL_DISABLED;

 

        spin_unlock_irq(&tp->lock);

 

        return 0;

 

static void

rtl8168_get_drvinfo(struct net_device *dev,

                    struct ethtool_drvinfo *info)

        struct rtl8168_private *tp = netdev_priv(dev);

 

        strcpy(info->driver, MODULENAME);

        strcpy(info->version, RTL8168_VERSION);

        strcpy(info->bus_info, pci_name(tp->pci_dev));

        info->regdump_len = R8168_REGS_SIZE;

        info->eedump_len = tp->eeprom_len;

 

static int

rtl8168_get_regs_len(struct net_device *dev)

        return R8168_REGS_SIZE;

 

static int

rtl8168_set_speed_xmii(struct net_device *dev,

                       u8 autoneg,

                       u16 speed,

                       u8 duplex)

        struct rtl8168_private *tp = netdev_priv(dev);

        int auto_nego = 0;

        int giga_ctrl = 0;

        int bmcr_true_force = 0;

        unsigned long flags;

 

        if ((speed != SPEED_1000) &&

            (speed != SPEED_100) &&

            (speed != SPEED_10)) {

                speed = SPEED_1000;

                duplex = DUPLEX_FULL;

        }

 

        if ((autoneg == AUTONEG_ENABLE) || (speed == SPEED_1000)) {

                /*n-way force*/

                if ((speed == SPEED_10) && (duplex == DUPLEX_HALF)) {

                        auto_nego |= ADVERTISE_10HALF;

                } else if ((speed == SPEED_10) && (duplex == DUPLEX_FULL)) {

                        auto_nego |= ADVERTISE_10HALF |

                                     ADVERTISE_10FULL;

                } else if ((speed == SPEED_100) && (duplex == DUPLEX_HALF)) {

                        auto_nego |= ADVERTISE_100HALF |

                                     ADVERTISE_10HALF |

                                     ADVERTISE_10FULL;

                } else if ((speed == SPEED_100) && (duplex == DUPLEX_FULL)) {

                        auto_nego |= ADVERTISE_100HALF |

                                     ADVERTISE_100FULL |

                                     ADVERTISE_10HALF |

                                     ADVERTISE_10FULL;

                } else if (speed == SPEED_1000) {

                        giga_ctrl |= ADVERTISE_1000HALF |

                                     ADVERTISE_1000FULL;

 

                        auto_nego |= ADVERTISE_100HALF |

                                     ADVERTISE_100FULL |

                                     ADVERTISE_10HALF |

                                     ADVERTISE_10FULL;

                }

 

                //flow contorol

                auto_nego |= ADVERTISE_PAUSE_CAP|ADVERTISE_PAUSE_ASYM;

 

                tp->phy_auto_nego_reg = auto_nego;

                tp->phy_1000_ctrl_reg = giga_ctrl;

 

                tp->autoneg = autoneg;

                tp->speed = speed;

                tp->duplex = duplex;

 

                spin_lock_irqsave(&tp->phy_lock, flags);

                mdio_write(tp, 0x1f, 0x0000);

                mdio_write(tp, MII_ADVERTISE, auto_nego);

                mdio_write(tp, MII_CTRL1000, giga_ctrl);

                mdio_write(tp, MII_BMCR, BMCR_RESET | BMCR_ANENABLE | BMCR_ANRESTART);

                spin_unlock_irqrestore(&tp->phy_lock, flags);

                mdelay(20);

        } else {

                /*true force*/

#ifndef BMCR_SPEED100

#define BMCR_SPEED100        0x0040

#endif

 

#ifndef BMCR_SPEED10

#define BMCR_SPEED10        0x0000

#endif

                if ((speed == SPEED_10) && (duplex == DUPLEX_HALF)) {

                        bmcr_true_force = BMCR_SPEED10;

                } else if ((speed == SPEED_10) && (duplex == DUPLEX_FULL)) {

                        bmcr_true_force = BMCR_SPEED10 | BMCR_FULLDPLX;

                } else if ((speed == SPEED_100) && (duplex == DUPLEX_HALF)) {

                        bmcr_true_force = BMCR_SPEED100;

                } else if ((speed == SPEED_100) && (duplex == DUPLEX_FULL)) {

                        bmcr_true_force = BMCR_SPEED100 | BMCR_FULLDPLX;

                }

 

                spin_lock_irqsave(&tp->phy_lock, flags);

                mdio_write(tp, 0x1f, 0x0000);

                mdio_write(tp, MII_BMCR, bmcr_true_force);

                spin_unlock_irqrestore(&tp->phy_lock, flags);

        }

 

        if (tp->mcfg == CFG_METHOD_11)

                rtl8168dp_10mbps_gphy_para(dev);

 

        return 0;

 

static int

rtl8168_set_speed(struct net_device *dev,

                  u8 autoneg,

                  u16 speed,

                  u8 duplex)

        struct rtl8168_private *tp = netdev_priv(dev);

        int ret;

 

        ret = tp->set_speed(dev, autoneg, speed, duplex);

 

        return ret;

 

static int

rtl8168_set_settings(struct net_device *dev,

                     struct ethtool_cmd *cmd)

        struct rtl8168_private *tp = netdev_priv(dev);

        unsigned long flags;

        int ret;

 

        spin_lock_irqsave(&tp->lock, flags);

        ret = rtl8168_set_speed(dev, cmd->autoneg, cmd->speed, cmd->duplex);

        spin_unlock_irqrestore(&tp->lock, flags);

 

        return ret;

 

static u32

rtl8168_get_tx_csum(struct net_device *dev)

        return (dev->features & NETIF_F_IP_CSUM) != 0;

 

static u32

rtl8168_get_rx_csum(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

 

        return tp->cp_cmd & RxChkSum;

 

static int

rtl8168_set_tx_csum(struct net_device *dev,

                    u32 data)

        struct rtl8168_private *tp = netdev_priv(dev);

       

        if (tp->mcfg == CFG_METHOD_DEFAULT)

                return -EOPNOTSUPP;

 

        if (data)

                dev->features |= NETIF_F_IP_CSUM;

        else

                dev->features &= ~NETIF_F_IP_CSUM;

 

        return 0;

 

static int

rtl8168_set_rx_csum(struct net_device *dev,

                    u32 data)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        unsigned long flags;

 

        if (tp->mcfg == CFG_METHOD_DEFAULT)

                return -EOPNOTSUPP;

 

        spin_lock_irqsave(&tp->lock, flags);

 

        if (data)

                tp->cp_cmd |= RxChkSum;

        else

                tp->cp_cmd &= ~RxChkSum;

 

        RTL_W16(CPlusCmd, tp->cp_cmd);

 

        spin_unlock_irqrestore(&tp->lock, flags);

 

        return 0;

 

#ifdef CONFIG_R8168_VLAN

 

static inline u32

rtl8168_tx_vlan_tag(struct rtl8168_private *tp,

                    struct sk_buff *skb)

#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)

        return (tp->vlgrp && vlan_tx_tag_present(skb)) ?

#else

        return (vlan_tx_tag_present(skb)) ?

#endif

                TxVlanTag | swab16(vlan_tx_tag_get(skb)) : 0x00;

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)

 

static void

rtl8168_vlan_rx_register(struct net_device *dev,

                         struct vlan_group *grp)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        unsigned long flags;

 

        spin_lock_irqsave(&tp->lock, flags);

        tp->vlgrp = grp;

        if (tp->vlgrp)

                tp->cp_cmd |= RxVlan;

        else

                tp->cp_cmd &= ~RxVlan;

        RTL_W16(CPlusCmd, tp->cp_cmd);

        RTL_R16(CPlusCmd);

        spin_unlock_irqrestore(&tp->lock, flags);

 

#endif

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)

static void

rtl8168_vlan_rx_kill_vid(struct net_device *dev,

                         unsigned short vid)

        struct rtl8168_private *tp = netdev_priv(dev);

        unsigned long flags;

 

        spin_lock_irqsave(&tp->lock, flags);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)

        if (tp->vlgrp)

                tp->vlgrp->vlan_devices[vid] = NULL;

#else

        vlan_group_set_device(tp->vlgrp, vid, NULL);

#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)

        spin_unlock_irqrestore(&tp->lock, flags);

#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)

 

static int

rtl8168_rx_vlan_skb(struct rtl8168_private *tp,

                    struct RxDesc *desc,

                    struct sk_buff *skb)

        u32 opts2 = le32_to_cpu(desc->opts2);

        int ret = -1;

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)

        if (tp->vlgrp && (opts2 & RxVlanTag)) {

                rtl8168_rx_hwaccel_skb(skb, tp->vlgrp,

                                       swab16(opts2 & 0xffff));

                ret = 0;

        }

#else

        if (opts2 & RxVlanTag)

                __vlan_hwaccel_put_tag(skb, swab16(opts2 & 0xffff));

#endif

 

        desc->opts2 = 0;

        return ret;

 

#else /* !CONFIG_R8168_VLAN */

 

static inline u32

rtl8168_tx_vlan_tag(struct rtl8168_private *tp,

                    struct sk_buff *skb)

        return 0;

 

static int

rtl8168_rx_vlan_skb(struct rtl8168_private *tp,

                    struct RxDesc *desc,

                    struct sk_buff *skb)

        return -1;

 

#endif

 

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0)

 

static u32 rtl8168_fix_features(struct net_device *dev, u32 features)

        if (dev->mtu > MSSMask)

                features &= ~NETIF_F_ALL_TSO;

 

        return features;

 

static int rtl8168_set_features(struct net_device *dev, u32 features)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        unsigned long flags;

 

        spin_lock_irqsave(&tp->lock, flags);

 

        if (features & NETIF_F_RXCSUM)

                tp->cp_cmd |= RxChkSum;

        else

                tp->cp_cmd &= ~RxChkSum;

 

        if (dev->features & NETIF_F_HW_VLAN_RX)

                tp->cp_cmd |= RxVlan;

        else

                tp->cp_cmd &= ~RxVlan;

 

        RTL_W16(CPlusCmd, tp->cp_cmd);

        RTL_R16(CPlusCmd);

 

        spin_unlock_irqrestore(&tp->lock, flags);

 

        return 0;

 

#endif

 

static void rtl8168_gset_xmii(struct net_device *dev,

                  struct ethtool_cmd *cmd)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        u8 status;

        unsigned long flags;

 

        cmd->supported = SUPPORTED_10baseT_Half |

                         SUPPORTED_10baseT_Full |

                         SUPPORTED_100baseT_Half |

                         SUPPORTED_100baseT_Full |

                         SUPPORTED_1000baseT_Full |

                         SUPPORTED_Autoneg |

                         SUPPORTED_TP;

 

        spin_lock_irqsave(&tp->phy_lock, flags);

        cmd->autoneg = (mdio_read(tp, MII_BMCR) & BMCR_ANENABLE) ? 1 : 0;

        spin_unlock_irqrestore(&tp->phy_lock, flags);

        cmd->advertising = ADVERTISED_TP | ADVERTISED_Autoneg;

 

        if (tp->phy_auto_nego_reg & ADVERTISE_10HALF)

                cmd->advertising |= ADVERTISED_10baseT_Half;

        if (tp->phy_auto_nego_reg & ADVERTISE_10FULL)

                cmd->advertising |= ADVERTISED_10baseT_Full;

        if (tp->phy_auto_nego_reg & ADVERTISE_100HALF)

                cmd->advertising |= ADVERTISED_100baseT_Half;

        if (tp->phy_auto_nego_reg & ADVERTISE_100FULL)

                cmd->advertising |= ADVERTISED_100baseT_Full;

        if (tp->phy_1000_ctrl_reg & ADVERTISE_1000FULL)

                cmd->advertising |= ADVERTISED_1000baseT_Full;

 

        status = RTL_R8(PHYstatus);

 

        if (status & _1000bpsF)

                cmd->speed = SPEED_1000;

        else if (status & _100bps)

                cmd->speed = SPEED_100;

        else if (status & _10bps)

                cmd->speed = SPEED_10;

 

        if (status & TxFlowCtrl)

                cmd->advertising |= ADVERTISED_Asym_Pause;

 

        if (status & RxFlowCtrl)

                cmd->advertising |= ADVERTISED_Pause;

 

        cmd->duplex = ((status & _1000bpsF) || (status & FullDup)) ?

                      DUPLEX_FULL : DUPLEX_HALF;

 

 

 

static int

rtl8168_get_settings(struct net_device *dev,

                     struct ethtool_cmd *cmd)

        struct rtl8168_private *tp = netdev_priv(dev);

        unsigned long flags;

 

        spin_lock_irqsave(&tp->lock, flags);

 

        tp->get_settings(dev, cmd);

 

        spin_unlock_irqrestore(&tp->lock, flags);

        return 0;

 

static void rtl8168_get_regs(struct net_device *dev, struct ethtool_regs *regs,

                             void *p)

        struct rtl8168_private *tp = netdev_priv(dev);

        unsigned long flags;

 

        if (regs->len > R8168_REGS_SIZE)

                regs->len = R8168_REGS_SIZE;

 

        spin_lock_irqsave(&tp->lock, flags);

        memcpy_fromio(p, tp->mmio_addr, regs->len);

        spin_unlock_irqrestore(&tp->lock, flags);

 

static u32

rtl8168_get_msglevel(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

 

        return tp->msg_enable;

 

static void

rtl8168_set_msglevel(struct net_device *dev,

                     u32 value)

        struct rtl8168_private *tp = netdev_priv(dev);

 

        tp->msg_enable = value;

 

static const char rtl8168_gstrings[][ETH_GSTRING_LEN] = {

        "tx_packets",

        "rx_packets",

        "tx_errors",

        "rx_errors",

        "rx_missed",

        "align_errors",

        "tx_single_collisions",

        "tx_multi_collisions",

        "unicast",

        "broadcast",

        "multicast",

        "tx_aborted",

        "tx_underrun",

};

 

struct rtl8168_counters {

        u64        tx_packets;

        u64        rx_packets;

        u64        tx_errors;

        u32        rx_errors;

        u16        rx_missed;

        u16        align_errors;

        u32        tx_one_collision;

        u32        tx_multi_collision;

        u64        rx_unicast;

        u64        rx_broadcast;

        u32        rx_multicast;

        u16        tx_aborted;

        u16        tx_underun;

};

 

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)

static int rtl8168_get_stats_count(struct net_device *dev)

        return ARRAY_SIZE(rtl8168_gstrings);

#else

static int rtl8168_get_sset_count(struct net_device *dev, int sset)

        switch (sset) {

        case ETH_SS_STATS:

                return ARRAY_SIZE(rtl8168_gstrings);

        default:

                return -EOPNOTSUPP;

        }

#endif

static void

rtl8168_get_ethtool_stats(struct net_device *dev,

                          struct ethtool_stats *stats,

                          u64 *data)

        struct rtl8168_private *tp = netdev_priv(dev);

        void __iomem *ioaddr = tp->mmio_addr;

        struct rtl8168_counters *counters;

        dma_addr_t paddr;

        u32 cmd;

 

        ASSERT_RTNL();

 

        counters = pci_alloc_consistent(tp->pci_dev, sizeof(*counters), &paddr);

        if (!counters)

                return;

 

        RTL_W32(CounterAddrHigh, (u64)paddr >> 32);

        cmd = (u64)paddr & DMA_BIT_MASK(32);

        RTL_W32(CounterAddrLow, cmd);

        RTL_W32(CounterAddrLow, cmd | CounterDump);

 

        while (RTL_R32(CounterAddrLow) & CounterDump) {

                if (msleep_interruptible(1))

                        break;

        }

 

        RTL_W32(CounterAddrLow, 0);

        RTL_W32(CounterAddrHigh, 0);

 

        data[0]        = le64_to_cpu(counters->tx_packets);

        data[1] = le64_to_cpu(counters->rx_packets);

        data[2] = le64_to_cpu(counters->tx_errors);

        data[3] = le32_to_cpu(counters->rx_errors);

        data[4] = le16_to_cpu(counters->rx_missed);

        data[5] = le16_to_cpu(counters->align_errors);

        data[6] = le32_to_cpu(counters->tx_one_collision);

        data[7] = le32_to_cpu(counters->tx_multi_collision);

        data[8] = le64_to_cpu(counters->rx_unicast);

        data[9] = le64_to_cpu(counters->rx_broadcast);

        data[10] = le32_to_cpu(counters->rx_multicast);

        data[11] = le16_to_cpu(counters->tx_aborted);

        data[12] = le16_to_cpu(counters->tx_underun);

        pci_free_consistent(tp->pci_dev, sizeof(*counters), counters, paddr);

 

static void

rtl8168_get_strings(struct net_device *dev,

                    u32 stringset,

                    u8 *data)

        switch (stringset) {

        case ETH_SS_STATS:

                memcpy(data, *rtl8168_gstrings, sizeof(rtl8168_gstrings));

                break;

        }

static int rtl_get_eeprom_len(struct net_device *dev)

        struct rtl8168_private *tp = netdev_priv(dev);

 

        return tp->eeprom_len;

 

static int rtl_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8

*buf)

        struct rtl8168_private *tp = netdev_priv(dev);

        int        i,j,ret;

        int        start_w, end_w;

        int        VPD_addr, VPD_data;

        u32 *eeprom_buff;

        u16 tmp;

        void __iomem *ioaddr = tp->mmio_addr;

 

        if (tp->eeprom_type==EEPROM_TYPE_NONE)

        {

                dev_printk(KERN_DEBUG, &tp->pci_dev->dev, "Detect none EEPROM\n");

                return -EOPNOTSUPP;

        }

        else if (eeprom->len == 0 || (eeprom->offset+eeprom->len) > tp->eeprom_len)

        {

                dev_printk(KERN_DEBUG, &tp->pci_dev->dev, "Invalid parameter\n");

                return -EINVAL;

        }

 

        switch (tp->mcfg)

        {

                case CFG_METHOD_9:

                case CFG_METHOD_10:

                        VPD_addr = 0xCE;

                        VPD_data = 0xD0;

                        break;

 

                case CFG_METHOD_4:

                case CFG_METHOD_5:

                case CFG_METHOD_6:

                case CFG_METHOD_7:

                case CFG_METHOD_8:

                case CFG_METHOD_14:

                case CFG_METHOD_15:

                        VPD_addr = 0xD2;

                        VPD_data = 0xD4;

                        break;

 

                case CFG_METHOD_1:

                case CFG_METHOD_2:

                case CFG_METHOD_3:

                default:

                        return -EOPNOTSUPP;

        }

 

        start_w = eeprom->offset >> 2;

        end_w = (eeprom->offset + eeprom->len - 1) >> 2;

 

        eeprom_buff = kmalloc(sizeof(u32)*(end_w - start_w + 1), GFP_KERNEL);

        if (!eeprom_buff)

        {

                return -ENOMEM;

        }

 

        RTL_W8(Cfg9346, Cfg9346_Unlock);

        ret = -EFAULT;

        for (i=start_w; i<=end_w; i++)

        {

                pci_write_config_word(tp->pci_dev, VPD_addr, (u16)i*4);

                ret = -EFAULT;

                for (j=0;j<10;j++)

                {

                        udelay(400);

                        pci_read_config_word(tp->pci_dev, VPD_addr, &tmp);

                        if (tmp&0x8000)

                        {

                                ret = 0;

                                break;

                        }

                }

 

                if (ret)

                {

                        break;

                }

 

                pci_read_config_dword(tp->pci_dev, VPD_data, &eeprom_buff[i-start_w]);

        }

        RTL_W8(Cfg9346, Cfg9346_Lock);

 

        if (!ret)

        {

                memcpy(buf, (u8 *)eeprom_buff + (eeprom->offset & 3), eeprom->len);

        }

 

        kfree(eeprom_buff);

 

        return ret;

 

#undef ethtool_op_get_link

#define ethtool_op_get_link _kc_ethtool_op_get_link

u32 _kc_ethtool_op_get_link(struct net_device *dev)

        return netif_carrier_ok(dev) ? 1 : 0;

 

#undef ethtool_op_get_sg

#define ethtool_op_get_sg _kc_ethtool_op_get_sg

u32 _kc_ethtool_op_get_sg(struct net_device *dev)

#ifdef NETIF_F_SG

        return (dev->features & NETIF_F_SG) != 0;

#else

        return 0;

#endif

 

#undef ethtool_op_set_sg

#define ethtool_op_set_sg _kc_ethtool_op_set_sg

int _kc_ethtool_op_set_sg(struct net_device *dev, u32 data)

        struct rtl8168_private *tp = netdev_priv(dev);

       

        if (tp->mcfg == CFG_METHOD_DEFAULT)

                return -EOPNOTSUPP;

 

#ifdef NETIF_F_SG

        if (data)

                dev->features |= NETIF_F_SG;

        else

                dev->features &= ~NETIF_F_SG;

#endif

 

        return 0;

 

static struct ethtool_ops rtl8168_ethtool_ops = {

        .get_drvinfo                = rtl8168_get_drvinfo,

        .get_regs_len                = rtl8168_get_regs_len,

        .get_link                = ethtool_op_get_link,

        .get_settings                = rtl8168_get_settings,

        .set_settings                = rtl8168_set_settings,

        .get_msglevel                = rtl8168_get_msglevel,

        .set_msglevel                = rtl8168_set_msglevel,

        //.get_rx_csum                = rtl8168_get_rx_csum,

        //.set_rx_csum                = rtl8168_set_rx_csum,

        //.get_tx_csum                = rtl8168_get_tx_csum,

        //.set_tx_csum                = rtl8168_set_tx_csum,

        //.get_sg                        = ethtool_op_get_sg,

        //.set_sg                        = ethtool_op_set_sg,

#ifdef NETIF_F_TSO

        //.get_tso                = ethtool_op_get_tso,

        //.set_tso                = ethtool_op_set_tso,

#endif

        .get_regs                = rtl8168_get_regs,

        .get_wol                = rtl8168_get_wol,

        .set_wol                = rtl8168_set_wol,

        .get_strings                = rtl8168_get_strings,

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)

        .get_stats_count        = rtl8168_get_stats_count,

#else

        .get_sset_count                = rtl8168_get_sset_count,

#endif

        .get_ethtool_stats        = rtl8168_get_ethtool_stats,

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)

#ifdef ETHTOOL_GPERMADDR

        .get_perm_addr                = ethtool_op_get_perm_addr,

#endif

#endif //LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)

        .get_eeprom                = rtl_get_eeprom,

        .get_eeprom_len                = rtl_get_eeprom_len,

};

 

 

static int rtl8168_enable_EEE(struct rtl8168_private *tp)

        void __iomem *ioaddr = tp->mmio_addr;

        int        ret;

        unsigned long flags;

        __u16        data;

 

        ret = 0;

        switch (tp->mcfg) {

        case CFG_METHOD_14:

        case CFG_METHOD_15:

                spin_lock_irqsave(&tp->phy_lock, flags);

                mdio_write(tp, 0x1F, 0x0007);

                mdio_write(tp, 0x1E, 0x0020);

                data = mdio_read(tp, 0x15) | 0x0100;

                mdio_write(tp, 0x15, data);

                mdio_write(tp, 0x1F, 0x0006);

                mdio_write(tp, 0x00, 0x5A30);

                mdio_write(tp, 0x1F, 0x0000);

                mdio_write(tp, 0x0D, 0x0007);

                mdio_write(tp, 0x0E, 0x003C);

                mdio_write(tp, 0x0D, 0x4007);

                mdio_write(tp, 0x0E, 0x0006);

                mdio_write(tp, 0x0D, 0x0000);

                spin_unlock_irqrestore(&tp->phy_lock, flags);

                if((RTL_R8(Config4)&0x40) && (RTL_R8(0x6D) & BIT_7))

                {

                        data = RTL_R16(CustomLED);

                        spin_lock_irqsave(&tp->phy_lock, flags);

                        mdio_write(tp, 0x1F, 0x0005);

                        mdio_write(tp, 0x05, 0x8AC8);

                        mdio_write(tp, 0x06, data);

                        mdio_write(tp, 0x05, 0x8B82);

                        data = mdio_read(tp, 0x06) | 0x0010;

                        mdio_write(tp, 0x05, 0x8B82);

                        mdio_write(tp, 0x06, data);

                        mdio_write(tp, 0x1F, 0x0000);

                        spin_unlock_irqrestore(&tp->phy_lock, flags);

                }

                break;

 

        case CFG_METHOD_16:

        case CFG_METHOD_17:

                spin_lock_irqsave(&tp->phy_lock,flags);

                data = rtl8168_eri_read(ioaddr,0x1B0 ,4,ERIAR_ExGMAC) | 0x0003;

                rtl8168_eri_write(ioaddr, 0x1B0, 4, data, ERIAR_ExGMAC);

                mdio_write(tp,0x1F , 0x0004);

                mdio_write(tp,0x1F , 0x0007);

                mdio_write(tp,0x1E , 0x0020);

                data = mdio_read(tp, 0x15)|0x0100;

                mdio_write(tp,0x15 , data);

                mdio_write(tp,0x1F , 0x0002);

                mdio_write(tp,0x1F , 0x0005);

                mdio_write(tp,0x05 , 0x8B85);

                data = mdio_read(tp, 0x06)|0x2000;

                mdio_write(tp,0x06 , data);

                mdio_write(tp,0x1F , 0x0000);

                mdio_write(tp,0x0D , 0x0007);

                mdio_write(tp,0x0E , 0x003C);

                mdio_write(tp,0x0D , 0x4007);

                mdio_write(tp,0x0E , 0x0006);

                mdio_write(tp,0x1D , 0x0000);

                spin_unlock_irqrestore(&tp->phy_lock,flags);

                break;

 

        case CFG_METHOD_18:

        case CFG_METHOD_19:

        case CFG_METHOD_20:

                spin_lock_irqsave(&tp->phy_lock,flags);

                data = rtl8168_eri_read(ioaddr,0x1B0 ,4,ERIAR_ExGMAC);

                data |= BIT_1 | BIT_0;

                rtl8168_eri_write(ioaddr, 0x1B0, 4, data, ERIAR_ExGMAC);

                mdio_write(tp, 0x1F, 0x0007);

                mdio_write(tp, 0x1e, 0x0020);