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