[mirror_ubuntu-artful-kernel.git] / drivers / net / dummy.c

/* dummy.c: a dummy net driver

	The purpose of this driver is to provide a device to point a
	route through, but not to actually transmit packets.

	Why?  If you have a machine whose only connection is an occasional
	PPP/SLIP/PLIP link, you can only connect to your own hostname
	when the link is up.  Otherwise you have to use localhost.
	This isn't very consistent.

	One solution is to set up a dummy link using PPP/SLIP/PLIP,
	but this seems (to me) too much overhead for too little gain.
	This driver provides a small alternative. Thus you can do

	[when not running slip]
		ifconfig dummy slip.addr.ess.here up
	[to go to slip]
		ifconfig dummy down
		dip whatever

	This was written by looking at Donald Becker's skeleton driver
	and the loopback driver.  I then threw away anything that didn't
	apply!	Thanks to Alan Cox for the key clue on what to do with
	misguided packets.

			Nick Holloway, 27th May 1994
	[I tweaked this explanation a little but that's all]
			Alan Cox, 30th May 1994
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/rtnetlink.h>
#include <linux/net_tstamp.h>
#include <net/rtnetlink.h>
#include <linux/u64_stats_sync.h>

#define DRV_NAME	"dummy"
#define DRV_VERSION	"1.0"

#undef pr_fmt
#define pr_fmt(fmt) DRV_NAME ": " fmt

static int numdummies = 1;
static int num_vfs;

struct vf_data_storage {
	u8	vf_mac[ETH_ALEN];
	u16	pf_vlan; /* When set, guest VLAN config not allowed. */
	u16	pf_qos;
	__be16	vlan_proto;
	u16	min_tx_rate;
	u16	max_tx_rate;
	u8	spoofchk_enabled;
	bool	rss_query_enabled;
	u8	trusted;
	int	link_state;
};

struct dummy_priv {
	struct vf_data_storage	*vfinfo;
};

static int dummy_num_vf(struct device *dev)
{
	return num_vfs;
}

static struct bus_type dummy_bus = {
	.name	= "dummy",
	.num_vf	= dummy_num_vf,
};

static void release_dummy_parent(struct device *dev)
{
}

static struct device dummy_parent = {
	.init_name	= "dummy",
	.bus		= &dummy_bus,
	.release	= release_dummy_parent,
};

/* fake multicast ability */
static void set_multicast_list(struct net_device *dev)
{
}

struct pcpu_dstats {
	u64			tx_packets;
	u64			tx_bytes;
	struct u64_stats_sync	syncp;
};

static void dummy_get_stats64(struct net_device *dev,
			      struct rtnl_link_stats64 *stats)
{
	int i;

	for_each_possible_cpu(i) {
		const struct pcpu_dstats *dstats;
		u64 tbytes, tpackets;
		unsigned int start;

		dstats = per_cpu_ptr(dev->dstats, i);
		do {
			start = u64_stats_fetch_begin_irq(&dstats->syncp);
			tbytes = dstats->tx_bytes;
			tpackets = dstats->tx_packets;
		} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
		stats->tx_bytes += tbytes;
		stats->tx_packets += tpackets;
	}
}

static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);

	u64_stats_update_begin(&dstats->syncp);
	dstats->tx_packets++;
	dstats->tx_bytes += skb->len;
	u64_stats_update_end(&dstats->syncp);

	skb_tx_timestamp(skb);
	dev_kfree_skb(skb);
	return NETDEV_TX_OK;
}

static int dummy_dev_init(struct net_device *dev)
{
	struct dummy_priv *priv = netdev_priv(dev);

	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
	if (!dev->dstats)
		return -ENOMEM;

	priv->vfinfo = NULL;

	if (!num_vfs)
		return 0;

	dev->dev.parent = &dummy_parent;
	priv->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),
			       GFP_KERNEL);
	if (!priv->vfinfo) {
		free_percpu(dev->dstats);
		return -ENOMEM;
	}

	return 0;
}

static void dummy_dev_uninit(struct net_device *dev)
{
	free_percpu(dev->dstats);
}

static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
{
	if (new_carrier)
		netif_carrier_on(dev);
	else
		netif_carrier_off(dev);
	return 0;
}

