[GitHub/mt8127/android_kernel_alcatel_ttab.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 <linux/slab.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>
5a0e3ad6	51	#include <linux/slab.h>
ccb29637 OH	52	#include <net/rtnetlink.h>
	53
	54	static __initdata const char banner[] =
	55	KERN_INFO "vcan: Virtual CAN interface driver\n";
	56
	57	MODULE_DESCRIPTION("virtual CAN interface");
	58	MODULE_LICENSE("Dual BSD/GPL");
	59	MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>");
	60
	61
	62	/*
	63	* CAN test feature:
	64	* Enable the echo on driver level for testing the CAN core echo modes.
	65	* See Documentation/networking/can.txt for details.
	66	*/
	67
	68	static int echo; /* echo testing. Default: 0 (Off) */
	69	module_param(echo, bool, S_IRUGO);
	70	MODULE_PARM_DESC(echo, "Echo sent frames (for testing). Default: 0 (Off)");
	71
	72
	73	static void vcan_rx(struct sk_buff skb, struct net_device dev)
	74	{
3ccd4c61	75	struct can_frame cf = (struct can_frame )skb->data;
ccb29637 OH	76	struct net_device_stats *stats = &dev->stats;
	77
	78	stats->rx_packets++;
3ccd4c61	79	stats->rx_bytes += cf->can_dlc;
ccb29637 OH	80
	81	skb->protocol = htons(ETH_P_CAN);
	82	skb->pkt_type = PACKET_BROADCAST;
	83	skb->dev = dev;
	84	skb->ip_summed = CHECKSUM_UNNECESSARY;
	85
481a8199	86	netif_rx_ni(skb);
ccb29637 OH	87	}
ccb29637 OH	88
424efe9c	89	static netdev_tx_t vcan_tx(struct sk_buff skb, struct net_device dev)
ccb29637	90	{
3ccd4c61	91	struct can_frame cf = (struct can_frame )skb->data;
ccb29637 OH	92	struct net_device_stats *stats = &dev->stats;
	93	int loop;
	94
3ccd4c61 OH	95	if (can_dropped_invalid_skb(dev, skb))
	96	return NETDEV_TX_OK;
	97
ccb29637	98	stats->tx_packets++;
3ccd4c61	99	stats->tx_bytes += cf->can_dlc;
ccb29637 OH	100
	101	/* set flag whether this packet has to be looped back */
	102	loop = skb->pkt_type == PACKET_LOOPBACK;
	103
	104	if (!echo) {
	105	/* no echo handling available inside this driver */
	106
	107	if (loop) {
	108	/*
	109	* only count the packets here, because the
	110	* CAN core already did the echo for us
	111	*/
	112	stats->rx_packets++;
3ccd4c61	113	stats->rx_bytes += cf->can_dlc;
ccb29637 OH	114	}
	115	kfree_skb(skb);
	116	return NETDEV_TX_OK;
	117	}
	118
	119	/* perform standard echo handling for CAN network interfaces */
	120
	121	if (loop) {
	122	struct sock *srcsk = skb->sk;
	123
	124	skb = skb_share_check(skb, GFP_ATOMIC);
	125	if (!skb)
	126	return NETDEV_TX_OK;
	127
	128	/* receive with packet counting */
	129	skb->sk = srcsk;
	130	vcan_rx(skb, dev);
	131	} else {
	132	/* no looped packets => no counting */
	133	kfree_skb(skb);
	134	}
	135	return NETDEV_TX_OK;
	136	}
	137
5ad258c0 OH	138	static const struct net_device_ops vcan_netdev_ops = {
	139	.ndo_start_xmit = vcan_tx,
	140	};
	141
ccb29637 OH	142	static void vcan_setup(struct net_device *dev)
ccb29637 OH	143	{
fc10af8e OH	144	dev->type = ARPHRD_CAN;
	145	dev->mtu = sizeof(struct can_frame);
	146	dev->hard_header_len = 0;
	147	dev->addr_len = 0;
	148	dev->tx_queue_len = 0;
	149	dev->flags = IFF_NOARP;
ccb29637 OH	150
	151	/* set flags according to driver capabilities */
	152	if (echo)
	153	dev->flags \|= IFF_ECHO;
	154
fc10af8e OH	155	dev->netdev_ops = &vcan_netdev_ops;
fc10af8e OH	156	dev->destructor = free_netdev;
ccb29637 OH	157	}
	158
	159	static struct rtnl_link_ops vcan_link_ops __read_mostly = {
fc10af8e OH	160	.kind = "vcan",
fc10af8e OH	161	.setup = vcan_setup,
ccb29637 OH	162	};
	163
	164	static __init int vcan_init_module(void)
	165	{
	166	printk(banner);
	167
	168	if (echo)
	169	printk(KERN_INFO "vcan: enabled echo on driver level.\n");
	170
	171	return rtnl_link_register(&vcan_link_ops);
	172	}
	173
	174	static __exit void vcan_cleanup_module(void)
	175	{
	176	rtnl_link_unregister(&vcan_link_ops);
	177	}
	178
	179	module_init(vcan_init_module);
	180	module_exit(vcan_cleanup_module);