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