static int dummy_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (!is_valid_ether_addr(mac) || (vf >= num_vfs))
		return -EINVAL;

	memcpy(priv->vfinfo[vf].vf_mac, mac, ETH_ALEN);

	return 0;
}

static int dummy_set_vf_vlan(struct net_device *dev, int vf,
			     u16 vlan, u8 qos, __be16 vlan_proto)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if ((vf >= num_vfs) || (vlan > 4095) || (qos > 7))
		return -EINVAL;

	priv->vfinfo[vf].pf_vlan = vlan;
	priv->vfinfo[vf].pf_qos = qos;
	priv->vfinfo[vf].vlan_proto = vlan_proto;

	return 0;
}

static int dummy_set_vf_rate(struct net_device *dev, int vf, int min, int max)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].min_tx_rate = min;
	priv->vfinfo[vf].max_tx_rate = max;

	return 0;
}

static int dummy_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].spoofchk_enabled = val;

	return 0;
}

static int dummy_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].rss_query_enabled = val;

	return 0;
}

static int dummy_set_vf_trust(struct net_device *dev, int vf, bool val)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].trusted = val;

	return 0;
}

static int dummy_get_vf_config(struct net_device *dev,
			       int vf, struct ifla_vf_info *ivi)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	ivi->vf = vf;
	memcpy(&ivi->mac, priv->vfinfo[vf].vf_mac, ETH_ALEN);
	ivi->vlan = priv->vfinfo[vf].pf_vlan;
	ivi->qos = priv->vfinfo[vf].pf_qos;
	ivi->spoofchk = priv->vfinfo[vf].spoofchk_enabled;
	ivi->linkstate = priv->vfinfo[vf].link_state;
	ivi->min_tx_rate = priv->vfinfo[vf].min_tx_rate;
	ivi->max_tx_rate = priv->vfinfo[vf].max_tx_rate;
	ivi->rss_query_en = priv->vfinfo[vf].rss_query_enabled;
	ivi->trusted = priv->vfinfo[vf].trusted;
	ivi->vlan_proto = priv->vfinfo[vf].vlan_proto;

	return 0;
}

static int dummy_set_vf_link_state(struct net_device *dev, int vf, int state)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].link_state = state;

	return 0;
}

static const struct net_device_ops dummy_netdev_ops = {
	.ndo_init		= dummy_dev_init,
	.ndo_uninit		= dummy_dev_uninit,
	.ndo_start_xmit		= dummy_xmit,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_rx_mode	= set_multicast_list,
	.ndo_set_mac_address	= eth_mac_addr,
	.ndo_get_stats64	= dummy_get_stats64,
	.ndo_change_carrier	= dummy_change_carrier,
	.ndo_set_vf_mac		= dummy_set_vf_mac,
	.ndo_set_vf_vlan	= dummy_set_vf_vlan,
	.ndo_set_vf_rate	= dummy_set_vf_rate,
	.ndo_set_vf_spoofchk	= dummy_set_vf_spoofchk,
	.ndo_set_vf_trust	= dummy_set_vf_trust,
	.ndo_get_vf_config	= dummy_get_vf_config,
	.ndo_set_vf_link_state	= dummy_set_vf_link_state,
	.ndo_set_vf_rss_query_en = dummy_set_vf_rss_query_en,
};

static void dummy_get_drvinfo(struct net_device *dev,
			      struct ethtool_drvinfo *info)
{
	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
}

static int dummy_get_ts_info(struct net_device *dev,
			      struct ethtool_ts_info *ts_info)
{
	ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
				   SOF_TIMESTAMPING_RX_SOFTWARE |
				   SOF_TIMESTAMPING_SOFTWARE;

	ts_info->phc_index = -1;

	return 0;
};

static const struct ethtool_ops dummy_ethtool_ops = {
	.get_drvinfo            = dummy_get_drvinfo,
	.get_ts_info		= dummy_get_ts_info,
};

static void dummy_free_netdev(struct net_device *dev)
{
	struct dummy_priv *priv = netdev_priv(dev);

	kfree(priv->vfinfo);
}

