git.oblomov.eu Git - linux-2.6/blob - 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, 0x0000300c },
  70         /* Commands */
  71         {
  72                 { 0x0 },
  73                 /* OGF_LINK_CTL */
  74                 { 0xbe000006, 0x00000001, 0x0000, 0x00 },
  75                 /* OGF_LINK_POLICY */
  76                 { 0x00005200, 0x00000000, 0x0000, 0x00 },
  77                 /* OGF_HOST_CTL */
  78                 { 0xaab00200, 0x2b402aaa, 0x0154, 0x00 },
  79                 /* OGF_INFO_PARAM */
  80                 { 0x000002be, 0x00000000, 0x0000, 0x00 },
  81                 /* OGF_STATUS_PARAM */
  82                 { 0x000000ea, 0x00000000, 0x0000, 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((skb->pkt_type == HCI_VENDOR_PKT) ?
 114                                 0 : (skb->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
 115                         continue;
 116
 117                 if (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), &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                 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(int), &bt_cb(skb)->incoming);
 332
 333         if (mask & HCI_CMSG_TSTAMP)
 334                 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(skb->stamp), &skb->stamp);
 335 }
 336
 337 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 338                                 struct msghdr *msg, size_t len, int flags)
 339 {
 340         int noblock = flags & MSG_DONTWAIT;
 341         struct sock *sk = sock->sk;
 342         struct sk_buff *skb;
 343         int copied, err;
 344
 345         BT_DBG("sock %p, sk %p", sock, sk);
 346
 347         if (flags & (MSG_OOB))
 348                 return -EOPNOTSUPP;
 349
 350         if (sk->sk_state == BT_CLOSED)
 351                 return 0;
 352
 353         if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
 354                 return err;
 355
 356         msg->msg_namelen = 0;
 357
 358         copied = skb->len;
 359         if (len < copied) {
 360                 msg->msg_flags |= MSG_TRUNC;
 361                 copied = len;
 362         }
 363
 364         skb->h.raw = skb->data;
 365         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 366
 367         hci_sock_cmsg(sk, msg, skb);
 368
 369         skb_free_datagram(sk, skb);
 370
 371         return err ? : copied;
 372 }
 373
 374 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 375                             struct msghdr *msg, size_t len)
 376 {
 377         struct sock *sk = sock->sk;
 378         struct hci_dev *hdev;
 379         struct sk_buff *skb;
 380         int err;
 381
 382         BT_DBG("sock %p sk %p", sock, sk);
 383
 384         if (msg->msg_flags & MSG_OOB)
 385                 return -EOPNOTSUPP;
 386
 387         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
 388                 return -EINVAL;
 389
 390         if (len < 4 || len > HCI_MAX_FRAME_SIZE)
 391                 return -EINVAL;
 392
 393         lock_sock(sk);
 394
 395         if (!(hdev = hci_pi(sk)->hdev)) {
 396                 err = -EBADFD;
 397                 goto done;
 398         }
 399
 400         if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
 401                 goto done;
 402
 403         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
 404                 err = -EFAULT;
 405                 goto drop;
 406         }
 407
 408         skb->pkt_type = *((unsigned char *) skb->data);
 409         skb_pull(skb, 1);
 410         skb->dev = (void *) hdev;
 411
 412         if (skb->pkt_type == HCI_COMMAND_PKT) {
 413                 u16 opcode = __le16_to_cpu(get_unaligned((u16 *)skb->data));
 414                 u16 ogf = hci_opcode_ogf(opcode);
 415                 u16 ocf = hci_opcode_ocf(opcode);
 416
 417                 if (((ogf > HCI_SFLT_MAX_OGF) ||
 418                                 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
 419                                         !capable(CAP_NET_RAW)) {
 420                         err = -EPERM;
 421                         goto drop;
 422                 }
 423
 424                 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
 425                         skb_queue_tail(&hdev->raw_q, skb);
 426                         hci_sched_tx(hdev);
 427                 } else {
 428                         skb_queue_tail(&hdev->cmd_q, skb);
 429                         hci_sched_cmd(hdev);
 430                 }
 431         } else {
 432                 if (!capable(CAP_NET_RAW)) {
 433                         err = -EPERM;
 434                         goto drop;
 435                 }
 436
 437                 skb_queue_tail(&hdev->raw_q, skb);
 438                 hci_sched_tx(hdev);
 439         }
 440
 441         err = len;
 442
 443 done:
 444         release_sock(sk);
 445         return err;
 446
 447 drop:
 448         kfree_skb(skb);
 449         goto done;
 450 }
 451
 452 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
 453 {
 454         struct hci_ufilter uf = { .opcode = 0 };
 455         struct sock *sk = sock->sk;
 456         int err = 0, opt = 0;
 457
 458         BT_DBG("sk %p, opt %d", sk, optname);
 459
 460         lock_sock(sk);
 461
 462         switch (optname) {
 463         case HCI_DATA_DIR:
 464                 if (get_user(opt, (int __user *)optval)) {
 465                         err = -EFAULT;
 466                         break;
 467                 }
 468
 469                 if (opt)
 470                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
 471                 else
 472                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
 473                 break;
 474
 475         case HCI_TIME_STAMP:
 476                 if (get_user(opt, (int __user *)optval)) {
 477                         err = -EFAULT;
 478                         break;
 479                 }
 480
 481                 if (opt)
 482                         hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
 483                 else
 484                         hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
 485                 break;
 486
 487         case HCI_FILTER:
 488                 len = min_t(unsigned int, len, sizeof(uf));
 489                 if (copy_from_user(&uf, optval, len)) {
 490                         err = -EFAULT;
 491                         break;
 492                 }
 493
 494                 if (!capable(CAP_NET_RAW)) {
 495                         uf.type_mask &= hci_sec_filter.type_mask;
 496                         uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
 497                         uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
 498                 }
 499
 500                 {
 501                         struct hci_filter *f = &hci_pi(sk)->filter;
 502
 503                         f->type_mask = uf.type_mask;
 504                         f->opcode    = uf.opcode;
 505                         *((u32 *) f->event_mask + 0) = uf.event_mask[0];
 506                         *((u32 *) f->event_mask + 1) = uf.event_mask[1];
 507                 }
 508                 break;
 509
 510         default:
 511                 err = -ENOPROTOOPT;
 512                 break;
 513         }
 514
 515         release_sock(sk);
 516         return err;
 517 }
 518
 519 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 520 {
 521         struct hci_ufilter uf;
 522         struct sock *sk = sock->sk;
 523         int len, opt;
 524
 525         if (get_user(len, optlen))
 526                 return -EFAULT;
 527
 528         switch (optname) {
 529         case HCI_DATA_DIR:
 530                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
 531                         opt = 1;
 532                 else
 533                         opt = 0;
 534
 535                 if (put_user(opt, optval))
 536                         return -EFAULT;
 537                 break;
 538
 539         case HCI_TIME_STAMP:
 540                 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
 541                         opt = 1;
 542                 else
 543                         opt = 0;
 544
 545                 if (put_user(opt, optval))
 546                         return -EFAULT;
 547                 break;
 548
 549         case HCI_FILTER:
 550                 {
 551                         struct hci_filter *f = &hci_pi(sk)->filter;
 552
 553                         uf.type_mask = f->type_mask;
 554                         uf.opcode    = f->opcode;
 555                         uf.event_mask[0] = *((u32 *) f->event_mask + 0);
 556                         uf.event_mask[1] = *((u32 *) f->event_mask + 1);
 557                 }
 558
 559                 len = min_t(unsigned int, len, sizeof(uf));
 560                 if (copy_to_user(optval, &uf, len))
 561                         return -EFAULT;
 562                 break;
 563
 564         default:
 565                 return -ENOPROTOOPT;
 566                 break;
 567         }
 568
 569         return 0;
 570 }
 571
 572 static struct proto_ops hci_sock_ops = {
 573         .family         = PF_BLUETOOTH,
 574         .owner          = THIS_MODULE,
 575         .release        = hci_sock_release,
 576         .bind           = hci_sock_bind,
 577         .getname        = hci_sock_getname,
 578         .sendmsg        = hci_sock_sendmsg,
 579         .recvmsg        = hci_sock_recvmsg,
 580         .ioctl          = hci_sock_ioctl,
 581         .poll           = datagram_poll,
 582         .listen         = sock_no_listen,
 583         .shutdown       = sock_no_shutdown,
 584         .setsockopt     = hci_sock_setsockopt,
 585         .getsockopt     = hci_sock_getsockopt,
 586         .connect        = sock_no_connect,
 587         .socketpair     = sock_no_socketpair,
 588         .accept         = sock_no_accept,
 589         .mmap           = sock_no_mmap
 590 };
 591
 592 static struct proto hci_sk_proto = {
 593         .name           = "HCI",
 594         .owner          = THIS_MODULE,
 595         .obj_size       = sizeof(struct hci_pinfo)
 596 };
 597
 598 static int hci_sock_create(struct socket *sock, int protocol)
 599 {
 600         struct sock *sk;
 601
 602         BT_DBG("sock %p", sock);
 603
 604         if (sock->type != SOCK_RAW)
 605                 return -ESOCKTNOSUPPORT;
 606
 607         sock->ops = &hci_sock_ops;
 608
 609         sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, &hci_sk_proto, 1);
 610         if (!sk)
 611                 return -ENOMEM;
 612
 613         sock_init_data(sock, sk);
 614
 615         sock_reset_flag(sk, SOCK_ZAPPED);
 616
 617         sk->sk_protocol = protocol;
 618
 619         sock->state = SS_UNCONNECTED;
 620         sk->sk_state = BT_OPEN;
 621
 622         bt_sock_link(&hci_sk_list, sk);
 623         return 0;
 624 }
 625
 626 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
 627 {
 628         struct hci_dev *hdev = (struct hci_dev *) ptr;
 629         struct hci_ev_si_device ev;
 630
 631         BT_DBG("hdev %s event %ld", hdev->name, event);
 632
 633         /* Send event to sockets */
 634         ev.event  = event;
 635         ev.dev_id = hdev->id;
 636         hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
 637
 638         if (event == HCI_DEV_UNREG) {
 639                 struct sock *sk;
 640                 struct hlist_node *node;
 641
 642                 /* Detach sockets from device */
 643                 read_lock(&hci_sk_list.lock);
 644                 sk_for_each(sk, node, &hci_sk_list.head) {
 645                         bh_lock_sock(sk);
 646                         if (hci_pi(sk)->hdev == hdev) {
 647                                 hci_pi(sk)->hdev = NULL;
 648                                 sk->sk_err = EPIPE;
 649                                 sk->sk_state = BT_OPEN;
 650                                 sk->sk_state_change(sk);
 651
 652                                 hci_dev_put(hdev);
 653                         }
 654                         bh_unlock_sock(sk);
 655                 }
 656                 read_unlock(&hci_sk_list.lock);
 657         }
 658
 659         return NOTIFY_DONE;
 660 }
 661
 662 static struct net_proto_family hci_sock_family_ops = {
 663         .family = PF_BLUETOOTH,
 664         .owner  = THIS_MODULE,
 665         .create = hci_sock_create,
 666 };
 667
 668 static struct notifier_block hci_sock_nblock = {
 669         .notifier_call = hci_sock_dev_event
 670 };
 671
 672 int __init hci_sock_init(void)
 673 {
 674         int err;
 675
 676         err = proto_register(&hci_sk_proto, 0);
 677         if (err < 0)
 678                 return err;
 679
 680         err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
 681         if (err < 0)
 682                 goto error;
 683
 684         hci_register_notifier(&hci_sock_nblock);
 685
 686         BT_INFO("HCI socket layer initialized");
 687
 688         return 0;
 689
 690 error:
 691         BT_ERR("HCI socket registration failed");
 692         proto_unregister(&hci_sk_proto);
 693         return err;
 694 }
 695
 696 int __exit hci_sock_cleanup(void)
 697 {
 698         if (bt_sock_unregister(BTPROTO_HCI) < 0)
 699                 BT_ERR("HCI socket unregistration failed");
 700
 701         hci_unregister_notifier(&hci_sock_nblock);
 702
 703         proto_unregister(&hci_sk_proto);
 704
 705         return 0;
 706 }