[mirror_ubuntu-hirsute-kernel.git] / drivers / net / can / vcan.c

/*
 * vcan.c - Virtual CAN interface
 *
 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of Volkswagen nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * Alternatively, provided that this notice is retained in full, this
 * software may be distributed under the terms of the GNU General
 * Public License ("GPL") version 2, in which case the provisions of the
 * GPL apply INSTEAD OF those given above.
 *
 * The provided data structures and external interfaces from this code
 * are not restricted to be used by modules with a GPL compatible license.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * Send feedback to <socketcan-users@lists.berlios.de>
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/if_ether.h>
#include <linux/can.h>
#include <linux/can/dev.h>
#include <net/rtnetlink.h>

static __initdata const char banner[] =
	KERN_INFO "vcan: Virtual CAN interface driver\n";

MODULE_DESCRIPTION("virtual CAN interface");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");


/*
 * CAN test feature:
 * Enable the echo on driver level for testing the CAN core echo modes.
 * See Documentation/networking/can.txt for details.
 */

static int echo; /* echo testing. Default: 0 (Off) */
module_param(echo, bool, S_IRUGO);
MODULE_PARM_DESC(echo, "Echo sent frames (for testing). Default: 0 (Off)");


static void vcan_rx(struct sk_buff *skb, struct net_device *dev)
{
	struct can_frame *cf = (struct can_frame *)skb->data;
	struct net_device_stats *stats = &dev->stats;

	stats->rx_packets++;
	stats->rx_bytes += cf->can_dlc;

	skb->protocol  = htons(ETH_P_CAN);
	skb->pkt_type  = PACKET_BROADCAST;
	skb->dev       = dev;
	skb->ip_summed = CHECKSUM_UNNECESSARY;

	netif_rx_ni(skb);
}

static netdev_tx_t vcan_tx(struct sk_buff *skb, struct net_device *dev)
{
	struct can_frame *cf = (struct can_frame *)skb->data;
	struct net_device_stats *stats = &dev->stats;
	int loop;

	if (can_dropped_invalid_skb(dev, skb))
		return NETDEV_TX_OK;

	stats->tx_packets++;
	stats->tx_bytes += cf->can_dlc;

	/* set flag whether this packet has to be looped back */
	loop = skb->pkt_type == PACKET_LOOPBACK;

	if (!echo) {
		/* no echo handling available inside this driver */

		if (loop) {
			/*
			 * only count the packets here, because the
			 * CAN core already did the echo for us
			 */
			stats->rx_packets++;
			stats->rx_bytes += cf->can_dlc;
		}
		kfree_skb(skb);
		return NETDEV_TX_OK;
	}

	/* perform standard echo handling for CAN network interfaces */

	if (loop) {
		struct sock *srcsk = skb->sk;

		skb = skb_share_check(skb, GFP_ATOMIC);
		if (!skb)
			return NETDEV_TX_OK;

		/* receive with packet counting */
		skb->sk = srcsk;
		vcan_rx(skb, dev);
	} else {
		/* no looped packets => no counting */
		kfree_skb(skb);
	}
	return NETDEV_TX_OK;
}

static const struct net_device_ops vcan_netdev_ops = {
	.ndo_start_xmit = vcan_tx,
};

static void vcan_setup(struct net_device *dev)
{
	dev->type		= ARPHRD_CAN;
	dev->mtu		= sizeof(struct can_frame);
	dev->hard_header_len	= 0;
	dev->addr_len		= 0;
	dev->tx_queue_len	= 0;
	dev->flags		= IFF_NOARP;

	/* set flags according to driver capabilities */
	if (echo)
		dev->flags |= IFF_ECHO;

	dev->netdev_ops		= &vcan_netdev_ops;
	dev->destructor		= free_netdev;
}

static struct rtnl_link_ops vcan_link_ops __read_mostly = {
	.kind	= "vcan",
	.setup	= vcan_setup,
};

static __init int vcan_init_module(void)
{
	printk(banner);

	if (echo)
		printk(KERN_INFO "vcan: enabled echo on driver level.\n");

	return rtnl_link_register(&vcan_link_ops);
}

static __exit void vcan_cleanup_module(void)
{
	rtnl_link_unregister(&vcan_link_ops);
}

module_init(vcan_init_module);
module_exit(vcan_cleanup_module);
Commit	Line	Data
ccb29637 OH	1	/*
	2	* vcan.c - Virtual CAN interface
	3	*
	4	* Copyright (c) 2002-2007 Volkswagen Group Electronic Research
	5	* All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	* 1. Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions and the following disclaimer.
	12	* 2. Redistributions in binary form must reproduce the above copyright
	13	* notice, this list of conditions and the following disclaimer in the
	14	* documentation and/or other materials provided with the distribution.
	15	* 3. Neither the name of Volkswagen nor the names of its contributors
	16	* may be used to endorse or promote products derived from this software
	17	* without specific prior written permission.
	18	*
	19	* Alternatively, provided that this notice is retained in full, this
	20	* software may be distributed under the terms of the GNU General
	21	* Public License ("GPL") version 2, in which case the provisions of the
	22	* GPL apply INSTEAD OF those given above.
	23	*
	24	* The provided data structures and external interfaces from this code
	25	* are not restricted to be used by modules with a GPL compatible license.
	26	*
	27	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	28	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	29	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	30	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	31	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	32	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	33	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	34	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	35	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	36	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	37	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
	38	* DAMAGE.
	39	*
	40	* Send feedback to <socketcan-users@lists.berlios.de>
	41	*
	42	*/
	43
	44	#include <linux/module.h>
	45	#include <linux/init.h>
	46	#include <linux/netdevice.h>
	47	#include <linux/if_arp.h>
	48	#include <linux/if_ether.h>
	49	#include <linux/can.h>
