Re: [PATCH v7 4/5] Bluetooth: Enable 6LoWPAN support for BT LE devices

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi Jukka,

you might want to add a bit of commit message here.

> Signed-off-by: Jukka Rissanen <jukka.rissanen@xxxxxxxxxxxxxxx>
> ---
> include/net/bluetooth/hci.h      |   1 +
> include/net/bluetooth/hci_core.h |   1 +
> include/net/bluetooth/l2cap.h    |   1 +
> net/bluetooth/6lowpan.c          | 881 +++++++++++++++++++++++++++++++++++++++
> net/bluetooth/6lowpan.h          |  26 ++
> net/bluetooth/Makefile           |   6 +-
> net/bluetooth/hci_event.c        |   3 +
> net/bluetooth/l2cap_core.c       |  14 +-
> 8 files changed, 931 insertions(+), 2 deletions(-)
> create mode 100644 net/bluetooth/6lowpan.c
> create mode 100644 net/bluetooth/6lowpan.h
> 
> diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
> index cc2da73..5dc3d90 100644
> --- a/include/net/bluetooth/hci.h
> +++ b/include/net/bluetooth/hci.h
> @@ -131,6 +131,7 @@ enum {
> 	HCI_PERIODIC_INQ,
> 	HCI_FAST_CONNECTABLE,
> 	HCI_BREDR_ENABLED,
> +	HCI_6LOWPAN_ENABLED,
> };
> 
> /* A mask for the flags that are supposed to remain when a reset happens
> diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
> index b796161..f2f0cf5 100644
> --- a/include/net/bluetooth/hci_core.h
> +++ b/include/net/bluetooth/hci_core.h
> @@ -448,6 +448,7 @@ enum {
> 	HCI_CONN_SSP_ENABLED,
> 	HCI_CONN_POWER_SAVE,
> 	HCI_CONN_REMOTE_OOB,
> +	HCI_CONN_6LOWPAN,
> };
> 
> static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
> diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h
> index e149e99..dbc4a89 100644
> --- a/include/net/bluetooth/l2cap.h
> +++ b/include/net/bluetooth/l2cap.h
> @@ -136,6 +136,7 @@ struct l2cap_conninfo {
> #define L2CAP_FC_L2CAP		0x02
> #define L2CAP_FC_CONNLESS	0x04
> #define L2CAP_FC_A2MP		0x08
> +#define L2CAP_FC_6LOWPAN        0x3e /* reserved and temporary value */
> 
> /* L2CAP Control Field bit masks */
> #define L2CAP_CTRL_SAR			0xC000
> diff --git a/net/bluetooth/6lowpan.c b/net/bluetooth/6lowpan.c
> new file mode 100644
> index 0000000..5b6966a
> --- /dev/null
> +++ b/net/bluetooth/6lowpan.c
> @@ -0,0 +1,881 @@
> +/*
> +   Copyright (c) 2013 Intel Corp.
> +
> +   This program is free software; you can redistribute it and/or modify
> +   it under the terms of the GNU General Public License version 2 and
> +   only version 2 as published by the Free Software Foundation.
> +
> +   This program is distributed in the hope that 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.
> +*/
> +
> +#include <linux/version.h>
> +#include <linux/if_arp.h>
> +#include <linux/netdevice.h>
> +#include <linux/etherdevice.h>
> +
> +#include <net/ipv6.h>
> +#include <net/ip6_route.h>
> +#include <net/addrconf.h>
> +
> +#include <net/af_ieee802154.h> /* to get the address type */

Is this still needed? What address type is it that we need?

