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