[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / bnep / netdev.c

/*
   BNEP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2001-2002 Inventel Systemes
   Written 2001-2002 by
	Clément Moreau <clement.moreau@inventel.fr>
	David Libault  <david.libault@inventel.fr>

   Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

#include <linux/etherdevice.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/l2cap.h>

#include "bnep.h"

#define BNEP_TX_QUEUE_LEN 20

static int bnep_net_open(struct net_device *dev)
{
	netif_start_queue(dev);
	return 0;
}

static int bnep_net_close(struct net_device *dev)
{
	netif_stop_queue(dev);
	return 0;
}

static void bnep_net_set_mc_list(struct net_device *dev)
{
#ifdef CONFIG_BT_BNEP_MC_FILTER
	struct bnep_session *s = netdev_priv(dev);
	struct sock *sk = s->sock->sk;
	struct bnep_set_filter_req *r;
	struct sk_buff *skb;
	int size;

	BT_DBG("%s mc_count %d", dev->name, netdev_mc_count(dev));

	size = sizeof(*r) + (BNEP_MAX_MULTICAST_FILTERS + 1) * ETH_ALEN * 2;
	skb  = alloc_skb(size, GFP_ATOMIC);
	if (!skb) {
		BT_ERR("%s Multicast list allocation failed", dev->name);
		return;
	}

	r = (void *) skb->data;
	__skb_put(skb, sizeof(*r));

	r->type = BNEP_CONTROL;
	r->ctrl = BNEP_FILTER_MULTI_ADDR_SET;

	if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
		u8 start[ETH_ALEN] = { 0x01 };

		/* Request all addresses */
		memcpy(__skb_put(skb, ETH_ALEN), start, ETH_ALEN);
		memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
		r->len = htons(ETH_ALEN * 2);
	} else {
		struct netdev_hw_addr *ha;
		int i, len = skb->len;

		if (dev->flags & IFF_BROADCAST) {
			memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
			memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
		}

		/* FIXME: We should group addresses here. */

		i = 0;
		netdev_for_each_mc_addr(ha, dev) {
			if (i == BNEP_MAX_MULTICAST_FILTERS)
				break;
			memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);
			memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);

			i++;
		}
		r->len = htons(skb->len - len);
	}

	skb_queue_tail(&sk->sk_write_queue, skb);
	wake_up_interruptible(sk_sleep(sk));
#endif
}

static int bnep_net_set_mac_addr(struct net_device *dev, void *arg)
{
	BT_DBG("%s", dev->name);
	return 0;
}

static void bnep_net_timeout(struct net_device *dev)
{
	BT_DBG("net_timeout");
	netif_wake_queue(dev);
}

#ifdef CONFIG_BT_BNEP_MC_FILTER
static int bnep_net_mc_filter(struct sk_buff *skb, struct bnep_session *s)
{
	struct ethhdr *eh = (void *) skb->data;

	if ((eh->h_dest[0] & 1) && !test_bit(bnep_mc_hash(eh->h_dest), (ulong *) &s->mc_filter))
		return 1;
	return 0;
}
#endif

#ifdef CONFIG_BT_BNEP_PROTO_FILTER
/* Determine ether protocol. Based on eth_type_trans. */
static u16 bnep_net_eth_proto(struct sk_buff *skb)
{
	struct ethhdr *eh = (void *) skb->data;
	u16 proto = ntohs(eh->h_proto);

	if (proto >= ETH_P_802_3_MIN)
		return proto;

	if (get_unaligned((__be16 *) skb->data) == htons(0xFFFF))
		return ETH_P_802_3;

	return ETH_P_802_2;
}

static int bnep_net_proto_filter(struct sk_buff *skb, struct bnep_session *s)
{
	u16 proto = bnep_net_eth_proto(skb);
	struct bnep_proto_filter *f = s->proto_filter;
	int i;

	for (i = 0; i < BNEP_MAX_PROTO_FILTERS && f[i].end; i++) {
		if (proto >= f[i].start && proto <= f[i].end)
			return 0;
	}

	BT_DBG("BNEP: filtered skb %p, proto 0x%.4x", skb, proto);
	return 1;
}
#endif

