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