static void dummy_setup(struct net_device *dev)
{
	ether_setup(dev);

	/* Initialize the device structure. */
	dev->netdev_ops = &dummy_netdev_ops;
	dev->ethtool_ops = &dummy_ethtool_ops;
	dev->needs_free_netdev = true;
	dev->priv_destructor = dummy_free_netdev;

	/* Fill in device structure with ethernet-generic values. */
	dev->flags |= IFF_NOARP;
	dev->flags &= ~IFF_MULTICAST;
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
	dev->features	|= NETIF_F_SG | NETIF_F_FRAGLIST;
	dev->features	|= NETIF_F_ALL_TSO | NETIF_F_UFO;
	dev->features	|= NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_LLTX;
	dev->features	|= NETIF_F_GSO_ENCAP_ALL;
	dev->hw_features |= dev->features;
	dev->hw_enc_features |= dev->features;
	eth_hw_addr_random(dev);

	dev->min_mtu = 0;
	dev->max_mtu = ETH_MAX_MTU;
}

static int dummy_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}
	return 0;
}

static struct rtnl_link_ops dummy_link_ops __read_mostly = {
	.kind		= DRV_NAME,
	.priv_size	= sizeof(struct dummy_priv),
	.setup		= dummy_setup,
	.validate	= dummy_validate,
};

/* Number of dummy devices to be set up by this module. */
module_param(numdummies, int, 0);
MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");

module_param(num_vfs, int, 0);
MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");

static int __init dummy_init_one(void)
{
	struct net_device *dev_dummy;
	int err;

	dev_dummy = alloc_netdev(sizeof(struct dummy_priv),
				 "dummy%d", NET_NAME_UNKNOWN, dummy_setup);
	if (!dev_dummy)
		return -ENOMEM;

	dev_dummy->rtnl_link_ops = &dummy_link_ops;
	err = register_netdevice(dev_dummy);
	if (err < 0)
		goto err;
	return 0;

err:
	free_netdev(dev_dummy);
	return err;
}

static int __init dummy_init_module(void)
{
	int i, err = 0;

	if (num_vfs) {
		err = bus_register(&dummy_bus);
		if (err < 0) {
			pr_err("registering dummy bus failed\n");
			return err;
		}

		err = device_register(&dummy_parent);
		if (err < 0) {
			pr_err("registering dummy parent device failed\n");
			bus_unregister(&dummy_bus);
			return err;
		}
	}

	rtnl_lock();
	err = __rtnl_link_register(&dummy_link_ops);
	if (err < 0)
		goto out;

	for (i = 0; i < numdummies && !err; i++) {
		err = dummy_init_one();
		cond_resched();
	}
	if (err < 0)
		__rtnl_link_unregister(&dummy_link_ops);

out:
	rtnl_unlock();

	if (err && num_vfs) {
		device_unregister(&dummy_parent);
		bus_unregister(&dummy_bus);
	}

	return err;
}

static void __exit dummy_cleanup_module(void)
{
	rtnl_link_unregister(&dummy_link_ops);

	if (num_vfs) {
		device_unregister(&dummy_parent);
		bus_unregister(&dummy_bus);
	}
}

module_init(dummy_init_module);
module_exit(dummy_cleanup_module);
MODULE_LICENSE("GPL");
MODULE_ALIAS_RTNL_LINK(DRV_NAME);
MODULE_VERSION(DRV_VERSION);
Commit	Line	Data
1da177e4 LT	1	/* dummy.c: a dummy net driver
	2
	3	The purpose of this driver is to provide a device to point a
	4	route through, but not to actually transmit packets.
	5
	6	Why? If you have a machine whose only connection is an occasional
	7	PPP/SLIP/PLIP link, you can only connect to your own hostname
	8	when the link is up. Otherwise you have to use localhost.
	9	This isn't very consistent.
	10
	11	One solution is to set up a dummy link using PPP/SLIP/PLIP,
	12	but this seems (to me) too much overhead for too little gain.
	13	This driver provides a small alternative. Thus you can do
6aa20a22	14
1da177e4 LT	15	[when not running slip]
	16	ifconfig dummy slip.addr.ess.here up
	17	[to go to slip]
	18	ifconfig dummy down
	19	dip whatever
	20
	21	This was written by looking at Donald Becker's skeleton driver
	22	and the loopback driver. I then threw away anything that didn't
	23	apply! Thanks to Alan Cox for the key clue on what to do with
	24	misguided packets.
	25
	26	Nick Holloway, 27th May 1994
	27	[I tweaked this explanation a little but that's all]
	28	Alan Cox, 30th May 1994
	29	*/
	30
