net/bluetooth/hci_sock.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 /* Bluetooth HCI sockets. */
  26
  27 #include <linux/config.h>
  28 #include <linux/module.h>
  29
  30 #include <linux/types.h>
  31 #include <linux/errno.h>
  32 #include <linux/kernel.h>
  33 #include <linux/major.h>
  34 #include <linux/sched.h>
  35 #include <linux/slab.h>
  36 #include <linux/poll.h>
  37 #include <linux/fcntl.h>
  38 #include <linux/init.h>
  39 #include <linux/skbuff.h>
  40 #include <linux/workqueue.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/socket.h>
  43 #include <linux/ioctl.h>
  44 #include <net/sock.h>
  45
  46 #include <asm/system.h>
  47 #include <asm/uaccess.h>
  48 #include <asm/unaligned.h>
  49
  50 #include <net/bluetooth/bluetooth.h>
  51 #include <net/bluetooth/hci_core.h>
  52
  53 #ifndef CONFIG_BT_HCI_SOCK_DEBUG
  54 #undef  BT_DBG
  55 #define BT_DBG(D...)
  56 #endif
  57
  58 /* ----- HCI socket interface ----- */
  59
  60 static inline int hci_test_bit(int nr, void *addr)
  61 {
  62         return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
  63 }
  64
  65 /* Security filter */
  66 static struct hci_sec_filter hci_sec_filter = {
  67         /* Packet types */
  68         0x10,
  69         /* Events */
  70         { 0x1000d9fe, 0x0000300c },
  71         /* Commands */
  72         {
  73                 { 0x0 },
  74                 /* OGF_LINK_CTL */
  75                 { 0xbe000006, 0x00000001, 0x0000, 0x00 },
  76                 /* OGF_LINK_POLICY */
  77                 { 0x00005200, 0x00000000, 0x0000, 0x00 },
  78                 /* OGF_HOST_CTL */
  79                 { 0xaab00200, 0x2b402aaa, 0x0154, 0x00 },
  80                 /* OGF_INFO_PARAM */
  81                 { 0x000002be, 0x00000000, 0x0000, 0x00 },
  82                 /* OGF_STATUS_PARAM */
  83                 { 0x000000ea, 0x00000000, 0x0000, 0x00 }
  84         }
  85 };
  86
  87 static struct bt_sock_list hci_sk_list = {
  88         .lock = RW_LOCK_UNLOCKED
  89 };
  90
  91 /* Send frame to RAW socket */
  92 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
  93 {
  94         struct sock *sk;
  95         struct hlist_node *node;
  96
  97         BT_DBG("hdev %p len %d", hdev, skb->len);
  98
  99         read_lock(&hci_sk_list.lock);
 100         sk_for_each(sk, node, &hci_sk_list.head) {
 101                 struct hci_filter *flt;
 102                 struct sk_buff *nskb;
 103
 104                 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
 105                         continue;
 106
 107                 /* Don't send frame to the socket it came from */
 108                 if (skb->sk == sk)
 109                         continue;
 110
 111                 /* Apply filter */
 112                 flt = &hci_pi(sk)->filter;
 113
 114                 if (!test_bit((skb->pkt_type == HCI_VENDOR_PKT) ?
 115                                 0 : (skb->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
 116                         continue;
 117
 118                 if (skb->pkt_type == HCI_EVENT_PKT) {
 119                         register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
 120
 121                         if (!hci_test_bit(evt, &flt->event_mask))
 122                                 continue;
 123
 124                         if (flt->opcode && ((evt == HCI_EV_CMD_COMPLETE &&
 125                                         flt->opcode != *(__u16 *)(skb->data + 3)) ||
 126                                         (evt == HCI_EV_CMD_STATUS &&
 127                                         flt->opcode != *(__u16 *)(skb->data + 4))))
 128                                 continue;
 129                 }
 130
 131                 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
 132                         continue;
 133
 134                 /* Put type byte before the data */
 135                 memcpy(skb_push(nskb, 1), &nskb->pkt_type, 1);
 136
 137                 if (sock_queue_rcv_skb(sk, nskb))
 138                         kfree_skb(nskb);
 139         }
 140         read_unlock(&hci_sk_list.lock);
 141 }
 142
 143 static int hci_sock_release(struct socket *sock)
 144 {
 145         struct sock *sk = sock->sk;
 146         struct hci_dev *hdev = hci_pi(sk)->hdev;
 147
 148         BT_DBG("sock %p sk %p", sock, sk);
 149
 150         if (!sk)
 151                 return 0;
 152
 153         bt_sock_unlink(&hci_sk_list, sk);
 154
 155         if (hdev) {
 156                 atomic_dec(&hdev->promisc);
 157                 hci_dev_put(hdev);
 158         }
 159
 160         sock_orphan(sk);
 161
 162         skb_queue_purge(&sk->sk_receive_queue);
 163         skb_queue_purge(&sk->sk_write_queue);
 164
 165         sock_put(sk);
 166         return 0;
 167 }
 168
 169 /* Ioctls that require bound socket */
 170 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
 171 {
 172         struct hci_dev *hdev = hci_pi(sk)->hdev;
 173
 174         if (!hdev)
 175                 return -EBADFD;
 176
 177         switch (cmd) {
 178         case HCISETRAW:
 179                 if (!capable(CAP_NET_ADMIN))
 180                         return -EACCES;
 181
 182                 if (arg)
 183                         set_bit(HCI_RAW, &hdev->flags);
 184                 else
 185                         clear_bit(HCI_RAW, &hdev->flags);
 186
 187                 return 0;
 188
 189         case HCISETSECMGR:
 190                 if (!capable(CAP_NET_ADMIN))
 191                         return -EACCES;
 192
 193                 if (arg)
 194                         set_bit(HCI_SECMGR, &hdev->flags);
 195                 else
 196                         clear_bit(HCI_SECMGR, &hdev->flags);
 197
 198                 return 0;
 199
 200         case HCIGETCONNINFO:
 201                 return hci_get_conn_info(hdev, (void __user *)arg);
 202
 203         default:
 204                 if (hdev->ioctl)
 205                         return hdev->ioctl(hdev, cmd, arg);
 206                 return -EINVAL;
 207         }
 208 }
 209
 210 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 211 {
 212         struct sock *sk = sock->sk;
 213         void __user *argp = (void __user *)arg;
 214         int err;
 215
 216         BT_DBG("cmd %x arg %lx", cmd, arg);
 217
 218         switch (cmd) {
 219         case HCIGETDEVLIST:
 220                 return hci_get_dev_list(argp);
 221
 222         case HCIGETDEVINFO:
 223                 return hci_get_dev_info(argp);
 224
 225         case HCIGETCONNLIST:
 226                 return hci_get_conn_list(argp);
 227
 228         case HCIDEVUP:
 229                 if (!capable(CAP_NET_ADMIN))
 230                         return -EACCES;
 231                 return hci_dev_open(arg);
 232
 233         case HCIDEVDOWN:
 234                 if (!capable(CAP_NET_ADMIN))
 235                         return -EACCES;
 236                 return hci_dev_close(arg);
 237
 238         case HCIDEVRESET:
 239                 if (!capable(CAP_NET_ADMIN))
 240                         return -EACCES;
 241                 return hci_dev_reset(arg);
 242
 243         case HCIDEVRESTAT:
 244                 if (!capable(CAP_NET_ADMIN))
 245                         return -EACCES;
 246                 return hci_dev_reset_stat(arg);
 247
 248         case HCISETSCAN:
 249         case HCISETAUTH:
 250         case HCISETENCRYPT:
 251         case HCISETPTYPE:
 252         case HCISETLINKPOL:
 253         case HCISETLINKMODE:
 254         case HCISETACLMTU:
 255         case HCISETSCOMTU:
 256                 if (!capable(CAP_NET_ADMIN))
 257                         return -EACCES;
 258                 return hci_dev_cmd(cmd, argp);
 259
 260         case HCIINQUIRY:
 261                 return hci_inquiry(argp);
 262
 263         default:
 264                 lock_sock(sk);
 265                 err = hci_sock_bound_ioctl(sk, cmd, arg);
 266                 release_sock(sk);
 267                 return err;
 268         }
 269 }
 270
 271 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 272 {
 273         struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
 274         struct sock *sk = sock->sk;
 275         struct hci_dev *hdev = NULL;
 276         int err = 0;
 277
 278         BT_DBG("sock %p sk %p", sock, sk);
 279
 280         if (!haddr || haddr->hci_family != AF_BLUETOOTH)
 281                 return -EINVAL;
 282
 283         lock_sock(sk);
 284
 285         if (hci_pi(sk)->hdev) {
 286                 err = -EALREADY;
 287                 goto done;
 288         }
 289
 290         if (haddr->hci_dev != HCI_DEV_NONE) {
 291                 if (!(hdev = hci_dev_get(haddr->hci_dev))) {
 292                         err = -ENODEV;
 293                         goto done;
 294                 }
 295
 296                 atomic_inc(&hdev->promisc);
 297         }
 298
 299         hci_pi(sk)->hdev = hdev;
 300         sk->sk_state = BT_BOUND;
 301
 302 done:
 303         release_sock(sk);
 304         return err;
 305 }
 306
 307 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
 308 {
 309         struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
 310         struct sock *sk = sock->sk;
 311
 312         BT_DBG("sock %p sk %p", sock, sk);
 313
 314         lock_sock(sk);
 315
 316         *addr_len = sizeof(*haddr);
 317         haddr->hci_family = AF_BLUETOOTH;
 318         haddr->hci_dev    = hci_pi(sk)->hdev->id;
 319
 320         release_sock(sk);
 321         return 0;
 322 }
 323
 324 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
 325 {
 326         __u32 mask = hci_pi(sk)->cmsg_mask;
 327
 328         if (mask & HCI_CMSG_DIR)
 329                 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(int), &bt_cb(skb)->incoming);
 330
 331         if (mask & HCI_CMSG_TSTAMP)
 332                 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(skb->stamp), &skb->stamp);
 333 }
 334
 335 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 336                                 struct msghdr *msg, size_t len, int flags)
 337 {
 338         int noblock = flags & MSG_DONTWAIT;
 339         struct sock *sk = sock->sk;
 340         struct sk_buff *skb;
 341         int copied, err;
 342
 343         BT_DBG("sock %p, sk %p", sock, sk);
 344
 345         if (flags & (MSG_OOB))
 346                 return -EOPNOTSUPP;
 347
 348         if (sk->sk_state == BT_CLOSED)
 349                 return 0;
 350
 351         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
 352                 return err;
 353
 354         msg->msg_namelen = 0;
 355
 356         copied = skb->len;
 357         if (len < copied) {
 358                 msg->msg_flags |= MSG_TRUNC;
 359                 copied = len;
 360         }
 361
 362         skb->h.raw = skb->data;
 363         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 364
 365         hci_sock_cmsg(sk, msg, skb);
 366
 367         skb_free_datagram(sk, skb);
 368
 369         return err ? : copied;
 370 }
 371
 372 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 373                             struct msghdr *msg, size_t len)
 374 {
 375         struct sock *sk = sock->sk;
 376         struct hci_dev *hdev;
 377         struct sk_buff *skb;
 378         int err;
 379
 380         BT_DBG("sock %p sk %p", sock, sk);
 381
 382         if (msg->msg_flags & MSG_OOB)
 383                 return -EOPNOTSUPP;
 384
 385         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
 386                 return -EINVAL;
 387
 388         if (len < 4 || len > HCI_MAX_FRAME_SIZE)
 389                 return -EINVAL;
 390
 391         lock_sock(sk);
 392
 393         if (!(hdev = hci_pi(sk)->hdev)) {
 394                 err = -EBADFD;
 395                 goto done;
 396         }
 397
 398         if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
 399                 goto done;
 400
 401         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
 402                 err = -EFAULT;
 403                 goto drop;
 404         }
 405
 406         skb->pkt_type = *((unsigned char *) skb->data);
 407         skb_pull(skb, 1);
 408         skb->dev = (void *) hdev;
 409
 410         if (skb->pkt_type == HCI_COMMAND_PKT) {
 411                 u16 opcode = __le16_to_cpu(get_unaligned((u16 *)skb->data));
 412                 u16 ogf = hci_opcode_ogf(opcode);
 413                 u16 ocf = hci_opcode_ocf(opcode);
 414
 415                 if (((ogf > HCI_SFLT_MAX_OGF) ||
 416                                 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
 417                                         !capable(CAP_NET_RAW)) {
 418                         err = -EPERM;
 419                         goto drop;
 420                 }
 421
 422                 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
 423                         skb_queue_tail(&hdev->raw_q, skb);
 424                         hci_sched_tx(hdev);
 425                 } else {
 426                         skb_queue_tail(&hdev->cmd_q, skb);
 427                         hci_sched_cmd(hdev);
 428                 }
 429         } else {
 430                 if (!capable(CAP_NET_RAW)) {
 431                         err = -EPERM;
 432                         goto drop;
 433                 }
 434
 435                 skb_queue_tail(&hdev->raw_q, skb);
 436                 hci_sched_tx(hdev);
 437         }
 438
 439         err = len;
 440
 441 done:
 442         release_sock(sk);
 443         return err;
 444
 445 drop:
 446         kfree_skb(skb);
 447         goto done;
 448 }
 449
 450 int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
 451 {
 452         struct hci_ufilter uf = { .opcode = 0 };
 453         struct sock *sk = sock->sk;
 454         int err = 0, opt = 0;
 455
 456         BT_DBG("sk %p, opt %d", sk, optname);
 457
 458         lock_sock(sk);
 459
 460         switch (optname) {
 461         case HCI_DATA_DIR:
 462                 if (get_user(opt, (int __user *)optval)) {
 463                         err = -EFAULT;
 464                         break;
 465                 }
 466
 467                 if (opt)
 468                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
 469                 else
 470                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
 471                 break;
 472
 473         case HCI_TIME_STAMP:
 474                 if (get_user(opt, (int __user *)optval)) {
 475                         err = -EFAULT;
 476                         break;
 477                 }
 478
 479                 if (opt)
 480                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
 481                 else
 482                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
 483                 break;
 484
 485         case HCI_FILTER:
 486                 len = min_t(unsigned int, len, sizeof(uf));
 487                 if (copy_from_user(&uf, optval, len)) {
 488                         err = -EFAULT;
 489                         break;
 490                 }
 491
 492                 if (!capable(CAP_NET_RAW)) {
 493                         uf.type_mask &= hci_sec_filter.type_mask;
 494                         uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
 495                         uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
 496                 }
 497
 498                 {
 499                         struct hci_filter *f = &hci_pi(sk)->filter;
 500
 501                         f->type_mask = uf.type_mask;
 502                         f->opcode    = uf.opcode;
 503                         *((u32 *) f->event_mask + 0) = uf.event_mask[0];
 504                         *((u32 *) f->event_mask + 1) = uf.event_mask[1];
 505                 }
 506                 break;
 507
 508         default:
 509                 err = -ENOPROTOOPT;
 510                 break;
 511         }
 512
 513         release_sock(sk);
 514         return err;
 515 }
 516
 517 int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 518 {
 519         struct hci_ufilter uf;
 520         struct sock *sk = sock->sk;
 521         int len, opt;
 522
 523         if (get_user(len, optlen))
 524                 return -EFAULT;
 525
 526         switch (optname) {
 527         case HCI_DATA_DIR:
 528                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
 529                         opt = 1;
 530                 else
 531                         opt = 0;
 532
 533                 if (put_user(opt, optval))
 534                         return -EFAULT;
 535                 break;
 536
 537         case HCI_TIME_STAMP:
 538                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
 539                         opt = 1;
 540                 else
 541                         opt = 0;
 542
 543                 if (put_user(opt, optval))
 544                         return -EFAULT;
 545                 break;
 546
 547         case HCI_FILTER:
 548                 {
 549                         struct hci_filter *f = &hci_pi(sk)->filter;
 550
 551                         uf.type_mask = f->type_mask;
 552                         uf.opcode    = f->opcode;
 553                         uf.event_mask[0] = *((u32 *) f->event_mask + 0);
 554                         uf.event_mask[1] = *((u32 *) f->event_mask + 1);
 555                 }
 556
 557                 len = min_t(unsigned int, len, sizeof(uf));
 558                 if (copy_to_user(optval, &uf, len))
 559                         return -EFAULT;
 560                 break;
 561
 562         default:
 563                 return -ENOPROTOOPT;
 564                 break;
 565         }
 566
 567         return 0;
 568 }
 569
 570 struct proto_ops hci_sock_ops = {
 571         .family         = PF_BLUETOOTH,
 572         .owner          = THIS_MODULE,
 573         .release        = hci_sock_release,
 574         .bind           = hci_sock_bind,
 575         .getname        = hci_sock_getname,
 576         .sendmsg        = hci_sock_sendmsg,
 577         .recvmsg        = hci_sock_recvmsg,
 578         .ioctl          = hci_sock_ioctl,
 579         .poll           = datagram_poll,
 580         .listen         = sock_no_listen,
 581         .shutdown       = sock_no_shutdown,
 582         .setsockopt     = hci_sock_setsockopt,
 583         .getsockopt     = hci_sock_getsockopt,
 584         .connect        = sock_no_connect,
 585         .socketpair     = sock_no_socketpair,
 586         .accept         = sock_no_accept,
 587         .mmap           = sock_no_mmap
 588 };
 589
 590 static int hci_sock_create(struct socket *sock, int protocol)
 591 {
 592         struct sock *sk;
 593
 594         BT_DBG("sock %p", sock);
 595
 596         if (sock->type != SOCK_RAW)
 597                 return -ESOCKTNOSUPPORT;
 598
 599         sock->ops = &hci_sock_ops;
 600
 601         sk = bt_sock_alloc(sock, protocol, sizeof(struct hci_pinfo), GFP_KERNEL);
 602         if (!sk)
 603                 return -ENOMEM;
 604
 605         sk_set_owner(sk, THIS_MODULE);
 606
 607         sock->state = SS_UNCONNECTED;
 608         sk->sk_state = BT_OPEN;
 609
 610         bt_sock_link(&hci_sk_list, sk);
 611         return 0;
 612 }
 613
 614 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
 615 {
 616         struct hci_dev *hdev = (struct hci_dev *) ptr;
 617         struct hci_ev_si_device ev;
 618
 619         BT_DBG("hdev %s event %ld", hdev->name, event);
 620
 621         /* Send event to sockets */
 622         ev.event  = event;
 623         ev.dev_id = hdev->id;
 624         hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
 625
 626         if (event == HCI_DEV_UNREG) {
 627                 struct sock *sk;
 628                 struct hlist_node *node;
 629
 630                 /* Detach sockets from device */
 631                 read_lock(&hci_sk_list.lock);
 632                 sk_for_each(sk, node, &hci_sk_list.head) {
 633                         bh_lock_sock(sk);
 634                         if (hci_pi(sk)->hdev == hdev) {
 635                                 hci_pi(sk)->hdev = NULL;
 636                                 sk->sk_err = EPIPE;
 637                                 sk->sk_state = BT_OPEN;
 638                                 sk->sk_state_change(sk);
 639
 640                                 hci_dev_put(hdev);
 641                         }
 642                         bh_unlock_sock(sk);
 643                 }
 644                 read_unlock(&hci_sk_list.lock);
 645         }
 646
 647         return NOTIFY_DONE;
 648 }
 649
 650 struct net_proto_family hci_sock_family_ops = {
 651         .family = PF_BLUETOOTH,
 652         .owner  = THIS_MODULE,
 653         .create = hci_sock_create,
 654 };
 655
 656 struct notifier_block hci_sock_nblock = {
 657         .notifier_call = hci_sock_dev_event
 658 };
 659
 660 int __init hci_sock_init(void)
 661 {
 662         if (bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops)) {
 663                 BT_ERR("HCI socket registration failed");
 664                 return -EPROTO;
 665         }
 666
 667         hci_register_notifier(&hci_sock_nblock);
 668
 669         BT_INFO("HCI socket layer initialized");
 670
 671         return 0;
 672 }
 673
 674 int __exit hci_sock_cleanup(void)
 675 {
 676         if (bt_sock_unregister(BTPROTO_HCI))
 677                 BT_ERR("HCI socket unregistration failed");
 678
 679         hci_unregister_notifier(&hci_sock_nblock);
 680         return 0;
 681 }