/*******************************************************************************  Intel PRO/1000 Linux driver  Copyright(c) 1999 - 2008 Intel Corporation.  This program is free software; you can redistribute it and/or modify it  under the terms and conditions of the GNU General Public License,  version 2, as published by the Free Software Foundation.  This program is distributed in the hope 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.,  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.  The full GNU General Public License is included in this distribution in  the file called "COPYING".  Contact Information:  Linux NICS <linux.nics@intel.com>  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497*******************************************************************************//* * net/core/ethtool.c - Ethtool ioctl handler * Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx> * * This file is where we call all the ethtool_ops commands to get * the information ethtool needs.  We fall back to calling do_ioctl() * for drivers which haven't been converted to ethtool_ops yet. * * It's GPL, stupid. * * Modification by sfeldma@pobox.com to work as backward compat * solution for pre-ethtool_ops kernels. * 	- copied struct ethtool_ops from ethtool.h * 	- defined SET_ETHTOOL_OPS * 	- put in some #ifndef NETIF_F_xxx wrappers * 	- changes refs to dev->ethtool_ops to ethtool_ops * 	- changed dev_ethtool to ethtool_ioctl *      - remove EXPORT_SYMBOL()s *      - added _kc_ prefix in built-in ethtool_op_xxx ops. */#include <linux/module.h>#include <linux/types.h>#include <linux/errno.h>#include <linux/mii.h>#include <linux/ethtool.h>#include <linux/netdevice.h>#include <asm/uaccess.h>#include "kcompat.h"#undef SUPPORTED_10000baseT_Full#define SUPPORTED_10000baseT_Full	(1 << 12)#undef ADVERTISED_10000baseT_Full#define ADVERTISED_10000baseT_Full	(1 << 12)#undef SPEED_10000#define SPEED_10000		10000#undef ethtool_ops#define ethtool_ops _kc_ethtool_opsstruct _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))/* * Some useful ethtool_ops methods that are device independent. If we find that * all drivers want to do the same thing here, we can turn these into dev_() * function calls. */#undef ethtool_op_get_link#define ethtool_op_get_link _kc_ethtool_op_get_linku32 _kc_ethtool_op_get_link(struct net_device *dev){	return netif_carrier_ok(dev) ? 1 : 0;}#undef ethtool_op_get_tx_csum#define ethtool_op_get_tx_csum _kc_ethtool_op_get_tx_csumu32 _kc_ethtool_op_get_tx_csum(struct net_device *dev){#ifdef NETIF_F_IP_CSUM	return (dev->features & NETIF_F_IP_CSUM) != 0;#else	return 0;#endif}#undef ethtool_op_set_tx_csum#define ethtool_op_set_tx_csum _kc_ethtool_op_set_tx_csumint _kc_ethtool_op_set_tx_csum(struct net_device *dev, u32 data){#ifdef NETIF_F_IP_CSUM	if (data)#ifdef NETIF_F_IPV6_CSUM		dev->features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);	else		dev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);#else		dev->features |= NETIF_F_IP_CSUM;	else		dev->features &= ~NETIF_F_IP_CSUM;#endif#endif	return 0;}#undef ethtool_op_get_sg#define ethtool_op_get_sg _kc_ethtool_op_get_sgu32 _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_sgint _kc_ethtool_op_set_sg(struct net_device *dev, u32 data){#ifdef NETIF_F_SG	if (data)		dev->features |= NETIF_F_SG;	else		dev->features &= ~NETIF_F_SG;#endif	return 0;}#undef ethtool_op_get_tso#define ethtool_op_get_tso _kc_ethtool_op_get_tsou32 _kc_ethtool_op_get_tso(struct net_device *dev){#ifdef NETIF_F_TSO	return (dev->features & NETIF_F_TSO) != 0;#else	return 0;#endif}#undef ethtool_op_set_tso#define ethtool_op_set_tso _kc_ethtool_op_set_tsoint _kc_ethtool_op_set_tso(struct net_device *dev, u32 data){#ifdef NETIF_F_TSO	if (data)		dev->features |= NETIF_F_TSO;	else		dev->features &= ~NETIF_F_TSO;#endif	return 0;}/* Handlers for each ethtool command */static int ethtool_get_settings(struct net_device *dev, void *useraddr){	struct ethtool_cmd cmd = { ETHTOOL_GSET };	int err;	if (!ethtool_ops->get_settings)		return -EOPNOTSUPP;	err = ethtool_ops->get_settings(dev, &cmd);	if (err < 0)		return err;	if (copy_to_user(useraddr, &cmd, sizeof(cmd)))		return -EFAULT;	return 0;}static int ethtool_set_settings(struct net_device *dev, void *useraddr){	struct ethtool_cmd cmd;	if (!ethtool_ops->set_settings)		return -EOPNOTSUPP;	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))		return -EFAULT;	return ethtool_ops->set_settings(dev, &cmd);}static int ethtool_get_drvinfo(struct net_device *dev, void *useraddr){	struct ethtool_drvinfo info;	struct ethtool_ops *ops = ethtool_ops;	if (!ops->get_drvinfo)		return -EOPNOTSUPP;	memset(&info, 0, sizeof(info));	info.cmd = ETHTOOL_GDRVINFO;	ops->get_drvinfo(dev, &info);	if (ops->self_test_count)		info.testinfo_len = ops->self_test_count(dev);	if (ops->get_stats_count)		info.n_stats = ops->get_stats_count(dev);	if (ops->get_regs_len)		info.regdump_len = ops->get_regs_len(dev);	if (ops->get_eeprom_len)		info.eedump_len = ops->get_eeprom_len(dev);	if (copy_to_user(useraddr, &info, sizeof(info)))		return -EFAULT;	return 0;}static int ethtool_get_regs(struct net_device *dev, char *useraddr){	struct ethtool_regs regs;	struct ethtool_ops *ops = ethtool_ops;	void *regbuf;	int reglen, ret;	if (!ops->get_regs || !ops->get_regs_len)		return -EOPNOTSUPP;	if (copy_from_user(&regs, useraddr, sizeof(regs)))		return -EFAULT;	reglen = ops->get_regs_len(dev);	if (regs.len > reglen)		regs.len = reglen;	regbuf = kmalloc(reglen, GFP_USER);	if (!regbuf)		return -ENOMEM;	ops->get_regs(dev, &regs, regbuf);	ret = -EFAULT;	if (copy_to_user(useraddr, &regs, sizeof(regs)))		goto out;	useraddr += offsetof(struct ethtool_regs, data);	if (copy_to_user(useraddr, regbuf, reglen))		goto out;	ret = 0;out:	kfree(regbuf);	return ret;}static int ethtool_get_wol(struct net_device *dev, char *useraddr){	struct ethtool_wolinfo wol = { ETHTOOL_GWOL };	if (!ethtool_ops->get_wol)		return -EOPNOTSUPP;	ethtool_ops->get_wol(dev, &wol);	if (copy_to_user(useraddr, &wol, sizeof(wol)))		return -EFAULT;	return 0;}static int ethtool_set_wol(struct net_device *dev, char *useraddr){	struct ethtool_wolinfo wol;	if (!ethtool_ops->set_wol)		return -EOPNOTSUPP;	if (copy_from_user(&wol, useraddr, sizeof(wol)))		return -EFAULT;	return ethtool_ops->set_wol(dev, &wol);}static int ethtool_get_msglevel(struct net_device *dev, char *useraddr){	struct ethtool_value edata = { ETHTOOL_GMSGLVL };	if (!ethtool_ops->get_msglevel)		return -EOPNOTSUPP;	edata.data = ethtool_ops->get_msglevel(dev);	if (copy_to_user(useraddr, &edata, sizeof(edata)))		return -EFAULT;	return 0;}static int ethtool_set_msglevel(struct net_device *dev, char *useraddr){	struct ethtool_value edata;	if (!ethtool_ops->set_msglevel)		return -EOPNOTSUPP;	if (copy_from_user(&edata, useraddr, sizeof(edata)))		return -EFAULT;	ethtool_ops->set_msglevel(dev, edata.data);	return 0;}static int ethtool_nway_reset(struct net_device *dev){	if (!ethtool_ops->nway_reset)		return -EOPNOTSUPP;	return ethtool_ops->nway_reset(dev);}static int ethtool_get_link(struct net_device *dev, void *useraddr){	struct ethtool_value edata = { ETHTOOL_GLINK };	if (!ethtool_ops->get_link)		return -EOPNOTSUPP;	edata.data = ethtool_ops->get_link(dev);	if (copy_to_user(useraddr, &edata, sizeof(edata)))		return -EFAULT;	return 0;}static int ethtool_get_eeprom(struct net_device *dev, void *useraddr){	struct ethtool_eeprom eeprom;	struct ethtool_ops *ops = ethtool_ops;	u8 *data;	int ret;	if (!ops->get_eeprom || !ops->get_eeprom_len)		return -EOPNOTSUPP;	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))		return -EFAULT;	/* Check for wrap and zero */	if (eeprom.offset + eeprom.len <= eeprom.offset)		return -EINVAL;	/* Check for exceeding total eeprom len */	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))		return -EINVAL;	data = kmalloc(eeprom.len, GFP_USER);	if (!data)		return -ENOMEM;	ret = -EFAULT;	if (copy_from_user(data, useraddr + sizeof(eeprom), eeprom.len))		goto out;	ret = ops->get_eeprom(dev, &eeprom, data);	if (ret)		goto out;	ret = -EFAULT;	if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))		goto out;	if (copy_to_user(useraddr + sizeof(eeprom), data, eeprom.len))		goto out;	ret = 0;out:	kfree(data);	return ret;}static int ethtool_set_eeprom(struct net_device *dev, void *useraddr){	struct ethtool_eeprom eeprom;	struct ethtool_ops *ops = ethtool_ops;	u8 *data;	int ret;	if (!ops->set_eeprom || !ops->get_eeprom_len)		return -EOPNOTSUPP;	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))		return -EFAULT;	/* Check for wrap and zero */	if (eeprom.offset + eeprom.len <= eeprom.offset)		return -EINVAL;	/* Check for exceeding total eeprom len */	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))		return -EINVAL;	data = kmalloc(eeprom.len, GFP_USER);	if (!data)		return -ENOMEM;	ret = -EFAULT;	if (copy_from_user(data, useraddr + sizeof(eeprom), eeprom.len))		goto out;	ret = ops->set_eeprom(dev, &eeprom, data);	if (ret)		goto out;	if (copy_to_user(useraddr + sizeof(eeprom), data, eeprom.len))		ret = -EFAULT;out:	kfree(data);	return ret;}static int ethtool_get_coalesce(struct net_device *dev, void *useraddr){	struct ethtool_coalesce coalesce = { ETHTOOL_GCOALESCE };	if (!ethtool_ops->get_coalesce)		return -EOPNOTSUPP;	ethtool_ops->get_coalesce(dev, &coalesce);	if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))		return -EFAULT;	return 0;}static int ethtool_set_coalesce(struct net_device *dev, void *useraddr){	struct ethtool_coalesce coalesce;	if (!ethtool_ops->get_coalesce)		return -EOPNOTSUPP;	if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))		return -EFAULT;	return ethtool_ops->set_coalesce(dev, &coalesce);}static int ethtool_get_ringparam(struct net_device *dev, void *useraddr){	struct ethtool_ringparam ringparam = { ETHTOOL_GRINGPARAM };	if (!ethtool_ops->get_ringparam)		return -EOPNOTSUPP;	ethtool_ops->get_ringparam(dev, &ringparam);	if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))		return -EFAULT;	return 0;}static int ethtool_set_ringparam(struct net_device *dev, void *useraddr){	struct ethtool_ringparam ringparam;	if (!ethtool_ops->get_ringparam)		return -EOPNOTSUPP;	if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))		return -EFAULT;	return ethtool_ops->set_ringparam(dev, &ringparam);}static int ethtool_get_pauseparam(struct net_device *dev, void *useraddr){	struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };	if (!ethtool_ops->get_pauseparam)		return -EOPNOTSUPP;	ethtool_ops->get_pauseparam(dev, &pauseparam);	if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))		return -EFAULT;	return 0;}static int ethtool_set_pauseparam(struct net_device *dev, void *useraddr){	struct ethtool_pauseparam pauseparam;	if (!ethtool_ops->get_pauseparam)		return -EOPNOTSUPP;	if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))		return -EFAULT;	return ethtool_ops->set_pauseparam(dev, &pauseparam);}static int ethtool_get_rx_csum(struct net_device *dev, char *useraddr){	struct ethtool_value edata = { ETHTOOL_GRXCSUM };	if (!ethtool_ops->get_rx_csum)		return -EOPNOTSUPP;	edata.data = ethtool_ops->get_rx_csum(dev);	if (copy_to_user(useraddr, &edata, sizeof(edata)))		return -EFAULT;	return 0;}static int ethtool_set_rx_csum(struct net_device *dev, char *useraddr){	struct ethtool_value edata;	if (!ethtool_ops->set_rx_csum)		return -EOPNOTSUPP;	if (copy_from_user(&edata, useraddr, sizeof(edata)))		return -EFAULT;	ethtool_ops->set_rx_csum(dev, edata.data);	return 0;}static int ethtool_get_tx_csum(struct net_device *dev, char *useraddr){	struct ethtool_value edata = { ETHTOOL_GTXCSUM };	if (!ethtool_ops->get_tx_csum)		return -EOPNOTSUPP;	edata.data = ethtool_ops->get_tx_csum(dev);	if (copy_to_user(useraddr, &edata, sizeof(edata)))		return -EFAULT;	return 0;}