1da177e4 LT	31	#include <linux/module.h>
	32	#include <linux/kernel.h>
	33	#include <linux/netdevice.h>
	34	#include <linux/etherdevice.h>
	35	#include <linux/init.h>
	36	#include <linux/moduleparam.h>
206c9fb2	37	#include <linux/rtnetlink.h>
6df014cf	38	#include <linux/net_tstamp.h>
5d5cb173	39	#include <net/rtnetlink.h>
6d81f41c	40	#include <linux/u64_stats_sync.h>
206c9fb2	41
c19be735 FL	42	#define DRV_NAME "dummy"
	43	#define DRV_VERSION "1.0"
	44
e1636836 PS	45	#undef pr_fmt
	46	#define pr_fmt(fmt) DRV_NAME ": " fmt
	47
1da177e4	48	static int numdummies = 1;
e1636836 PS	49	static int num_vfs;
	50
	51	struct vf_data_storage {
	52	u8 vf_mac[ETH_ALEN];
	53	u16 pf_vlan; /* When set, guest VLAN config not allowed. */
	54	u16 pf_qos;
	55	__be16 vlan_proto;
	56	u16 min_tx_rate;
	57	u16 max_tx_rate;
	58	u8 spoofchk_enabled;
	59	bool rss_query_enabled;
	60	u8 trusted;
	61	int link_state;
	62	};
	63
	64	struct dummy_priv {
	65	struct vf_data_storage *vfinfo;
	66	};
	67
	68	static int dummy_num_vf(struct device *dev)
	69	{
	70	return num_vfs;
	71	}
	72
	73	static struct bus_type dummy_bus = {
	74	.name = "dummy",
	75	.num_vf = dummy_num_vf,
	76	};
	77
	78	static void release_dummy_parent(struct device *dev)
	79	{
	80	}
	81
	82	static struct device dummy_parent = {
	83	.init_name = "dummy",
	84	.bus = &dummy_bus,
	85	.release = release_dummy_parent,
	86	};
1da177e4	87
1da177e4 LT	88	/* fake multicast ability */
	89	static void set_multicast_list(struct net_device *dev)
	90	{
	91	}
	92
6d81f41c ED	93	struct pcpu_dstats {
	94	u64 tx_packets;
	95	u64 tx_bytes;
	96	struct u64_stats_sync syncp;
	97	};
	98
bc1f4470	99	static void dummy_get_stats64(struct net_device *dev,
bc1f4470	100	struct rtnl_link_stats64 *stats)
6d81f41c ED	101	{
	102	int i;
	103
	104	for_each_possible_cpu(i) {
	105	const struct pcpu_dstats *dstats;
	106	u64 tbytes, tpackets;
	107	unsigned int start;
	108
	109	dstats = per_cpu_ptr(dev->dstats, i);
	110	do {
57a7744e	111	start = u64_stats_fetch_begin_irq(&dstats->syncp);
6d81f41c ED	112	tbytes = dstats->tx_bytes;
6d81f41c ED	113	tpackets = dstats->tx_packets;
57a7744e	114	} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
6d81f41c ED	115	stats->tx_bytes += tbytes;
	116	stats->tx_packets += tpackets;
	117	}
6d81f41c	118	}
424efe9c SH	119
	120	static netdev_tx_t dummy_xmit(struct sk_buff skb, struct net_device dev)
	121	{
6d81f41c ED	122	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
	123
	124	u64_stats_update_begin(&dstats->syncp);
	125	dstats->tx_packets++;
	126	dstats->tx_bytes += skb->len;
	127	u64_stats_update_end(&dstats->syncp);
424efe9c	128
6df014cf	129	skb_tx_timestamp(skb);
424efe9c SH	130	dev_kfree_skb(skb);
	131	return NETDEV_TX_OK;
	132	}
	133
6d81f41c ED	134	static int dummy_dev_init(struct net_device *dev)
6d81f41c ED	135	{
e1636836 PS	136	struct dummy_priv *priv = netdev_priv(dev);
e1636836 PS	137
1c213bd2	138	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
6d81f41c ED	139	if (!dev->dstats)
	140	return -ENOMEM;
	141
e1636836 PS	142	priv->vfinfo = NULL;
	143
	144	if (!num_vfs)
	145	return 0;
	146
	147	dev->dev.parent = &dummy_parent;
	148	priv->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),
	149	GFP_KERNEL);
	150	if (!priv->vfinfo) {
	151	free_percpu(dev->dstats);
	152	return -ENOMEM;
	153	}
	154
