projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
kcmp: make it depend on CHECKPOINT_RESTORE
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / sco.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 SCO sockets. */
26
1da177e4 27#include <linux/module.h>
aef7d97c
MH		 28#include <linux/debugfs.h>
29#include <linux/seq_file.h>
1da177e4
LT		 30
31#include <net/bluetooth/bluetooth.h>
32#include <net/bluetooth/hci_core.h>
33#include <net/bluetooth/sco.h>
34
eb939922 35static bool disable_esco;
1da177e4 36
90ddc4f0 37static const struct proto_ops sco_sock_ops;
1da177e4
LT		 38
39static struct bt_sock_list sco_sk_list = {
d5fb2962 40 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
1da177e4
LT		 41};
42
43static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
44static void sco_chan_del(struct sock *sk, int err);
45
1da177e4
LT		 46static void sco_sock_close(struct sock *sk);
47static void sco_sock_kill(struct sock *sk);
48
49/* ---- SCO timers ---- */
50static void sco_sock_timeout(unsigned long arg)
51{
52 struct sock *sk = (struct sock *) arg;
53
54 BT_DBG("sock %p state %d", sk, sk->sk_state);
55
56 bh_lock_sock(sk);
57 sk->sk_err = ETIMEDOUT;
58 sk->sk_state_change(sk);
59 bh_unlock_sock(sk);
60
61 sco_sock_kill(sk);
62 sock_put(sk);
63}
64
65static void sco_sock_set_timer(struct sock *sk, long timeout)
66{
67 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
68 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
69}
70
71static void sco_sock_clear_timer(struct sock *sk)
72{
73 BT_DBG("sock %p state %d", sk, sk->sk_state);
74 sk_stop_timer(sk, &sk->sk_timer);
75}
76
1da177e4 77/* ---- SCO connections ---- */
519e42b3 78static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
1da177e4
LT		 79{
80 struct hci_dev *hdev = hcon->hdev;
25ea6db0 81 struct sco_conn *conn = hcon->sco_data;
1da177e4 82
519e42b3 83 if (conn)
1da177e4
LT		 84 return conn;
85
25ea6db0
MH		 86 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
87 if (!conn)
1da177e4 88 return NULL;
1da177e4
LT		 89
90 spin_lock_init(&conn->lock);
91
92 hcon->sco_data = conn;
93 conn->hcon = hcon;
94
95 conn->src = &hdev->bdaddr;
96 conn->dst = &hcon->dst;
97
98 if (hdev->sco_mtu > 0)
99 conn->mtu = hdev->sco_mtu;
100 else
101 conn->mtu = 60;
102
103 BT_DBG("hcon %p conn %p", hcon, conn);
25ea6db0 104
1da177e4
LT		 105 return conn;
106}
107
6039aa73 108static struct sock *sco_chan_get(struct sco_conn *conn)
1da177e4
LT		 109{
110 struct sock *sk = NULL;
111 sco_conn_lock(conn);
112 sk = conn->sk;
113 sco_conn_unlock(conn);
114 return sk;
115}
116
117static int sco_conn_del(struct hci_conn *hcon, int err)
118{
735cbc47 119 struct sco_conn *conn = hcon->sco_data;
1da177e4
LT		 120 struct sock *sk;
121
735cbc47 122 if (!conn)
1da177e4
LT		 123 return 0;
124
125 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
126
127 /* Kill socket */
735cbc47
AE		 128 sk = sco_chan_get(conn);
129 if (sk) {
1da177e4
LT		 130 bh_lock_sock(sk);
131 sco_sock_clear_timer(sk);
132 sco_chan_del(sk, err);
133 bh_unlock_sock(sk);
134 sco_sock_kill(sk);
135 }
136
137 hcon->sco_data = NULL;
138 kfree(conn);
139 return 0;
140}
141
6039aa73
GP		 142static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
143 struct sock *parent)
1da177e4
LT		 144{
145 int err = 0;
146
147 sco_conn_lock(conn);
b9dbdbc1 148 if (conn->sk)
1da177e4 149 err = -EBUSY;
b9dbdbc1 150 else
1da177e4 151 __sco_chan_add(conn, sk, parent);
b9dbdbc1 152
1da177e4
LT		 153 sco_conn_unlock(conn);
154 return err;
155}
156
157static int sco_connect(struct sock *sk)
158{
159 bdaddr_t *src = &bt_sk(sk)->src;
160 bdaddr_t *dst = &bt_sk(sk)->dst;
161 struct sco_conn *conn;
162 struct hci_conn *hcon;
163 struct hci_dev *hdev;
b6a0dc82 164 int err, type;
1da177e4 165
6ed93dc6 166 BT_DBG("%pMR -> %pMR", src, dst);
1da177e4 167
735cbc47
AE		 168 hdev = hci_get_route(dst, src);
169 if (!hdev)
1da177e4
LT		 170 return -EHOSTUNREACH;
171
09fd0de5 172 hci_dev_lock(hdev);
1da177e4 173
7cb127d5
MH		 174 if (lmp_esco_capable(hdev) && !disable_esco)
175 type = ESCO_LINK;
176 else
177 type = SCO_LINK;
b6a0dc82 178
b12f62cf
AG		 179 hcon = hci_connect(hdev, type, dst, BDADDR_BREDR, BT_SECURITY_LOW,
180 HCI_AT_NO_BONDING);
30e76272
VT		 181 if (IS_ERR(hcon)) {
182 err = PTR_ERR(hcon);
1da177e4 183 goto done;
30e76272 184 }
1da177e4 185
519e42b3 186 conn = sco_conn_add(hcon);
1da177e4
LT		 187 if (!conn) {
188 hci_conn_put(hcon);
30e76272 189 err = -ENOMEM;
1da177e4
LT		 190 goto done;
191 }
192
193 /* Update source addr of the socket */
194 bacpy(src, conn->src);
195
196 err = sco_chan_add(conn, sk, NULL);
197 if (err)
198 goto done;
199
200 if (hcon->state == BT_CONNECTED) {
201 sco_sock_clear_timer(sk);
202 sk->sk_state = BT_CONNECTED;
203 } else {
204 sk->sk_state = BT_CONNECT;
205 sco_sock_set_timer(sk, sk->sk_sndtimeo);
206 }
b6a0dc82 207
1da177e4 208done:
09fd0de5 209 hci_dev_unlock(hdev);
1da177e4
LT		 210 hci_dev_put(hdev);
211 return err;
212}
213
6039aa73 214static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
1da177e4
LT		 215{
216 struct sco_conn *conn = sco_pi(sk)->conn;
217 struct sk_buff *skb;
088ce088 218 int err;
1da177e4
LT		 219
220 /* Check outgoing MTU */
221 if (len > conn->mtu)
222 return -EINVAL;
223
224 BT_DBG("sk %p len %d", sk, len);
225
088ce088 226 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
b9dbdbc1 227 if (!skb)
1da177e4
LT		 228 return err;
229
088ce088 230 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
b9dbdbc1
GP		 231 kfree_skb(skb);
232 return -EFAULT;
1da177e4
LT		 233 }
234
0d861d8b 235 hci_send_sco(conn->hcon, skb);
1da177e4 236
088ce088 237 return len;
1da177e4
LT		 238}
239
6039aa73 240static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
1da177e4
LT		 241{
242 struct sock *sk = sco_chan_get(conn);
243
244 if (!sk)
245 goto drop;
246
247 BT_DBG("sk %p len %d", sk, skb->len);
248
249 if (sk->sk_state != BT_CONNECTED)
250 goto drop;
251
252 if (!sock_queue_rcv_skb(sk, skb))
253 return;
254
255drop:
256 kfree_skb(skb);
1da177e4
LT		 257}
258
259/* -------- Socket interface ---------- */
fb334059 260static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
1da177e4 261{
1da177e4 262 struct hlist_node *node;
fb334059
MH		 263 struct sock *sk;
264
265 sk_for_each(sk, node, &sco_sk_list.head) {
266 if (sk->sk_state != BT_LISTEN)
267 continue;
1da177e4 268
1da177e4 269 if (!bacmp(&bt_sk(sk)->src, ba))
fb334059
MH		 270 return sk;
271 }
272
273 return NULL;
1da177e4
LT		 274}
275
276/* Find socket listening on source bdaddr.
277 * Returns closest match.
278 */
279static struct sock *sco_get_sock_listen(bdaddr_t *src)
280{
281 struct sock *sk = NULL, *sk1 = NULL;
282 struct hlist_node *node;
283
284 read_lock(&sco_sk_list.lock);
285
286 sk_for_each(sk, node, &sco_sk_list.head) {
287 if (sk->sk_state != BT_LISTEN)
288 continue;
289
290 /* Exact match. */
291 if (!bacmp(&bt_sk(sk)->src, src))
292 break;
293
294 /* Closest match */
295 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
296 sk1 = sk;
297 }
298
299 read_unlock(&sco_sk_list.lock);
300
301 return node ? sk : sk1;
302}
303
304static void sco_sock_destruct(struct sock *sk)
305{
306 BT_DBG("sk %p", sk);
307
308 skb_queue_purge(&sk->sk_receive_queue);
309 skb_queue_purge(&sk->sk_write_queue);
310}
311
312static void sco_sock_cleanup_listen(struct sock *parent)
313{
314 struct sock *sk;
315
316 BT_DBG("parent %p", parent);
317
318 /* Close not yet accepted channels */
319 while ((sk = bt_accept_dequeue(parent, NULL))) {
320 sco_sock_close(sk);
321 sco_sock_kill(sk);
322 }
323
324 parent->sk_state = BT_CLOSED;
325 sock_set_flag(parent, SOCK_ZAPPED);
326}
327
328/* Kill socket (only if zapped and orphan)
329 * Must be called on unlocked socket.
330 */
331static void sco_sock_kill(struct sock *sk)
332{
333 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
334 return;
335
336 BT_DBG("sk %p state %d", sk, sk->sk_state);
337
338 /* Kill poor orphan */
339 bt_sock_unlink(&sco_sk_list, sk);
340 sock_set_flag(sk, SOCK_DEAD);
341 sock_put(sk);
342}
343
fd0b3ff7 344static void __sco_sock_close(struct sock *sk)
1da177e4 345{
fd0b3ff7 346 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
1da177e4
LT		 347
348 switch (sk->sk_state) {
349 case BT_LISTEN:
350 sco_sock_cleanup_listen(sk);
351 break;
352
353 case BT_CONNECTED:
354 case BT_CONFIG:
b7e98b51 355 if (sco_pi(sk)->conn->hcon) {
4a77708b
LAD		 356 sk->sk_state = BT_DISCONN;
357 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
358 hci_conn_put(sco_pi(sk)->conn->hcon);
359 sco_pi(sk)->conn->hcon = NULL;
360 } else
361 sco_chan_del(sk, ECONNRESET);
362 break;
363
1da177e4
LT		 364 case BT_CONNECT:
365 case BT_DISCONN:
366 sco_chan_del(sk, ECONNRESET);
367 break;
368
369 default:
370 sock_set_flag(sk, SOCK_ZAPPED);
371 break;
3ff50b79 372 }
fd0b3ff7 373}
1da177e4 374
fd0b3ff7
MH		 375/* Must be called on unlocked socket. */
376static void sco_sock_close(struct sock *sk)
377{
378 sco_sock_clear_timer(sk);
379 lock_sock(sk);
380 __sco_sock_close(sk);
1da177e4 381 release_sock(sk);
1da177e4
LT		 382 sco_sock_kill(sk);
383}
384
385static void sco_sock_init(struct sock *sk, struct sock *parent)
386{
387 BT_DBG("sk %p", sk);
388
6230c9b4 389 if (parent) {
1da177e4 390 sk->sk_type = parent->sk_type;
20714bfe 391 bt_sk(sk)->flags = bt_sk(parent)->flags;
6230c9b4
PM		 392 security_sk_clone(parent, sk);
393 }
1da177e4
LT		 394}
395
396static struct proto sco_proto = {
397 .name = "SCO",
398 .owner = THIS_MODULE,
399 .obj_size = sizeof(struct sco_pinfo)
400};
401
1b8d7ae4 402static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1da177e4
LT		 403{
404 struct sock *sk;
405
6257ff21 406 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
1da177e4
LT		 407 if (!sk)
408 return NULL;
409
410 sock_init_data(sock, sk);
411 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
412
413 sk->sk_destruct = sco_sock_destruct;
414 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
415
416 sock_reset_flag(sk, SOCK_ZAPPED);
417
418 sk->sk_protocol = proto;
419 sk->sk_state = BT_OPEN;
420
b24b8a24 421 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
1da177e4
LT		 422
423 bt_sock_link(&sco_sk_list, sk);
424 return sk;
425}
426
3f378b68
EP		 427static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
428 int kern)
1da177e4
LT		 429{
430 struct sock *sk;
431
432 BT_DBG("sock %p", sock);
433
434 sock->state = SS_UNCONNECTED;
435
436 if (sock->type != SOCK_SEQPACKET)
437 return -ESOCKTNOSUPPORT;
438
439 sock->ops = &sco_sock_ops;
440
1b8d7ae4 441 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
74da626a 442 if (!sk)
1da177e4
LT		 443 return -ENOMEM;
444
445 sco_sock_init(sk, NULL);
446 return 0;
447}
448
449static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
450{
451 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
452 struct sock *sk = sock->sk;
1da177e4
LT		 453 int err = 0;
454
6ed93dc6 455 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
1da177e4
LT		 456
457 if (!addr || addr->sa_family != AF_BLUETOOTH)
458 return -EINVAL;
459
460 lock_sock(sk);
461
462 if (sk->sk_state != BT_OPEN) {
463 err = -EBADFD;
464 goto done;
465 }
466
8ed21f7e
MH		 467 if (sk->sk_type != SOCK_SEQPACKET) {
468 err = -EINVAL;
469 goto done;
1da177e4
LT		 470 }
471
8ed21f7e
MH		 472 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
473
474 sk->sk_state = BT_BOUND;
1da177e4
LT		 475
476done:
477 release_sock(sk);
478 return err;
479}
480
481static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
482{
483 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
484 struct sock *sk = sock->sk;
485 int err = 0;
486
487
488 BT_DBG("sk %p", sk);
489
6503d961
CG		 490 if (alen < sizeof(struct sockaddr_sco) ||
491 addr->sa_family != AF_BLUETOOTH)
1da177e4
LT		 492 return -EINVAL;
493
494 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
495 return -EBADFD;
496
497 if (sk->sk_type != SOCK_SEQPACKET)
498 return -EINVAL;
499
500 lock_sock(sk);
501
502 /* Set destination address and psm */
503 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
504
735cbc47
AE		 505 err = sco_connect(sk);
506 if (err)
1da177e4
LT		 507 goto done;
508
8e87d142 509 err = bt_sock_wait_state(sk, BT_CONNECTED,
be7c2b99 510 sock_sndtimeo(sk, flags & O_NONBLOCK));
1da177e4
LT		 511
512done:
513 release_sock(sk);
514 return err;
515}
516
517static int sco_sock_listen(struct socket *sock, int backlog)
518{
519 struct sock *sk = sock->sk;
fb334059 520 bdaddr_t *src = &bt_sk(sk)->src;
1da177e4
LT		 521 int err = 0;
522
523 BT_DBG("sk %p backlog %d", sk, backlog);
524
525 lock_sock(sk);
526
7d5d775a 527 if (sk->sk_state != BT_BOUND) {
1da177e4
LT		 528 err = -EBADFD;
529 goto done;
530 }
531
7d5d775a
MH		 532 if (sk->sk_type != SOCK_SEQPACKET) {
533 err = -EINVAL;
534 goto done;
535 }
536
fb334059
MH		 537 write_lock(&sco_sk_list.lock);
538
539 if (__sco_get_sock_listen_by_addr(src)) {
540 err = -EADDRINUSE;
541 goto unlock;
542 }
543
1da177e4
LT		 544 sk->sk_max_ack_backlog = backlog;
545 sk->sk_ack_backlog = 0;
fb334059 546
1da177e4
LT		 547 sk->sk_state = BT_LISTEN;
548
fb334059
MH		 549unlock:
550 write_unlock(&sco_sk_list.lock);
551
1da177e4
LT		 552done:
553 release_sock(sk);
554 return err;
555}
556
557static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
558{
559 DECLARE_WAITQUEUE(wait, current);
560 struct sock *sk = sock->sk, *ch;
561 long timeo;
562 int err = 0;
563
564 lock_sock(sk);
565
1da177e4
LT		 566 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
567
568 BT_DBG("sk %p timeo %ld", sk, timeo);
569
570 /* Wait for an incoming connection. (wake-one). */
aa395145 571 add_wait_queue_exclusive(sk_sleep(sk), &wait);
552b0d3c 572 while (1) {
1da177e4 573 set_current_state(TASK_INTERRUPTIBLE);
552b0d3c
PH		 574
575 if (sk->sk_state != BT_LISTEN) {
576 err = -EBADFD;
1da177e4
LT		 577 break;
578 }
579
552b0d3c
PH		 580 ch = bt_accept_dequeue(sk, newsock);
581 if (ch)
582 break;
1da177e4 583
552b0d3c
PH		 584 if (!timeo) {
585 err = -EAGAIN;
1da177e4
LT		 586 break;
587 }
588
589 if (signal_pending(current)) {
590 err = sock_intr_errno(timeo);
591 break;
592 }
552b0d3c
PH		 593
594 release_sock(sk);
595 timeo = schedule_timeout(timeo);
596 lock_sock(sk);
1da177e4 597 }
552b0d3c 598 __set_current_state(TASK_RUNNING);
aa395145 599 remove_wait_queue(sk_sleep(sk), &wait);
1da177e4
LT		 600
601 if (err)
602 goto done;
603
604 newsock->state = SS_CONNECTED;
605
606 BT_DBG("new socket %p", ch);
607
608done:
609 release_sock(sk);
610 return err;
611}
612
613static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
614{
615 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
616 struct sock *sk = sock->sk;
617
618 BT_DBG("sock %p, sk %p", sock, sk);
619
620 addr->sa_family = AF_BLUETOOTH;
621 *len = sizeof(struct sockaddr_sco);
622
623 if (peer)
624 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
625 else
626 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
627
628 return 0;
629}
630
8e87d142 631static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
1da177e4
LT		 632 struct msghdr *msg, size_t len)
633{
634 struct sock *sk = sock->sk;
b9dbdbc1 635 int err;
1da177e4
LT		 636
637 BT_DBG("sock %p, sk %p", sock, sk);
638
c1cbe4b7
BL		 639 err = sock_error(sk);
640 if (err)
641 return err;
1da177e4
LT		 642
643 if (msg->msg_flags & MSG_OOB)
644 return -EOPNOTSUPP;
645
646 lock_sock(sk);
647
648 if (sk->sk_state == BT_CONNECTED)
649 err = sco_send_frame(sk, msg, len);
650 else
651 err = -ENOTCONN;
652
653 release_sock(sk);
654 return err;
655}
656
20714bfe
FD		 657static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
658 struct msghdr *msg, size_t len, int flags)
659{
660 struct sock *sk = sock->sk;
661 struct sco_pinfo *pi = sco_pi(sk);
662
663 lock_sock(sk);
664
665 if (sk->sk_state == BT_CONNECT2 &&
666 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
667 hci_conn_accept(pi->conn->hcon, 0);
668 sk->sk_state = BT_CONFIG;
669
670 release_sock(sk);
671 return 0;
672 }
673
674 release_sock(sk);
675
676 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
677}
678
b7058842 679static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
1da177e4
LT		 680{
681 struct sock *sk = sock->sk;
682 int err = 0;
b96e9c67 683 u32 opt;
1da177e4
LT		 684
685 BT_DBG("sk %p", sk);
686
687 lock_sock(sk);
688
689 switch (optname) {
b96e9c67
FD		 690
691 case BT_DEFER_SETUP:
692 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
693 err = -EINVAL;
694 break;
695 }
696
697 if (get_user(opt, (u32 __user *) optval)) {
698 err = -EFAULT;
699 break;
700 }
701
702 if (opt)
703 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
704 else
705 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
706 break;
707
1da177e4
LT		 708 default:
709 err = -ENOPROTOOPT;
710 break;
711 }
712
713 release_sock(sk);
714 return err;
715}
716
d58daf42 717static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
1da177e4
LT		 718{
719 struct sock *sk = sock->sk;
720 struct sco_options opts;
721 struct sco_conninfo cinfo;
8e87d142 722 int len, err = 0;
1da177e4
LT		 723
724 BT_DBG("sk %p", sk);
725
726 if (get_user(len, optlen))
727 return -EFAULT;
728
729 lock_sock(sk);
730
731 switch (optname) {
732 case SCO_OPTIONS:
733 if (sk->sk_state != BT_CONNECTED) {
734 err = -ENOTCONN;
735 break;
736 }
737
738 opts.mtu = sco_pi(sk)->conn->mtu;
739
740 BT_DBG("mtu %d", opts.mtu);
741
742 len = min_t(unsigned int, len, sizeof(opts));
743 if (copy_to_user(optval, (char *)&opts, len))
744 err = -EFAULT;
745
746 break;
747
748 case SCO_CONNINFO:
749 if (sk->sk_state != BT_CONNECTED) {
750 err = -ENOTCONN;
751 break;
752 }
753
c4c896e1 754 memset(&cinfo, 0, sizeof(cinfo));
1da177e4
LT		 755 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
756 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
757
758 len = min_t(unsigned int, len, sizeof(cinfo));
759 if (copy_to_user(optval, (char *)&cinfo, len))
760 err = -EFAULT;
761
762 break;
763
764 default:
765 err = -ENOPROTOOPT;
766 break;
767 }
768
769 release_sock(sk);
770 return err;
771}
772
d58daf42
MH		 773static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
774{
775 struct sock *sk = sock->sk;
776 int len, err = 0;
777
778 BT_DBG("sk %p", sk);
779
780 if (level == SOL_SCO)
781 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
782
783 if (get_user(len, optlen))
784 return -EFAULT;
785
786 lock_sock(sk);
787
788 switch (optname) {
b96e9c67
FD		 789
790 case BT_DEFER_SETUP:
791 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
792 err = -EINVAL;
793 break;
794 }
795
796 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
797 (u32 __user *) optval))
798 err = -EFAULT;
799
800 break;
801
d58daf42
MH		 802 default:
803 err = -ENOPROTOOPT;
804 break;
805 }
806
807 release_sock(sk);
808 return err;
809}
810
fd0b3ff7
MH		 811static int sco_sock_shutdown(struct socket *sock, int how)
812{
813 struct sock *sk = sock->sk;
814 int err = 0;
815
816 BT_DBG("sock %p, sk %p", sock, sk);
817
818 if (!sk)
819 return 0;
820
821 lock_sock(sk);
822 if (!sk->sk_shutdown) {
823 sk->sk_shutdown = SHUTDOWN_MASK;
824 sco_sock_clear_timer(sk);
825 __sco_sock_close(sk);
826
827 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
828 err = bt_sock_wait_state(sk, BT_CLOSED,
be7c2b99 829 sk->sk_lingertime);
fd0b3ff7
MH		 830 }
831 release_sock(sk);
832 return err;
833}
834
1da177e4
LT		 835static int sco_sock_release(struct socket *sock)
836{
837 struct sock *sk = sock->sk;
838 int err = 0;
839
840 BT_DBG("sock %p, sk %p", sock, sk);
841
842 if (!sk)
843 return 0;
844
845 sco_sock_close(sk);
846
847 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
848 lock_sock(sk);
849 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
850 release_sock(sk);
851 }
852
853 sock_orphan(sk);
854 sco_sock_kill(sk);
855 return err;
856}
857
858static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
859{
860 BT_DBG("conn %p", conn);
861
862 sco_pi(sk)->conn = conn;
863 conn->sk = sk;
864
865 if (parent)
866 bt_accept_enqueue(parent, sk);
867}
868
8e87d142 869/* Delete channel.
1da177e4
LT		 870 * Must be called on the locked socket. */
871static void sco_chan_del(struct sock *sk, int err)
872{
873 struct sco_conn *conn;
874
875 conn = sco_pi(sk)->conn;
876
877 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
878
0b27a4b9
GP		 879 if (conn) {
880 sco_conn_lock(conn);
881 conn->sk = NULL;
882 sco_pi(sk)->conn = NULL;
883 sco_conn_unlock(conn);
884
885 if (conn->hcon)
886 hci_conn_put(conn->hcon);
887 }
888
1da177e4
LT		 889 sk->sk_state = BT_CLOSED;
890 sk->sk_err = err;
891 sk->sk_state_change(sk);
892
893 sock_set_flag(sk, SOCK_ZAPPED);
894}
895
896static void sco_conn_ready(struct sco_conn *conn)
897{
735cbc47
AE		 898 struct sock *parent;
899 struct sock *sk = conn->sk;
1da177e4
LT		 900
901 BT_DBG("conn %p", conn);
902
735cbc47 903 if (sk) {
1da177e4
LT		 904 sco_sock_clear_timer(sk);
905 bh_lock_sock(sk);
906 sk->sk_state = BT_CONNECTED;
907 sk->sk_state_change(sk);
908 bh_unlock_sock(sk);
909 } else {
40528088
AG		 910 sco_conn_lock(conn);
911
1da177e4 912 parent = sco_get_sock_listen(conn->src);
40528088
AG		 913 if (!parent) {
914 sco_conn_unlock(conn);
915 return;
916 }
1da177e4
LT		 917
918 bh_lock_sock(parent);
919
b9dbdbc1 920 sk = sco_sock_alloc(sock_net(parent), NULL,
be7c2b99 921 BTPROTO_SCO, GFP_ATOMIC);
1da177e4
LT		 922 if (!sk) {
923 bh_unlock_sock(parent);
40528088
AG		 924 sco_conn_unlock(conn);
925 return;
1da177e4
LT		 926 }
927
928 sco_sock_init(sk, parent);
929
930 bacpy(&bt_sk(sk)->src, conn->src);
931 bacpy(&bt_sk(sk)->dst, conn->dst);
932
933 hci_conn_hold(conn->hcon);
934 __sco_chan_add(conn, sk, parent);
935
20714bfe
FD		 936 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
937 sk->sk_state = BT_CONNECT2;
938 else
939 sk->sk_state = BT_CONNECTED;
1da177e4
LT		 940
941 /* Wake up parent */
942 parent->sk_data_ready(parent, 1);
943
944 bh_unlock_sock(parent);
1da177e4 945
40528088
AG		 946 sco_conn_unlock(conn);
947 }
1da177e4
LT		 948}
949
950/* ----- SCO interface with lower layer (HCI) ----- */
20714bfe 951int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1da177e4 952{
fc5fef61 953 struct sock *sk;
71aeeaa1
MH		 954 struct hlist_node *node;
955 int lm = 0;
956
6ed93dc6 957 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1da177e4 958
71aeeaa1
MH		 959 /* Find listening sockets */
960 read_lock(&sco_sk_list.lock);
961 sk_for_each(sk, node, &sco_sk_list.head) {
962 if (sk->sk_state != BT_LISTEN)
963 continue;
964
965 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
be7c2b99 966 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
71aeeaa1 967 lm |= HCI_LM_ACCEPT;
20714bfe
FD		 968
969 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
970 *flags |= HCI_PROTO_DEFER;
71aeeaa1
MH		 971 break;
972 }
973 }
974 read_unlock(&sco_sk_list.lock);
975
976 return lm;
1da177e4
LT		 977}
978
9e664631 979void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1da177e4 980{
6ed93dc6 981 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1da177e4
LT		 982 if (!status) {
983 struct sco_conn *conn;
984
519e42b3 985 conn = sco_conn_add(hcon);
1da177e4
LT		 986 if (conn)
987 sco_conn_ready(conn);
8e87d142 988 } else
e175072f 989 sco_conn_del(hcon, bt_to_errno(status));
1da177e4
LT		 990}
991
9e664631 992void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1da177e4
LT		 993{
994 BT_DBG("hcon %p reason %d", hcon, reason);
995
e175072f 996 sco_conn_del(hcon, bt_to_errno(reason));
1da177e4
LT		 997}
998
686ebf28 999int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1da177e4
LT		 1000{
1001 struct sco_conn *conn = hcon->sco_data;
1002
1003 if (!conn)
1004 goto drop;
1005
1006 BT_DBG("conn %p len %d", conn, skb->len);
1007
1008 if (skb->len) {
1009 sco_recv_frame(conn, skb);
1010 return 0;
1011 }
1012
1013drop:
8e87d142 1014 kfree_skb(skb);
1da177e4
LT		 1015 return 0;
1016}
1017
aef7d97c 1018static int sco_debugfs_show(struct seq_file *f, void *p)
1da177e4
LT		 1019{
1020 struct sock *sk;
1021 struct hlist_node *node;
1da177e4 1022
ee65d19e 1023 read_lock(&sco_sk_list.lock);
1da177e4 1024
be9d1227 1025 sk_for_each(sk, node, &sco_sk_list.head) {
fcb73338
AE		 1026 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1027 &bt_sk(sk)->dst, sk->sk_state);
be9d1227 1028 }
1da177e4 1029
ee65d19e 1030 read_unlock(&sco_sk_list.lock);
1da177e4 1031
aef7d97c 1032 return 0;
1da177e4
LT		 1033}
1034
aef7d97c
MH		 1035static int sco_debugfs_open(struct inode *inode, struct file *file)
1036{
1037 return single_open(file, sco_debugfs_show, inode->i_private);
1038}
1039
1040static const struct file_operations sco_debugfs_fops = {
1041 .open = sco_debugfs_open,
1042 .read = seq_read,
1043 .llseek = seq_lseek,
1044 .release = single_release,
1045};
1046
1047static struct dentry *sco_debugfs;
1da177e4 1048
90ddc4f0 1049static const struct proto_ops sco_sock_ops = {
1da177e4
LT		 1050 .family = PF_BLUETOOTH,
1051 .owner = THIS_MODULE,
1052 .release = sco_sock_release,
1053 .bind = sco_sock_bind,
1054 .connect = sco_sock_connect,
1055 .listen = sco_sock_listen,
1056 .accept = sco_sock_accept,
1057 .getname = sco_sock_getname,
1058 .sendmsg = sco_sock_sendmsg,
20714bfe 1059 .recvmsg = sco_sock_recvmsg,
1da177e4 1060 .poll = bt_sock_poll,
3241ad82 1061 .ioctl = bt_sock_ioctl,
1da177e4
LT		 1062 .mmap = sock_no_mmap,
1063 .socketpair = sock_no_socketpair,
fd0b3ff7 1064 .shutdown = sco_sock_shutdown,
1da177e4
LT		 1065 .setsockopt = sco_sock_setsockopt,
1066 .getsockopt = sco_sock_getsockopt
1067};
1068
ec1b4cf7 1069static const struct net_proto_family sco_sock_family_ops = {
1da177e4
LT		 1070 .family = PF_BLUETOOTH,
1071 .owner = THIS_MODULE,
1072 .create = sco_sock_create,
1073};
1074
64274518 1075int __init sco_init(void)
1da177e4
LT		 1076{
1077 int err;
1078
1079 err = proto_register(&sco_proto, 0);
1080 if (err < 0)
1081 return err;
1082
1083 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1084 if (err < 0) {
1085 BT_ERR("SCO socket registration failed");
1086 goto error;
1087 }
1088
de9b9212
MY		 1089 err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1090 if (err < 0) {
1091 BT_ERR("Failed to create SCO proc file");
1092 bt_sock_unregister(BTPROTO_SCO);
1093 goto error;
1094 }
1095
aef7d97c 1096 if (bt_debugfs) {
be7c2b99
GP		 1097 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1098 NULL, &sco_debugfs_fops);
aef7d97c
MH		 1099 if (!sco_debugfs)
1100 BT_ERR("Failed to create SCO debug file");
1101 }
1da177e4 1102
1da177e4
LT		 1103 BT_INFO("SCO socket layer initialized");
1104
1105 return 0;
1106
1107error:
1108 proto_unregister(&sco_proto);
1109 return err;
1110}
1111
64274518 1112void __exit sco_exit(void)
1da177e4 1113{
de9b9212
MY		 1114 bt_procfs_cleanup(&init_net, "sco");
1115
aef7d97c 1116 debugfs_remove(sco_debugfs);
1da177e4
LT		 1117
1118 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1119 BT_ERR("SCO socket unregistration failed");
1120
1da177e4
LT		 1121 proto_unregister(&sco_proto);
1122}
1123
7cb127d5
MH		 1124module_param(disable_esco, bool, 0644);
1125MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
kernel source for telekom puls (alcatel/mediatek)