3ccd4c61	50	#include <linux/can/dev.h>
ccb29637 OH	51	#include <net/rtnetlink.h>
	52
	53	static __initdata const char banner[] =
	54	KERN_INFO "vcan: Virtual CAN interface driver\n";
	55
	56	MODULE_DESCRIPTION("virtual CAN interface");
	57	MODULE_LICENSE("Dual BSD/GPL");
	58	MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
	59
	60
	61	/*
	62	* CAN test feature:
	63	* Enable the echo on driver level for testing the CAN core echo modes.
	64	* See Documentation/networking/can.txt for details.
	65	*/
	66
	67	static int echo; /* echo testing. Default: 0 (Off) */
	68	module_param(echo, bool, S_IRUGO);
	69	MODULE_PARM_DESC(echo, "Echo sent frames (for testing). Default: 0 (Off)");
	70
	71
	72	static void vcan_rx(struct sk_buff skb, struct net_device dev)
	73	{
3ccd4c61	74	struct can_frame cf = (struct can_frame )skb->data;
ccb29637 OH	75	struct net_device_stats *stats = &dev->stats;
	76
	77	stats->rx_packets++;
3ccd4c61	78	stats->rx_bytes += cf->can_dlc;
ccb29637 OH	79
	80	skb->protocol = htons(ETH_P_CAN);
	81	skb->pkt_type = PACKET_BROADCAST;
	82	skb->dev = dev;
	83	skb->ip_summed = CHECKSUM_UNNECESSARY;
	84
481a8199	85	netif_rx_ni(skb);
ccb29637 OH	86	}
ccb29637 OH	87
424efe9c	88	static netdev_tx_t vcan_tx(struct sk_buff skb, struct net_device dev)
ccb29637	89	{
3ccd4c61	90	struct can_frame cf = (struct can_frame )skb->data;
ccb29637 OH	91	struct net_device_stats *stats = &dev->stats;
	92	int loop;
	93
3ccd4c61 OH	94	if (can_dropped_invalid_skb(dev, skb))
	95	return NETDEV_TX_OK;
	96
ccb29637	97	stats->tx_packets++;
3ccd4c61	98	stats->tx_bytes += cf->can_dlc;
ccb29637 OH	99
	100	/* set flag whether this packet has to be looped back */
	101	loop = skb->pkt_type == PACKET_LOOPBACK;
	102
	103	if (!echo) {
	104	/* no echo handling available inside this driver */
	105
	106	if (loop) {
	107	/*
	108	* only count the packets here, because the
	109	* CAN core already did the echo for us
	110	*/
	111	stats->rx_packets++;
3ccd4c61	112	stats->rx_bytes += cf->can_dlc;
ccb29637 OH	113	}
	114	kfree_skb(skb);
	115	return NETDEV_TX_OK;
	116	}
	117
	118	/* perform standard echo handling for CAN network interfaces */
	119
	120	if (loop) {
	121	struct sock *srcsk = skb->sk;
	122
	123	skb = skb_share_check(skb, GFP_ATOMIC);
	124	if (!skb)
	125	return NETDEV_TX_OK;
	126
	127	/* receive with packet counting */
	128	skb->sk = srcsk;
	129	vcan_rx(skb, dev);
	130	} else {
	131	/* no looped packets => no counting */
	132	kfree_skb(skb);
	133	}
	134	return NETDEV_TX_OK;
	135	}
	136
5ad258c0 OH	137	static const struct net_device_ops vcan_netdev_ops = {
	138	.ndo_start_xmit = vcan_tx,
	139	};
	140
ccb29637 OH	141	static void vcan_setup(struct net_device *dev)
ccb29637 OH	142	{
fc10af8e OH	143	dev->type = ARPHRD_CAN;
	144	dev->mtu = sizeof(struct can_frame);
	145	dev->hard_header_len = 0;
	146	dev->addr_len = 0;
	147	dev->tx_queue_len = 0;
	148	dev->flags = IFF_NOARP;
ccb29637 OH	149
	150	/* set flags according to driver capabilities */
	151	if (echo)
	152	dev->flags \|= IFF_ECHO;
	153
fc10af8e OH	154	dev->netdev_ops = &vcan_netdev_ops;
fc10af8e OH	155	dev->destructor = free_netdev;
ccb29637 OH	156	}
	157
	158	static struct rtnl_link_ops vcan_link_ops __read_mostly = {
fc10af8e OH	159	.kind = "vcan",
fc10af8e OH	160	.setup = vcan_setup,
ccb29637 OH	161	};
	162
	163	static __init int vcan_init_module(void)
	164	{
	165	printk(banner);
	166
	167	if (echo)
	168	printk(KERN_INFO "vcan: enabled echo on driver level.\n");
	169
	170	return rtnl_link_register(&vcan_link_ops);
	171	}
	172
	173	static __exit void vcan_cleanup_module(void)
	174	{
	175	rtnl_link_unregister(&vcan_link_ops);
	176	}
	177
	178	module_init(vcan_init_module);
	179	module_exit(vcan_cleanup_module);