6d81f41c ED	155	return 0;
	156	}
	157
890fdf2a	158	static void dummy_dev_uninit(struct net_device *dev)
6d81f41c ED	159	{
6d81f41c ED	160	free_percpu(dev->dstats);
6d81f41c ED	161	}
6d81f41c ED	162
210ab665 JP	163	static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
	164	{
	165	if (new_carrier)
	166	netif_carrier_on(dev);
	167	else
	168	netif_carrier_off(dev);
	169	return 0;
	170	}
	171
e1636836 PS	172	static int dummy_set_vf_mac(struct net_device dev, int vf, u8 mac)
	173	{
	174	struct dummy_priv *priv = netdev_priv(dev);
	175
	176	if (!is_valid_ether_addr(mac) \|\| (vf >= num_vfs))
	177	return -EINVAL;
	178
	179	memcpy(priv->vfinfo[vf].vf_mac, mac, ETH_ALEN);
	180
	181	return 0;
	182	}
	183
	184	static int dummy_set_vf_vlan(struct net_device *dev, int vf,
	185	u16 vlan, u8 qos, __be16 vlan_proto)
	186	{
	187	struct dummy_priv *priv = netdev_priv(dev);
	188
	189	if ((vf >= num_vfs) \|\| (vlan > 4095) \|\| (qos > 7))
	190	return -EINVAL;
	191
	192	priv->vfinfo[vf].pf_vlan = vlan;
	193	priv->vfinfo[vf].pf_qos = qos;
	194	priv->vfinfo[vf].vlan_proto = vlan_proto;
	195
	196	return 0;
	197	}
	198
	199	static int dummy_set_vf_rate(struct net_device *dev, int vf, int min, int max)
	200	{
	201	struct dummy_priv *priv = netdev_priv(dev);
	202
	203	if (vf >= num_vfs)
	204	return -EINVAL;
	205
	206	priv->vfinfo[vf].min_tx_rate = min;
	207	priv->vfinfo[vf].max_tx_rate = max;
	208
	209	return 0;
	210	}
	211
	212	static int dummy_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
	213	{
	214	struct dummy_priv *priv = netdev_priv(dev);
	215
	216	if (vf >= num_vfs)
	217	return -EINVAL;
	218
	219	priv->vfinfo[vf].spoofchk_enabled = val;
	220
	221	return 0;
	222	}
	223
	224	static int dummy_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
	225	{
	226	struct dummy_priv *priv = netdev_priv(dev);
	227
	228	if (vf >= num_vfs)
	229	return -EINVAL;
	230
	231	priv->vfinfo[vf].rss_query_enabled = val;
	232
	233	return 0;
	234	}
	235
