Add Attansic L1 ethernet driver. (f3cc28c7) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/net/Kconfig

+11 −0

Original line number	Original line	Diff line number	Diff line
	@@ -2335,6 +2335,17 @@ config QLA3XXX
	To compile this driver as a module, choose M here: the module		To compile this driver as a module, choose M here: the module
	will be called qla3xxx.		will be called qla3xxx.

			config ATL1
			tristate "Attansic L1 Gigabit Ethernet support (EXPERIMENTAL)"
			depends on NET_PCI && PCI && EXPERIMENTAL
			select CRC32
			select MII
			help
			This driver supports the Attansic L1 gigabit ethernet adapter.

			To compile this driver as a module, choose M here. The module
			will be called atl1.

	endmenu		endmenu

	#		#

drivers/net/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -9,6 +9,7 @@ obj-$(CONFIG_CHELSIO_T1) += chelsio/
	obj-$(CONFIG_CHELSIO_T3) += cxgb3/		obj-$(CONFIG_CHELSIO_T3) += cxgb3/
	obj-$(CONFIG_EHEA) += ehea/		obj-$(CONFIG_EHEA) += ehea/
	obj-$(CONFIG_BONDING) += bonding/		obj-$(CONFIG_BONDING) += bonding/
			obj-$(CONFIG_ATL1) += atl1/
	obj-$(CONFIG_GIANFAR) += gianfar_driver.o		obj-$(CONFIG_GIANFAR) += gianfar_driver.o

	gianfar_driver-objs := gianfar.o \		gianfar_driver-objs := gianfar.o \

drivers/net/atl1/Makefile

0 → 100644

+2 −0

Original line number	Original line	Diff line number	Diff line
			obj-$(CONFIG_ATL1) += atl1.o
			atl1-y += atl1_main.o atl1_hw.o atl1_ethtool.o atl1_param.o

drivers/net/atl1/atl1.h

0 → 100644

