blob: d8c67a5e7a0236cd03f64bda13fab8c91a45b23e [file] [log] [blame]
Jukka Rissanen18722c22013-12-11 17:05:37 +02001/*
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03002 Copyright (c) 2013-2014 Intel Corp.
Jukka Rissanen18722c22013-12-11 17:05:37 +02003
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License version 2 and
6 only version 2 as published by the Free Software Foundation.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12*/
13
Jukka Rissanen18722c22013-12-11 17:05:37 +020014#include <linux/if_arp.h>
15#include <linux/netdevice.h>
16#include <linux/etherdevice.h>
Jukka Rissanen5547e482014-06-18 16:37:09 +030017#include <linux/module.h>
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +030018#include <linux/debugfs.h>
Jukka Rissanen18722c22013-12-11 17:05:37 +020019
20#include <net/ipv6.h>
21#include <net/ip6_route.h>
22#include <net/addrconf.h>
23
24#include <net/af_ieee802154.h> /* to get the address type */
25
26#include <net/bluetooth/bluetooth.h>
27#include <net/bluetooth/hci_core.h>
28#include <net/bluetooth/l2cap.h>
29
Alexander Aringcefc8c82014-03-05 14:29:05 +010030#include <net/6lowpan.h> /* for the compression support */
Jukka Rissanen18722c22013-12-11 17:05:37 +020031
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +030032#define VERSION "0.1"
33
34static struct dentry *lowpan_psm_debugfs;
35static struct dentry *lowpan_control_debugfs;
36
Jukka Rissanen18722c22013-12-11 17:05:37 +020037#define IFACE_NAME_TEMPLATE "bt%d"
38#define EUI64_ADDR_LEN 8
39
40struct skb_cb {
41 struct in6_addr addr;
Jukka Rissanen39e90c72014-09-08 12:11:45 +030042 struct in6_addr gw;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +030043 struct l2cap_chan *chan;
44 int status;
Jukka Rissanen18722c22013-12-11 17:05:37 +020045};
46#define lowpan_cb(skb) ((struct skb_cb *)((skb)->cb))
47
48/* The devices list contains those devices that we are acting
49 * as a proxy. The BT 6LoWPAN device is a virtual device that
50 * connects to the Bluetooth LE device. The real connection to
51 * BT device is done via l2cap layer. There exists one
52 * virtual device / one BT 6LoWPAN network (=hciX device).
53 * The list contains struct lowpan_dev elements.
54 */
55static LIST_HEAD(bt_6lowpan_devices);
Jukka Rissanen90305822014-10-28 17:16:47 +020056static DEFINE_SPINLOCK(devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +020057
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +030058/* If psm is set to 0 (default value), then 6lowpan is disabled.
59 * Other values are used to indicate a Protocol Service Multiplexer
60 * value for 6lowpan.
61 */
62static u16 psm_6lowpan;
63
64/* We are listening incoming connections via this channel
65 */
66static struct l2cap_chan *listen_chan;
67
Jukka Rissanen18722c22013-12-11 17:05:37 +020068struct lowpan_peer {
69 struct list_head list;
Jukka Rissanen90305822014-10-28 17:16:47 +020070 struct rcu_head rcu;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +030071 struct l2cap_chan *chan;
Jukka Rissanen18722c22013-12-11 17:05:37 +020072
73 /* peer addresses in various formats */
74 unsigned char eui64_addr[EUI64_ADDR_LEN];
75 struct in6_addr peer_addr;
76};
77
78struct lowpan_dev {
79 struct list_head list;
80
81 struct hci_dev *hdev;
82 struct net_device *netdev;
83 struct list_head peers;
84 atomic_t peer_count; /* number of items in peers list */
85
86 struct work_struct delete_netdev;
87 struct delayed_work notify_peers;
88};
89
90static inline struct lowpan_dev *lowpan_dev(const struct net_device *netdev)
91{
92 return netdev_priv(netdev);
93}
94
95static inline void peer_add(struct lowpan_dev *dev, struct lowpan_peer *peer)
96{
Jukka Rissanen90305822014-10-28 17:16:47 +020097 list_add_rcu(&peer->list, &dev->peers);
Jukka Rissanen18722c22013-12-11 17:05:37 +020098 atomic_inc(&dev->peer_count);
99}
100
101static inline bool peer_del(struct lowpan_dev *dev, struct lowpan_peer *peer)
102{
Jukka Rissanen90305822014-10-28 17:16:47 +0200103 list_del_rcu(&peer->list);
Johan Hedberg4e790222014-11-11 14:16:29 +0200104 kfree_rcu(peer, rcu);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200105
Jukka Rissanen18d93c12014-06-18 16:37:10 +0300106 module_put(THIS_MODULE);
107
Jukka Rissanen18722c22013-12-11 17:05:37 +0200108 if (atomic_dec_and_test(&dev->peer_count)) {
109 BT_DBG("last peer");
110 return true;
111 }
112
113 return false;
114}
115
116static inline struct lowpan_peer *peer_lookup_ba(struct lowpan_dev *dev,
117 bdaddr_t *ba, __u8 type)
118{
Jukka Rissanen90305822014-10-28 17:16:47 +0200119 struct lowpan_peer *peer;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200120
121 BT_DBG("peers %d addr %pMR type %d", atomic_read(&dev->peer_count),
122 ba, type);
123
Jukka Rissanen90305822014-10-28 17:16:47 +0200124 rcu_read_lock();
125
126 list_for_each_entry_rcu(peer, &dev->peers, list) {
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300127 BT_DBG("dst addr %pMR dst type %d",
128 &peer->chan->dst, peer->chan->dst_type);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200129
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300130 if (bacmp(&peer->chan->dst, ba))
Jukka Rissanen18722c22013-12-11 17:05:37 +0200131 continue;
132
Jukka Rissanen90305822014-10-28 17:16:47 +0200133 if (type == peer->chan->dst_type) {
134 rcu_read_unlock();
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300135 return peer;
Jukka Rissanen90305822014-10-28 17:16:47 +0200136 }
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300137 }
138
Jukka Rissanen90305822014-10-28 17:16:47 +0200139 rcu_read_unlock();
140
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300141 return NULL;
142}
143
Jukka Rissanen90305822014-10-28 17:16:47 +0200144static inline struct lowpan_peer *__peer_lookup_chan(struct lowpan_dev *dev,
145 struct l2cap_chan *chan)
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300146{
Jukka Rissanen90305822014-10-28 17:16:47 +0200147 struct lowpan_peer *peer;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300148
Jukka Rissanen90305822014-10-28 17:16:47 +0200149 list_for_each_entry_rcu(peer, &dev->peers, list) {
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300150 if (peer->chan == chan)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200151 return peer;
152 }
153
154 return NULL;
155}
156
Jukka Rissanen90305822014-10-28 17:16:47 +0200157static inline struct lowpan_peer *__peer_lookup_conn(struct lowpan_dev *dev,
158 struct l2cap_conn *conn)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200159{
Jukka Rissanen90305822014-10-28 17:16:47 +0200160 struct lowpan_peer *peer;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200161
Jukka Rissanen90305822014-10-28 17:16:47 +0200162 list_for_each_entry_rcu(peer, &dev->peers, list) {
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300163 if (peer->chan->conn == conn)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200164 return peer;
165 }
166
167 return NULL;
168}
169
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300170static inline struct lowpan_peer *peer_lookup_dst(struct lowpan_dev *dev,
171 struct in6_addr *daddr,
172 struct sk_buff *skb)
173{
Jukka Rissanen90305822014-10-28 17:16:47 +0200174 struct lowpan_peer *peer;
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300175 struct in6_addr *nexthop;
176 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
177 int count = atomic_read(&dev->peer_count);
178
179 BT_DBG("peers %d addr %pI6c rt %p", count, daddr, rt);
180
181 /* If we have multiple 6lowpan peers, then check where we should
182 * send the packet. If only one peer exists, then we can send the
183 * packet right away.
184 */
Jukka Rissanen90305822014-10-28 17:16:47 +0200185 if (count == 1) {
186 rcu_read_lock();
187 peer = list_first_or_null_rcu(&dev->peers, struct lowpan_peer,
188 list);
189 rcu_read_unlock();
190 return peer;
191 }
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300192
193 if (!rt) {
194 nexthop = &lowpan_cb(skb)->gw;
195
196 if (ipv6_addr_any(nexthop))
197 return NULL;
198 } else {
199 nexthop = rt6_nexthop(rt);
200
201 /* We need to remember the address because it is needed
202 * by bt_xmit() when sending the packet. In bt_xmit(), the
203 * destination routing info is not set.
204 */
205 memcpy(&lowpan_cb(skb)->gw, nexthop, sizeof(struct in6_addr));
206 }
207
208 BT_DBG("gw %pI6c", nexthop);
209
Jukka Rissanen90305822014-10-28 17:16:47 +0200210 rcu_read_lock();
211
212 list_for_each_entry_rcu(peer, &dev->peers, list) {
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300213 BT_DBG("dst addr %pMR dst type %d ip %pI6c",
214 &peer->chan->dst, peer->chan->dst_type,
215 &peer->peer_addr);
216
Jukka Rissanen90305822014-10-28 17:16:47 +0200217 if (!ipv6_addr_cmp(&peer->peer_addr, nexthop)) {
218 rcu_read_unlock();
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300219 return peer;
Jukka Rissanen90305822014-10-28 17:16:47 +0200220 }
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300221 }
222
Jukka Rissanen90305822014-10-28 17:16:47 +0200223 rcu_read_unlock();
224
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300225 return NULL;
226}
227
Jukka Rissanen18722c22013-12-11 17:05:37 +0200228static struct lowpan_peer *lookup_peer(struct l2cap_conn *conn)
229{
Jukka Rissanen90305822014-10-28 17:16:47 +0200230 struct lowpan_dev *entry;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200231 struct lowpan_peer *peer = NULL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200232
Jukka Rissanen90305822014-10-28 17:16:47 +0200233 rcu_read_lock();
Jukka Rissanen18722c22013-12-11 17:05:37 +0200234
Jukka Rissanen90305822014-10-28 17:16:47 +0200235 list_for_each_entry_rcu(entry, &bt_6lowpan_devices, list) {
236 peer = __peer_lookup_conn(entry, conn);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200237 if (peer)
238 break;
239 }
240
Jukka Rissanen90305822014-10-28 17:16:47 +0200241 rcu_read_unlock();
Jukka Rissanen18722c22013-12-11 17:05:37 +0200242
243 return peer;
244}
245
246static struct lowpan_dev *lookup_dev(struct l2cap_conn *conn)
247{
Jukka Rissanen90305822014-10-28 17:16:47 +0200248 struct lowpan_dev *entry;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200249 struct lowpan_dev *dev = NULL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200250
Jukka Rissanen90305822014-10-28 17:16:47 +0200251 rcu_read_lock();
Jukka Rissanen18722c22013-12-11 17:05:37 +0200252
Jukka Rissanen90305822014-10-28 17:16:47 +0200253 list_for_each_entry_rcu(entry, &bt_6lowpan_devices, list) {
Jukka Rissanen18722c22013-12-11 17:05:37 +0200254 if (conn->hcon->hdev == entry->hdev) {
255 dev = entry;
256 break;
257 }
258 }
259
Jukka Rissanen90305822014-10-28 17:16:47 +0200260 rcu_read_unlock();
Jukka Rissanen18722c22013-12-11 17:05:37 +0200261
262 return dev;
263}
264
Jukka Rissanen18722c22013-12-11 17:05:37 +0200265static int give_skb_to_upper(struct sk_buff *skb, struct net_device *dev)
266{
267 struct sk_buff *skb_cp;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200268
269 skb_cp = skb_copy(skb, GFP_ATOMIC);
270 if (!skb_cp)
Martin Townsendf8b36172014-10-23 15:40:53 +0100271 return NET_RX_DROP;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200272
Li RongQing4456c502014-10-16 10:21:55 +0800273 return netif_rx(skb_cp);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200274}
275
Martin Townsend01141232014-10-23 15:40:56 +0100276static int iphc_decompress(struct sk_buff *skb, struct net_device *netdev,
277 struct l2cap_chan *chan)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200278{
279 const u8 *saddr, *daddr;
280 u8 iphc0, iphc1;
281 struct lowpan_dev *dev;
282 struct lowpan_peer *peer;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200283
284 dev = lowpan_dev(netdev);
285
Jukka Rissanen90305822014-10-28 17:16:47 +0200286 rcu_read_lock();
287 peer = __peer_lookup_chan(dev, chan);
288 rcu_read_unlock();
Jukka Rissanen18722c22013-12-11 17:05:37 +0200289 if (!peer)
Martin Townsend56b2c3e2014-11-06 19:15:13 +0000290 return -EINVAL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200291
292 saddr = peer->eui64_addr;
293 daddr = dev->netdev->dev_addr;
294
295 /* at least two bytes will be used for the encoding */
296 if (skb->len < 2)
Martin Townsend56b2c3e2014-11-06 19:15:13 +0000297 return -EINVAL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200298
299 if (lowpan_fetch_skb_u8(skb, &iphc0))
Martin Townsend56b2c3e2014-11-06 19:15:13 +0000300 return -EINVAL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200301
302 if (lowpan_fetch_skb_u8(skb, &iphc1))
Martin Townsend56b2c3e2014-11-06 19:15:13 +0000303 return -EINVAL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200304
Martin Townsend01141232014-10-23 15:40:56 +0100305 return lowpan_header_decompress(skb, netdev,
306 saddr, IEEE802154_ADDR_LONG,
307 EUI64_ADDR_LEN, daddr,
308 IEEE802154_ADDR_LONG, EUI64_ADDR_LEN,
309 iphc0, iphc1);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200310
Jukka Rissanen18722c22013-12-11 17:05:37 +0200311}
312
313static int recv_pkt(struct sk_buff *skb, struct net_device *dev,
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300314 struct l2cap_chan *chan)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200315{
316 struct sk_buff *local_skb;
317 int ret;
318
319 if (!netif_running(dev))
320 goto drop;
321
322 if (dev->type != ARPHRD_6LOWPAN)
323 goto drop;
324
Martin Townsend11e3ff72014-10-13 11:00:56 +0100325 skb = skb_share_check(skb, GFP_ATOMIC);
326 if (!skb)
327 goto drop;
328
Jukka Rissanen18722c22013-12-11 17:05:37 +0200329 /* check that it's our buffer */
330 if (skb->data[0] == LOWPAN_DISPATCH_IPV6) {
331 /* Copy the packet so that the IPv6 header is
332 * properly aligned.
333 */
334 local_skb = skb_copy_expand(skb, NET_SKB_PAD - 1,
335 skb_tailroom(skb), GFP_ATOMIC);
336 if (!local_skb)
337 goto drop;
338
339 local_skb->protocol = htons(ETH_P_IPV6);
340 local_skb->pkt_type = PACKET_HOST;
341
342 skb_reset_network_header(local_skb);
343 skb_set_transport_header(local_skb, sizeof(struct ipv6hdr));
344
345 if (give_skb_to_upper(local_skb, dev) != NET_RX_SUCCESS) {
346 kfree_skb(local_skb);
347 goto drop;
348 }
349
350 dev->stats.rx_bytes += skb->len;
351 dev->stats.rx_packets++;
352
Martin Townsend3c400b82014-10-23 15:40:55 +0100353 consume_skb(local_skb);
354 consume_skb(skb);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200355 } else {
356 switch (skb->data[0] & 0xe0) {
357 case LOWPAN_DISPATCH_IPHC: /* ipv6 datagram */
358 local_skb = skb_clone(skb, GFP_ATOMIC);
359 if (!local_skb)
360 goto drop;
361
Martin Townsend01141232014-10-23 15:40:56 +0100362 ret = iphc_decompress(local_skb, dev, chan);
Martin Townsend56b2c3e2014-11-06 19:15:13 +0000363 if (ret < 0) {
364 kfree_skb(local_skb);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200365 goto drop;
Martin Townsend56b2c3e2014-11-06 19:15:13 +0000366 }
Jukka Rissanen18722c22013-12-11 17:05:37 +0200367
Martin Townsendf8b36172014-10-23 15:40:53 +0100368 local_skb->protocol = htons(ETH_P_IPV6);
369 local_skb->pkt_type = PACKET_HOST;
370 local_skb->dev = dev;
371
372 if (give_skb_to_upper(local_skb, dev)
373 != NET_RX_SUCCESS) {
374 kfree_skb(local_skb);
375 goto drop;
376 }
377
Jukka Rissanen18722c22013-12-11 17:05:37 +0200378 dev->stats.rx_bytes += skb->len;
379 dev->stats.rx_packets++;
380
Martin Townsend3c400b82014-10-23 15:40:55 +0100381 consume_skb(local_skb);
382 consume_skb(skb);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200383 break;
384 default:
385 break;
386 }
387 }
388
389 return NET_RX_SUCCESS;
390
391drop:
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300392 dev->stats.rx_dropped++;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200393 kfree_skb(skb);
394 return NET_RX_DROP;
395}
396
397/* Packet from BT LE device */
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300398static int chan_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200399{
400 struct lowpan_dev *dev;
401 struct lowpan_peer *peer;
402 int err;
403
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300404 peer = lookup_peer(chan->conn);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200405 if (!peer)
406 return -ENOENT;
407
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300408 dev = lookup_dev(chan->conn);
Johan Hedberg30d3db42013-12-12 09:53:21 +0200409 if (!dev || !dev->netdev)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200410 return -ENOENT;
411
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300412 err = recv_pkt(skb, dev->netdev, chan);
413 if (err) {
414 BT_DBG("recv pkt %d", err);
415 err = -EAGAIN;
416 }
Jukka Rissanen18722c22013-12-11 17:05:37 +0200417
418 return err;
419}
420
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300421static u8 get_addr_type_from_eui64(u8 byte)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200422{
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300423 /* Is universal(0) or local(1) bit */
424 return ((byte & 0x02) ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300425}
426
427static void copy_to_bdaddr(struct in6_addr *ip6_daddr, bdaddr_t *addr)
428{
429 u8 *eui64 = ip6_daddr->s6_addr + 8;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200430
431 addr->b[0] = eui64[7];
432 addr->b[1] = eui64[6];
433 addr->b[2] = eui64[5];
434 addr->b[3] = eui64[2];
435 addr->b[4] = eui64[1];
436 addr->b[5] = eui64[0];
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300437}
Jukka Rissanen18722c22013-12-11 17:05:37 +0200438
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300439static void convert_dest_bdaddr(struct in6_addr *ip6_daddr,
440 bdaddr_t *addr, u8 *addr_type)
441{
442 copy_to_bdaddr(ip6_daddr, addr);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200443
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300444 /* We need to toggle the U/L bit that we got from IPv6 address
445 * so that we get the proper address and type of the BD address.
446 */
447 addr->b[5] ^= 0x02;
448
449 *addr_type = get_addr_type_from_eui64(addr->b[5]);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200450}
451
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300452static int setup_header(struct sk_buff *skb, struct net_device *netdev,
453 bdaddr_t *peer_addr, u8 *peer_addr_type)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200454{
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300455 struct in6_addr ipv6_daddr;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200456 struct lowpan_dev *dev;
457 struct lowpan_peer *peer;
458 bdaddr_t addr, *any = BDADDR_ANY;
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300459 u8 *daddr = any->b;
460 int err, status = 0;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200461
462 dev = lowpan_dev(netdev);
463
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300464 memcpy(&ipv6_daddr, &lowpan_cb(skb)->addr, sizeof(ipv6_daddr));
465
466 if (ipv6_addr_is_multicast(&ipv6_daddr)) {
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300467 lowpan_cb(skb)->chan = NULL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200468 } else {
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300469 u8 addr_type;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200470
471 /* Get destination BT device from skb.
472 * If there is no such peer then discard the packet.
473 */
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300474 convert_dest_bdaddr(&ipv6_daddr, &addr, &addr_type);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200475
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300476 BT_DBG("dest addr %pMR type %d IP %pI6c", &addr,
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300477 addr_type, &ipv6_daddr);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200478
Jukka Rissanen18722c22013-12-11 17:05:37 +0200479 peer = peer_lookup_ba(dev, &addr, addr_type);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200480 if (!peer) {
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300481 /* The packet might be sent to 6lowpan interface
482 * because of routing (either via default route
483 * or user set route) so get peer according to
484 * the destination address.
485 */
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300486 peer = peer_lookup_dst(dev, &ipv6_daddr, skb);
Jukka Rissanen39e90c72014-09-08 12:11:45 +0300487 if (!peer) {
488 BT_DBG("no such peer %pMR found", &addr);
489 return -ENOENT;
490 }
Jukka Rissanen18722c22013-12-11 17:05:37 +0200491 }
492
493 daddr = peer->eui64_addr;
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300494 *peer_addr = addr;
495 *peer_addr_type = addr_type;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300496 lowpan_cb(skb)->chan = peer->chan;
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300497
498 status = 1;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200499 }
500
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300501 lowpan_header_compress(skb, netdev, ETH_P_IPV6, daddr,
502 dev->netdev->dev_addr, skb->len);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200503
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300504 err = dev_hard_header(skb, netdev, ETH_P_IPV6, NULL, NULL, 0);
505 if (err < 0)
506 return err;
507
508 return status;
509}
510
511static int header_create(struct sk_buff *skb, struct net_device *netdev,
512 unsigned short type, const void *_daddr,
513 const void *_saddr, unsigned int len)
514{
515 struct ipv6hdr *hdr;
516
517 if (type != ETH_P_IPV6)
518 return -EINVAL;
519
520 hdr = ipv6_hdr(skb);
521
522 memcpy(&lowpan_cb(skb)->addr, &hdr->daddr, sizeof(struct in6_addr));
523
524 return 0;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200525}
526
527/* Packet to BT LE device */
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300528static int send_pkt(struct l2cap_chan *chan, struct sk_buff *skb,
Jukka Rissanend7b6b0a2014-10-01 15:59:14 +0300529 struct net_device *netdev)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200530{
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300531 struct msghdr msg;
532 struct kvec iv;
533 int err;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200534
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300535 /* Remember the skb so that we can send EAGAIN to the caller if
Jukka Rissanend7b6b0a2014-10-01 15:59:14 +0300536 * we run out of credits.
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300537 */
Jukka Rissanend7b6b0a2014-10-01 15:59:14 +0300538 chan->data = skb;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300539
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300540 iv.iov_base = skb->data;
541 iv.iov_len = skb->len;
542
Al Viroc0371da2014-11-24 10:42:55 -0500543 memset(&msg, 0, sizeof(msg));
544 iov_iter_init(&msg.msg_iter, WRITE, (struct iovec *) &iv, 1, skb->len);
545
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300546 err = l2cap_chan_send(chan, &msg, skb->len);
547 if (err > 0) {
548 netdev->stats.tx_bytes += err;
549 netdev->stats.tx_packets++;
550 return 0;
551 }
552
553 if (!err)
554 err = lowpan_cb(skb)->status;
555
556 if (err < 0) {
557 if (err == -EAGAIN)
558 netdev->stats.tx_dropped++;
559 else
560 netdev->stats.tx_errors++;
561 }
562
563 return err;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200564}
565
Jukka Rissanen9c238ca2014-10-01 15:59:15 +0300566static int send_mcast_pkt(struct sk_buff *skb, struct net_device *netdev)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200567{
568 struct sk_buff *local_skb;
Jukka Rissanen90305822014-10-28 17:16:47 +0200569 struct lowpan_dev *entry;
Jukka Rissanen9c238ca2014-10-01 15:59:15 +0300570 int err = 0;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200571
Jukka Rissanen90305822014-10-28 17:16:47 +0200572 rcu_read_lock();
Jukka Rissanen18722c22013-12-11 17:05:37 +0200573
Jukka Rissanen90305822014-10-28 17:16:47 +0200574 list_for_each_entry_rcu(entry, &bt_6lowpan_devices, list) {
575 struct lowpan_peer *pentry;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200576 struct lowpan_dev *dev;
577
578 if (entry->netdev != netdev)
579 continue;
580
581 dev = lowpan_dev(entry->netdev);
582
Jukka Rissanen90305822014-10-28 17:16:47 +0200583 list_for_each_entry_rcu(pentry, &dev->peers, list) {
Jukka Rissanen9c238ca2014-10-01 15:59:15 +0300584 int ret;
585
Jukka Rissanen18722c22013-12-11 17:05:37 +0200586 local_skb = skb_clone(skb, GFP_ATOMIC);
587
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300588 BT_DBG("xmit %s to %pMR type %d IP %pI6c chan %p",
589 netdev->name,
590 &pentry->chan->dst, pentry->chan->dst_type,
591 &pentry->peer_addr, pentry->chan);
Jukka Rissanen9c238ca2014-10-01 15:59:15 +0300592 ret = send_pkt(pentry->chan, local_skb, netdev);
593 if (ret < 0)
594 err = ret;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200595
596 kfree_skb(local_skb);
597 }
598 }
599
Jukka Rissanen90305822014-10-28 17:16:47 +0200600 rcu_read_unlock();
Jukka Rissanen9c238ca2014-10-01 15:59:15 +0300601
602 return err;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200603}
604
605static netdev_tx_t bt_xmit(struct sk_buff *skb, struct net_device *netdev)
606{
607 int err = 0;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200608 bdaddr_t addr;
609 u8 addr_type;
610
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300611 /* We must take a copy of the skb before we modify/replace the ipv6
612 * header as the header could be used elsewhere
613 */
Alexander Aringb0c42cd2014-10-08 10:24:53 +0200614 skb = skb_unshare(skb, GFP_ATOMIC);
615 if (!skb)
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300616 return NET_XMIT_DROP;
617
618 /* Return values from setup_header()
619 * <0 - error, packet is dropped
620 * 0 - this is a multicast packet
621 * 1 - this is unicast packet
622 */
623 err = setup_header(skb, netdev, &addr, &addr_type);
624 if (err < 0) {
625 kfree_skb(skb);
626 return NET_XMIT_DROP;
627 }
628
629 if (err) {
630 if (lowpan_cb(skb)->chan) {
631 BT_DBG("xmit %s to %pMR type %d IP %pI6c chan %p",
632 netdev->name, &addr, addr_type,
633 &lowpan_cb(skb)->addr, lowpan_cb(skb)->chan);
Jukka Rissanend7b6b0a2014-10-01 15:59:14 +0300634 err = send_pkt(lowpan_cb(skb)->chan, skb, netdev);
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300635 } else {
636 err = -ENOENT;
637 }
638 } else {
639 /* We need to send the packet to every device behind this
640 * interface.
Jukka Rissanen18722c22013-12-11 17:05:37 +0200641 */
Jukka Rissanen9c238ca2014-10-01 15:59:15 +0300642 err = send_mcast_pkt(skb, netdev);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200643 }
Jukka Rissanen18722c22013-12-11 17:05:37 +0200644
Jukka Rissanenfc125182014-10-01 11:30:26 +0300645 dev_kfree_skb(skb);
646
Jukka Rissanen18722c22013-12-11 17:05:37 +0200647 if (err)
648 BT_DBG("ERROR: xmit failed (%d)", err);
649
Jukka Rissanen36b3dd22014-09-29 16:37:25 +0300650 return err < 0 ? NET_XMIT_DROP : err;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200651}
652
Jukka Rissanendf092302014-10-28 17:16:48 +0200653static struct lock_class_key bt_tx_busylock;
654static struct lock_class_key bt_netdev_xmit_lock_key;
655
656static void bt_set_lockdep_class_one(struct net_device *dev,
657 struct netdev_queue *txq,
658 void *_unused)
659{
660 lockdep_set_class(&txq->_xmit_lock, &bt_netdev_xmit_lock_key);
661}
662
663static int bt_dev_init(struct net_device *dev)
664{
665 netdev_for_each_tx_queue(dev, bt_set_lockdep_class_one, NULL);
666 dev->qdisc_tx_busylock = &bt_tx_busylock;
667
668 return 0;
669}
670
Jukka Rissanen18722c22013-12-11 17:05:37 +0200671static const struct net_device_ops netdev_ops = {
Jukka Rissanendf092302014-10-28 17:16:48 +0200672 .ndo_init = bt_dev_init,
Jukka Rissanen18722c22013-12-11 17:05:37 +0200673 .ndo_start_xmit = bt_xmit,
674};
675
676static struct header_ops header_ops = {
677 .create = header_create,
678};
679
680static void netdev_setup(struct net_device *dev)
681{
682 dev->addr_len = EUI64_ADDR_LEN;
683 dev->type = ARPHRD_6LOWPAN;
684
685 dev->hard_header_len = 0;
686 dev->needed_tailroom = 0;
687 dev->mtu = IPV6_MIN_MTU;
688 dev->tx_queue_len = 0;
Jukka Rissanen156395c2014-09-29 16:37:26 +0300689 dev->flags = IFF_RUNNING | IFF_POINTOPOINT |
690 IFF_MULTICAST;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200691 dev->watchdog_timeo = 0;
692
693 dev->netdev_ops = &netdev_ops;
694 dev->header_ops = &header_ops;
695 dev->destructor = free_netdev;
696}
697
698static struct device_type bt_type = {
699 .name = "bluetooth",
700};
701
702static void set_addr(u8 *eui, u8 *addr, u8 addr_type)
703{
704 /* addr is the BT address in little-endian format */
705 eui[0] = addr[5];
706 eui[1] = addr[4];
707 eui[2] = addr[3];
708 eui[3] = 0xFF;
709 eui[4] = 0xFE;
710 eui[5] = addr[2];
711 eui[6] = addr[1];
712 eui[7] = addr[0];
713
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300714 /* Universal/local bit set, BT 6lowpan draft ch. 3.2.1 */
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300715 if (addr_type == BDADDR_LE_PUBLIC)
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300716 eui[0] &= ~0x02;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200717 else
Jukka Rissanen62bbd5b2014-05-27 11:33:22 +0300718 eui[0] |= 0x02;
719
720 BT_DBG("type %d addr %*phC", addr_type, 8, eui);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200721}
722
723static void set_dev_addr(struct net_device *netdev, bdaddr_t *addr,
724 u8 addr_type)
725{
726 netdev->addr_assign_type = NET_ADDR_PERM;
727 set_addr(netdev->dev_addr, addr->b, addr_type);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200728}
729
730static void ifup(struct net_device *netdev)
731{
732 int err;
733
734 rtnl_lock();
735 err = dev_open(netdev);
736 if (err < 0)
737 BT_INFO("iface %s cannot be opened (%d)", netdev->name, err);
738 rtnl_unlock();
739}
740
Jukka Rissanen7f118252014-06-18 16:37:11 +0300741static void ifdown(struct net_device *netdev)
742{
743 int err;
744
745 rtnl_lock();
746 err = dev_close(netdev);
747 if (err < 0)
748 BT_INFO("iface %s cannot be closed (%d)", netdev->name, err);
749 rtnl_unlock();
750}
751
Jukka Rissanen18722c22013-12-11 17:05:37 +0200752static void do_notify_peers(struct work_struct *work)
753{
754 struct lowpan_dev *dev = container_of(work, struct lowpan_dev,
755 notify_peers.work);
756
757 netdev_notify_peers(dev->netdev); /* send neighbour adv at startup */
758}
759
760static bool is_bt_6lowpan(struct hci_conn *hcon)
761{
762 if (hcon->type != LE_LINK)
763 return false;
764
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300765 if (!psm_6lowpan)
766 return false;
767
768 return true;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200769}
770
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300771static struct l2cap_chan *chan_create(void)
772{
773 struct l2cap_chan *chan;
774
775 chan = l2cap_chan_create();
776 if (!chan)
777 return NULL;
778
779 l2cap_chan_set_defaults(chan);
780
781 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
782 chan->mode = L2CAP_MODE_LE_FLOWCTL;
783 chan->omtu = 65535;
784 chan->imtu = chan->omtu;
785
786 return chan;
787}
788
789static struct l2cap_chan *chan_open(struct l2cap_chan *pchan)
790{
791 struct l2cap_chan *chan;
792
793 chan = chan_create();
794 if (!chan)
795 return NULL;
796
797 chan->remote_mps = chan->omtu;
798 chan->mps = chan->omtu;
799
800 chan->state = BT_CONNECTED;
801
802 return chan;
803}
804
Jukka Rissanenb2799ce2014-09-08 12:11:44 +0300805static void set_ip_addr_bits(u8 addr_type, u8 *addr)
806{
807 if (addr_type == BDADDR_LE_PUBLIC)
808 *addr |= 0x02;
809 else
810 *addr &= ~0x02;
811}
812
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300813static struct l2cap_chan *add_peer_chan(struct l2cap_chan *chan,
814 struct lowpan_dev *dev)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200815{
816 struct lowpan_peer *peer;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200817
818 peer = kzalloc(sizeof(*peer), GFP_ATOMIC);
819 if (!peer)
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300820 return NULL;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200821
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300822 peer->chan = chan;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200823 memset(&peer->peer_addr, 0, sizeof(struct in6_addr));
824
825 /* RFC 2464 ch. 5 */
826 peer->peer_addr.s6_addr[0] = 0xFE;
827 peer->peer_addr.s6_addr[1] = 0x80;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300828 set_addr((u8 *)&peer->peer_addr.s6_addr + 8, chan->dst.b,
829 chan->dst_type);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200830
831 memcpy(&peer->eui64_addr, (u8 *)&peer->peer_addr.s6_addr + 8,
832 EUI64_ADDR_LEN);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200833
Jukka Rissanenb2799ce2014-09-08 12:11:44 +0300834 /* IPv6 address needs to have the U/L bit set properly so toggle
835 * it back here.
836 */
837 set_ip_addr_bits(chan->dst_type, (u8 *)&peer->peer_addr.s6_addr + 8);
838
Jukka Rissanen90305822014-10-28 17:16:47 +0200839 spin_lock(&devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200840 INIT_LIST_HEAD(&peer->list);
841 peer_add(dev, peer);
Jukka Rissanen90305822014-10-28 17:16:47 +0200842 spin_unlock(&devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200843
844 /* Notifying peers about us needs to be done without locks held */
845 INIT_DELAYED_WORK(&dev->notify_peers, do_notify_peers);
846 schedule_delayed_work(&dev->notify_peers, msecs_to_jiffies(100));
847
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300848 return peer->chan;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200849}
850
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300851static int setup_netdev(struct l2cap_chan *chan, struct lowpan_dev **dev)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200852{
Jukka Rissanen18722c22013-12-11 17:05:37 +0200853 struct net_device *netdev;
854 int err = 0;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200855
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300856 netdev = alloc_netdev(sizeof(struct lowpan_dev), IFACE_NAME_TEMPLATE,
Tom Gundersenc835a672014-07-14 16:37:24 +0200857 NET_NAME_UNKNOWN, netdev_setup);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200858 if (!netdev)
859 return -ENOMEM;
860
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300861 set_dev_addr(netdev, &chan->src, chan->src_type);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200862
863 netdev->netdev_ops = &netdev_ops;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300864 SET_NETDEV_DEV(netdev, &chan->conn->hcon->dev);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200865 SET_NETDEV_DEVTYPE(netdev, &bt_type);
866
867 err = register_netdev(netdev);
868 if (err < 0) {
869 BT_INFO("register_netdev failed %d", err);
870 free_netdev(netdev);
871 goto out;
872 }
873
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300874 BT_DBG("ifindex %d peer bdaddr %pMR type %d my addr %pMR type %d",
875 netdev->ifindex, &chan->dst, chan->dst_type,
876 &chan->src, chan->src_type);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200877 set_bit(__LINK_STATE_PRESENT, &netdev->state);
878
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300879 *dev = netdev_priv(netdev);
880 (*dev)->netdev = netdev;
881 (*dev)->hdev = chan->conn->hcon->hdev;
882 INIT_LIST_HEAD(&(*dev)->peers);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200883
Jukka Rissanen90305822014-10-28 17:16:47 +0200884 spin_lock(&devices_lock);
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300885 INIT_LIST_HEAD(&(*dev)->list);
Jukka Rissanen90305822014-10-28 17:16:47 +0200886 list_add_rcu(&(*dev)->list, &bt_6lowpan_devices);
887 spin_unlock(&devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200888
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300889 return 0;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200890
891out:
892 return err;
893}
894
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300895static inline void chan_ready_cb(struct l2cap_chan *chan)
896{
897 struct lowpan_dev *dev;
898
899 dev = lookup_dev(chan->conn);
900
901 BT_DBG("chan %p conn %p dev %p", chan, chan->conn, dev);
902
903 if (!dev) {
904 if (setup_netdev(chan, &dev) < 0) {
905 l2cap_chan_del(chan, -ENOENT);
906 return;
907 }
908 }
909
Jukka Rissanen18d93c12014-06-18 16:37:10 +0300910 if (!try_module_get(THIS_MODULE))
911 return;
912
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300913 add_peer_chan(chan, dev);
914 ifup(dev->netdev);
915}
916
Johan Hedberg2b293492014-08-07 10:03:32 +0300917static inline struct l2cap_chan *chan_new_conn_cb(struct l2cap_chan *pchan)
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300918{
Johan Hedberg2b293492014-08-07 10:03:32 +0300919 struct l2cap_chan *chan;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300920
Johan Hedberg2b293492014-08-07 10:03:32 +0300921 chan = chan_open(pchan);
922 chan->ops = pchan->ops;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300923
924 BT_DBG("chan %p pchan %p", chan, pchan);
925
Johan Hedberg2b293492014-08-07 10:03:32 +0300926 return chan;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300927}
928
Jukka Rissanen18722c22013-12-11 17:05:37 +0200929static void delete_netdev(struct work_struct *work)
930{
931 struct lowpan_dev *entry = container_of(work, struct lowpan_dev,
932 delete_netdev);
933
934 unregister_netdev(entry->netdev);
935
936 /* The entry pointer is deleted in device_event() */
937}
938
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300939static void chan_close_cb(struct l2cap_chan *chan)
Jukka Rissanen18722c22013-12-11 17:05:37 +0200940{
Jukka Rissanen90305822014-10-28 17:16:47 +0200941 struct lowpan_dev *entry;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200942 struct lowpan_dev *dev = NULL;
943 struct lowpan_peer *peer;
944 int err = -ENOENT;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300945 bool last = false, removed = true;
Jukka Rissanen18722c22013-12-11 17:05:37 +0200946
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300947 BT_DBG("chan %p conn %p", chan, chan->conn);
948
949 if (chan->conn && chan->conn->hcon) {
950 if (!is_bt_6lowpan(chan->conn->hcon))
951 return;
952
953 /* If conn is set, then the netdev is also there and we should
954 * not remove it.
955 */
956 removed = false;
957 }
Jukka Rissanen18722c22013-12-11 17:05:37 +0200958
Jukka Rissanen90305822014-10-28 17:16:47 +0200959 spin_lock(&devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200960
Jukka Rissanen90305822014-10-28 17:16:47 +0200961 list_for_each_entry_rcu(entry, &bt_6lowpan_devices, list) {
Jukka Rissanen18722c22013-12-11 17:05:37 +0200962 dev = lowpan_dev(entry->netdev);
Jukka Rissanen90305822014-10-28 17:16:47 +0200963 peer = __peer_lookup_chan(dev, chan);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200964 if (peer) {
965 last = peer_del(dev, peer);
966 err = 0;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300967
968 BT_DBG("dev %p removing %speer %p", dev,
969 last ? "last " : "1 ", peer);
970 BT_DBG("chan %p orig refcnt %d", chan,
971 atomic_read(&chan->kref.refcount));
972
973 l2cap_chan_put(chan);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200974 break;
975 }
976 }
977
978 if (!err && last && dev && !atomic_read(&dev->peer_count)) {
Jukka Rissanen90305822014-10-28 17:16:47 +0200979 spin_unlock(&devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200980
981 cancel_delayed_work_sync(&dev->notify_peers);
982
Jukka Rissanen7f118252014-06-18 16:37:11 +0300983 ifdown(dev->netdev);
984
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300985 if (!removed) {
986 INIT_WORK(&entry->delete_netdev, delete_netdev);
987 schedule_work(&entry->delete_netdev);
988 }
Jukka Rissanen18722c22013-12-11 17:05:37 +0200989 } else {
Jukka Rissanen90305822014-10-28 17:16:47 +0200990 spin_unlock(&devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +0200991 }
992
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +0300993 return;
994}
995
996static void chan_state_change_cb(struct l2cap_chan *chan, int state, int err)
997{
998 BT_DBG("chan %p conn %p state %s err %d", chan, chan->conn,
999 state_to_string(state), err);
1000}
1001
1002static struct sk_buff *chan_alloc_skb_cb(struct l2cap_chan *chan,
1003 unsigned long hdr_len,
1004 unsigned long len, int nb)
1005{
1006 /* Note that we must allocate using GFP_ATOMIC here as
1007 * this function is called originally from netdev hard xmit
1008 * function in atomic context.
1009 */
1010 return bt_skb_alloc(hdr_len + len, GFP_ATOMIC);
1011}
1012
1013static void chan_suspend_cb(struct l2cap_chan *chan)
1014{
1015 struct sk_buff *skb = chan->data;
1016
1017 BT_DBG("chan %p conn %p skb %p", chan, chan->conn, skb);
1018
Jukka Rissanen59790aa2014-09-29 10:55:46 +03001019 if (!skb)
1020 return;
1021
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001022 lowpan_cb(skb)->status = -EAGAIN;
1023}
1024
1025static void chan_resume_cb(struct l2cap_chan *chan)
1026{
1027 struct sk_buff *skb = chan->data;
1028
1029 BT_DBG("chan %p conn %p skb %p", chan, chan->conn, skb);
1030
Jukka Rissanen59790aa2014-09-29 10:55:46 +03001031 if (!skb)
1032 return;
1033
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001034 lowpan_cb(skb)->status = 0;
1035}
1036
1037static long chan_get_sndtimeo_cb(struct l2cap_chan *chan)
1038{
Jukka Rissanen2ae50d82014-09-08 12:11:43 +03001039 return L2CAP_CONN_TIMEOUT;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001040}
1041
1042static const struct l2cap_ops bt_6lowpan_chan_ops = {
1043 .name = "L2CAP 6LoWPAN channel",
1044 .new_connection = chan_new_conn_cb,
1045 .recv = chan_recv_cb,
1046 .close = chan_close_cb,
1047 .state_change = chan_state_change_cb,
1048 .ready = chan_ready_cb,
1049 .resume = chan_resume_cb,
1050 .suspend = chan_suspend_cb,
1051 .get_sndtimeo = chan_get_sndtimeo_cb,
1052 .alloc_skb = chan_alloc_skb_cb,
1053 .memcpy_fromiovec = l2cap_chan_no_memcpy_fromiovec,
1054
1055 .teardown = l2cap_chan_no_teardown,
1056 .defer = l2cap_chan_no_defer,
1057 .set_shutdown = l2cap_chan_no_set_shutdown,
1058};
1059
1060static inline __u8 bdaddr_type(__u8 type)
1061{
1062 if (type == ADDR_LE_DEV_PUBLIC)
1063 return BDADDR_LE_PUBLIC;
1064 else
1065 return BDADDR_LE_RANDOM;
1066}
1067
1068static struct l2cap_chan *chan_get(void)
1069{
1070 struct l2cap_chan *pchan;
1071
1072 pchan = chan_create();
1073 if (!pchan)
1074 return NULL;
1075
1076 pchan->ops = &bt_6lowpan_chan_ops;
1077
1078 return pchan;
1079}
1080
1081static int bt_6lowpan_connect(bdaddr_t *addr, u8 dst_type)
1082{
1083 struct l2cap_chan *pchan;
1084 int err;
1085
1086 pchan = chan_get();
1087 if (!pchan)
1088 return -EINVAL;
1089
1090 err = l2cap_chan_connect(pchan, cpu_to_le16(psm_6lowpan), 0,
1091 addr, dst_type);
1092
1093 BT_DBG("chan %p err %d", pchan, err);
1094 if (err < 0)
1095 l2cap_chan_put(pchan);
1096
Jukka Rissanen18722c22013-12-11 17:05:37 +02001097 return err;
1098}
1099
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001100static int bt_6lowpan_disconnect(struct l2cap_conn *conn, u8 dst_type)
1101{
1102 struct lowpan_peer *peer;
1103
1104 BT_DBG("conn %p dst type %d", conn, dst_type);
1105
1106 peer = lookup_peer(conn);
1107 if (!peer)
1108 return -ENOENT;
1109
1110 BT_DBG("peer %p chan %p", peer, peer->chan);
1111
1112 l2cap_chan_close(peer->chan, ENOENT);
1113
1114 return 0;
1115}
1116
1117static struct l2cap_chan *bt_6lowpan_listen(void)
1118{
1119 bdaddr_t *addr = BDADDR_ANY;
1120 struct l2cap_chan *pchan;
1121 int err;
1122
1123 if (psm_6lowpan == 0)
1124 return NULL;
1125
1126 pchan = chan_get();
1127 if (!pchan)
1128 return NULL;
1129
1130 pchan->state = BT_LISTEN;
1131 pchan->src_type = BDADDR_LE_PUBLIC;
1132
Johan Hedberg2773b022014-11-13 09:46:05 +02001133 atomic_set(&pchan->nesting, L2CAP_NESTING_PARENT);
1134
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001135 BT_DBG("psm 0x%04x chan %p src type %d", psm_6lowpan, pchan,
1136 pchan->src_type);
1137
1138 err = l2cap_add_psm(pchan, addr, cpu_to_le16(psm_6lowpan));
1139 if (err) {
1140 l2cap_chan_put(pchan);
1141 BT_ERR("psm cannot be added err %d", err);
1142 return NULL;
1143 }
1144
1145 return pchan;
1146}
1147
1148static int get_l2cap_conn(char *buf, bdaddr_t *addr, u8 *addr_type,
1149 struct l2cap_conn **conn)
1150{
1151 struct hci_conn *hcon;
1152 struct hci_dev *hdev;
1153 bdaddr_t *src = BDADDR_ANY;
1154 int n;
1155
1156 n = sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx %hhu",
1157 &addr->b[5], &addr->b[4], &addr->b[3],
1158 &addr->b[2], &addr->b[1], &addr->b[0],
1159 addr_type);
1160
1161 if (n < 7)
1162 return -EINVAL;
1163
1164 hdev = hci_get_route(addr, src);
1165 if (!hdev)
1166 return -ENOENT;
1167
1168 hci_dev_lock(hdev);
1169 hcon = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr);
1170 hci_dev_unlock(hdev);
1171
1172 if (!hcon)
1173 return -ENOENT;
1174
1175 *conn = (struct l2cap_conn *)hcon->l2cap_data;
1176
1177 BT_DBG("conn %p dst %pMR type %d", *conn, &hcon->dst, hcon->dst_type);
1178
1179 return 0;
1180}
1181
1182static void disconnect_all_peers(void)
1183{
Jukka Rissanen90305822014-10-28 17:16:47 +02001184 struct lowpan_dev *entry;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001185 struct lowpan_peer *peer, *tmp_peer, *new_peer;
1186 struct list_head peers;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001187
1188 INIT_LIST_HEAD(&peers);
1189
1190 /* We make a separate list of peers as the close_cb() will
1191 * modify the device peers list so it is better not to mess
1192 * with the same list at the same time.
1193 */
1194
Jukka Rissanen90305822014-10-28 17:16:47 +02001195 rcu_read_lock();
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001196
Jukka Rissanen90305822014-10-28 17:16:47 +02001197 list_for_each_entry_rcu(entry, &bt_6lowpan_devices, list) {
1198 list_for_each_entry_rcu(peer, &entry->peers, list) {
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001199 new_peer = kmalloc(sizeof(*new_peer), GFP_ATOMIC);
1200 if (!new_peer)
1201 break;
1202
1203 new_peer->chan = peer->chan;
1204 INIT_LIST_HEAD(&new_peer->list);
1205
1206 list_add(&new_peer->list, &peers);
1207 }
1208 }
1209
Jukka Rissanen90305822014-10-28 17:16:47 +02001210 rcu_read_unlock();
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001211
Jukka Rissanen90305822014-10-28 17:16:47 +02001212 spin_lock(&devices_lock);
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001213 list_for_each_entry_safe(peer, tmp_peer, &peers, list) {
1214 l2cap_chan_close(peer->chan, ENOENT);
Jukka Rissanen90305822014-10-28 17:16:47 +02001215
1216 list_del_rcu(&peer->list);
Johan Hedberg4e790222014-11-11 14:16:29 +02001217 kfree_rcu(peer, rcu);
Jukka Rissanen90305822014-10-28 17:16:47 +02001218
1219 module_put(THIS_MODULE);
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001220 }
Jukka Rissanen90305822014-10-28 17:16:47 +02001221 spin_unlock(&devices_lock);
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001222}
1223
Jukka Rissanen90305822014-10-28 17:16:47 +02001224struct set_psm {
1225 struct work_struct work;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001226 u16 psm;
Jukka Rissanen90305822014-10-28 17:16:47 +02001227};
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001228
Jukka Rissanen90305822014-10-28 17:16:47 +02001229static void do_psm_set(struct work_struct *work)
1230{
1231 struct set_psm *set_psm = container_of(work, struct set_psm, work);
1232
1233 if (set_psm->psm == 0 || psm_6lowpan != set_psm->psm)
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001234 /* Disconnect existing connections if 6lowpan is
1235 * disabled (psm = 0), or if psm changes.
1236 */
1237 disconnect_all_peers();
1238
Jukka Rissanen90305822014-10-28 17:16:47 +02001239 psm_6lowpan = set_psm->psm;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001240
1241 if (listen_chan) {
1242 l2cap_chan_close(listen_chan, 0);
1243 l2cap_chan_put(listen_chan);
1244 }
1245
1246 listen_chan = bt_6lowpan_listen();
1247
Jukka Rissanen90305822014-10-28 17:16:47 +02001248 kfree(set_psm);
1249}
1250
1251static int lowpan_psm_set(void *data, u64 val)
1252{
1253 struct set_psm *set_psm;
1254
1255 set_psm = kzalloc(sizeof(*set_psm), GFP_KERNEL);
1256 if (!set_psm)
1257 return -ENOMEM;
1258
1259 set_psm->psm = val;
1260 INIT_WORK(&set_psm->work, do_psm_set);
1261
1262 schedule_work(&set_psm->work);
1263
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001264 return 0;
1265}
1266
1267static int lowpan_psm_get(void *data, u64 *val)
1268{
1269 *val = psm_6lowpan;
1270 return 0;
1271}
1272
1273DEFINE_SIMPLE_ATTRIBUTE(lowpan_psm_fops, lowpan_psm_get,
1274 lowpan_psm_set, "%llu\n");
1275
1276static ssize_t lowpan_control_write(struct file *fp,
1277 const char __user *user_buffer,
1278 size_t count,
1279 loff_t *position)
1280{
1281 char buf[32];
1282 size_t buf_size = min(count, sizeof(buf) - 1);
1283 int ret;
1284 bdaddr_t addr;
1285 u8 addr_type;
1286 struct l2cap_conn *conn = NULL;
1287
1288 if (copy_from_user(buf, user_buffer, buf_size))
1289 return -EFAULT;
1290
1291 buf[buf_size] = '\0';
1292
1293 if (memcmp(buf, "connect ", 8) == 0) {
1294 ret = get_l2cap_conn(&buf[8], &addr, &addr_type, &conn);
1295 if (ret == -EINVAL)
1296 return ret;
1297
1298 if (listen_chan) {
1299 l2cap_chan_close(listen_chan, 0);
1300 l2cap_chan_put(listen_chan);
1301 listen_chan = NULL;
1302 }
1303
1304 if (conn) {
1305 struct lowpan_peer *peer;
1306
1307 if (!is_bt_6lowpan(conn->hcon))
1308 return -EINVAL;
1309
1310 peer = lookup_peer(conn);
1311 if (peer) {
1312 BT_DBG("6LoWPAN connection already exists");
1313 return -EALREADY;
1314 }
1315
1316 BT_DBG("conn %p dst %pMR type %d user %d", conn,
1317 &conn->hcon->dst, conn->hcon->dst_type,
1318 addr_type);
1319 }
1320
1321 ret = bt_6lowpan_connect(&addr, addr_type);
1322 if (ret < 0)
1323 return ret;
1324
1325 return count;
1326 }
1327
1328 if (memcmp(buf, "disconnect ", 11) == 0) {
1329 ret = get_l2cap_conn(&buf[11], &addr, &addr_type, &conn);
1330 if (ret < 0)
1331 return ret;
1332
1333 ret = bt_6lowpan_disconnect(conn, addr_type);
1334 if (ret < 0)
1335 return ret;
1336
1337 return count;
1338 }
1339
1340 return count;
1341}
1342
1343static int lowpan_control_show(struct seq_file *f, void *ptr)
1344{
Jukka Rissanen90305822014-10-28 17:16:47 +02001345 struct lowpan_dev *entry;
1346 struct lowpan_peer *peer;
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001347
Jukka Rissanen90305822014-10-28 17:16:47 +02001348 spin_lock(&devices_lock);
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001349
Jukka Rissanen90305822014-10-28 17:16:47 +02001350 list_for_each_entry(entry, &bt_6lowpan_devices, list) {
1351 list_for_each_entry(peer, &entry->peers, list)
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001352 seq_printf(f, "%pMR (type %u)\n",
1353 &peer->chan->dst, peer->chan->dst_type);
1354 }
1355
Jukka Rissanen90305822014-10-28 17:16:47 +02001356 spin_unlock(&devices_lock);
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001357
1358 return 0;
1359}
1360
1361static int lowpan_control_open(struct inode *inode, struct file *file)
1362{
1363 return single_open(file, lowpan_control_show, inode->i_private);
1364}
1365
1366static const struct file_operations lowpan_control_fops = {
1367 .open = lowpan_control_open,
1368 .read = seq_read,
1369 .write = lowpan_control_write,
1370 .llseek = seq_lseek,
1371 .release = single_release,
1372};
1373
Jukka Rissanen7f118252014-06-18 16:37:11 +03001374static void disconnect_devices(void)
1375{
Dan Carpenterdaac1972014-10-29 19:10:57 +03001376 struct lowpan_dev *entry, *tmp, *new_dev;
Jukka Rissanen7f118252014-06-18 16:37:11 +03001377 struct list_head devices;
Jukka Rissanen7f118252014-06-18 16:37:11 +03001378
1379 INIT_LIST_HEAD(&devices);
1380
1381 /* We make a separate list of devices because the unregister_netdev()
1382 * will call device_event() which will also want to modify the same
1383 * devices list.
1384 */
1385
Jukka Rissanen90305822014-10-28 17:16:47 +02001386 rcu_read_lock();
Jukka Rissanen7f118252014-06-18 16:37:11 +03001387
Jukka Rissanen90305822014-10-28 17:16:47 +02001388 list_for_each_entry_rcu(entry, &bt_6lowpan_devices, list) {
Jukka Rissanen7f118252014-06-18 16:37:11 +03001389 new_dev = kmalloc(sizeof(*new_dev), GFP_ATOMIC);
1390 if (!new_dev)
1391 break;
1392
1393 new_dev->netdev = entry->netdev;
1394 INIT_LIST_HEAD(&new_dev->list);
1395
Jukka Rissanen90305822014-10-28 17:16:47 +02001396 list_add_rcu(&new_dev->list, &devices);
Jukka Rissanen7f118252014-06-18 16:37:11 +03001397 }
1398
Jukka Rissanen90305822014-10-28 17:16:47 +02001399 rcu_read_unlock();
Jukka Rissanen7f118252014-06-18 16:37:11 +03001400
Dan Carpenterdaac1972014-10-29 19:10:57 +03001401 list_for_each_entry_safe(entry, tmp, &devices, list) {
Jukka Rissanen7f118252014-06-18 16:37:11 +03001402 ifdown(entry->netdev);
1403 BT_DBG("Unregistering netdev %s %p",
1404 entry->netdev->name, entry->netdev);
1405 unregister_netdev(entry->netdev);
1406 kfree(entry);
1407 }
1408}
1409
Jukka Rissanen18722c22013-12-11 17:05:37 +02001410static int device_event(struct notifier_block *unused,
1411 unsigned long event, void *ptr)
1412{
1413 struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
Jukka Rissanen90305822014-10-28 17:16:47 +02001414 struct lowpan_dev *entry;
Jukka Rissanen18722c22013-12-11 17:05:37 +02001415
1416 if (netdev->type != ARPHRD_6LOWPAN)
1417 return NOTIFY_DONE;
1418
1419 switch (event) {
1420 case NETDEV_UNREGISTER:
Jukka Rissanen90305822014-10-28 17:16:47 +02001421 spin_lock(&devices_lock);
1422 list_for_each_entry(entry, &bt_6lowpan_devices, list) {
Jukka Rissanen18722c22013-12-11 17:05:37 +02001423 if (entry->netdev == netdev) {
Jukka Rissanen7f118252014-06-18 16:37:11 +03001424 BT_DBG("Unregistered netdev %s %p",
1425 netdev->name, netdev);
Jukka Rissanen18722c22013-12-11 17:05:37 +02001426 list_del(&entry->list);
1427 kfree(entry);
1428 break;
1429 }
1430 }
Jukka Rissanen90305822014-10-28 17:16:47 +02001431 spin_unlock(&devices_lock);
Jukka Rissanen18722c22013-12-11 17:05:37 +02001432 break;
1433 }
1434
1435 return NOTIFY_DONE;
1436}
1437
1438static struct notifier_block bt_6lowpan_dev_notifier = {
1439 .notifier_call = device_event,
1440};
1441
Jukka Rissanen5547e482014-06-18 16:37:09 +03001442static int __init bt_6lowpan_init(void)
Jukka Rissanen18722c22013-12-11 17:05:37 +02001443{
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001444 lowpan_psm_debugfs = debugfs_create_file("6lowpan_psm", 0644,
1445 bt_debugfs, NULL,
1446 &lowpan_psm_fops);
1447 lowpan_control_debugfs = debugfs_create_file("6lowpan_control", 0644,
1448 bt_debugfs, NULL,
1449 &lowpan_control_fops);
1450
Jukka Rissanen18722c22013-12-11 17:05:37 +02001451 return register_netdevice_notifier(&bt_6lowpan_dev_notifier);
1452}
1453
Jukka Rissanen5547e482014-06-18 16:37:09 +03001454static void __exit bt_6lowpan_exit(void)
Jukka Rissanen18722c22013-12-11 17:05:37 +02001455{
Jukka Rissanen6b8d4a62014-06-18 16:37:08 +03001456 debugfs_remove(lowpan_psm_debugfs);
1457 debugfs_remove(lowpan_control_debugfs);
1458
1459 if (listen_chan) {
1460 l2cap_chan_close(listen_chan, 0);
1461 l2cap_chan_put(listen_chan);
1462 }
1463
Jukka Rissanen7f118252014-06-18 16:37:11 +03001464 disconnect_devices();
1465
Jukka Rissanen18722c22013-12-11 17:05:37 +02001466 unregister_netdevice_notifier(&bt_6lowpan_dev_notifier);
1467}
Jukka Rissanen5547e482014-06-18 16:37:09 +03001468
1469module_init(bt_6lowpan_init);
1470module_exit(bt_6lowpan_exit);
1471
1472MODULE_AUTHOR("Jukka Rissanen <jukka.rissanen@linux.intel.com>");
1473MODULE_DESCRIPTION("Bluetooth 6LoWPAN");
1474MODULE_VERSION(VERSION);
1475MODULE_LICENSE("GPL");