static netdev_tx_t bnep_net_xmit(struct sk_buff *skb,
				 struct net_device *dev)
{
	struct bnep_session *s = netdev_priv(dev);
	struct sock *sk = s->sock->sk;

	BT_DBG("skb %p, dev %p", skb, dev);

#ifdef CONFIG_BT_BNEP_MC_FILTER
	if (bnep_net_mc_filter(skb, s)) {
		kfree_skb(skb);
		return NETDEV_TX_OK;
	}
#endif

#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	if (bnep_net_proto_filter(skb, s)) {
		kfree_skb(skb);
		return NETDEV_TX_OK;
	}
#endif

	/*
	 * We cannot send L2CAP packets from here as we are potentially in a bh.
	 * So we have to queue them and wake up session thread which is sleeping
	 * on the sk_sleep(sk).
	 */
	dev->trans_start = jiffies;
	skb_queue_tail(&sk->sk_write_queue, skb);
	wake_up_interruptible(sk_sleep(sk));

	if (skb_queue_len(&sk->sk_write_queue) >= BNEP_TX_QUEUE_LEN) {
		BT_DBG("tx queue is full");

		/* Stop queuing.
		 * Session thread will do netif_wake_queue() */
		netif_stop_queue(dev);
	}

	return NETDEV_TX_OK;
}

static const struct net_device_ops bnep_netdev_ops = {
	.ndo_open            = bnep_net_open,
	.ndo_stop            = bnep_net_close,
	.ndo_start_xmit	     = bnep_net_xmit,
	.ndo_validate_addr   = eth_validate_addr,
	.ndo_set_rx_mode     = bnep_net_set_mc_list,
	.ndo_set_mac_address = bnep_net_set_mac_addr,
	.ndo_tx_timeout      = bnep_net_timeout,
	.ndo_change_mtu	     = eth_change_mtu,

};

void bnep_net_setup(struct net_device *dev)
{

	memset(dev->broadcast, 0xff, ETH_ALEN);
	dev->addr_len = ETH_ALEN;

	ether_setup(dev);
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
	dev->netdev_ops = &bnep_netdev_ops;

	dev->watchdog_timeo  = HZ * 2;
}
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	BNEP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2001-2002 Inventel Systemes
	4	Written 2001-2002 by
96de0e25	5	Clément Moreau <clement.moreau@inventel.fr>
1da177e4 LT	6	David Libault <david.libault@inventel.fr>
	7
	8	Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License version 2 as
	12	published by the Free Software Foundation;
	13
	14	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	15	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	17	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	18	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	19	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	20	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	21	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	22
8e87d142 YH	23	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	24	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	25	SOFTWARE IS DISCLAIMED.
	26	*/
	27
1da177e4	28	#include <linux/etherdevice.h>
1da177e4 LT	29
	30	#include <net/bluetooth/bluetooth.h>
	31	#include <net/bluetooth/hci_core.h>
	32	#include <net/bluetooth/l2cap.h>
	33
	34	#include "bnep.h"
	35
1da177e4 LT	36	#define BNEP_TX_QUEUE_LEN 20
	37
	38	static int bnep_net_open(struct net_device *dev)
	39	{
	40	netif_start_queue(dev);
	41	return 0;
	42	}
	43
	44	static int bnep_net_close(struct net_device *dev)
	45	{
	46	netif_stop_queue(dev);
	47	return 0;
	48	}
	49
