net/bluetooth/6lowpan.c

   1 /*
   2    Copyright (c) 2013-2014 Intel Corp.
   3
   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
  14 #include <linux/if_arp.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/module.h>
  18 #include <linux/debugfs.h>
  19
  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
  30 #include <net/6lowpan.h> /* for the compression support */
  31
  32 #define VERSION "0.1"
  33
  34 static struct dentry *lowpan_psm_debugfs;
  35 static struct dentry *lowpan_control_debugfs;
  36
  37 #define IFACE_NAME_TEMPLATE "bt%d"
  38 #define EUI64_ADDR_LEN 8
  39
  40 struct skb_cb {
  41         struct in6_addr addr;
  42         struct in6_addr gw;
  43         struct l2cap_chan *chan;
  44         int status;
  45 };
  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  */
  55 static LIST_HEAD(bt_6lowpan_devices);
  56 static DEFINE_RWLOCK(devices_lock);
  57
  58 /* 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  */
  62 static u16 psm_6lowpan;
  63
  64 /* We are listening incoming connections via this channel
  65  */
  66 static struct l2cap_chan *listen_chan;
  67
  68 struct lowpan_peer {
  69         struct list_head list;
  70         struct l2cap_chan *chan;
  71
  72         /* peer addresses in various formats */
  73         unsigned char eui64_addr[EUI64_ADDR_LEN];
  74         struct in6_addr peer_addr;
  75 };
  76
  77 struct lowpan_dev {
  78         struct list_head list;
  79
  80         struct hci_dev *hdev;
  81         struct net_device *netdev;
  82         struct list_head peers;
  83         atomic_t peer_count; /* number of items in peers list */
  84
  85         struct work_struct delete_netdev;
  86         struct delayed_work notify_peers;
  87 };
  88
  89 static inline struct lowpan_dev *lowpan_dev(const struct net_device *netdev)
  90 {
  91         return netdev_priv(netdev);
  92 }
  93
  94 static inline void peer_add(struct lowpan_dev *dev, struct lowpan_peer *peer)
  95 {
  96         list_add(&peer->list, &dev->peers);
  97         atomic_inc(&dev->peer_count);
  98 }
  99
 100 static inline bool peer_del(struct lowpan_dev *dev, struct lowpan_peer *peer)
 101 {
 102         list_del(&peer->list);
 103
 104         module_put(THIS_MODULE);
 105
 106         if (atomic_dec_and_test(&dev->peer_count)) {
 107                 BT_DBG("last peer");
 108                 return true;
 109         }
 110
 111         return false;
 112 }
 113
 114 static inline struct lowpan_peer *peer_lookup_ba(struct lowpan_dev *dev,
 115                                                  bdaddr_t *ba, __u8 type)
 116 {
 117         struct lowpan_peer *peer, *tmp;
 118
 119         BT_DBG("peers %d addr %pMR type %d", atomic_read(&dev->peer_count),
 120                ba, type);
 121
 122         list_for_each_entry_safe(peer, tmp, &dev->peers, list) {
 123                 BT_DBG("dst addr %pMR dst type %d",
 124                        &peer->chan->dst, peer->chan->dst_type);
 125
 126                 if (bacmp(&peer->chan->dst, ba))
 127                         continue;
 128
 129                 if (type == peer->chan->dst_type)
 130                         return peer;
 131         }
 132
 133         return NULL;
 134 }
 135
 136 static inline struct lowpan_peer *peer_lookup_chan(struct lowpan_dev *dev,
 137                                                    struct l2cap_chan *chan)
 138 {
 139         struct lowpan_peer *peer, *tmp;
 140
 141         list_for_each_entry_safe(peer, tmp, &dev->peers, list) {
 142                 if (peer->chan == chan)
 143                         return peer;
 144         }
 145
 146         return NULL;
 147 }
 148
 149 static inline struct lowpan_peer *peer_lookup_conn(struct lowpan_dev *dev,
 150                                                    struct l2cap_conn *conn)
 151 {
 152         struct lowpan_peer *peer, *tmp;
 153
 154         list_for_each_entry_safe(peer, tmp, &dev->peers, list) {
 155                 if (peer->chan->conn == conn)
 156                         return peer;
 157         }
 158
 159         return NULL;
 160 }
 161
 162 static inline struct lowpan_peer *peer_lookup_dst(struct lowpan_dev *dev,
 163                                                   struct in6_addr *daddr,
 164                                                   struct sk_buff *skb)
 165 {
 166         struct lowpan_peer *peer, *tmp;
 167         struct in6_addr *nexthop;
 168         struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
 169         int count = atomic_read(&dev->peer_count);
 170
 171         BT_DBG("peers %d addr %pI6c rt %p", count, daddr, rt);
 172
 173         /* If we have multiple 6lowpan peers, then check where we should
 174          * send the packet. If only one peer exists, then we can send the
 175          * packet right away.
 176          */
 177         if (count == 1)
 178                 return list_first_entry(&dev->peers, struct lowpan_peer,
 179                                         list);
 180
 181         if (!rt) {
 182                 nexthop = &lowpan_cb(skb)->gw;
 183
 184                 if (ipv6_addr_any(nexthop))
 185                         return NULL;
 186         } else {
 187                 nexthop = rt6_nexthop(rt);
 188
 189                 /* We need to remember the address because it is needed
 190                  * by bt_xmit() when sending the packet. In bt_xmit(), the
 191                  * destination routing info is not set.
 192                  */
 193                 memcpy(&lowpan_cb(skb)->gw, nexthop, sizeof(struct in6_addr));
 194         }
 195
 196         BT_DBG("gw %pI6c", nexthop);
 197
 198         list_for_each_entry_safe(peer, tmp, &dev->peers, list) {
 199                 BT_DBG("dst addr %pMR dst type %d ip %pI6c",
 200                        &peer->chan->dst, peer->chan->dst_type,
 201                        &peer->peer_addr);
 202
 203                 if (!ipv6_addr_cmp(&peer->peer_addr, nexthop))
 204                         return peer;
 205         }
 206
 207         return NULL;
 208 }
 209
 210 static struct lowpan_peer *lookup_peer(struct l2cap_conn *conn)
 211 {
 212         struct lowpan_dev *entry, *tmp;
 213         struct lowpan_peer *peer = NULL;
 214         unsigned long flags;
 215
 216         read_lock_irqsave(&devices_lock, flags);
 217
 218         list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
 219                 peer = peer_lookup_conn(entry, conn);
 220                 if (peer)
 221                         break;
 222         }
 223
 224         read_unlock_irqrestore(&devices_lock, flags);
 225
 226         return peer;
 227 }
 228
 229 static struct lowpan_dev *lookup_dev(struct l2cap_conn *conn)
 230 {
 231         struct lowpan_dev *entry, *tmp;
 232         struct lowpan_dev *dev = NULL;
 233         unsigned long flags;
 234
 235         read_lock_irqsave(&devices_lock, flags);
 236
 237         list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
 238                 if (conn->hcon->hdev == entry->hdev) {
 239                         dev = entry;
 240                         break;
 241                 }
 242         }
 243
 244         read_unlock_irqrestore(&devices_lock, flags);
 245
 246         return dev;
 247 }
 248
 249 static int give_skb_to_upper(struct sk_buff *skb, struct net_device *dev)
 250 {
 251         struct sk_buff *skb_cp;
 252         int ret;
 253
 254         skb_cp = skb_copy(skb, GFP_ATOMIC);
 255         if (!skb_cp)
 256                 return -ENOMEM;
 257
 258         ret = netif_rx(skb_cp);
 259         if (ret < 0) {
 260                 BT_DBG("receive skb %d", ret);
 261                 return NET_RX_DROP;
 262         }
 263
 264         return ret;
 265 }
 266
 267 static int process_data(struct sk_buff *skb, struct net_device *netdev,
 268                         struct l2cap_chan *chan)
 269 {
 270         const u8 *saddr, *daddr;
 271         u8 iphc0, iphc1;
 272         struct lowpan_dev *dev;
 273         struct lowpan_peer *peer;
 274         unsigned long flags;
 275
 276         dev = lowpan_dev(netdev);
 277
 278         read_lock_irqsave(&devices_lock, flags);
 279         peer = peer_lookup_chan(dev, chan);
 280         read_unlock_irqrestore(&devices_lock, flags);
 281         if (!peer)
 282                 goto drop;
 283
 284         saddr = peer->eui64_addr;
 285         daddr = dev->netdev->dev_addr;
 286
 287         /* at least two bytes will be used for the encoding */
 288         if (skb->len < 2)
 289                 goto drop;
 290
 291         if (lowpan_fetch_skb_u8(skb, &iphc0))
 292                 goto drop;
 293
 294         if (lowpan_fetch_skb_u8(skb, &iphc1))
 295                 goto drop;
 296
 297         return lowpan_process_data(skb, netdev,
 298                                    saddr, IEEE802154_ADDR_LONG, EUI64_ADDR_LEN,
 299                                    daddr, IEEE802154_ADDR_LONG, EUI64_ADDR_LEN,
 300                                    iphc0, iphc1, give_skb_to_upper);
 301
 302 drop:
 303         kfree_skb(skb);
 304         return -EINVAL;
 305 }
 306
 307 static int recv_pkt(struct sk_buff *skb, struct net_device *dev,
 308                     struct l2cap_chan *chan)
 309 {
 310         struct sk_buff *local_skb;
 311         int ret;
 312
 313         if (!netif_running(dev))
 314                 goto drop;
 315
 316         if (dev->type != ARPHRD_6LOWPAN)
 317                 goto drop;
 318
 319         /* check that it's our buffer */
 320         if (skb->data[0] == LOWPAN_DISPATCH_IPV6) {
 321                 /* Copy the packet so that the IPv6 header is
 322                  * properly aligned.
 323                  */
 324                 local_skb = skb_copy_expand(skb, NET_SKB_PAD - 1,
 325                                             skb_tailroom(skb), GFP_ATOMIC);
 326                 if (!local_skb)
 327                         goto drop;
 328
 329                 local_skb->protocol = htons(ETH_P_IPV6);
 330                 local_skb->pkt_type = PACKET_HOST;
 331
 332                 skb_reset_network_header(local_skb);
 333                 skb_set_transport_header(local_skb, sizeof(struct ipv6hdr));
 334
 335                 if (give_skb_to_upper(local_skb, dev) != NET_RX_SUCCESS) {
 336                         kfree_skb(local_skb);
 337                         goto drop;
 338                 }
 339
 340                 dev->stats.rx_bytes += skb->len;
 341                 dev->stats.rx_packets++;
 342
 343                 kfree_skb(local_skb);
 344                 kfree_skb(skb);
 345         } else {
 346                 switch (skb->data[0] & 0xe0) {
 347                 case LOWPAN_DISPATCH_IPHC:      /* ipv6 datagram */
 348                         local_skb = skb_clone(skb, GFP_ATOMIC);
 349                         if (!local_skb)
 350                                 goto drop;
 351
 352                         ret = process_data(local_skb, dev, chan);
 353                         if (ret != NET_RX_SUCCESS)
 354                                 goto drop;
 355
 356                         dev->stats.rx_bytes += skb->len;
 357                         dev->stats.rx_packets++;
 358
 359                         kfree_skb(skb);
 360                         break;
 361                 default:
 362                         break;
 363                 }
 364         }
 365
 366         return NET_RX_SUCCESS;
 367
 368 drop:
 369         dev->stats.rx_dropped++;
 370         kfree_skb(skb);
 371         return NET_RX_DROP;
 372 }
 373
 374 /* Packet from BT LE device */
 375 static int chan_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
 376 {
 377         struct lowpan_dev *dev;
 378         struct lowpan_peer *peer;
 379         int err;
 380
 381         peer = lookup_peer(chan->conn);
 382         if (!peer)
 383                 return -ENOENT;
 384
 385         dev = lookup_dev(chan->conn);
 386         if (!dev || !dev->netdev)
 387                 return -ENOENT;
 388
 389         err = recv_pkt(skb, dev->netdev, chan);
 390         if (err) {
 391                 BT_DBG("recv pkt %d", err);
 392                 err = -EAGAIN;
 393         }
 394
 395         return err;
 396 }
 397
 398 static u8 get_addr_type_from_eui64(u8 byte)
 399 {
 400         /* Is universal(0) or local(1) bit */
 401         return ((byte & 0x02) ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
 402 }
 403
 404 static void copy_to_bdaddr(struct in6_addr *ip6_daddr, bdaddr_t *addr)
 405 {
 406         u8 *eui64 = ip6_daddr->s6_addr + 8;
 407
 408         addr->b[0] = eui64[7];
 409         addr->b[1] = eui64[6];
 410         addr->b[2] = eui64[5];
 411         addr->b[3] = eui64[2];
 412         addr->b[4] = eui64[1];
 413         addr->b[5] = eui64[0];
 414 }
 415
 416 static void convert_dest_bdaddr(struct in6_addr *ip6_daddr,
 417                                 bdaddr_t *addr, u8 *addr_type)
 418 {
 419         copy_to_bdaddr(ip6_daddr, addr);
 420
 421         /* We need to toggle the U/L bit that we got from IPv6 address
 422          * so that we get the proper address and type of the BD address.
 423          */
 424         addr->b[5] ^= 0x02;
 425
 426         *addr_type = get_addr_type_from_eui64(addr->b[5]);
 427 }
 428
 429 static int setup_header(struct sk_buff *skb, struct net_device *netdev,
 430                         bdaddr_t *peer_addr, u8 *peer_addr_type)
 431 {
 432         struct in6_addr ipv6_daddr;
 433         struct lowpan_dev *dev;
 434         struct lowpan_peer *peer;
 435         bdaddr_t addr, *any = BDADDR_ANY;
 436         u8 *daddr = any->b;
 437         int err, status = 0;
 438
 439         dev = lowpan_dev(netdev);
 440
 441         memcpy(&ipv6_daddr, &lowpan_cb(skb)->addr, sizeof(ipv6_daddr));
 442
 443         if (ipv6_addr_is_multicast(&ipv6_daddr)) {
 444                 lowpan_cb(skb)->chan = NULL;
 445         } else {
 446                 unsigned long flags;
 447                 u8 addr_type;
 448
 449                 /* Get destination BT device from skb.
 450                  * If there is no such peer then discard the packet.
 451                  */
 452                 convert_dest_bdaddr(&ipv6_daddr, &addr, &addr_type);
 453
 454                 BT_DBG("dest addr %pMR type %d IP %pI6c", &addr,
 455                        addr_type, &ipv6_daddr);
 456
 457                 read_lock_irqsave(&devices_lock, flags);
 458                 peer = peer_lookup_ba(dev, &addr, addr_type);
 459                 read_unlock_irqrestore(&devices_lock, flags);
 460
 461                 if (!peer) {
 462                         /* The packet might be sent to 6lowpan interface
 463                          * because of routing (either via default route
 464                          * or user set route) so get peer according to
 465                          * the destination address.
 466                          */
 467                         read_lock_irqsave(&devices_lock, flags);
 468                         peer = peer_lookup_dst(dev, &ipv6_daddr, skb);
 469                         read_unlock_irqrestore(&devices_lock, flags);
 470                         if (!peer) {
 471                                 BT_DBG("no such peer %pMR found", &addr);
 472                                 return -ENOENT;
 473                         }
 474                 }
 475
 476                 daddr = peer->eui64_addr;
 477                 *peer_addr = addr;
 478                 *peer_addr_type = addr_type;
 479                 lowpan_cb(skb)->chan = peer->chan;
 480
 481                 status = 1;
 482         }
 483
 484         lowpan_header_compress(skb, netdev, ETH_P_IPV6, daddr,
 485                                dev->netdev->dev_addr, skb->len);
 486
 487         err = dev_hard_header(skb, netdev, ETH_P_IPV6, NULL, NULL, 0);
 488         if (err < 0)
 489                 return err;
 490
 491         return status;
 492 }
 493
 494 static int header_create(struct sk_buff *skb, struct net_device *netdev,
 495                          unsigned short type, const void *_daddr,
 496                          const void *_saddr, unsigned int len)
 497 {
 498         struct ipv6hdr *hdr;
 499
 500         if (type != ETH_P_IPV6)
 501                 return -EINVAL;
 502
 503         hdr = ipv6_hdr(skb);
 504
 505         memcpy(&lowpan_cb(skb)->addr, &hdr->daddr, sizeof(struct in6_addr));
 506
 507         return 0;
 508 }
 509
 510 /* Packet to BT LE device */
 511 static int send_pkt(struct l2cap_chan *chan, struct sk_buff *skb,
 512                     struct net_device *netdev, bool is_mcast)
 513 {
 514         struct msghdr msg;
 515         struct kvec iv;
 516         int err;
 517
 518         /* Remember the skb so that we can send EAGAIN to the caller if
 519          * we run out of credits. This is not done for multicast packets
 520          * because we generate mcast packet in this module and are not
 521          * really able to remember the skb after this packet is sent.
 522          */
 523         if (is_mcast)
 524                 chan->data = NULL;
 525         else
 526                 chan->data = skb;
 527
 528         memset(&msg, 0, sizeof(msg));
 529         msg.msg_iov = (struct iovec *) &iv;
 530         msg.msg_iovlen = 1;
 531         iv.iov_base = skb->data;
 532         iv.iov_len = skb->len;
 533
 534         err = l2cap_chan_send(chan, &msg, skb->len);
 535         if (err > 0) {
 536                 netdev->stats.tx_bytes += err;
 537                 netdev->stats.tx_packets++;
 538                 return 0;
 539         }
 540
 541         if (!err)
 542                 err = lowpan_cb(skb)->status;
 543
 544         if (err < 0) {
 545                 if (err == -EAGAIN)
 546                         netdev->stats.tx_dropped++;
 547                 else
 548                         netdev->stats.tx_errors++;
 549         }
 550
 551         return err;
 552 }
 553
 554 static void send_mcast_pkt(struct sk_buff *skb, struct net_device *netdev)
 555 {
 556         struct sk_buff *local_skb;
 557         struct lowpan_dev *entry, *tmp;
 558         unsigned long flags;
 559
 560         read_lock_irqsave(&devices_lock, flags);
 561
 562         list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
 563                 struct lowpan_peer *pentry, *ptmp;
 564                 struct lowpan_dev *dev;
 565
 566                 if (entry->netdev != netdev)
 567                         continue;
 568
 569                 dev = lowpan_dev(entry->netdev);
 570
 571                 list_for_each_entry_safe(pentry, ptmp, &dev->peers, list) {
 572                         local_skb = skb_clone(skb, GFP_ATOMIC);
 573
 574                         BT_DBG("xmit %s to %pMR type %d IP %pI6c chan %p",
 575                                netdev->name,
 576                                &pentry->chan->dst, pentry->chan->dst_type,
 577                                &pentry->peer_addr, pentry->chan);
 578                         send_pkt(pentry->chan, local_skb, netdev, true);
 579
 580                         kfree_skb(local_skb);
 581                 }
 582         }
 583
 584         read_unlock_irqrestore(&devices_lock, flags);
 585 }
 586
 587 static netdev_tx_t bt_xmit(struct sk_buff *skb, struct net_device *netdev)
 588 {
 589         int err = 0;
 590         bdaddr_t addr;
 591         u8 addr_type;
 592
 593         /* We must take a copy of the skb before we modify/replace the ipv6
 594          * header as the header could be used elsewhere
 595          */
 596         skb = skb_unshare(skb, GFP_ATOMIC);
 597         if (!skb)
 598                 return NET_XMIT_DROP;
 599
 600         /* Return values from setup_header()
 601          *  <0 - error, packet is dropped
 602          *   0 - this is a multicast packet
 603          *   1 - this is unicast packet
 604          */
 605         err = setup_header(skb, netdev, &addr, &addr_type);
 606         if (err < 0) {
 607                 kfree_skb(skb);
 608                 return NET_XMIT_DROP;
 609         }
 610
 611         if (err) {
 612                 if (lowpan_cb(skb)->chan) {
 613                         BT_DBG("xmit %s to %pMR type %d IP %pI6c chan %p",
 614                                netdev->name, &addr, addr_type,
 615                                &lowpan_cb(skb)->addr, lowpan_cb(skb)->chan);
 616                         err = send_pkt(lowpan_cb(skb)->chan, skb, netdev,
 617                                        false);
 618                 } else {
 619                         err = -ENOENT;
 620                 }
 621         } else {
 622                 /* We need to send the packet to every device behind this
 623                  * interface.
 624                  */
 625                 send_mcast_pkt(skb, netdev);
 626         }
 627
 628         dev_kfree_skb(skb);
 629
 630         if (err)
 631                 BT_DBG("ERROR: xmit failed (%d)", err);
 632
 633         return err < 0 ? NET_XMIT_DROP : err;
 634 }
 635
 636 static const struct net_device_ops netdev_ops = {
 637         .ndo_start_xmit         = bt_xmit,
 638 };
 639
 640 static struct header_ops header_ops = {
 641         .create = header_create,
 642 };
 643
 644 static void netdev_setup(struct net_device *dev)
 645 {
 646         dev->addr_len           = EUI64_ADDR_LEN;
 647         dev->type               = ARPHRD_6LOWPAN;
 648
 649         dev->hard_header_len    = 0;
 650         dev->needed_tailroom    = 0;
 651         dev->mtu                = IPV6_MIN_MTU;
 652         dev->tx_queue_len       = 0;
 653         dev->flags              = IFF_RUNNING | IFF_POINTOPOINT |
 654                                   IFF_MULTICAST;
 655         dev->watchdog_timeo     = 0;
 656
 657         dev->netdev_ops         = &netdev_ops;
 658         dev->header_ops         = &header_ops;
 659         dev->destructor         = free_netdev;
 660 }
 661
 662 static struct device_type bt_type = {
 663         .name   = "bluetooth",
 664 };
 665
 666 static void set_addr(u8 *eui, u8 *addr, u8 addr_type)
 667 {
 668         /* addr is the BT address in little-endian format */
 669         eui[0] = addr[5];
 670         eui[1] = addr[4];
 671         eui[2] = addr[3];
 672         eui[3] = 0xFF;
 673         eui[4] = 0xFE;
 674         eui[5] = addr[2];
 675         eui[6] = addr[1];
 676         eui[7] = addr[0];
 677
 678         /* Universal/local bit set, BT 6lowpan draft ch. 3.2.1 */
 679         if (addr_type == BDADDR_LE_PUBLIC)
 680                 eui[0] &= ~0x02;
 681         else
 682                 eui[0] |= 0x02;
 683
 684         BT_DBG("type %d addr %*phC", addr_type, 8, eui);
 685 }
 686
 687 static void set_dev_addr(struct net_device *netdev, bdaddr_t *addr,
 688                          u8 addr_type)
 689 {
 690         netdev->addr_assign_type = NET_ADDR_PERM;
 691         set_addr(netdev->dev_addr, addr->b, addr_type);
 692 }
 693
 694 static void ifup(struct net_device *netdev)
 695 {
 696         int err;
 697
 698         rtnl_lock();
 699         err = dev_open(netdev);
 700         if (err < 0)
 701                 BT_INFO("iface %s cannot be opened (%d)", netdev->name, err);
 702         rtnl_unlock();
 703 }
 704
 705 static void ifdown(struct net_device *netdev)
 706 {
 707         int err;
 708
 709         rtnl_lock();
 710         err = dev_close(netdev);
 711         if (err < 0)
 712                 BT_INFO("iface %s cannot be closed (%d)", netdev->name, err);
 713         rtnl_unlock();
 714 }
 715
 716 static void do_notify_peers(struct work_struct *work)
 717 {
 718         struct lowpan_dev *dev = container_of(work, struct lowpan_dev,
 719                                               notify_peers.work);
 720
 721         netdev_notify_peers(dev->netdev); /* send neighbour adv at startup */
 722 }
 723
 724 static bool is_bt_6lowpan(struct hci_conn *hcon)
 725 {
 726         if (hcon->type != LE_LINK)
 727                 return false;
 728
 729         if (!psm_6lowpan)
 730                 return false;
 731
 732         return true;
 733 }
 734
 735 static struct l2cap_chan *chan_create(void)
 736 {
 737         struct l2cap_chan *chan;
 738
 739         chan = l2cap_chan_create();
 740         if (!chan)
 741                 return NULL;
 742
 743         l2cap_chan_set_defaults(chan);
 744
 745         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
 746         chan->mode = L2CAP_MODE_LE_FLOWCTL;
 747         chan->omtu = 65535;
 748         chan->imtu = chan->omtu;
 749
 750         return chan;
 751 }
 752
 753 static struct l2cap_chan *chan_open(struct l2cap_chan *pchan)
 754 {
 755         struct l2cap_chan *chan;
 756
 757         chan = chan_create();
 758         if (!chan)
 759                 return NULL;
 760
 761         chan->remote_mps = chan->omtu;
 762         chan->mps = chan->omtu;
 763
 764         chan->state = BT_CONNECTED;
 765
 766         return chan;
 767 }
 768
 769 static void set_ip_addr_bits(u8 addr_type, u8 *addr)
 770 {
 771         if (addr_type == BDADDR_LE_PUBLIC)
 772                 *addr |= 0x02;
 773         else
 774                 *addr &= ~0x02;
 775 }
 776
 777 static struct l2cap_chan *add_peer_chan(struct l2cap_chan *chan,
 778                                         struct lowpan_dev *dev)
 779 {
 780         struct lowpan_peer *peer;
 781         unsigned long flags;
 782
 783         peer = kzalloc(sizeof(*peer), GFP_ATOMIC);
 784         if (!peer)
 785                 return NULL;
 786
 787         peer->chan = chan;
 788         memset(&peer->peer_addr, 0, sizeof(struct in6_addr));
 789
 790         /* RFC 2464 ch. 5 */
 791         peer->peer_addr.s6_addr[0] = 0xFE;
 792         peer->peer_addr.s6_addr[1] = 0x80;
 793         set_addr((u8 *)&peer->peer_addr.s6_addr + 8, chan->dst.b,
 794                  chan->dst_type);
 795
 796         memcpy(&peer->eui64_addr, (u8 *)&peer->peer_addr.s6_addr + 8,
 797                EUI64_ADDR_LEN);
 798
 799         /* IPv6 address needs to have the U/L bit set properly so toggle
 800          * it back here.
 801          */
 802         set_ip_addr_bits(chan->dst_type, (u8 *)&peer->peer_addr.s6_addr + 8);
 803
 804         write_lock_irqsave(&devices_lock, flags);
 805         INIT_LIST_HEAD(&peer->list);
 806         peer_add(dev, peer);
 807         write_unlock_irqrestore(&devices_lock, flags);
 808
 809         /* Notifying peers about us needs to be done without locks held */
 810         INIT_DELAYED_WORK(&dev->notify_peers, do_notify_peers);
 811         schedule_delayed_work(&dev->notify_peers, msecs_to_jiffies(100));
 812
 813         return peer->chan;
 814 }
 815
 816 static int setup_netdev(struct l2cap_chan *chan, struct lowpan_dev **dev)
 817 {
 818         struct net_device *netdev;
 819         int err = 0;
 820         unsigned long flags;
 821
 822         netdev = alloc_netdev(sizeof(struct lowpan_dev), IFACE_NAME_TEMPLATE,
 823                               NET_NAME_UNKNOWN, netdev_setup);
 824         if (!netdev)
 825                 return -ENOMEM;
 826
 827         set_dev_addr(netdev, &chan->src, chan->src_type);
 828
 829         netdev->netdev_ops = &netdev_ops;
 830         SET_NETDEV_DEV(netdev, &chan->conn->hcon->dev);
 831         SET_NETDEV_DEVTYPE(netdev, &bt_type);
 832
 833         err = register_netdev(netdev);
 834         if (err < 0) {
 835                 BT_INFO("register_netdev failed %d", err);
 836                 free_netdev(netdev);
 837                 goto out;
 838         }
 839
 840         BT_DBG("ifindex %d peer bdaddr %pMR type %d my addr %pMR type %d",
 841                netdev->ifindex, &chan->dst, chan->dst_type,
 842                &chan->src, chan->src_type);
 843         set_bit(__LINK_STATE_PRESENT, &netdev->state);
 844
 845         *dev = netdev_priv(netdev);
 846         (*dev)->netdev = netdev;
 847         (*dev)->hdev = chan->conn->hcon->hdev;
 848         INIT_LIST_HEAD(&(*dev)->peers);
 849
 850         write_lock_irqsave(&devices_lock, flags);
 851         INIT_LIST_HEAD(&(*dev)->list);
 852         list_add(&(*dev)->list, &bt_6lowpan_devices);
 853         write_unlock_irqrestore(&devices_lock, flags);
 854
 855         return 0;
 856
 857 out:
 858         return err;
 859 }
 860
 861 static inline void chan_ready_cb(struct l2cap_chan *chan)
 862 {
 863         struct lowpan_dev *dev;
 864
 865         dev = lookup_dev(chan->conn);
 866
 867         BT_DBG("chan %p conn %p dev %p", chan, chan->conn, dev);
 868
 869         if (!dev) {
 870                 if (setup_netdev(chan, &dev) < 0) {
 871                         l2cap_chan_del(chan, -ENOENT);
 872                         return;
 873                 }
 874         }
 875
 876         if (!try_module_get(THIS_MODULE))
 877                 return;
 878
 879         add_peer_chan(chan, dev);
 880         ifup(dev->netdev);
 881 }
 882
 883 static inline struct l2cap_chan *chan_new_conn_cb(struct l2cap_chan *pchan)
 884 {
 885         struct l2cap_chan *chan;
 886
 887         chan = chan_open(pchan);
 888         chan->ops = pchan->ops;
 889
 890         BT_DBG("chan %p pchan %p", chan, pchan);
 891
 892         return chan;
 893 }
 894
 895 static void delete_netdev(struct work_struct *work)
 896 {
 897         struct lowpan_dev *entry = container_of(work, struct lowpan_dev,
 898                                                 delete_netdev);
 899
 900         unregister_netdev(entry->netdev);
 901
 902         /* The entry pointer is deleted in device_event() */
 903 }
 904
 905 static void chan_close_cb(struct l2cap_chan *chan)
 906 {
 907         struct lowpan_dev *entry, *tmp;
 908         struct lowpan_dev *dev = NULL;
 909         struct lowpan_peer *peer;
 910         int err = -ENOENT;
 911         unsigned long flags;
 912         bool last = false, removed = true;
 913
 914         BT_DBG("chan %p conn %p", chan, chan->conn);
 915
 916         if (chan->conn && chan->conn->hcon) {
 917                 if (!is_bt_6lowpan(chan->conn->hcon))
 918                         return;
 919
 920                 /* If conn is set, then the netdev is also there and we should
 921                  * not remove it.
 922                  */
 923                 removed = false;
 924         }
 925
 926         write_lock_irqsave(&devices_lock, flags);
 927
 928         list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
 929                 dev = lowpan_dev(entry->netdev);
 930                 peer = peer_lookup_chan(dev, chan);
 931                 if (peer) {
 932                         last = peer_del(dev, peer);
 933                         err = 0;
 934
 935                         BT_DBG("dev %p removing %speer %p", dev,
 936                                last ? "last " : "1 ", peer);
 937                         BT_DBG("chan %p orig refcnt %d", chan,
 938                                atomic_read(&chan->kref.refcount));
 939
 940                         l2cap_chan_put(chan);
 941                         kfree(peer);
 942                         break;
 943                 }
 944         }
 945
 946         if (!err && last && dev && !atomic_read(&dev->peer_count)) {
 947                 write_unlock_irqrestore(&devices_lock, flags);
 948
 949                 cancel_delayed_work_sync(&dev->notify_peers);
 950
 951                 ifdown(dev->netdev);
 952
 953                 if (!removed) {
 954                         INIT_WORK(&entry->delete_netdev, delete_netdev);
 955                         schedule_work(&entry->delete_netdev);
 956                 }
 957         } else {
 958                 write_unlock_irqrestore(&devices_lock, flags);
 959         }
 960
 961         return;
 962 }
 963
 964 static void chan_state_change_cb(struct l2cap_chan *chan, int state, int err)
 965 {
 966         BT_DBG("chan %p conn %p state %s err %d", chan, chan->conn,
 967                state_to_string(state), err);
 968 }
 969
 970 static struct sk_buff *chan_alloc_skb_cb(struct l2cap_chan *chan,
 971                                          unsigned long hdr_len,
 972                                          unsigned long len, int nb)
 973 {
 974         /* Note that we must allocate using GFP_ATOMIC here as
 975          * this function is called originally from netdev hard xmit
 976          * function in atomic context.
 977          */
 978         return bt_skb_alloc(hdr_len + len, GFP_ATOMIC);
 979 }
 980
 981 static void chan_suspend_cb(struct l2cap_chan *chan)
 982 {
 983         struct sk_buff *skb = chan->data;
 984
 985         BT_DBG("chan %p conn %p skb %p", chan, chan->conn, skb);
 986
 987         if (!skb)
 988                 return;
 989
 990         lowpan_cb(skb)->status = -EAGAIN;
 991 }
 992
 993 static void chan_resume_cb(struct l2cap_chan *chan)
 994 {
 995         struct sk_buff *skb = chan->data;
 996
 997         BT_DBG("chan %p conn %p skb %p", chan, chan->conn, skb);
 998
 999         if (!skb)
1000                 return;
1001
1002         lowpan_cb(skb)->status = 0;
1003 }
1004
1005 static long chan_get_sndtimeo_cb(struct l2cap_chan *chan)
1006 {
1007         return L2CAP_CONN_TIMEOUT;
1008 }
1009
1010 static const struct l2cap_ops bt_6lowpan_chan_ops = {
1011         .name                   = "L2CAP 6LoWPAN channel",
1012         .new_connection         = chan_new_conn_cb,
1013         .recv                   = chan_recv_cb,
1014         .close                  = chan_close_cb,
1015         .state_change           = chan_state_change_cb,
1016         .ready                  = chan_ready_cb,
1017         .resume                 = chan_resume_cb,
1018         .suspend                = chan_suspend_cb,
1019         .get_sndtimeo           = chan_get_sndtimeo_cb,
1020         .alloc_skb              = chan_alloc_skb_cb,
1021         .memcpy_fromiovec       = l2cap_chan_no_memcpy_fromiovec,
1022
1023         .teardown               = l2cap_chan_no_teardown,
1024         .defer                  = l2cap_chan_no_defer,
1025         .set_shutdown           = l2cap_chan_no_set_shutdown,
1026 };
1027
1028 static inline __u8 bdaddr_type(__u8 type)
1029 {
1030         if (type == ADDR_LE_DEV_PUBLIC)
1031                 return BDADDR_LE_PUBLIC;
1032         else
1033                 return BDADDR_LE_RANDOM;
1034 }
1035
1036 static struct l2cap_chan *chan_get(void)
1037 {
1038         struct l2cap_chan *pchan;
1039
1040         pchan = chan_create();
1041         if (!pchan)
1042                 return NULL;
1043
1044         pchan->ops = &bt_6lowpan_chan_ops;
1045
1046         return pchan;
1047 }
1048
1049 static int bt_6lowpan_connect(bdaddr_t *addr, u8 dst_type)
1050 {
1051         struct l2cap_chan *pchan;
1052         int err;
1053
1054         pchan = chan_get();
1055         if (!pchan)
1056                 return -EINVAL;
1057
1058         err = l2cap_chan_connect(pchan, cpu_to_le16(psm_6lowpan), 0,
1059                                  addr, dst_type);
1060
1061         BT_DBG("chan %p err %d", pchan, err);
1062         if (err < 0)
1063                 l2cap_chan_put(pchan);
1064
1065         return err;
1066 }
1067
1068 static int bt_6lowpan_disconnect(struct l2cap_conn *conn, u8 dst_type)
1069 {
1070         struct lowpan_peer *peer;
1071
1072         BT_DBG("conn %p dst type %d", conn, dst_type);
1073
1074         peer = lookup_peer(conn);
1075         if (!peer)
1076                 return -ENOENT;
1077
1078         BT_DBG("peer %p chan %p", peer, peer->chan);
1079
1080         l2cap_chan_close(peer->chan, ENOENT);
1081
1082         return 0;
1083 }
1084
1085 static struct l2cap_chan *bt_6lowpan_listen(void)
1086 {
1087         bdaddr_t *addr = BDADDR_ANY;
1088         struct l2cap_chan *pchan;
1089         int err;
1090
1091         if (psm_6lowpan == 0)
1092                 return NULL;
1093
1094         pchan = chan_get();
1095         if (!pchan)
1096                 return NULL;
1097
1098         pchan->state = BT_LISTEN;
1099         pchan->src_type = BDADDR_LE_PUBLIC;
1100
1101         BT_DBG("psm 0x%04x chan %p src type %d", psm_6lowpan, pchan,
1102                pchan->src_type);
1103
1104         err = l2cap_add_psm(pchan, addr, cpu_to_le16(psm_6lowpan));
1105         if (err) {
1106                 l2cap_chan_put(pchan);
1107                 BT_ERR("psm cannot be added err %d", err);
1108                 return NULL;
1109         }
1110
1111         return pchan;
1112 }
1113
1114 static int get_l2cap_conn(char *buf, bdaddr_t *addr, u8 *addr_type,
1115                           struct l2cap_conn **conn)
1116 {
1117         struct hci_conn *hcon;
1118         struct hci_dev *hdev;
1119         bdaddr_t *src = BDADDR_ANY;
1120         int n;
1121
1122         n = sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx %hhu",
1123                    &addr->b[5], &addr->b[4], &addr->b[3],
1124                    &addr->b[2], &addr->b[1], &addr->b[0],
1125                    addr_type);
1126
1127         if (n < 7)
1128                 return -EINVAL;
1129
1130         hdev = hci_get_route(addr, src);
1131         if (!hdev)
1132                 return -ENOENT;
1133
1134         hci_dev_lock(hdev);
1135         hcon = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr);
1136         hci_dev_unlock(hdev);
1137
1138         if (!hcon)
1139                 return -ENOENT;
1140
1141         *conn = (struct l2cap_conn *)hcon->l2cap_data;
1142
1143         BT_DBG("conn %p dst %pMR type %d", *conn, &hcon->dst, hcon->dst_type);
1144
1145         return 0;
1146 }
1147
1148 static void disconnect_all_peers(void)
1149 {
1150         struct lowpan_dev *entry, *tmp_dev;
1151         struct lowpan_peer *peer, *tmp_peer, *new_peer;
1152         struct list_head peers;
1153         unsigned long flags;
1154
1155         INIT_LIST_HEAD(&peers);
1156
1157         /* We make a separate list of peers as the close_cb() will
1158          * modify the device peers list so it is better not to mess
1159          * with the same list at the same time.
1160          */
1161
1162         read_lock_irqsave(&devices_lock, flags);
1163
1164         list_for_each_entry_safe(entry, tmp_dev, &bt_6lowpan_devices, list) {
1165                 list_for_each_entry_safe(peer, tmp_peer, &entry->peers, list) {
1166                         new_peer = kmalloc(sizeof(*new_peer), GFP_ATOMIC);
1167                         if (!new_peer)
1168                                 break;
1169
1170                         new_peer->chan = peer->chan;
1171                         INIT_LIST_HEAD(&new_peer->list);
1172
1173                         list_add(&new_peer->list, &peers);
1174                 }
1175         }
1176
1177         read_unlock_irqrestore(&devices_lock, flags);
1178
1179         list_for_each_entry_safe(peer, tmp_peer, &peers, list) {
1180                 l2cap_chan_close(peer->chan, ENOENT);
1181                 kfree(peer);
1182         }
1183 }
1184
1185 static int lowpan_psm_set(void *data, u64 val)
1186 {
1187         u16 psm;
1188
1189         psm = val;
1190         if (psm == 0 || psm_6lowpan != psm)
1191                 /* Disconnect existing connections if 6lowpan is
1192                  * disabled (psm = 0), or if psm changes.
1193                  */
1194                 disconnect_all_peers();
1195
1196         psm_6lowpan = psm;
1197
1198         if (listen_chan) {
1199                 l2cap_chan_close(listen_chan, 0);
1200                 l2cap_chan_put(listen_chan);
1201         }
1202
1203         listen_chan = bt_6lowpan_listen();
1204
1205         return 0;
1206 }
1207
1208 static int lowpan_psm_get(void *data, u64 *val)
1209 {
1210         *val = psm_6lowpan;
1211         return 0;
1212 }
1213
1214 DEFINE_SIMPLE_ATTRIBUTE(lowpan_psm_fops, lowpan_psm_get,
1215                         lowpan_psm_set, "%llu\n");
1216
1217 static ssize_t lowpan_control_write(struct file *fp,
1218                                     const char __user *user_buffer,
1219                                     size_t count,
1220                                     loff_t *position)
1221 {
1222         char buf[32];
1223         size_t buf_size = min(count, sizeof(buf) - 1);
1224         int ret;
1225         bdaddr_t addr;
1226         u8 addr_type;
1227         struct l2cap_conn *conn = NULL;
1228
1229         if (copy_from_user(buf, user_buffer, buf_size))
1230                 return -EFAULT;
1231
1232         buf[buf_size] = '\0';
1233
1234         if (memcmp(buf, "connect ", 8) == 0) {
1235                 ret = get_l2cap_conn(&buf[8], &addr, &addr_type, &conn);
1236                 if (ret == -EINVAL)
1237                         return ret;
1238
1239                 if (listen_chan) {
1240                         l2cap_chan_close(listen_chan, 0);
1241                         l2cap_chan_put(listen_chan);
1242                         listen_chan = NULL;
1243                 }
1244
1245                 if (conn) {
1246                         struct lowpan_peer *peer;
1247
1248                         if (!is_bt_6lowpan(conn->hcon))
1249                                 return -EINVAL;
1250
1251                         peer = lookup_peer(conn);
1252                         if (peer) {
1253                                 BT_DBG("6LoWPAN connection already exists");
1254                                 return -EALREADY;
1255                         }
1256
1257                         BT_DBG("conn %p dst %pMR type %d user %d", conn,
1258                                &conn->hcon->dst, conn->hcon->dst_type,
1259                                addr_type);
1260                 }
1261
1262                 ret = bt_6lowpan_connect(&addr, addr_type);
1263                 if (ret < 0)
1264                         return ret;
1265
1266                 return count;
1267         }
1268
1269         if (memcmp(buf, "disconnect ", 11) == 0) {
1270                 ret = get_l2cap_conn(&buf[11], &addr, &addr_type, &conn);
1271                 if (ret < 0)
1272                         return ret;
1273
1274                 ret = bt_6lowpan_disconnect(conn, addr_type);
1275                 if (ret < 0)
1276                         return ret;
1277
1278                 return count;
1279         }
1280
1281         return count;
1282 }
1283
1284 static int lowpan_control_show(struct seq_file *f, void *ptr)
1285 {
1286         struct lowpan_dev *entry, *tmp_dev;
1287         struct lowpan_peer *peer, *tmp_peer;
1288         unsigned long flags;
1289
1290         read_lock_irqsave(&devices_lock, flags);
1291
1292         list_for_each_entry_safe(entry, tmp_dev, &bt_6lowpan_devices, list) {
1293                 list_for_each_entry_safe(peer, tmp_peer, &entry->peers, list)
1294                         seq_printf(f, "%pMR (type %u)\n",
1295                                    &peer->chan->dst, peer->chan->dst_type);
1296         }
1297
1298         read_unlock_irqrestore(&devices_lock, flags);
1299
1300         return 0;
1301 }
1302
1303 static int lowpan_control_open(struct inode *inode, struct file *file)
1304 {
1305         return single_open(file, lowpan_control_show, inode->i_private);
1306 }
1307
1308 static const struct file_operations lowpan_control_fops = {
1309         .open           = lowpan_control_open,
1310         .read           = seq_read,
1311         .write          = lowpan_control_write,
1312         .llseek         = seq_lseek,
1313         .release        = single_release,
1314 };
1315
1316 static void disconnect_devices(void)
1317 {
1318         struct lowpan_dev *entry, *tmp, *new_dev;
1319         struct list_head devices;
1320         unsigned long flags;
1321
1322         INIT_LIST_HEAD(&devices);
1323
1324         /* We make a separate list of devices because the unregister_netdev()
1325          * will call device_event() which will also want to modify the same
1326          * devices list.
1327          */
1328
1329         read_lock_irqsave(&devices_lock, flags);
1330
1331         list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices, list) {
1332                 new_dev = kmalloc(sizeof(*new_dev), GFP_ATOMIC);
1333                 if (!new_dev)
1334                         break;
1335
1336                 new_dev->netdev = entry->netdev;
1337                 INIT_LIST_HEAD(&new_dev->list);
1338
1339                 list_add(&new_dev->list, &devices);
1340         }
1341
1342         read_unlock_irqrestore(&devices_lock, flags);
1343
1344         list_for_each_entry_safe(entry, tmp, &devices, list) {
1345                 ifdown(entry->netdev);
1346                 BT_DBG("Unregistering netdev %s %p",
1347                        entry->netdev->name, entry->netdev);
1348                 unregister_netdev(entry->netdev);
1349                 kfree(entry);
1350         }
1351 }
1352
1353 static int device_event(struct notifier_block *unused,
1354                         unsigned long event, void *ptr)
1355 {
1356         struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
1357         struct lowpan_dev *entry, *tmp;
1358         unsigned long flags;
1359
1360         if (netdev->type != ARPHRD_6LOWPAN)
1361                 return NOTIFY_DONE;
1362
1363         switch (event) {
1364         case NETDEV_UNREGISTER:
1365                 write_lock_irqsave(&devices_lock, flags);
1366                 list_for_each_entry_safe(entry, tmp, &bt_6lowpan_devices,
1367                                          list) {
1368                         if (entry->netdev == netdev) {
1369                                 BT_DBG("Unregistered netdev %s %p",
1370                                        netdev->name, netdev);
1371                                 list_del(&entry->list);
1372                                 kfree(entry);
1373                                 break;
1374                         }
1375                 }
1376                 write_unlock_irqrestore(&devices_lock, flags);
1377                 break;
1378         }
1379
1380         return NOTIFY_DONE;
1381 }
1382
1383 static struct notifier_block bt_6lowpan_dev_notifier = {
1384         .notifier_call = device_event,
1385 };
1386
1387 static int __init bt_6lowpan_init(void)
1388 {
1389         lowpan_psm_debugfs = debugfs_create_file("6lowpan_psm", 0644,
1390                                                  bt_debugfs, NULL,
1391                                                  &lowpan_psm_fops);
1392         lowpan_control_debugfs = debugfs_create_file("6lowpan_control", 0644,
1393                                                      bt_debugfs, NULL,
1394                                                      &lowpan_control_fops);
1395
1396         return register_netdevice_notifier(&bt_6lowpan_dev_notifier);
1397 }
1398
1399 static void __exit bt_6lowpan_exit(void)
1400 {
1401         debugfs_remove(lowpan_psm_debugfs);
1402         debugfs_remove(lowpan_control_debugfs);
1403
1404         if (listen_chan) {
1405                 l2cap_chan_close(listen_chan, 0);
1406                 l2cap_chan_put(listen_chan);
1407         }
1408
1409         disconnect_devices();
1410
1411         unregister_netdevice_notifier(&bt_6lowpan_dev_notifier);
1412 }
1413
1414 module_init(bt_6lowpan_init);
1415 module_exit(bt_6lowpan_exit);
1416
1417 MODULE_AUTHOR("Jukka Rissanen <jukka.rissanen@linux.intel.com>");
1418 MODULE_DESCRIPTION("Bluetooth 6LoWPAN");
1419 MODULE_VERSION(VERSION);
1420 MODULE_LICENSE("GPL");