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