> +
> +#include <net/bluetooth/bluetooth.h>
> +#include <net/bluetooth/hci_core.h>
> +#include <net/bluetooth/l2cap.h>
> +
> +#include "../ieee802154/6lowpan.h" /* for the compression support */
> +
> +#define IFACE_NAME_TEMPLATE "bt%d"
> +#define EUI64_ADDR_LEN 8
> +
> +struct skb_cb {
> +	struct in6_addr addr;
> +	struct l2cap_conn *conn;
> +};
> +#define lowpan_cb(skb) ((struct skb_cb *)((skb)->cb))
> +
> +/*
> + * The devices list contains those devices that we are acting
> + * as a proxy. The BT 6LoWPAN device is a virtual device that
> + * connects to the Bluetooth LE device. The real connection to
> + * BT device is done via l2cap layer. There exists one
> + * virtual device / one BT 6LoWPAN network (=hciX device).
> + * The list contains struct lowpan_dev elements.
> + */
> +static LIST_HEAD(bt_6lowpan_devices);
> +static DEFINE_RWLOCK(devices_lock);
> +
> +struct lowpan_dev {
> +	struct net_device *dev;
> +	struct work_struct delete_netdev;
> +	struct list_head list;
> +};
> +
> +struct lowpan_peer {
> +	struct list_head list;
> +	struct l2cap_conn *conn;
> +
> +	/* peer addresses in various formats */
> +	unsigned char eui64_addr[EUI64_ADDR_LEN];
> +	struct in6_addr peer_addr;
> +};
> +
> +struct lowpan_info {
> +	struct net_device *net;
> +	struct list_head peers;
> +	atomic_t peer_count; /* number of items in peers list */
> +
> +	struct delayed_work notify_peers;
> +};
> +
> +static inline struct lowpan_info *lowpan_info(const struct net_device *dev)
> +{
> +	return netdev_priv(dev);
> +}
> +
> +static inline void peer_add(struct lowpan_info *info, struct lowpan_peer *peer)
> +{
> +	list_add(&peer->list, &info->peers);
> +	atomic_inc(&info->peer_count);
> +}
> +
> +static inline bool peer_del(struct lowpan_info *info, struct lowpan_peer *peer)
> +{
> +	list_del(&peer->list);

I would add an extra empty line here.

> +	if (atomic_dec_and_test(&info->peer_count)) {
> +		BT_DBG("last peer");
> +		return true;
> +	}
> +
> +	return false;
> +}
> +
> +static inline struct lowpan_peer *peer_lookup_ba(struct lowpan_info *info,
> +						 bdaddr_t *ba, __u8 type)
> +{
> +	struct lowpan_peer *peer, *tmp;
> +
> +	BT_DBG("peers %d addr %pMR type %d", atomic_read(&info->peer_count),
> +					     ba, type);
> +
> +	list_for_each_entry_safe(peer, tmp, &info->peers, list) {
> +		BT_DBG("addr %pMR type %d",
> +			&peer->conn->hcon->dst, peer->conn->hcon->dst_type);
> +
> +		if (!bacmp(&peer->conn->hcon->dst, ba))
> +			return peer;
> +	}
> +
> +	return NULL;
> +}
> +
> +static inline struct lowpan_peer *peer_lookup_conn(struct lowpan_info *info,
> +						   struct l2cap_conn *conn)
> +{
> +	struct lowpan_peer *peer, *tmp;
> +
> +	list_for_each_entry_safe(peer, tmp, &info->peers, list) {
> +		if (peer->conn == conn)
> +			return peer;
> +	}
> +
> +	return NULL;
> +}
> +
> +static struct lowpan_peer *lookup_peer(struct l2cap_conn *conn,
> +				       struct lowpan_info **dev)
> +{
> +	struct lowpan_dev *entry, *tmp;
> +	struct lowpan_peer *peer = NULL;
> +	unsigned long flags;
> +
> +	read_lock_irqsave(&devices_lock, flags);
> +
> +	list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
> +		struct lowpan_info *info = lowpan_info(entry->dev);
> +
> +		peer = peer_lookup_conn(info, conn);
> +		if (peer) {
> +			if (dev)
> +				*dev = info;
> +			break;
> +		}
> +	}
> +
> +	read_unlock_irqrestore(&devices_lock, flags);
> +
> +	return peer;
> +}
> +
> +/* print data in line */
> +static inline void raw_dump_inline(const char *caller, char *msg,
> +				   unsigned char *buf, int len)
> +{
> +	if (msg)
> +		pr_debug("%s():%s: ", caller, msg);
> +	print_hex_dump_debug("", DUMP_PREFIX_NONE,
> +		       16, 1, buf, len, false);
> +}
> +
> +/*
> + * print data in a table format:
> + *
> + * addr: xx xx xx xx xx xx
> + * addr: xx xx xx xx xx xx
> + * ...
> + */
> +static inline void raw_dump_table(const char *caller, char *msg,
> +				  unsigned char *buf, int len)
> +{
> +	if (msg)
> +		pr_debug("%s():%s:\n", caller, msg);
> +	print_hex_dump_debug("\t", DUMP_PREFIX_OFFSET,
> +		       16, 1, buf, len, false);
> +}
> +
> +static int give_skb_to_upper(struct sk_buff *skb, struct net_device *dev)
> +{
> +	struct sk_buff *skb_cp;
> +	int ret = NET_RX_SUCCESS;
> +
> +	skb_cp = skb_copy(skb, GFP_ATOMIC);
> +	if (!skb_cp) {
> +		ret = -ENOMEM;

And reason we are not just doing this:

		return -ENOMEM;

> +	} else {
> +		ret = netif_rx(skb_cp);
> +
> +		BT_DBG("receive skb %d", ret);
> +		if (ret < 0)
> +			ret = NET_RX_DROP;
> +	}
> +
> +	return ret;
> +}
> +
> +static int process_data(struct sk_buff *skb, struct net_device *dev,
> +			struct l2cap_conn *conn)
> +{
> +	const u8 *saddr, *daddr;
> +	u8 iphc0, iphc1;
> +	struct lowpan_info *info;
> +	struct lowpan_peer *peer;
> +	unsigned long flags;
> +
> +	info = lowpan_info(dev);
> +
> +	read_lock_irqsave(&devices_lock, flags);
> +	peer = peer_lookup_conn(info, conn);
> +	read_unlock_irqrestore(&devices_lock, flags);
> +	if (!peer)
> +		return -EINVAL;
> +
> +	saddr = peer->eui64_addr;
> +	daddr = info->net->dev_addr;
> +
> +	/* at least two bytes will be used for the encoding */
> +	if (skb->len < 2)
> +		goto drop;
> +
> +	if (lowpan_fetch_skb_u8(skb, &iphc0))
> +		goto drop;
> +
> +	if (lowpan_fetch_skb_u8(skb, &iphc1))
> +		goto drop;
> +
> +	return lowpan_process_data(skb, dev,
> +				saddr, IEEE802154_ADDR_LONG, EUI64_ADDR_LEN,
> +				daddr, IEEE802154_ADDR_LONG, EUI64_ADDR_LEN,
> +				iphc0, iphc1, give_skb_to_upper);
> +
> +drop:
> +	kfree_skb(skb);
> +	return -EINVAL;
> +}
> +
> +static int recv_pkt(struct sk_buff *skb, struct net_device *dev,
> +		    struct l2cap_conn *conn)
> +{
> +	struct sk_buff *local_skb;
> +
> +	if (!netif_running(dev))
> +		goto drop;
> +
> +	if (dev->type != ARPHRD_6LOWPAN)
> +		goto drop;
> +
> +	/* check that it's our buffer */
> +	if (skb->data[0] == LOWPAN_DISPATCH_IPV6) {
> +		/* Copy the packet so that the IPv6 header is
> +		 * properly aligned.
> +		 */
> +		local_skb = skb_copy_expand(skb, NET_SKB_PAD - 1,
> +					    skb_tailroom(skb), GFP_ATOMIC);
> +		if (!local_skb)
> +			goto drop;
> +
> +		local_skb->protocol = htons(ETH_P_IPV6);
> +		local_skb->pkt_type = PACKET_HOST;
> +
> +		skb_reset_network_header(local_skb);
> +		skb_set_transport_header(local_skb, sizeof(struct ipv6hdr));
> +
> +		if (give_skb_to_upper(local_skb, dev) != NET_RX_SUCCESS) {
> +			kfree_skb(local_skb);
> +			goto drop;
> +		}
> +
> +		dev->stats.rx_bytes += skb->len;
> +		dev->stats.rx_packets++;
> +
> +		kfree_skb(local_skb);
> +		kfree_skb(skb);
> +	} else {
> +		switch (skb->data[0] & 0xe0) {
> +		case LOWPAN_DISPATCH_IPHC:	/* ipv6 datagram */
> +			local_skb = skb_clone(skb, GFP_ATOMIC);
> +			if (!local_skb)
> +				goto drop;
> +			if (process_data(local_skb, dev, conn)
> +							!= NET_RX_SUCCESS)
> +				goto drop;
> +
> +			dev->stats.rx_bytes += skb->len;
> +			dev->stats.rx_packets++;
> +
> +			kfree_skb(skb);
> +			break;
> +		default:
> +			break;
> +		}
> +	}
> +
> +	return NET_RX_SUCCESS;
> +
> +drop:
> +	kfree_skb(skb);
> +	return NET_RX_DROP;
> +}
> +
> +/* Packet from BT LE device */
> +int bt_6lowpan_recv(struct l2cap_conn *conn, struct sk_buff *skb)
> +{
> +	struct lowpan_info *info = NULL;
> +	struct lowpan_peer *peer;
> +	int err;
> +
> +	peer = lookup_peer(conn, &info);
> +	if (!peer)
> +		return -ENOENT;
> +
> +	if (info->net) {
> +		err = recv_pkt(skb, info->net, conn);
> +		BT_DBG("recv pkt %d", err);
> +	} else {
> +		err = -ENOENT;
> +	}

I would just do this:

	if (!info->net)
		return -ENOENT;

> +
> +	return err;
> +}
> +
> +static void do_send(struct l2cap_conn *conn, struct sk_buff *skb)
> +{
> +	BT_DBG("conn %p, skb %p len %d priority %u", conn, skb, skb->len,
> +	       skb->priority);
> +
> +	hci_send_acl(conn->hchan, skb, ACL_START);
> +}
> +
> +static inline int skbuff_copy(void *msg, int len, int count, int mtu,
> +			      struct sk_buff *skb, struct net_device *dev)
> +{
> +	struct sk_buff **frag;
> +	int sent = 0;
> +
> +	memcpy(skb_put(skb, count), msg, count);
> +
> +	sent += count;
> +	msg  += count;
> +	len  -= count;
> +
> +	dev->stats.tx_bytes += count;
> +	dev->stats.tx_packets++;
> +
> +	raw_dump_table(__func__, "Sending", skb->data, skb->len);
> +
> +	/* Continuation fragments (no L2CAP header) */
> +	frag = &skb_shinfo(skb)->frag_list;
> +	while (len > 0) {
> +		struct sk_buff *tmp;
> +
> +		count = min_t(unsigned int, mtu, len);
> +
> +		tmp = bt_skb_alloc(count, GFP_ATOMIC);
> +		if (IS_ERR(tmp))
> +			return PTR_ERR(tmp);
> +
> +		*frag = tmp;
> +
> +		memcpy(skb_put(*frag, count), msg, count);
> +
> +		raw_dump_table(__func__, "Sending fragment",
> +					(*frag)->data, count);
> +
> +		(*frag)->priority = skb->priority;
> +
> +		sent += count;
> +		msg  += count;
> +		len  -= count;
> +
> +		skb->len += (*frag)->len;
> +		skb->data_len += (*frag)->len;
> +
> +		frag = &(*frag)->next;
> +
> +		dev->stats.tx_bytes += count;
> +		dev->stats.tx_packets++;
> +	}
> +
> +	return sent;
> +}
> +
> +static struct sk_buff *create_pdu(struct l2cap_conn *conn, void *msg,
> +				  size_t len, u32 priority,
> +				  struct net_device *dev)
> +{
> +	struct sk_buff *skb;
> +	int err, count;
> +	struct l2cap_hdr *lh;
> +
> +	if (conn->mtu > (L2CAP_LE_MIN_MTU + L2CAP_HDR_SIZE))
> +		/* XXX: This should be not needed and atm is only used for
> +		 * testing purposes */
> +		conn->mtu = L2CAP_LE_MIN_MTU + L2CAP_HDR_SIZE;

The comment should go above the if itself.

> +
> +	count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len);
> +
> +	BT_DBG("conn %p len %zu mtu %d count %d", conn, len, conn->mtu, count);
> +
> +	skb = bt_skb_alloc(count + L2CAP_HDR_SIZE, GFP_ATOMIC);
> +	if (IS_ERR(skb))
> +		return skb;
> +
> +	skb->priority = priority;
> +
> +	lh = (struct l2cap_hdr *)skb_put(skb, L2CAP_HDR_SIZE);
> +	lh->cid = cpu_to_le16(L2CAP_FC_6LOWPAN);
> +	lh->len = cpu_to_le16(len);
> +
> +	err = skbuff_copy(msg, len, count, conn->mtu, skb, dev);
> +	if (unlikely(err < 0)) {
> +		kfree_skb(skb);
> +		BT_DBG("skbuff copy %d failed", err);
> +		return ERR_PTR(err);
> +	}
> +
> +	return skb;
> +}
> +
> +static int conn_send(struct l2cap_conn *conn,
> +		     void *msg, size_t len, u32 priority,
> +		     struct net_device *dev)
> +{
> +	struct sk_buff *skb;
> +
> +	skb = create_pdu(conn, msg, len, priority, dev);
> +	if (IS_ERR(skb))
> +		return -EINVAL;
> +
> +	do_send(conn, skb);
> +	return 0;
> +}
> +
> +static void get_dest_bdaddr(struct in6_addr *ip6_daddr,
> +			    bdaddr_t *addr, u8 *addr_type)
> +{
> +	u8 *eui64;
> +
> +	eui64 = ip6_daddr->s6_addr + 8;
> +
> +	addr->b[0] = eui64[7];
> +	addr->b[1] = eui64[6];
> +	addr->b[2] = eui64[5];
> +	addr->b[3] = eui64[2];
> +	addr->b[4] = eui64[1];
> +	addr->b[5] = eui64[0];
> +
> +	addr->b[5] ^= 2;
> +
> +	/* Set universal/local bit to 0 */
> +	if (addr->b[5] & 1) {
> +		addr->b[5] &= ~1;
> +		*addr_type = BDADDR_LE_PUBLIC;
> +	} else
> +		*addr_type = BDADDR_LE_RANDOM;
> +}
> +
> +static int header_create(struct sk_buff *skb, struct net_device *dev,
> +		         unsigned short type, const void *_daddr,
> +		         const void *_saddr, unsigned int len)
> +{
> +	struct ipv6hdr *hdr;
> +	struct lowpan_info *info;
> +	struct lowpan_peer *peer;
> +	bdaddr_t addr, *any = BDADDR_ANY;
> +	u8 *saddr, *daddr = any->b;
> +	u8 addr_type;
> +
> +	if (type != ETH_P_IPV6)
> +		return -EINVAL;
> +
> +	hdr = ipv6_hdr(skb);
> +
> +	info = lowpan_info(dev);
> +
> +	if (ipv6_addr_is_multicast(&hdr->daddr)) {
> +		memcpy(&lowpan_cb(skb)->addr, &hdr->daddr,
> +		       sizeof(struct in6_addr));
> +		lowpan_cb(skb)->conn = NULL;
> +	} else {
> +		unsigned long flags;
> +
> +		/*
> +		 * Get destination BT device from skb.
> +		 * If there is no such peer then discard the packet.
> +		 */
> +		get_dest_bdaddr(&hdr->daddr, &addr, &addr_type);
> +
> +		BT_DBG("dest addr %pMR type %d", &addr, addr_type);
> +
> +		read_lock_irqsave(&devices_lock, flags);
> +		peer = peer_lookup_ba(info, &addr, addr_type);
> +		read_unlock_irqrestore(&devices_lock, flags);
> +
> +		if (!peer) {
> +			BT_DBG("no such peer %pMR found", &addr);
> +			return -ENOENT;
> +		}
> +
> +		daddr = peer->eui64_addr;
> +
> +		memcpy(&lowpan_cb(skb)->addr, &hdr->daddr,
> +						sizeof(struct in6_addr));
> +		lowpan_cb(skb)->conn = peer->conn;
> +	}
> +
> +	saddr = info->net->dev_addr;
> +
> +	return lowpan_header_compress(skb, dev, type, daddr, saddr, len);
> +}
> +
> +/* Packet to BT LE device */
> +static int send_pkt(struct l2cap_conn *conn, const void *saddr,
> +		    const void *daddr, struct sk_buff *skb,
> +		    struct net_device *dev)
> +{
> +	raw_dump_table(__func__, "raw skb data dump before fragmentation",
> +				skb->data, skb->len);
> +
> +	return conn_send(conn, skb->data, skb->len, 0, dev);
> +}
> +
> +static int send_mcast_pkt(struct sk_buff *skb, struct net_device *dev)
> +{
> +	struct sk_buff *local_skb;
> +	struct lowpan_dev *entry, *tmp;
> +	int err = 0;
> +	unsigned long flags;
> +
> +	read_lock_irqsave(&devices_lock, flags);
> +
> +	list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
> +		struct lowpan_peer *pentry, *ptmp;
> +		struct lowpan_info *info;
> +
> +		if (entry->dev != dev)
> +			continue;
> +
> +		info = lowpan_info(entry->dev);
> +
> +		list_for_each_entry_safe(pentry, ptmp, &info->peers, list) {
> +			local_skb = skb_clone(skb, GFP_ATOMIC);
> +
> +			err = send_pkt(pentry->conn, dev->dev_addr,
> +				       pentry->eui64_addr,
> +				       local_skb, dev);
> +
> +			kfree_skb(local_skb);
> +		}
> +	}
> +
> +	read_unlock_irqrestore(&devices_lock, flags);
> +
> +	return err;
> +}
> +
> +static netdev_tx_t bt_xmit(struct sk_buff *skb, struct net_device *dev)
> +{
> +	int err = -ENOENT;
> +	unsigned char *eui64_addr;
> +	struct lowpan_info *info;
> +	struct lowpan_peer *peer;
> +	bdaddr_t addr;
> +	u8 addr_type;
> +
> +	if (ipv6_addr_is_multicast(&lowpan_cb(skb)->addr)) {
> +		/*
> +		 * We need to send the packet to every device
> +		 * behind this interface.
> +		 */
> +		err = send_mcast_pkt(skb, dev);
> +	} else {
> +		unsigned long flags;
> +
> +		get_dest_bdaddr(&lowpan_cb(skb)->addr, &addr, &addr_type);
> +		eui64_addr = lowpan_cb(skb)->addr.s6_addr + 8;
> +		info = lowpan_info(dev);
> +
> +		read_lock_irqsave(&devices_lock, flags);
> +		peer = peer_lookup_ba(info, &addr, addr_type);
> +		read_unlock_irqrestore(&devices_lock, flags);
> +
> +		BT_DBG("xmit from %s to %pMR (%pI6c), peer %p", dev->name,
> +			&addr, &lowpan_cb(skb)->addr, peer);
> +
> +		if (peer && peer->conn)
> +			err = send_pkt(peer->conn, dev->dev_addr, eui64_addr,
> +					skb, dev);
> +	}
> +	dev_kfree_skb(skb);
> +
> +	if (err)
> +		BT_DBG("ERROR: xmit failed (%d)", err);
> +
> +	return (err < 0) ? NET_XMIT_DROP : err;
> +}
> +
> +static const struct net_device_ops netdev_ops = {
> +	.ndo_start_xmit		= bt_xmit,
> +};
> +
> +static struct header_ops header_ops = {
> +	.create	= header_create,
> +};
> +
> +static void netdev_setup(struct net_device *dev)
> +{
> +	dev->addr_len		= EUI64_ADDR_LEN;
> +	dev->type		= ARPHRD_6LOWPAN;
> +
> +	dev->hard_header_len	= 0;
> +	dev->needed_tailroom	= 0;
> +	dev->mtu		= IPV6_MIN_MTU;
> +	dev->tx_queue_len	= 0;
> +	dev->flags		= IFF_RUNNING | IFF_POINTOPOINT;
> +	dev->watchdog_timeo	= 0;
> +
> +	dev->netdev_ops		= &netdev_ops;
> +	dev->header_ops		= &header_ops;
> +	dev->destructor		= free_netdev;
> +}
> +
> +static struct device_type bt_type = {
> +	.name	= "bluetooth",
> +};
> +
> +static void set_addr(u8 *eui, u8 *addr, u8 addr_type)
> +{
> +	/* addr is the BT address in little-endian format */
> +	eui[0] = addr[5];
> +	eui[1] = addr[4];
> +	eui[2] = addr[3];
> +	eui[3] = 0xFF;
> +	eui[4] = 0xFE;
> +	eui[5] = addr[2];
> +	eui[6] = addr[1];
> +	eui[7] = addr[0];
> +
> +	eui[0] ^= 2;
> +
> +	/*
> +	 * Universal/local bit set, RFC 4291
> +	 */

Single line comment here.

> +	if (addr_type == BDADDR_LE_PUBLIC)
> +		eui[0] |= 1;
> +	else
> +		eui[0] &= ~1;
> +}
> +
> +static void set_dev_addr(struct net_device *net, bdaddr_t *addr,
> +		         u8 addr_type)
> +{
> +	net->addr_assign_type = NET_ADDR_PERM;
> +	set_addr(net->dev_addr, addr->b, addr_type);
> +	net->dev_addr[0] ^= 2;
> +}