236	static int dummy_set_vf_trust(struct net_device *dev, int vf, bool val)
237	{
238	struct dummy_priv *priv = netdev_priv(dev);
239
240	if (vf >= num_vfs)
241	return -EINVAL;
242
243	priv->vfinfo[vf].trusted = val;
244
245	return 0;
246	}
247
248	static int dummy_get_vf_config(struct net_device *dev,
249	int vf, struct ifla_vf_info *ivi)
250	{
251	struct dummy_priv *priv = netdev_priv(dev);
252
253	if (vf >= num_vfs)
254	return -EINVAL;
255
256	ivi->vf = vf;
257	memcpy(&ivi->mac, priv->vfinfo[vf].vf_mac, ETH_ALEN);
258	ivi->vlan = priv->vfinfo[vf].pf_vlan;
259	ivi->qos = priv->vfinfo[vf].pf_qos;
260	ivi->spoofchk = priv->vfinfo[vf].spoofchk_enabled;
261	ivi->linkstate = priv->vfinfo[vf].link_state;
262	ivi->min_tx_rate = priv->vfinfo[vf].min_tx_rate;
263	ivi->max_tx_rate = priv->vfinfo[vf].max_tx_rate;
264	ivi->rss_query_en = priv->vfinfo[vf].rss_query_enabled;
265	ivi->trusted = priv->vfinfo[vf].trusted;
266	ivi->vlan_proto = priv->vfinfo[vf].vlan_proto;
267
268	return 0;
269	}
270
271	static int dummy_set_vf_link_state(struct net_device *dev, int vf, int state)
272	{
273	struct dummy_priv *priv = netdev_priv(dev);
274
275	if (vf >= num_vfs)
276	return -EINVAL;
277
278	priv->vfinfo[vf].link_state = state;
279
280	return 0;
281	}
282
aa18e9e8	283	static const struct net_device_ops dummy_netdev_ops = {
6d81f41c	284	.ndo_init = dummy_dev_init,
890fdf2a	285	.ndo_uninit = dummy_dev_uninit,
aa18e9e8 SH	286	.ndo_start_xmit = dummy_xmit,
aa18e9e8 SH	287	.ndo_validate_addr = eth_validate_addr,
afc4b13d	288	.ndo_set_rx_mode = set_multicast_list,
0d1632b4	289	.ndo_set_mac_address = eth_mac_addr,
6d81f41c	290	.ndo_get_stats64 = dummy_get_stats64,
210ab665	291	.ndo_change_carrier = dummy_change_carrier,
e1636836 PS	292	.ndo_set_vf_mac = dummy_set_vf_mac,
	293	.ndo_set_vf_vlan = dummy_set_vf_vlan,
	294	.ndo_set_vf_rate = dummy_set_vf_rate,
	295	.ndo_set_vf_spoofchk = dummy_set_vf_spoofchk,
	296	.ndo_set_vf_trust = dummy_set_vf_trust,
	297	.ndo_get_vf_config = dummy_get_vf_config,
	298	.ndo_set_vf_link_state = dummy_set_vf_link_state,
	299	.ndo_set_vf_rss_query_en = dummy_set_vf_rss_query_en,
aa18e9e8 SH	300	};
aa18e9e8 SH	301
c19be735 FL	302	static void dummy_get_drvinfo(struct net_device *dev,
	303	struct ethtool_drvinfo *info)
	304	{
	305	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
	306	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
	307	}
	308
6df014cf ELG	309	static int dummy_get_ts_info(struct net_device *dev,
	310	struct ethtool_ts_info *ts_info)
	311	{
	312	ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE \|
	313	SOF_TIMESTAMPING_RX_SOFTWARE \|
	314	SOF_TIMESTAMPING_SOFTWARE;
	315
	316	ts_info->phc_index = -1;
	317
	318	return 0;
	319	};
	320
c19be735 FL	321	static const struct ethtool_ops dummy_ethtool_ops = {
c19be735 FL	322	.get_drvinfo = dummy_get_drvinfo,
6df014cf	323	.get_ts_info = dummy_get_ts_info,
c19be735 FL	324	};
c19be735 FL	325
e1636836 PS	326	static void dummy_free_netdev(struct net_device *dev)
	327	{
	328	struct dummy_priv *priv = netdev_priv(dev);
	329
	330	kfree(priv->vfinfo);
e1636836 PS	331	}
e1636836 PS	332
5d5cb173	333	static void dummy_setup(struct net_device *dev)
1da177e4	334	{
aa18e9e8 SH	335	ether_setup(dev);
aa18e9e8 SH	336
1da177e4	337	/* Initialize the device structure. */
aa18e9e8	338	dev->netdev_ops = &dummy_netdev_ops;
c19be735	339	dev->ethtool_ops = &dummy_ethtool_ops;
cf124db5 DM	340	dev->needs_free_netdev = true;
cf124db5 DM	341	dev->priv_destructor = dummy_free_netdev;
1da177e4 LT	342
1da177e4 LT	343	/* Fill in device structure with ethernet-generic values. */
1da177e4 LT	344	dev->flags \|= IFF_NOARP;
1da177e4 LT	345	dev->flags &= ~IFF_MULTICAST;
ff42c02c	346	dev->priv_flags \|= IFF_LIVE_ADDR_CHANGE \| IFF_NO_QUEUE;
8f3af277 ED	347	dev->features \|= NETIF_F_SG \| NETIF_F_FRAGLIST;
8f3af277 ED	348	dev->features \|= NETIF_F_ALL_TSO \| NETIF_F_UFO;
34324dc2	349	dev->features \|= NETIF_F_HW_CSUM \| NETIF_F_HIGHDMA \| NETIF_F_LLTX;
8f3af277 ED	350	dev->features \|= NETIF_F_GSO_ENCAP_ALL;
	351	dev->hw_features \|= dev->features;
	352	dev->hw_enc_features \|= dev->features;
7ce5d222	353	eth_hw_addr_random(dev);
25e3e84b ZS	354
	355	dev->min_mtu = 0;
	356	dev->max_mtu = ETH_MAX_MTU;
1da177e4	357	}
6d81f41c	358
0e06877c PM	359	static int dummy_validate(struct nlattr tb[], struct nlattr data[])
	360	{
	361	if (tb[IFLA_ADDRESS]) {
	362	if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
	363	return -EINVAL;
	364	if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
	365	return -EADDRNOTAVAIL;
	366	}
	367	return 0;
	368	}
	369