1da177e4 LT	50	static void bnep_net_set_mc_list(struct net_device *dev)
	51	{
	52	#ifdef CONFIG_BT_BNEP_MC_FILTER
524ad0a7	53	struct bnep_session *s = netdev_priv(dev);
1da177e4 LT	54	struct sock *sk = s->sock->sk;
	55	struct bnep_set_filter_req *r;
	56	struct sk_buff *skb;
	57	int size;
	58
4cd24eaf	59	BT_DBG("%s mc_count %d", dev->name, netdev_mc_count(dev));
1da177e4 LT	60
	61	size = sizeof(r) + (BNEP_MAX_MULTICAST_FILTERS + 1) ETH_ALEN * 2;
	62	skb = alloc_skb(size, GFP_ATOMIC);
	63	if (!skb) {
	64	BT_ERR("%s Multicast list allocation failed", dev->name);
	65	return;
	66	}
	67
	68	r = (void *) skb->data;
	69	__skb_put(skb, sizeof(*r));
	70
	71	r->type = BNEP_CONTROL;
	72	r->ctrl = BNEP_FILTER_MULTI_ADDR_SET;
	73
8e87d142	74	if (dev->flags & (IFF_PROMISC \| IFF_ALLMULTI)) {
1da177e4 LT	75	u8 start[ETH_ALEN] = { 0x01 };
	76
	77	/* Request all addresses */
	78	memcpy(__skb_put(skb, ETH_ALEN), start, ETH_ALEN);
	79	memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
	80	r->len = htons(ETH_ALEN * 2);
	81	} else {
22bedad3	82	struct netdev_hw_addr *ha;
1da177e4 LT	83	int i, len = skb->len;
	84
	85	if (dev->flags & IFF_BROADCAST) {
	86	memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
	87	memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
8e87d142 YH	88	}
8e87d142 YH	89
1da177e4 LT	90	/* FIXME: We should group addresses here. */
1da177e4 LT	91
ff6e2163	92	i = 0;
22bedad3	93	netdev_for_each_mc_addr(ha, dev) {
ff6e2163 JP	94	if (i == BNEP_MAX_MULTICAST_FILTERS)
ff6e2163 JP	95	break;
22bedad3 JP	96	memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);
22bedad3 JP	97	memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN);
1a61a83f GP	98
1a61a83f GP	99	i++;
1da177e4 LT	100	}
	101	r->len = htons(skb->len - len);
	102	}
	103
	104	skb_queue_tail(&sk->sk_write_queue, skb);
aa395145	105	wake_up_interruptible(sk_sleep(sk));
1da177e4 LT	106	#endif
	107	}
	108
	109	static int bnep_net_set_mac_addr(struct net_device dev, void arg)
	110	{
	111	BT_DBG("%s", dev->name);
	112	return 0;
	113	}
	114
	115	static void bnep_net_timeout(struct net_device *dev)
	116	{
	117	BT_DBG("net_timeout");
	118	netif_wake_queue(dev);
	119	}
	120
1da177e4	121	#ifdef CONFIG_BT_BNEP_MC_FILTER
6039aa73	122	static int bnep_net_mc_filter(struct sk_buff skb, struct bnep_session s)
1da177e4 LT	123	{
	124	struct ethhdr eh = (void ) skb->data;
	125
	126	if ((eh->h_dest[0] & 1) && !test_bit(bnep_mc_hash(eh->h_dest), (ulong *) &s->mc_filter))
	127	return 1;
	128	return 0;
	129	}
	130	#endif
	131
	132	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	133	/* Determine ether protocol. Based on eth_type_trans. */