+283 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright(c) 2005 - 2006 Attansic Corporation. All rights reserved.
			* Copyright(c) 2006 Chris Snook <csnook@redhat.com>
			* Copyright(c) 2006 Jay Cliburn <jcliburn@gmail.com>
			*
			* Derived from Intel e1000 driver
			* Copyright(c) 1999 - 2005 Intel Corporation. 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, write to the Free Software Foundation, Inc., 59
			* Temple Place - Suite 330, Boston, MA 02111-1307, USA.
			*/

			#ifndef _ATL1_H_
			#define _ATL1_H_

			#include <linux/types.h>
			#include <linux/if_vlan.h>

			#include "atl1_hw.h"

			/* function prototypes needed by multiple files */
			s32 atl1_up(struct atl1_adapter *adapter);
			void atl1_down(struct atl1_adapter *adapter);
			int atl1_reset(struct atl1_adapter *adapter);
			s32 atl1_setup_ring_resources(struct atl1_adapter *adapter);
			void atl1_free_ring_resources(struct atl1_adapter *adapter);

			extern char atl1_driver_name[];
			extern char atl1_driver_version[];
			extern const struct ethtool_ops atl1_ethtool_ops;

			struct atl1_adapter;

			#define ATL1_MAX_INTR 3

			#define ATL1_DEFAULT_TPD 256
			#define ATL1_MAX_TPD 1024
			#define ATL1_MIN_TPD 64
			#define ATL1_DEFAULT_RFD 512
			#define ATL1_MIN_RFD 128
			#define ATL1_MAX_RFD 2048

			#define ATL1_GET_DESC(R, i, type) (&(((type *)((R)->desc))[i]))
			#define ATL1_RFD_DESC(R, i) ATL1_GET_DESC(R, i, struct rx_free_desc)
			#define ATL1_TPD_DESC(R, i) ATL1_GET_DESC(R, i, struct tx_packet_desc)
			#define ATL1_RRD_DESC(R, i) ATL1_GET_DESC(R, i, struct rx_return_desc)

			/*
			* Some workarounds require millisecond delays and are run during interrupt
			* context. Most notably, when establishing link, the phy may need tweaking
			* but cannot process phy register reads/writes faster than millisecond
			* intervals...and we establish link due to a "link status change" interrupt.
			*/

			/*
			* wrapper around a pointer to a socket buffer,
			* so a DMA handle can be stored along with the buffer
			*/
			struct atl1_buffer {
			struct sk_buff *skb;
			u16 length;
			u16 alloced;
			dma_addr_t dma;
			};

			#define MAX_TX_BUF_LEN 0x3000 /* 12KB */

			struct atl1_tpd_ring {
			void desc; / pointer to the descriptor ring memory */
			dma_addr_t dma; /* physical adress of the descriptor ring */
			u16 size; /* length of descriptor ring in bytes */
			u16 count; /* number of descriptors in the ring */
			u16 hw_idx; /* hardware index */
			atomic_t next_to_clean;
			atomic_t next_to_use;
			struct atl1_buffer *buffer_info;
			};

			struct atl1_rfd_ring {
			void *desc;
			dma_addr_t dma;
			u16 size;
			u16 count;
			atomic_t next_to_use;
			u16 next_to_clean;
			struct atl1_buffer *buffer_info;
			};

			struct atl1_rrd_ring {
			void *desc;
			dma_addr_t dma;
			unsigned int size;
			u16 count;
			u16 next_to_use;
			atomic_t next_to_clean;
			};

			struct atl1_ring_header {
			void desc; / pointer to the descriptor ring memory */
			dma_addr_t dma; /* physical adress of the descriptor ring */
			unsigned int size; /* length of descriptor ring in bytes */
			};

			struct atl1_cmb {
			struct coals_msg_block *cmb;
			dma_addr_t dma;
			};

			struct atl1_smb {
			struct stats_msg_block *smb;
			dma_addr_t dma;
			};

			/* Statistics counters */
			struct atl1_sft_stats {
			u64 rx_packets;
			u64 tx_packets;
			u64 rx_bytes;
			u64 tx_bytes;
			u64 multicast;
			u64 collisions;
			u64 rx_errors;
			u64 rx_length_errors;
			u64 rx_crc_errors;
			u64 rx_frame_errors;
			u64 rx_fifo_errors;
			u64 rx_missed_errors;
			u64 tx_errors;
			u64 tx_fifo_errors;
			u64 tx_aborted_errors;
			u64 tx_window_errors;
			u64 tx_carrier_errors;

			u64 tx_pause; /* num Pause packet transmitted. */
			u64 excecol; /* num tx packets aborted due to excessive collisions. */
			u64 deffer; /* num deferred tx packets */
			u64 scc; /* num packets subsequently transmitted successfully w/ single prior collision. */
			u64 mcc; /* num packets subsequently transmitted successfully w/ multiple prior collisions. */
			u64 latecol; /* num tx packets w/ late collisions. */
			u64 tx_underun; /* num tx packets aborted due to transmit FIFO underrun, or TRD FIFO underrun */
			u64 tx_trunc; /* num tx packets truncated due to size exceeding MTU, regardless whether truncated by Selene or not. (The name doesn't really reflect the meaning in this case.) */
			u64 rx_pause; /* num Pause packets received. */
			u64 rx_rrd_ov;
			u64 rx_trunc;
			};

			/* board specific private data structure */
			#define ATL1_REGS_LEN 8

			/* Structure containing variables used by the shared code */
			struct atl1_hw {
			u8 __iomem *hw_addr;
			struct atl1_adapter *back;
			enum atl1_dma_order dma_ord;
			enum atl1_dma_rcb rcb_value;
			enum atl1_dma_req_block dmar_block;
			enum atl1_dma_req_block dmaw_block;
			u8 preamble_len;
			u8 max_retry; /* Retransmission maximum, after which the packet will be discarded */
			u8 jam_ipg; /* IPG to start JAM for collision based flow control in half-duplex mode. In units of 8-bit time */
			u8 ipgt; /* Desired back to back inter-packet gap. The default is 96-bit time */
			u8 min_ifg; /* Minimum number of IFG to enforce in between RX frames. Frame gap below such IFP is dropped */
			u8 ipgr1; /* 64bit Carrier-Sense window */
			u8 ipgr2; /* 96-bit IPG window */
			u8 tpd_burst; /* Number of TPD to prefetch in cache-aligned burst. Each TPD is 16 bytes long */
			u8 rfd_burst; /* Number of RFD to prefetch in cache-aligned burst. Each RFD is 12 bytes long */
			u8 rfd_fetch_gap;
			u8 rrd_burst; /* Threshold number of RRDs that can be retired in a burst. Each RRD is 16 bytes long */
			u8 tpd_fetch_th;
			u8 tpd_fetch_gap;
			u16 tx_jumbo_task_th;
			u16 txf_burst; /* Number of data bytes to read in a cache-aligned burst. Each SRAM entry is
			8 bytes long */
			u16 rx_jumbo_th; /* Jumbo packet size for non-VLAN packet. VLAN packets should add 4 bytes */
			u16 rx_jumbo_lkah;
			u16 rrd_ret_timer; /* RRD retirement timer. Decrement by 1 after every 512ns passes. */
			u16 lcol; /* Collision Window */

			u16 cmb_tpd;
			u16 cmb_rrd;
			u16 cmb_rx_timer;
			u16 cmb_tx_timer;
			u32 smb_timer;
			u16 media_type;
			u16 autoneg_advertised;
			u16 pci_cmd_word;

			u16 mii_autoneg_adv_reg;
			u16 mii_1000t_ctrl_reg;

			u32 mem_rang;
			u32 txcw;
			u32 max_frame_size;
			u32 min_frame_size;
			u32 mc_filter_type;
			u32 num_mc_addrs;
			u32 collision_delta;
			u32 tx_packet_delta;
			u16 phy_spd_default;

			u16 dev_rev;
			u8 revision_id;

			/* spi flash */
			u8 flash_vendor;

			u8 dma_fairness;
			u8 mac_addr[ETH_ALEN];
			u8 perm_mac_addr[ETH_ALEN];

			/* bool phy_preamble_sup; */
			bool phy_configured;
			};

			struct atl1_adapter {
			/* OS defined structs */
			struct net_device *netdev;
			struct pci_dev *pdev;
			struct net_device_stats net_stats;
			struct atl1_sft_stats soft_stats;

			struct vlan_group *vlgrp;
			u32 rx_buffer_len;
			u32 wol;
			u16 link_speed;
			u16 link_duplex;
			spinlock_t lock;
			atomic_t irq_sem;
			struct work_struct tx_timeout_task;
			struct work_struct link_chg_task;
			struct work_struct pcie_dma_to_rst_task;
			struct timer_list watchdog_timer;
			struct timer_list phy_config_timer;
			bool phy_timer_pending;

			bool mac_disabled;

			/* All descriptor rings' memory */
			struct atl1_ring_header ring_header;

			/* TX */
			struct atl1_tpd_ring tpd_ring;
			spinlock_t mb_lock;

			/* RX */
			struct atl1_rfd_ring rfd_ring;
			struct atl1_rrd_ring rrd_ring;
			u64 hw_csum_err;
			u64 hw_csum_good;

			u32 gorcl;
			u64 gorcl_old;

			/* Interrupt Moderator timer ( 2us resolution) */
			u16 imt;
			/* Interrupt Clear timer (2us resolution) */
			u16 ict;

			/* MII interface info */
			struct mii_if_info mii;

			/* structs defined in atl1_hw.h */
			u32 bd_number; /* board number */
			bool pci_using_64;
			struct atl1_hw hw;
			struct atl1_smb smb;
			struct atl1_cmb cmb;

			u32 pci_state[16];
			};

			#endif /* _ATL1_H_ */