5d5cb173	370	static struct rtnl_link_ops dummy_link_ops __read_mostly = {
c19be735	371	.kind = DRV_NAME,
e1636836	372	.priv_size = sizeof(struct dummy_priv),
5d5cb173	373	.setup = dummy_setup,
0e06877c	374	.validate = dummy_validate,
5d5cb173 PM	375	};
5d5cb173 PM	376
1da177e4 LT	377	/* Number of dummy devices to be set up by this module. */
	378	module_param(numdummies, int, 0);
	379	MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");
	380
e1636836 PS	381	module_param(num_vfs, int, 0);
	382	MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");
	383
206c9fb2	384	static int __init dummy_init_one(void)
1da177e4 LT	385	{
	386	struct net_device *dev_dummy;
	387	int err;
	388
e1636836 PS	389	dev_dummy = alloc_netdev(sizeof(struct dummy_priv),
e1636836 PS	390	"dummy%d", NET_NAME_UNKNOWN, dummy_setup);
1da177e4 LT	391	if (!dev_dummy)
	392	return -ENOMEM;
	393
5d5cb173 PM	394	dev_dummy->rtnl_link_ops = &dummy_link_ops;
	395	err = register_netdevice(dev_dummy);
	396	if (err < 0)
	397	goto err;
5d5cb173	398	return 0;
206c9fb2	399
5d5cb173 PM	400	err:
	401	free_netdev(dev_dummy);
	402	return err;
6aa20a22	403	}
1da177e4 LT	404
1da177e4 LT	405	static int __init dummy_init_module(void)
6aa20a22	406	{
1da177e4	407	int i, err = 0;
206c9fb2	408
e1636836 PS	409	if (num_vfs) {
	410	err = bus_register(&dummy_bus);
	411	if (err < 0) {
	412	pr_err("registering dummy bus failed\n");
	413	return err;
	414	}
	415
	416	err = device_register(&dummy_parent);
	417	if (err < 0) {
	418	pr_err("registering dummy parent device failed\n");
	419	bus_unregister(&dummy_bus);
	420	return err;
	421	}
	422	}
	423
5d5cb173 PM	424	rtnl_lock();
5d5cb173 PM	425	err = __rtnl_link_register(&dummy_link_ops);
2c8a0189	426	if (err < 0)
2c8a0189	427	goto out;
5d5cb173	428
16b0dc29	429	for (i = 0; i < numdummies && !err; i++) {
206c9fb2	430	err = dummy_init_one();
16b0dc29 ED	431	cond_resched();
16b0dc29 ED	432	}
2d85cba2	433	if (err < 0)
5d5cb173	434	__rtnl_link_unregister(&dummy_link_ops);
2c8a0189	435
2c8a0189	436	out:
5d5cb173 PM	437	rtnl_unlock();
5d5cb173 PM	438
e1636836 PS	439	if (err && num_vfs) {
	440	device_unregister(&dummy_parent);
	441	bus_unregister(&dummy_bus);
	442	}
	443
1da177e4	444	return err;
6aa20a22	445	}
1da177e4 LT	446
	447	static void __exit dummy_cleanup_module(void)
	448	{
2d85cba2	449	rtnl_link_unregister(&dummy_link_ops);
e1636836 PS	450
	451	if (num_vfs) {
	452	device_unregister(&dummy_parent);
	453	bus_unregister(&dummy_bus);
	454	}
1da177e4 LT	455	}
	456
	457	module_init(dummy_init_module);
	458	module_exit(dummy_cleanup_module);
	459	MODULE_LICENSE("GPL");
c19be735	460	MODULE_ALIAS_RTNL_LINK(DRV_NAME);
6c702fab	461	MODULE_VERSION(DRV_VERSION);