If you use set_addr only here, consider putting it directly into set_dev_addr.

> +
> +static void ifup(struct net_device *net)
> +{
> +	int err;
> +
> +	rtnl_lock();
> +	err = dev_open(net);
> +	if (err < 0)
> +		BT_INFO("iface %s cannot be opened (%d)", net->name, err);
> +	rtnl_unlock();
> +}
> +
> +static void do_notify_peers(struct work_struct *work)
> +{
> +	struct lowpan_info *info = container_of(work, struct lowpan_info,
> +						notify_peers.work);
> +
> +	netdev_notify_peers(info->net); /* send neighbour adv at startup */
> +}
> +
> +static bool is_bt_6lowpan(struct hci_conn *hcon)
> +{
> +	if (hcon->type == LE_LINK && test_bit(HCI_CONN_6LOWPAN, &hcon->flags))
> +		return true;
> +
> +	return false;

	if (hcon->type != LE_LINK)
		return false;

	return test_bit(HCI_CONN_6LOWPAN, &hcon->flags);

> +}
> +
> +/*
> + * This gets called when BT LE 6LoWPAN device is connected. We then
> + * create network device that acts as a proxy between BT LE device
> + * and kernel network stack.
> + */
> +int bt_6lowpan_add_conn(struct l2cap_conn *conn)
> +{
> +	struct lowpan_info *dev = NULL;
> +	struct lowpan_peer *peer = NULL;
> +	struct net_device *net;
> +	struct lowpan_dev *entry;
> +	int err = 0;
> +	unsigned long flags;
> +
> +	if (!is_bt_6lowpan(conn->hcon))
> +		return 0;
> +
> +	peer = lookup_peer(conn, &dev);
> +	if (peer)
> +		return -EEXIST;
> +
> +	if (dev && !peer)
> +		goto add_peer;
> +
> +	net = alloc_netdev(sizeof(struct lowpan_info), IFACE_NAME_TEMPLATE,
> +		           netdev_setup);
> +	if (!net)
> +		return -ENOMEM;
> +
> +	dev = netdev_priv(net);
> +	dev->net = net;
> +	INIT_LIST_HEAD(&dev->peers);
> +
> +	set_dev_addr(net, &conn->hcon->src, conn->hcon->src_type);
> +
> +	net->netdev_ops = &netdev_ops;
> +	SET_NETDEV_DEV(net, &conn->hcon->dev);
> +	SET_NETDEV_DEVTYPE(net, &bt_type);
> +
> +	err = register_netdev(net);
> +	if (err < 0) {
> +		BT_INFO("register_netdev failed %d", err);
> +		free_netdev(net);
> +		goto out;
> +	}
> +
> +	BT_DBG("ifindex %d peer bdaddr %pMR my addr %pMR",
> +		net->ifindex, &conn->hcon->dst, &conn->hcon->src);
> +	set_bit(__LINK_STATE_PRESENT, &net->state);
> +
> +	entry = kzalloc(sizeof(struct lowpan_dev), GFP_ATOMIC);
> +	if (!entry) {
> +		unregister_netdev(net);
> +		return -ENOMEM;
> +	}
> +
> +	entry->dev = net;
> +
> +	write_lock_irqsave(&devices_lock, flags);
> +	INIT_LIST_HEAD(&entry->list);
> +	list_add(&entry->list, &bt_6lowpan_devices);
> +	write_unlock_irqrestore(&devices_lock, flags);
> +
> +	ifup(net);
> +
> +add_peer:
> +	peer = kzalloc(sizeof(struct lowpan_peer), GFP_ATOMIC);
> +	if (!peer)
> +		return -ENOMEM;
> +
> +	peer->conn = conn;
> +	memset(&peer->peer_addr, 0, sizeof(struct in6_addr));
> +
> +	/* RFC 2464 ch. 5 */
> +	peer->peer_addr.s6_addr[0] = 0xFE;
> +	peer->peer_addr.s6_addr[1] = 0x80;
> +	set_addr((u8 *)&peer->peer_addr.s6_addr + 8, conn->hcon->dst.b,
> +		conn->hcon->dst_type);
> +
> +	memcpy(&peer->eui64_addr, (u8 *)&peer->peer_addr.s6_addr + 8,
> +		EUI64_ADDR_LEN);
> +	peer->eui64_addr[0] ^= 2; /* second bit-flip (Universe/Local)
> +				   * is done according RFC2464
> +				   */
> +
> +	raw_dump_inline(__func__, "peer IPv6 address",
> +			(unsigned char *)&peer->peer_addr, 16);
> +	raw_dump_inline(__func__, "peer EUI64 address", peer->eui64_addr, 8);
> +
> +	write_lock_irqsave(&devices_lock, flags);
> +	INIT_LIST_HEAD(&peer->list);
> +	peer_add(dev, peer);
> +	write_unlock_irqrestore(&devices_lock, flags);
> +
> +	/*
> +	 * Notifying peers about us needs to be done without locks held
> +	 */
> +	INIT_DELAYED_WORK(&dev->notify_peers, do_notify_peers);
> +	schedule_delayed_work(&dev->notify_peers, msecs_to_jiffies(100));
> +
> +out:
> +	return err;
> +}
> +
> +static void delete_netdev(struct work_struct *work)
> +{
> +	struct lowpan_dev *entry = container_of(work, struct lowpan_dev,
> +						delete_netdev);
> +
> +	unregister_netdev(entry->dev);
> +
> +	/* The entry pointer is deleted in device_event() */
> +}
> +
> +int bt_6lowpan_del_conn(struct l2cap_conn *conn)
> +{
> +	struct lowpan_dev *entry, *tmp;
> +	struct lowpan_info *info = NULL;
> +	struct lowpan_peer *peer;
> +	int err = -ENOENT;
> +	unsigned long flags;
> +	bool last = false;
> +
> +	if (!is_bt_6lowpan(conn->hcon))
> +		return 0;
> +
> +	write_lock_irqsave(&devices_lock, flags);
> +
> +	list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
> +		info = lowpan_info(entry->dev);
> +		peer = peer_lookup_conn(info, conn);
> +		if (peer) {
> +			last = peer_del(info, peer);
> +			err = 0;
> +			break;
> +		}
> +	}
> +
> +	if (!err && last && info && !atomic_read(&info->peer_count)) {
> +		write_unlock_irqrestore(&devices_lock, flags);
> +
> +		cancel_delayed_work_sync(&info->notify_peers);
> +
> +		/*
> +		 * bt_6lowpan_del_conn() is called with hci dev lock held which
> +		 * means that we must delete the netdevice in worker thread.
> +		 */
> +		INIT_WORK(&entry->delete_netdev, delete_netdev);
> +		schedule_work(&entry->delete_netdev);
> +	} else
> +		write_unlock_irqrestore(&devices_lock, flags);
> +
> +	return err;
> +}
> +
> +static int device_event(struct notifier_block *unused,
> +			unsigned long event, void *ptr)
> +{
> +	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
> +	struct lowpan_dev *entry, *tmp;
> +	unsigned long flags;
> +
> +	if (dev->type != ARPHRD_6LOWPAN)
> +		return NOTIFY_DONE;
> +
> +	switch (event) {
> +	case NETDEV_UNREGISTER:
> +		write_lock_irqsave(&devices_lock, flags);
> +		list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices,
> +					list) {
> +			if (entry->dev == dev) {
> +				list_del(&entry->list);
> +				kfree(entry);
> +				break;
> +			}
> +		}
> +		write_unlock_irqrestore(&devices_lock, flags);
> +		break;
> +	}
> +
> +	return NOTIFY_DONE;
> +}
> +
> +static struct notifier_block bt_6lowpan_dev_notifier = {
> +	.notifier_call = device_event,
> +};
> +
> +int bt_6lowpan_init(void)
> +{
> +	return register_netdevice_notifier(&bt_6lowpan_dev_notifier);
> +}
> +
> +void bt_6lowpan_cleanup(void)
> +{
> +	unregister_netdevice_notifier(&bt_6lowpan_dev_notifier);
> +}
> diff --git a/net/bluetooth/6lowpan.h b/net/bluetooth/6lowpan.h
> new file mode 100644
> index 0000000..680eac8
> --- /dev/null
> +++ b/net/bluetooth/6lowpan.h
> @@ -0,0 +1,26 @@
> +/*
> +   Copyright (c) 2013 Intel Corp.
> +
> +   This program is free software; you can redistribute it and/or modify
> +   it under the terms of the GNU General Public License version 2 and
> +   only version 2 as published by the Free Software Foundation.
> +
> +   This program is distributed in the hope that 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.
> +*/
> +
> +#ifndef __6LOWPAN_H
> +#define __6LOWPAN_H
> +
> +#include <linux/skbuff.h>
> +#include <net/bluetooth/l2cap.h>
> +
> +int bt_6lowpan_recv(struct l2cap_conn *conn, struct sk_buff *skb);
> +int bt_6lowpan_add_conn(struct l2cap_conn *conn);
> +int bt_6lowpan_del_conn(struct l2cap_conn *conn);
> +int bt_6lowpan_init(void);
> +void bt_6lowpan_cleanup(void);
> +
> +#endif /* __6LOWPAN_H */
> diff --git a/net/bluetooth/Makefile b/net/bluetooth/Makefile
> index 6a791e7..cc6827e 100644
> --- a/net/bluetooth/Makefile
> +++ b/net/bluetooth/Makefile
> @@ -10,6 +10,10 @@ obj-$(CONFIG_BT_HIDP)	+= hidp/
> 
> bluetooth-y := af_bluetooth.o hci_core.o hci_conn.o hci_event.o mgmt.o \
> 	hci_sock.o hci_sysfs.o l2cap_core.o l2cap_sock.o smp.o sco.o lib.o \
> -	a2mp.o amp.o
> +	a2mp.o amp.o 6lowpan.o
> +
> +ifeq ($(CONFIG_IEEE802154_6LOWPAN),)
> +  bluetooth-y +=  ../ieee802154/6lowpan_iphc.o
> +endif
> 
> subdir-ccflags-y += -D__CHECK_ENDIAN__
> diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
> index 5fb3df6..5f81245 100644
> --- a/net/bluetooth/hci_event.c
> +++ b/net/bluetooth/hci_event.c
> @@ -3533,6 +3533,9 @@ static void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
> 	conn->handle = __le16_to_cpu(ev->handle);
> 	conn->state = BT_CONNECTED;
> 
> +	if (test_bit(HCI_6LOWPAN_ENABLED, &hdev->dev_flags))
> +		set_bit(HCI_CONN_6LOWPAN, &conn->flags);
> +
> 	hci_conn_add_sysfs(conn);
> 
> 	hci_proto_connect_cfm(conn, ev->status);
> diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c
> index ae0054c..9d6e952 100644
> --- a/net/bluetooth/l2cap_core.c
> +++ b/net/bluetooth/l2cap_core.c
> @@ -40,6 +40,7 @@
> #include "smp.h"
> #include "a2mp.h"
> #include "amp.h"
> +#include "6lowpan.h"
> 
> bool disable_ertm;
> 
> @@ -7093,6 +7094,10 @@ static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
> 			l2cap_conn_del(conn->hcon, EACCES);
> 		break;
> 
> +	case L2CAP_FC_6LOWPAN:
> +		bt_6lowpan_recv(conn, skb);
> +		break;
> +
> 	default:
> 		l2cap_data_channel(conn, cid, skb);
> 		break;
> @@ -7138,8 +7143,10 @@ void l2cap_connect_cfm(struct hci_conn *hcon, u8 status)
> 
> 	if (!status) {
> 		conn = l2cap_conn_add(hcon);
> -		if (conn)
> +		if (conn) {
> 			l2cap_conn_ready(conn);
> +			bt_6lowpan_add_conn(conn);
> +		}

Didn’t Johan add an l2cap_le_conn_ready for the LE CoC support.

> 	} else {
> 		l2cap_conn_del(hcon, bt_to_errno(status));
> 	}
> @@ -7160,6 +7167,8 @@ void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason)
> {
> 	BT_DBG("hcon %p reason %d", hcon, reason);
> 
> +	bt_6lowpan_del_conn(hcon->l2cap_data);
> +
> 	l2cap_conn_del(hcon, bt_to_errno(reason));
> }
> 
> @@ -7441,11 +7450,14 @@ int __init l2cap_init(void)
> 	debugfs_create_u16("l2cap_le_default_mps", 0466, bt_debugfs,
> 			   &le_default_mps);
> 
> +	bt_6lowpan_init();
> +
> 	return 0;
> }
> 
> void l2cap_exit(void)
> {
> +	bt_6lowpan_cleanup();
> 	debugfs_remove(l2cap_debugfs);
> 	l2cap_cleanup_sockets();
> }

Regards

Marcel

--
To unsubscribe from this list: send the line "unsubscribe linux-bluetooth" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Bluez Devel]     [Linux Wireless Networking]     [Linux Wireless Personal Area Networking]     [Linux ATH6KL]     [Linux USB Devel]     [Linux Media Drivers]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Big List of Linux Books]

  Powered by Linux