drivers/net/atl1/atl1_ethtool.c

0 → 100644

+508 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright(c) 2005 - 2006 Attansic Corporation. All rights reserved.
			* Copyright(c) 2006 Chris Snook <csnook@redhat.com>
			* Copyright(c) 2006 Jay Cliburn <jcliburn@gmail.com>
			*
			* Derived from Intel e1000 driver
			* Copyright(c) 1999 - 2005 Intel Corporation. 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, write to the Free Software Foundation, Inc., 59
			* Temple Place - Suite 330, Boston, MA 02111-1307, USA.
			*/

			#include <linux/types.h>
			#include <linux/pci.h>
			#include <linux/ethtool.h>
			#include <linux/netdevice.h>
			#include <linux/mii.h>
			#include <asm/uaccess.h>

			#include "atl1.h"

			struct atl1_stats {
			char stat_string[ETH_GSTRING_LEN];
			int sizeof_stat;
			int stat_offset;
			};

			#define ATL1_STAT(m) sizeof(((struct atl1_adapter *)0)->m), \
			offsetof(struct atl1_adapter, m)

			static struct atl1_stats atl1_gstrings_stats[] = {
			{"rx_packets", ATL1_STAT(soft_stats.rx_packets)},
			{"tx_packets", ATL1_STAT(soft_stats.tx_packets)},
			{"rx_bytes", ATL1_STAT(soft_stats.rx_bytes)},
			{"tx_bytes", ATL1_STAT(soft_stats.tx_bytes)},
			{"rx_errors", ATL1_STAT(soft_stats.rx_errors)},
			{"tx_errors", ATL1_STAT(soft_stats.tx_errors)},
			{"rx_dropped", ATL1_STAT(net_stats.rx_dropped)},
			{"tx_dropped", ATL1_STAT(net_stats.tx_dropped)},
			{"multicast", ATL1_STAT(soft_stats.multicast)},
			{"collisions", ATL1_STAT(soft_stats.collisions)},
			{"rx_length_errors", ATL1_STAT(soft_stats.rx_length_errors)},
			{"rx_over_errors", ATL1_STAT(soft_stats.rx_missed_errors)},
			{"rx_crc_errors", ATL1_STAT(soft_stats.rx_crc_errors)},
			{"rx_frame_errors", ATL1_STAT(soft_stats.rx_frame_errors)},
			{"rx_fifo_errors", ATL1_STAT(soft_stats.rx_fifo_errors)},
			{"rx_missed_errors", ATL1_STAT(soft_stats.rx_missed_errors)},
			{"tx_aborted_errors", ATL1_STAT(soft_stats.tx_aborted_errors)},
			{"tx_carrier_errors", ATL1_STAT(soft_stats.tx_carrier_errors)},
			{"tx_fifo_errors", ATL1_STAT(soft_stats.tx_fifo_errors)},
			{"tx_window_errors", ATL1_STAT(soft_stats.tx_window_errors)},
			{"tx_abort_exce_coll", ATL1_STAT(soft_stats.excecol)},
			{"tx_abort_late_coll", ATL1_STAT(soft_stats.latecol)},
			{"tx_deferred_ok", ATL1_STAT(soft_stats.deffer)},
			{"tx_single_coll_ok", ATL1_STAT(soft_stats.scc)},
			{"tx_multi_coll_ok", ATL1_STAT(soft_stats.mcc)},
			{"tx_underun", ATL1_STAT(soft_stats.tx_underun)},
			{"tx_trunc", ATL1_STAT(soft_stats.tx_trunc)},
			{"tx_pause", ATL1_STAT(soft_stats.tx_pause)},
			{"rx_pause", ATL1_STAT(soft_stats.rx_pause)},
			{"rx_rrd_ov", ATL1_STAT(soft_stats.rx_rrd_ov)},
			{"rx_trunc", ATL1_STAT(soft_stats.rx_trunc)}
			};

			static void atl1_get_ethtool_stats(struct net_device *netdev,
			struct ethtool_stats stats, u64 data)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			int i;
			char *p;

			for (i = 0; i < ARRAY_SIZE(atl1_gstrings_stats); i++) {
			p = (char *)adapter+atl1_gstrings_stats[i].stat_offset;
			data[i] = (atl1_gstrings_stats[i].sizeof_stat ==
			sizeof(u64)) ? (u64 )p : (u32 )p;
			}

			}

			static int atl1_get_stats_count(struct net_device *netdev)
			{
			return ARRAY_SIZE(atl1_gstrings_stats);
			}

			static int atl1_get_settings(struct net_device *netdev,
			struct ethtool_cmd *ecmd)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			struct atl1_hw *hw = &adapter->hw;

			ecmd->supported = (SUPPORTED_10baseT_Half \|
			SUPPORTED_10baseT_Full \|
			SUPPORTED_100baseT_Half \|
			SUPPORTED_100baseT_Full \|
			SUPPORTED_1000baseT_Full \|
			SUPPORTED_Autoneg \| SUPPORTED_TP);
			ecmd->advertising = ADVERTISED_TP;
			if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR \|\|
			hw->media_type == MEDIA_TYPE_1000M_FULL) {
			ecmd->advertising \|= ADVERTISED_Autoneg;
			if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR) {
			ecmd->advertising \|= ADVERTISED_Autoneg;
			ecmd->advertising \|=
			(ADVERTISED_10baseT_Half \|
			ADVERTISED_10baseT_Full \|
			ADVERTISED_100baseT_Half \|
			ADVERTISED_100baseT_Full \|
			ADVERTISED_1000baseT_Full);
			}
			else
			ecmd->advertising \|= (ADVERTISED_1000baseT_Full);
			}
			ecmd->port = PORT_TP;
			ecmd->phy_address = 0;
			ecmd->transceiver = XCVR_INTERNAL;

			if (netif_carrier_ok(adapter->netdev)) {
			u16 link_speed, link_duplex;
			atl1_get_speed_and_duplex(hw, &link_speed, &link_duplex);
			ecmd->speed = link_speed;
			if (link_duplex == FULL_DUPLEX)
			ecmd->duplex = DUPLEX_FULL;
			else
			ecmd->duplex = DUPLEX_HALF;
			} else {
			ecmd->speed = -1;
			ecmd->duplex = -1;
			}
			if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR \|\|
			hw->media_type == MEDIA_TYPE_1000M_FULL)
			ecmd->autoneg = AUTONEG_ENABLE;
			else
			ecmd->autoneg = AUTONEG_DISABLE;

			return 0;
			}

			static int atl1_set_settings(struct net_device *netdev,
			struct ethtool_cmd *ecmd)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			struct atl1_hw *hw = &adapter->hw;
			u16 phy_data;
			int ret_val = 0;
			u16 old_media_type = hw->media_type;

			if (netif_running(adapter->netdev)) {
			printk(KERN_DEBUG "%s: ethtool shutting down adapter\n",
			atl1_driver_name);
			atl1_down(adapter);
			}

			if (ecmd->autoneg == AUTONEG_ENABLE)
			hw->media_type = MEDIA_TYPE_AUTO_SENSOR;
			else {
			if (ecmd->speed == SPEED_1000) {
			if (ecmd->duplex != DUPLEX_FULL) {
			printk(KERN_WARNING
			"%s: can't force to 1000M half duplex\n",
			atl1_driver_name);
			ret_val = -EINVAL;
			goto exit_sset;
			}
			hw->media_type = MEDIA_TYPE_1000M_FULL;
			} else if (ecmd->speed == SPEED_100) {
			if (ecmd->duplex == DUPLEX_FULL) {
			hw->media_type = MEDIA_TYPE_100M_FULL;
			} else
			hw->media_type = MEDIA_TYPE_100M_HALF;
			} else {
			if (ecmd->duplex == DUPLEX_FULL)
			hw->media_type = MEDIA_TYPE_10M_FULL;
			else
			hw->media_type = MEDIA_TYPE_10M_HALF;
			}
			}
			switch (hw->media_type) {
			case MEDIA_TYPE_AUTO_SENSOR:
			ecmd->advertising =
			ADVERTISED_10baseT_Half \|
			ADVERTISED_10baseT_Full \|
			ADVERTISED_100baseT_Half \|
			ADVERTISED_100baseT_Full \|
			ADVERTISED_1000baseT_Full \|
			ADVERTISED_Autoneg \| ADVERTISED_TP;
			break;
			case MEDIA_TYPE_1000M_FULL:
			ecmd->advertising =
			ADVERTISED_1000baseT_Full \|
			ADVERTISED_Autoneg \| ADVERTISED_TP;
			break;
			default:
			ecmd->advertising = 0;
			break;
			}
			if (atl1_phy_setup_autoneg_adv(hw)) {
			ret_val = -EINVAL;
			printk(KERN_WARNING
			"%s: invalid ethtool speed/duplex setting\n",
			atl1_driver_name);
			goto exit_sset;
			}
			if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR \|\|
			hw->media_type == MEDIA_TYPE_1000M_FULL)
			phy_data = MII_CR_RESET \| MII_CR_AUTO_NEG_EN;
			else {
			switch (hw->media_type) {
			case MEDIA_TYPE_100M_FULL:
			phy_data =
			MII_CR_FULL_DUPLEX \| MII_CR_SPEED_100 \|
			MII_CR_RESET;
			break;
			case MEDIA_TYPE_100M_HALF:
			phy_data = MII_CR_SPEED_100 \| MII_CR_RESET;
			break;
			case MEDIA_TYPE_10M_FULL:
			phy_data =
			MII_CR_FULL_DUPLEX \| MII_CR_SPEED_10 \| MII_CR_RESET;
			break;
			default: /* MEDIA_TYPE_10M_HALF: */
			phy_data = MII_CR_SPEED_10 \| MII_CR_RESET;
			break;
			}
			}
			atl1_write_phy_reg(hw, MII_BMCR, phy_data);
			exit_sset:
			if (ret_val)
			hw->media_type = old_media_type;

			if (netif_running(adapter->netdev)) {
			printk(KERN_DEBUG "%s: ethtool starting adapter\n",
			atl1_driver_name);
			atl1_up(adapter);
			} else if (!ret_val) {
			printk(KERN_DEBUG "%s: ethtool resetting adapter\n",
			atl1_driver_name);
			atl1_reset(adapter);
			}
			return ret_val;
			}

			static void atl1_get_drvinfo(struct net_device *netdev,
			struct ethtool_drvinfo *drvinfo)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);

			strncpy(drvinfo->driver, atl1_driver_name, sizeof(drvinfo->driver));
			strncpy(drvinfo->version, atl1_driver_version,
			sizeof(drvinfo->version));
			strncpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
			strncpy(drvinfo->bus_info, pci_name(adapter->pdev),
			sizeof(drvinfo->bus_info));
			drvinfo->eedump_len = ATL1_EEDUMP_LEN;
			}

			static void atl1_get_wol(struct net_device *netdev,
			struct ethtool_wolinfo *wol)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);

			wol->supported = WAKE_UCAST \| WAKE_MCAST \| WAKE_BCAST \| WAKE_MAGIC;
			wol->wolopts = 0;
			if (adapter->wol & ATL1_WUFC_EX)
			wol->wolopts \|= WAKE_UCAST;
			if (adapter->wol & ATL1_WUFC_MC)
			wol->wolopts \|= WAKE_MCAST;
			if (adapter->wol & ATL1_WUFC_BC)
			wol->wolopts \|= WAKE_BCAST;
			if (adapter->wol & ATL1_WUFC_MAG)
			wol->wolopts \|= WAKE_MAGIC;
			return;
			}

			static int atl1_set_wol(struct net_device *netdev,
			struct ethtool_wolinfo *wol)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);

			if (wol->wolopts & (WAKE_PHY \| WAKE_ARP \| WAKE_MAGICSECURE))
			return -EOPNOTSUPP;
			adapter->wol = 0;
			if (wol->wolopts & WAKE_UCAST)
			adapter->wol \|= ATL1_WUFC_EX;
			if (wol->wolopts & WAKE_MCAST)
			adapter->wol \|= ATL1_WUFC_MC;
			if (wol->wolopts & WAKE_BCAST)
			adapter->wol \|= ATL1_WUFC_BC;
			if (wol->wolopts & WAKE_MAGIC)
			adapter->wol \|= ATL1_WUFC_MAG;
			return 0;
			}

			static void atl1_get_ringparam(struct net_device *netdev,
			struct ethtool_ringparam *ring)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			struct atl1_tpd_ring *txdr = &adapter->tpd_ring;
			struct atl1_rfd_ring *rxdr = &adapter->rfd_ring;

			ring->rx_max_pending = ATL1_MAX_RFD;
			ring->tx_max_pending = ATL1_MAX_TPD;
			ring->rx_mini_max_pending = 0;
			ring->rx_jumbo_max_pending = 0;
			ring->rx_pending = rxdr->count;
			ring->tx_pending = txdr->count;
			ring->rx_mini_pending = 0;
			ring->rx_jumbo_pending = 0;
			}

			static int atl1_set_ringparam(struct net_device *netdev,
			struct ethtool_ringparam *ring)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			struct atl1_tpd_ring *tpdr = &adapter->tpd_ring;
			struct atl1_rrd_ring *rrdr = &adapter->rrd_ring;
			struct atl1_rfd_ring *rfdr = &adapter->rfd_ring;

			struct atl1_tpd_ring tpd_old, tpd_new;
			struct atl1_rfd_ring rfd_old, rfd_new;
			struct atl1_rrd_ring rrd_old, rrd_new;
			struct atl1_ring_header rhdr_old, rhdr_new;
			int err;

			tpd_old = adapter->tpd_ring;
			rfd_old = adapter->rfd_ring;
			rrd_old = adapter->rrd_ring;
			rhdr_old = adapter->ring_header;

			if (netif_running(adapter->netdev))
			atl1_down(adapter);

			rfdr->count = (u16) max(ring->rx_pending, (u32) ATL1_MIN_RFD);
			rfdr->count = rfdr->count > ATL1_MAX_RFD ? ATL1_MAX_RFD :
			rfdr->count;
			rfdr->count = (rfdr->count + 3) & ~3;
			rrdr->count = rfdr->count;

			tpdr->count = (u16) max(ring->tx_pending, (u32) ATL1_MIN_TPD);
			tpdr->count = tpdr->count > ATL1_MAX_TPD ? ATL1_MAX_TPD :
			tpdr->count;
			tpdr->count = (tpdr->count + 3) & ~3;

			if (netif_running(adapter->netdev)) {
			/* try to get new resources before deleting old */
			err = atl1_setup_ring_resources(adapter);
			if (err)
			goto err_setup_ring;

			/*
			* save the new, restore the old in order to free it,
			* then restore the new back again
			*/

			rfd_new = adapter->rfd_ring;
			rrd_new = adapter->rrd_ring;
			tpd_new = adapter->tpd_ring;
			rhdr_new = adapter->ring_header;
			adapter->rfd_ring = rfd_old;
			adapter->rrd_ring = rrd_old;
			adapter->tpd_ring = tpd_old;
			adapter->ring_header = rhdr_old;
			atl1_free_ring_resources(adapter);
			adapter->rfd_ring = rfd_new;
			adapter->rrd_ring = rrd_new;
			adapter->tpd_ring = tpd_new;
			adapter->ring_header = rhdr_new;

			err = atl1_up(adapter);
			if (err)
			return err;
			}
			return 0;

			err_setup_ring:
			adapter->rfd_ring = rfd_old;
			adapter->rrd_ring = rrd_old;
			adapter->tpd_ring = tpd_old;
			adapter->ring_header = rhdr_old;
			atl1_up(adapter);
			return err;
			}

			static void atl1_get_pauseparam(struct net_device *netdev,
			struct ethtool_pauseparam *epause)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			struct atl1_hw *hw = &adapter->hw;

			if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR \|\|
			hw->media_type == MEDIA_TYPE_1000M_FULL) {
			epause->autoneg = AUTONEG_ENABLE;
			} else {
			epause->autoneg = AUTONEG_DISABLE;
			}
			epause->rx_pause = 1;
			epause->tx_pause = 1;
			}

			static int atl1_set_pauseparam(struct net_device *netdev,
			struct ethtool_pauseparam *epause)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			struct atl1_hw *hw = &adapter->hw;

			if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR \|\|
			hw->media_type == MEDIA_TYPE_1000M_FULL) {
			epause->autoneg = AUTONEG_ENABLE;
			} else {
			epause->autoneg = AUTONEG_DISABLE;
			}

			epause->rx_pause = 1;
			epause->tx_pause = 1;

			return 0;
			}

			static u32 atl1_get_rx_csum(struct net_device *netdev)
			{
			return 1;
			}

			static void atl1_get_strings(struct net_device *netdev, u32 stringset,
			u8 *data)
			{
			u8 *p = data;
			int i;

			switch (stringset) {
			case ETH_SS_STATS:
			for (i = 0; i < ARRAY_SIZE(atl1_gstrings_stats); i++) {
			memcpy(p, atl1_gstrings_stats[i].stat_string,
			ETH_GSTRING_LEN);
			p += ETH_GSTRING_LEN;
			}
			break;
			}
			}

			static int atl1_nway_reset(struct net_device *netdev)
			{
			struct atl1_adapter *adapter = netdev_priv(netdev);
			struct atl1_hw *hw = &adapter->hw;

			if (netif_running(netdev)) {
			u16 phy_data;
			atl1_down(adapter);

			if (hw->media_type == MEDIA_TYPE_AUTO_SENSOR \|\|
			hw->media_type == MEDIA_TYPE_1000M_FULL) {
			phy_data = MII_CR_RESET \| MII_CR_AUTO_NEG_EN;
			} else {
			switch (hw->media_type) {
			case MEDIA_TYPE_100M_FULL:
			phy_data = MII_CR_FULL_DUPLEX \|
			MII_CR_SPEED_100 \| MII_CR_RESET;
			break;
			case MEDIA_TYPE_100M_HALF:
			phy_data = MII_CR_SPEED_100 \| MII_CR_RESET;
			break;
			case MEDIA_TYPE_10M_FULL:
			phy_data = MII_CR_FULL_DUPLEX \|
			MII_CR_SPEED_10 \| MII_CR_RESET;
			break;
			default: /* MEDIA_TYPE_10M_HALF */
			phy_data = MII_CR_SPEED_10 \| MII_CR_RESET;
			}
			}
			atl1_write_phy_reg(hw, MII_BMCR, phy_data);
			atl1_up(adapter);
			}
			return 0;
			}

			const struct ethtool_ops atl1_ethtool_ops = {
			.get_settings = atl1_get_settings,
			.set_settings = atl1_set_settings,
			.get_drvinfo = atl1_get_drvinfo,
			.get_wol = atl1_get_wol,
			.set_wol = atl1_set_wol,
			.get_ringparam = atl1_get_ringparam,
			.set_ringparam = atl1_set_ringparam,
			.get_pauseparam = atl1_get_pauseparam,
			.set_pauseparam = atl1_set_pauseparam,
			.get_rx_csum = atl1_get_rx_csum,
			.get_tx_csum = ethtool_op_get_tx_csum,
			.set_tx_csum = ethtool_op_set_tx_hw_csum,
			.get_link = ethtool_op_get_link,
			.get_sg = ethtool_op_get_sg,
			.set_sg = ethtool_op_set_sg,
			.get_strings = atl1_get_strings,
			.nway_reset = atl1_nway_reset,
			.get_ethtool_stats = atl1_get_ethtool_stats,
			.get_stats_count = atl1_get_stats_count,
			.get_tso = ethtool_op_get_tso,
			.set_tso = ethtool_op_set_tso,
			};