6039aa73	134	static u16 bnep_net_eth_proto(struct sk_buff *skb)
1da177e4 LT	135	{
1da177e4 LT	136	struct ethhdr eh = (void ) skb->data;
e41d2169	137	u16 proto = ntohs(eh->h_proto);
8e87d142	138
e5c5d22e	139	if (proto >= ETH_P_802_3_MIN)
e41d2169	140	return proto;
8e87d142	141
e41d2169 AV	142	if (get_unaligned((__be16 *) skb->data) == htons(0xFFFF))
e41d2169 AV	143	return ETH_P_802_3;
8e87d142	144
e41d2169	145	return ETH_P_802_2;
1da177e4 LT	146	}
1da177e4 LT	147
6039aa73	148	static int bnep_net_proto_filter(struct sk_buff skb, struct bnep_session s)
1da177e4 LT	149	{
	150	u16 proto = bnep_net_eth_proto(skb);
	151	struct bnep_proto_filter *f = s->proto_filter;
	152	int i;
8e87d142	153
1da177e4 LT	154	for (i = 0; i < BNEP_MAX_PROTO_FILTERS && f[i].end; i++) {
	155	if (proto >= f[i].start && proto <= f[i].end)
	156	return 0;
	157	}
	158
	159	BT_DBG("BNEP: filtered skb %p, proto 0x%.4x", skb, proto);
	160	return 1;
	161	}
	162	#endif
	163
6fef4c0c SH	164	static netdev_tx_t bnep_net_xmit(struct sk_buff *skb,
6fef4c0c SH	165	struct net_device *dev)
1da177e4	166	{
524ad0a7	167	struct bnep_session *s = netdev_priv(dev);
1da177e4 LT	168	struct sock *sk = s->sock->sk;
	169
	170	BT_DBG("skb %p, dev %p", skb, dev);
	171
	172	#ifdef CONFIG_BT_BNEP_MC_FILTER
	173	if (bnep_net_mc_filter(skb, s)) {
	174	kfree_skb(skb);
6ed10654	175	return NETDEV_TX_OK;
1da177e4 LT	176	}
1da177e4 LT	177	#endif
8e87d142	178
1da177e4 LT	179	#ifdef CONFIG_BT_BNEP_PROTO_FILTER
	180	if (bnep_net_proto_filter(skb, s)) {
	181	kfree_skb(skb);
6ed10654	182	return NETDEV_TX_OK;
1da177e4 LT	183	}
1da177e4 LT	184	#endif
8e87d142	185
1da177e4 LT	186	/*
	187	* We cannot send L2CAP packets from here as we are potentially in a bh.
	188	* So we have to queue them and wake up session thread which is sleeping
aa395145	189	* on the sk_sleep(sk).
1da177e4 LT	190	*/
	191	dev->trans_start = jiffies;
	192	skb_queue_tail(&sk->sk_write_queue, skb);
aa395145	193	wake_up_interruptible(sk_sleep(sk));
1da177e4 LT	194
	195	if (skb_queue_len(&sk->sk_write_queue) >= BNEP_TX_QUEUE_LEN) {
	196	BT_DBG("tx queue is full");
	197
	198	/* Stop queuing.
	199	* Session thread will do netif_wake_queue() */
	200	netif_stop_queue(dev);
	201	}
	202
6ed10654	203	return NETDEV_TX_OK;
1da177e4 LT	204	}
1da177e4 LT	205
b4d7f0a4 SH	206	static const struct net_device_ops bnep_netdev_ops = {
	207	.ndo_open = bnep_net_open,
	208	.ndo_stop = bnep_net_close,
	209	.ndo_start_xmit = bnep_net_xmit,
	210	.ndo_validate_addr = eth_validate_addr,
afc4b13d	211	.ndo_set_rx_mode = bnep_net_set_mc_list,
b4d7f0a4 SH	212	.ndo_set_mac_address = bnep_net_set_mac_addr,
	213	.ndo_tx_timeout = bnep_net_timeout,
	214	.ndo_change_mtu = eth_change_mtu,
	215
	216	};
	217
1da177e4 LT	218	void bnep_net_setup(struct net_device *dev)
	219	{
	220
	221	memset(dev->broadcast, 0xff, ETH_ALEN);
	222	dev->addr_len = ETH_ALEN;
	223
	224	ether_setup(dev);
550fd08c	225	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
b4d7f0a4	226	dev->netdev_ops = &bnep_netdev_ops;
1da177e4 LT	227
1da177e4 LT	228	dev->watchdog_timeo = HZ * 2;
1da177e4	229	}