]> git.ipfire.org Git - thirdparty/linux.git/blob - net/bluetooth/sco.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
arm64: tegra: Add Tegra234 thermal support
[thirdparty/linux.git] / net / bluetooth / sco.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 SCO sockets. */
26
27 #include <linux/module.h>
28 #include <linux/debugfs.h>
29 #include <linux/seq_file.h>
30 #include <linux/sched/signal.h>
31
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/sco.h>
35
36 static bool disable_esco;
37
38 static const struct proto_ops sco_sock_ops;
39
40 static struct bt_sock_list sco_sk_list = {
41 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
42 };
43
44 /* ---- SCO connections ---- */
45 struct sco_conn {
46 struct hci_conn *hcon;
47
48 spinlock_t lock;
49 struct sock *sk;
50
51 struct delayed_work timeout_work;
52
53 unsigned int mtu;
54 };
55
56 #define sco_conn_lock(c) spin_lock(&c->lock)
57 #define sco_conn_unlock(c) spin_unlock(&c->lock)
58
59 static void sco_sock_close(struct sock *sk);
60 static void sco_sock_kill(struct sock *sk);
61
62 /* ----- SCO socket info ----- */
63 #define sco_pi(sk) ((struct sco_pinfo *) sk)
64
65 struct sco_pinfo {
66 struct bt_sock bt;
67 bdaddr_t src;
68 bdaddr_t dst;
69 __u32 flags;
70 __u16 setting;
71 __u8 cmsg_mask;
72 struct bt_codec codec;
73 struct sco_conn *conn;
74 };
75
76 /* ---- SCO timers ---- */
77 #define SCO_CONN_TIMEOUT (HZ * 40)
78 #define SCO_DISCONN_TIMEOUT (HZ * 2)
79
80 static void sco_sock_timeout(struct work_struct *work)
81 {
82 struct sco_conn *conn = container_of(work, struct sco_conn,
83 timeout_work.work);
84 struct sock *sk;
85
86 sco_conn_lock(conn);
87 sk = conn->sk;
88 if (sk)
89 sock_hold(sk);
90 sco_conn_unlock(conn);
91
92 if (!sk)
93 return;
94
95 BT_DBG("sock %p state %d", sk, sk->sk_state);
96
97 lock_sock(sk);
98 sk->sk_err = ETIMEDOUT;
99 sk->sk_state_change(sk);
100 release_sock(sk);
101 sock_put(sk);
102 }
103
104 static void sco_sock_set_timer(struct sock *sk, long timeout)
105 {
106 if (!sco_pi(sk)->conn)
107 return;
108
109 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
110 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
111 schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
112 }
113
114 static void sco_sock_clear_timer(struct sock *sk)
115 {
116 if (!sco_pi(sk)->conn)
117 return;
118
119 BT_DBG("sock %p state %d", sk, sk->sk_state);
120 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
121 }
122
123 /* ---- SCO connections ---- */
124 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
125 {
126 struct hci_dev *hdev = hcon->hdev;
127 struct sco_conn *conn = hcon->sco_data;
128
129 if (conn)
130 return conn;
131
132 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
133 if (!conn)
134 return NULL;
135
136 spin_lock_init(&conn->lock);
137 INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
138
139 hcon->sco_data = conn;
140 conn->hcon = hcon;
141
142 if (hdev->sco_mtu > 0)
143 conn->mtu = hdev->sco_mtu;
144 else
145 conn->mtu = 60;
146
147 BT_DBG("hcon %p conn %p", hcon, conn);
148
149 return conn;
150 }
151
152 /* Delete channel.
153 * Must be called on the locked socket. */
154 static void sco_chan_del(struct sock *sk, int err)
155 {
156 struct sco_conn *conn;
157
158 conn = sco_pi(sk)->conn;
159
160 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
161
162 if (conn) {
163 sco_conn_lock(conn);
164 conn->sk = NULL;
165 sco_pi(sk)->conn = NULL;
166 sco_conn_unlock(conn);
167
168 if (conn->hcon)
169 hci_conn_drop(conn->hcon);
170 }
171
172 sk->sk_state = BT_CLOSED;
173 sk->sk_err = err;
174 sk->sk_state_change(sk);
175
176 sock_set_flag(sk, SOCK_ZAPPED);
177 }
178
179 static void sco_conn_del(struct hci_conn *hcon, int err)
180 {
181 struct sco_conn *conn = hcon->sco_data;
182 struct sock *sk;
183
184 if (!conn)
185 return;
186
187 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
188
189 /* Kill socket */
190 sco_conn_lock(conn);
191 sk = conn->sk;
192 if (sk)
193 sock_hold(sk);
194 sco_conn_unlock(conn);
195
196 if (sk) {
197 lock_sock(sk);
198 sco_sock_clear_timer(sk);
199 sco_chan_del(sk, err);
200 release_sock(sk);
201 sock_put(sk);
202 }
203
204 /* Ensure no more work items will run before freeing conn. */
205 cancel_delayed_work_sync(&conn->timeout_work);
206
207 hcon->sco_data = NULL;
208 kfree(conn);
209 }
210
211 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
212 struct sock *parent)
213 {
214 BT_DBG("conn %p", conn);
215
216 sco_pi(sk)->conn = conn;
217 conn->sk = sk;
218
219 if (parent)
220 bt_accept_enqueue(parent, sk, true);
221 }
222
223 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
224 struct sock *parent)
225 {
226 int err = 0;
227
228 sco_conn_lock(conn);
229 if (conn->sk)
230 err = -EBUSY;
231 else
232 __sco_chan_add(conn, sk, parent);
233
234 sco_conn_unlock(conn);
235 return err;
236 }
237
238 static int sco_connect(struct sock *sk)
239 {
240 struct sco_conn *conn;
241 struct hci_conn *hcon;
242 struct hci_dev *hdev;
243 int err, type;
244
245 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
246
247 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
248 if (!hdev)
249 return -EHOSTUNREACH;
250
251 hci_dev_lock(hdev);
252
253 if (lmp_esco_capable(hdev) && !disable_esco)
254 type = ESCO_LINK;
255 else
256 type = SCO_LINK;
257
258 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
259 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
260 err = -EOPNOTSUPP;
261 goto unlock;
262 }
263
264 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
265 sco_pi(sk)->setting, &sco_pi(sk)->codec);
266 if (IS_ERR(hcon)) {
267 err = PTR_ERR(hcon);
268 goto unlock;
269 }
270
271 hci_dev_unlock(hdev);
272 hci_dev_put(hdev);
273
274 conn = sco_conn_add(hcon);
275 if (!conn) {
276 hci_conn_drop(hcon);
277 return -ENOMEM;
278 }
279
280 err = sco_chan_add(conn, sk, NULL);
281 if (err)
282 return err;
283
284 lock_sock(sk);
285
286 /* Update source addr of the socket */
287 bacpy(&sco_pi(sk)->src, &hcon->src);
288
289 if (hcon->state == BT_CONNECTED) {
290 sco_sock_clear_timer(sk);
291 sk->sk_state = BT_CONNECTED;
292 } else {
293 sk->sk_state = BT_CONNECT;
294 sco_sock_set_timer(sk, sk->sk_sndtimeo);
295 }
296
297 release_sock(sk);
298
299 return err;
300
301 unlock:
302 hci_dev_unlock(hdev);
303 hci_dev_put(hdev);
304 return err;
305 }
306
307 static int sco_send_frame(struct sock *sk, struct sk_buff *skb)
308 {
309 struct sco_conn *conn = sco_pi(sk)->conn;
310 int len = skb->len;
311
312 /* Check outgoing MTU */
313 if (len > conn->mtu)
314 return -EINVAL;
315
316 BT_DBG("sk %p len %d", sk, len);
317
318 hci_send_sco(conn->hcon, skb);
319
320 return len;
321 }
322
323 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
324 {
325 struct sock *sk;
326
327 sco_conn_lock(conn);
328 sk = conn->sk;
329 sco_conn_unlock(conn);
330
331 if (!sk)
332 goto drop;
333
334 BT_DBG("sk %p len %u", sk, skb->len);
335
336 if (sk->sk_state != BT_CONNECTED)
337 goto drop;
338
339 if (!sock_queue_rcv_skb(sk, skb))
340 return;
341
342 drop:
343 kfree_skb(skb);
344 }
345
346 /* -------- Socket interface ---------- */
347 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
348 {
349 struct sock *sk;
350
351 sk_for_each(sk, &sco_sk_list.head) {
352 if (sk->sk_state != BT_LISTEN)
353 continue;
354
355 if (!bacmp(&sco_pi(sk)->src, ba))
356 return sk;
357 }
358
359 return NULL;
360 }
361
362 /* Find socket listening on source bdaddr.
363 * Returns closest match.
364 */
365 static struct sock *sco_get_sock_listen(bdaddr_t *src)
366 {
367 struct sock *sk = NULL, *sk1 = NULL;
368
369 read_lock(&sco_sk_list.lock);
370
371 sk_for_each(sk, &sco_sk_list.head) {
372 if (sk->sk_state != BT_LISTEN)
373 continue;
374
375 /* Exact match. */
376 if (!bacmp(&sco_pi(sk)->src, src))
377 break;
378
379 /* Closest match */
380 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
381 sk1 = sk;
382 }
383
384 read_unlock(&sco_sk_list.lock);
385
386 return sk ? sk : sk1;
387 }
388
389 static void sco_sock_destruct(struct sock *sk)
390 {
391 BT_DBG("sk %p", sk);
392
393 skb_queue_purge(&sk->sk_receive_queue);
394 skb_queue_purge(&sk->sk_write_queue);
395 }
396
397 static void sco_sock_cleanup_listen(struct sock *parent)
398 {
399 struct sock *sk;
400
401 BT_DBG("parent %p", parent);
402
403 /* Close not yet accepted channels */
404 while ((sk = bt_accept_dequeue(parent, NULL))) {
405 sco_sock_close(sk);
406 sco_sock_kill(sk);
407 }
408
409 parent->sk_state = BT_CLOSED;
410 sock_set_flag(parent, SOCK_ZAPPED);
411 }
412
413 /* Kill socket (only if zapped and orphan)
414 * Must be called on unlocked socket.
415 */
416 static void sco_sock_kill(struct sock *sk)
417 {
418 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
419 return;
420
421 BT_DBG("sk %p state %d", sk, sk->sk_state);
422
423 /* Kill poor orphan */
424 bt_sock_unlink(&sco_sk_list, sk);
425 sock_set_flag(sk, SOCK_DEAD);
426 sock_put(sk);
427 }
428
429 static void __sco_sock_close(struct sock *sk)
430 {
431 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
432
433 switch (sk->sk_state) {
434 case BT_LISTEN:
435 sco_sock_cleanup_listen(sk);
436 break;
437
438 case BT_CONNECTED:
439 case BT_CONFIG:
440 if (sco_pi(sk)->conn->hcon) {
441 sk->sk_state = BT_DISCONN;
442 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
443 sco_conn_lock(sco_pi(sk)->conn);
444 hci_conn_drop(sco_pi(sk)->conn->hcon);
445 sco_pi(sk)->conn->hcon = NULL;
446 sco_conn_unlock(sco_pi(sk)->conn);
447 } else
448 sco_chan_del(sk, ECONNRESET);
449 break;
450
451 case BT_CONNECT2:
452 case BT_CONNECT:
453 case BT_DISCONN:
454 sco_chan_del(sk, ECONNRESET);
455 break;
456
457 default:
458 sock_set_flag(sk, SOCK_ZAPPED);
459 break;
460 }
461
462 }
463
464 /* Must be called on unlocked socket. */
465 static void sco_sock_close(struct sock *sk)
466 {
467 lock_sock(sk);
468 sco_sock_clear_timer(sk);
469 __sco_sock_close(sk);
470 release_sock(sk);
471 }
472
473 static void sco_skb_put_cmsg(struct sk_buff *skb, struct msghdr *msg,
474 struct sock *sk)
475 {
476 if (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS)
477 put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_STATUS,
478 sizeof(bt_cb(skb)->sco.pkt_status),
479 &bt_cb(skb)->sco.pkt_status);
480 }
481
482 static void sco_sock_init(struct sock *sk, struct sock *parent)
483 {
484 BT_DBG("sk %p", sk);
485
486 if (parent) {
487 sk->sk_type = parent->sk_type;
488 bt_sk(sk)->flags = bt_sk(parent)->flags;
489 security_sk_clone(parent, sk);
490 } else {
491 bt_sk(sk)->skb_put_cmsg = sco_skb_put_cmsg;
492 }
493 }
494
495 static struct proto sco_proto = {
496 .name = "SCO",
497 .owner = THIS_MODULE,
498 .obj_size = sizeof(struct sco_pinfo)
499 };
500
501 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
502 int proto, gfp_t prio, int kern)
503 {
504 struct sock *sk;
505
506 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
507 if (!sk)
508 return NULL;
509
510 sock_init_data(sock, sk);
511 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
512
513 sk->sk_destruct = sco_sock_destruct;
514 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
515
516 sock_reset_flag(sk, SOCK_ZAPPED);
517
518 sk->sk_protocol = proto;
519 sk->sk_state = BT_OPEN;
520
521 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
522 sco_pi(sk)->codec.id = BT_CODEC_CVSD;
523 sco_pi(sk)->codec.cid = 0xffff;
524 sco_pi(sk)->codec.vid = 0xffff;
525 sco_pi(sk)->codec.data_path = 0x00;
526
527 bt_sock_link(&sco_sk_list, sk);
528 return sk;
529 }
530
531 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
532 int kern)
533 {
534 struct sock *sk;
535
536 BT_DBG("sock %p", sock);
537
538 sock->state = SS_UNCONNECTED;
539
540 if (sock->type != SOCK_SEQPACKET)
541 return -ESOCKTNOSUPPORT;
542
543 sock->ops = &sco_sock_ops;
544
545 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
546 if (!sk)
547 return -ENOMEM;
548
549 sco_sock_init(sk, NULL);
550 return 0;
551 }
552
553 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
554 int addr_len)
555 {
556 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
557 struct sock *sk = sock->sk;
558 int err = 0;
559
560 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
561 addr->sa_family != AF_BLUETOOTH)
562 return -EINVAL;
563
564 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
565
566 lock_sock(sk);
567
568 if (sk->sk_state != BT_OPEN) {
569 err = -EBADFD;
570 goto done;
571 }
572
573 if (sk->sk_type != SOCK_SEQPACKET) {
574 err = -EINVAL;
575 goto done;
576 }
577
578 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
579
580 sk->sk_state = BT_BOUND;
581
582 done:
583 release_sock(sk);
584 return err;
585 }
586
587 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
588 {
589 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
590 struct sock *sk = sock->sk;
591 int err;
592
593 BT_DBG("sk %p", sk);
594
595 if (alen < sizeof(struct sockaddr_sco) ||
596 addr->sa_family != AF_BLUETOOTH)
597 return -EINVAL;
598
599 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
600 return -EBADFD;
601
602 if (sk->sk_type != SOCK_SEQPACKET)
603 err = -EINVAL;
604
605 lock_sock(sk);
606 /* Set destination address and psm */
607 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
608 release_sock(sk);
609
610 err = sco_connect(sk);
611 if (err)
612 return err;
613
614 lock_sock(sk);
615
616 err = bt_sock_wait_state(sk, BT_CONNECTED,
617 sock_sndtimeo(sk, flags & O_NONBLOCK));
618
619 release_sock(sk);
620 return err;
621 }
622
623 static int sco_sock_listen(struct socket *sock, int backlog)
624 {
625 struct sock *sk = sock->sk;
626 bdaddr_t *src = &sco_pi(sk)->src;
627 int err = 0;
628
629 BT_DBG("sk %p backlog %d", sk, backlog);
630
631 lock_sock(sk);
632
633 if (sk->sk_state != BT_BOUND) {
634 err = -EBADFD;
635 goto done;
636 }
637
638 if (sk->sk_type != SOCK_SEQPACKET) {
639 err = -EINVAL;
640 goto done;
641 }
642
643 write_lock(&sco_sk_list.lock);
644
645 if (__sco_get_sock_listen_by_addr(src)) {
646 err = -EADDRINUSE;
647 goto unlock;
648 }
649
650 sk->sk_max_ack_backlog = backlog;
651 sk->sk_ack_backlog = 0;
652
653 sk->sk_state = BT_LISTEN;
654
655 unlock:
656 write_unlock(&sco_sk_list.lock);
657
658 done:
659 release_sock(sk);
660 return err;
661 }
662
663 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
664 int flags, bool kern)
665 {
666 DEFINE_WAIT_FUNC(wait, woken_wake_function);
667 struct sock *sk = sock->sk, *ch;
668 long timeo;
669 int err = 0;
670
671 lock_sock(sk);
672
673 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
674
675 BT_DBG("sk %p timeo %ld", sk, timeo);
676
677 /* Wait for an incoming connection. (wake-one). */
678 add_wait_queue_exclusive(sk_sleep(sk), &wait);
679 while (1) {
680 if (sk->sk_state != BT_LISTEN) {
681 err = -EBADFD;
682 break;
683 }
684
685 ch = bt_accept_dequeue(sk, newsock);
686 if (ch)
687 break;
688
689 if (!timeo) {
690 err = -EAGAIN;
691 break;
692 }
693
694 if (signal_pending(current)) {
695 err = sock_intr_errno(timeo);
696 break;
697 }
698
699 release_sock(sk);
700
701 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
702 lock_sock(sk);
703 }
704 remove_wait_queue(sk_sleep(sk), &wait);
705
706 if (err)
707 goto done;
708
709 newsock->state = SS_CONNECTED;
710
711 BT_DBG("new socket %p", ch);
712
713 done:
714 release_sock(sk);
715 return err;
716 }
717
718 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
719 int peer)
720 {
721 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
722 struct sock *sk = sock->sk;
723
724 BT_DBG("sock %p, sk %p", sock, sk);
725
726 addr->sa_family = AF_BLUETOOTH;
727
728 if (peer)
729 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
730 else
731 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
732
733 return sizeof(struct sockaddr_sco);
734 }
735
736 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
737 size_t len)
738 {
739 struct sock *sk = sock->sk;
740 struct sk_buff *skb;
741 int err;
742
743 BT_DBG("sock %p, sk %p", sock, sk);
744
745 err = sock_error(sk);
746 if (err)
747 return err;
748
749 if (msg->msg_flags & MSG_OOB)
750 return -EOPNOTSUPP;
751
752 skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
753 if (IS_ERR(skb))
754 return PTR_ERR(skb);
755
756 lock_sock(sk);
757
758 if (sk->sk_state == BT_CONNECTED)
759 err = sco_send_frame(sk, skb);
760 else
761 err = -ENOTCONN;
762
763 release_sock(sk);
764
765 if (err < 0)
766 kfree_skb(skb);
767 return err;
768 }
769
770 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
771 {
772 struct hci_dev *hdev = conn->hdev;
773
774 BT_DBG("conn %p", conn);
775
776 conn->state = BT_CONFIG;
777
778 if (!lmp_esco_capable(hdev)) {
779 struct hci_cp_accept_conn_req cp;
780
781 bacpy(&cp.bdaddr, &conn->dst);
782 cp.role = 0x00; /* Ignored */
783
784 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
785 } else {
786 struct hci_cp_accept_sync_conn_req cp;
787
788 bacpy(&cp.bdaddr, &conn->dst);
789 cp.pkt_type = cpu_to_le16(conn->pkt_type);
790
791 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
792 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
793 cp.content_format = cpu_to_le16(setting);
794
795 switch (setting & SCO_AIRMODE_MASK) {
796 case SCO_AIRMODE_TRANSP:
797 if (conn->pkt_type & ESCO_2EV3)
798 cp.max_latency = cpu_to_le16(0x0008);
799 else
800 cp.max_latency = cpu_to_le16(0x000D);
801 cp.retrans_effort = 0x02;
802 break;
803 case SCO_AIRMODE_CVSD:
804 cp.max_latency = cpu_to_le16(0xffff);
805 cp.retrans_effort = 0xff;
806 break;
807 default:
808 /* use CVSD settings as fallback */
809 cp.max_latency = cpu_to_le16(0xffff);
810 cp.retrans_effort = 0xff;
811 break;
812 }
813
814 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
815 sizeof(cp), &cp);
816 }
817 }
818
819 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
820 size_t len, int flags)
821 {
822 struct sock *sk = sock->sk;
823 struct sco_pinfo *pi = sco_pi(sk);
824
825 lock_sock(sk);
826
827 if (sk->sk_state == BT_CONNECT2 &&
828 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
829 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
830 sk->sk_state = BT_CONFIG;
831
832 release_sock(sk);
833 return 0;
834 }
835
836 release_sock(sk);
837
838 return bt_sock_recvmsg(sock, msg, len, flags);
839 }
840
841 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
842 sockptr_t optval, unsigned int optlen)
843 {
844 struct sock *sk = sock->sk;
845 int len, err = 0;
846 struct bt_voice voice;
847 u32 opt;
848 struct bt_codecs *codecs;
849 struct hci_dev *hdev;
850 __u8 buffer[255];
851
852 BT_DBG("sk %p", sk);
853
854 lock_sock(sk);
855
856 switch (optname) {
857
858 case BT_DEFER_SETUP:
859 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
860 err = -EINVAL;
861 break;
862 }
863
864 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
865 err = -EFAULT;
866 break;
867 }
868
869 if (opt)
870 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
871 else
872 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
873 break;
874
875 case BT_VOICE:
876 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
877 sk->sk_state != BT_CONNECT2) {
878 err = -EINVAL;
879 break;
880 }
881
882 voice.setting = sco_pi(sk)->setting;
883
884 len = min_t(unsigned int, sizeof(voice), optlen);
885 if (copy_from_sockptr(&voice, optval, len)) {
886 err = -EFAULT;
887 break;
888 }
889
890 /* Explicitly check for these values */
891 if (voice.setting != BT_VOICE_TRANSPARENT &&
892 voice.setting != BT_VOICE_CVSD_16BIT) {
893 err = -EINVAL;
894 break;
895 }
896
897 sco_pi(sk)->setting = voice.setting;
898 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
899 BDADDR_BREDR);
900 if (!hdev) {
901 err = -EBADFD;
902 break;
903 }
904 if (enhanced_sync_conn_capable(hdev) &&
905 voice.setting == BT_VOICE_TRANSPARENT)
906 sco_pi(sk)->codec.id = BT_CODEC_TRANSPARENT;
907 hci_dev_put(hdev);
908 break;
909
910 case BT_PKT_STATUS:
911 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
912 err = -EFAULT;
913 break;
914 }
915
916 if (opt)
917 sco_pi(sk)->cmsg_mask |= SCO_CMSG_PKT_STATUS;
918 else
919 sco_pi(sk)->cmsg_mask &= SCO_CMSG_PKT_STATUS;
920 break;
921
922 case BT_CODEC:
923 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
924 sk->sk_state != BT_CONNECT2) {
925 err = -EINVAL;
926 break;
927 }
928
929 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
930 BDADDR_BREDR);
931 if (!hdev) {
932 err = -EBADFD;
933 break;
934 }
935
936 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
937 hci_dev_put(hdev);
938 err = -EOPNOTSUPP;
939 break;
940 }
941
942 if (!hdev->get_data_path_id) {
943 hci_dev_put(hdev);
944 err = -EOPNOTSUPP;
945 break;
946 }
947
948 if (optlen < sizeof(struct bt_codecs) ||
949 optlen > sizeof(buffer)) {
950 hci_dev_put(hdev);
951 err = -EINVAL;
952 break;
953 }
954
955 if (copy_from_sockptr(buffer, optval, optlen)) {
956 hci_dev_put(hdev);
957 err = -EFAULT;
958 break;
959 }
960
961 codecs = (void *)buffer;
962
963 if (codecs->num_codecs > 1) {
964 hci_dev_put(hdev);
965 err = -EINVAL;
966 break;
967 }
968
969 sco_pi(sk)->codec = codecs->codecs[0];
970 hci_dev_put(hdev);
971 break;
972
973 default:
974 err = -ENOPROTOOPT;
975 break;
976 }
977
978 release_sock(sk);
979 return err;
980 }
981
982 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
983 char __user *optval, int __user *optlen)
984 {
985 struct sock *sk = sock->sk;
986 struct sco_options opts;
987 struct sco_conninfo cinfo;
988 int len, err = 0;
989
990 BT_DBG("sk %p", sk);
991
992 if (get_user(len, optlen))
993 return -EFAULT;
994
995 lock_sock(sk);
996
997 switch (optname) {
998 case SCO_OPTIONS:
999 if (sk->sk_state != BT_CONNECTED &&
1000 !(sk->sk_state == BT_CONNECT2 &&
1001 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
1002 err = -ENOTCONN;
1003 break;
1004 }
1005
1006 opts.mtu = sco_pi(sk)->conn->mtu;
1007
1008 BT_DBG("mtu %u", opts.mtu);
1009
1010 len = min_t(unsigned int, len, sizeof(opts));
1011 if (copy_to_user(optval, (char *)&opts, len))
1012 err = -EFAULT;
1013
1014 break;
1015
1016 case SCO_CONNINFO:
1017 if (sk->sk_state != BT_CONNECTED &&
1018 !(sk->sk_state == BT_CONNECT2 &&
1019 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
1020 err = -ENOTCONN;
1021 break;
1022 }
1023
1024 memset(&cinfo, 0, sizeof(cinfo));
1025 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
1026 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
1027
1028 len = min_t(unsigned int, len, sizeof(cinfo));
1029 if (copy_to_user(optval, (char *)&cinfo, len))
1030 err = -EFAULT;
1031
1032 break;
1033
1034 default:
1035 err = -ENOPROTOOPT;
1036 break;
1037 }
1038
1039 release_sock(sk);
1040 return err;
1041 }
1042
1043 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
1044 char __user *optval, int __user *optlen)
1045 {
1046 struct sock *sk = sock->sk;
1047 int len, err = 0;
1048 struct bt_voice voice;
1049 u32 phys;
1050 int pkt_status;
1051 int buf_len;
1052 struct codec_list *c;
1053 u8 num_codecs, i, __user *ptr;
1054 struct hci_dev *hdev;
1055 struct hci_codec_caps *caps;
1056 struct bt_codec codec;
1057
1058 BT_DBG("sk %p", sk);
1059
1060 if (level == SOL_SCO)
1061 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
1062
1063 if (get_user(len, optlen))
1064 return -EFAULT;
1065
1066 lock_sock(sk);
1067
1068 switch (optname) {
1069
1070 case BT_DEFER_SETUP:
1071 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1072 err = -EINVAL;
1073 break;
1074 }
1075
1076 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1077 (u32 __user *)optval))
1078 err = -EFAULT;
1079
1080 break;
1081
1082 case BT_VOICE:
1083 voice.setting = sco_pi(sk)->setting;
1084
1085 len = min_t(unsigned int, len, sizeof(voice));
1086 if (copy_to_user(optval, (char *)&voice, len))
1087 err = -EFAULT;
1088
1089 break;
1090
1091 case BT_PHY:
1092 if (sk->sk_state != BT_CONNECTED) {
1093 err = -ENOTCONN;
1094 break;
1095 }
1096
1097 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1098
1099 if (put_user(phys, (u32 __user *) optval))
1100 err = -EFAULT;
1101 break;
1102
1103 case BT_PKT_STATUS:
1104 pkt_status = (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS);
1105
1106 if (put_user(pkt_status, (int __user *)optval))
1107 err = -EFAULT;
1108 break;
1109
1110 case BT_SNDMTU:
1111 case BT_RCVMTU:
1112 if (sk->sk_state != BT_CONNECTED) {
1113 err = -ENOTCONN;
1114 break;
1115 }
1116
1117 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1118 err = -EFAULT;
1119 break;
1120
1121 case BT_CODEC:
1122 num_codecs = 0;
1123 buf_len = 0;
1124
1125 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
1126 if (!hdev) {
1127 err = -EBADFD;
1128 break;
1129 }
1130
1131 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
1132 hci_dev_put(hdev);
1133 err = -EOPNOTSUPP;
1134 break;
1135 }
1136
1137 if (!hdev->get_data_path_id) {
1138 hci_dev_put(hdev);
1139 err = -EOPNOTSUPP;
1140 break;
1141 }
1142
1143 release_sock(sk);
1144
1145 /* find total buffer size required to copy codec + caps */
1146 hci_dev_lock(hdev);
1147 list_for_each_entry(c, &hdev->local_codecs, list) {
1148 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1149 continue;
1150 num_codecs++;
1151 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1152 buf_len += 1 + caps->len;
1153 caps = (void *)&caps->data[caps->len];
1154 }
1155 buf_len += sizeof(struct bt_codec);
1156 }
1157 hci_dev_unlock(hdev);
1158
1159 buf_len += sizeof(struct bt_codecs);
1160 if (buf_len > len) {
1161 hci_dev_put(hdev);
1162 return -ENOBUFS;
1163 }
1164 ptr = optval;
1165
1166 if (put_user(num_codecs, ptr)) {
1167 hci_dev_put(hdev);
1168 return -EFAULT;
1169 }
1170 ptr += sizeof(num_codecs);
1171
1172 /* Iterate all the codecs supported over SCO and populate
1173 * codec data
1174 */
1175 hci_dev_lock(hdev);
1176 list_for_each_entry(c, &hdev->local_codecs, list) {
1177 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1178 continue;
1179
1180 codec.id = c->id;
1181 codec.cid = c->cid;
1182 codec.vid = c->vid;
1183 err = hdev->get_data_path_id(hdev, &codec.data_path);
1184 if (err < 0)
1185 break;
1186 codec.num_caps = c->num_caps;
1187 if (copy_to_user(ptr, &codec, sizeof(codec))) {
1188 err = -EFAULT;
1189 break;
1190 }
1191 ptr += sizeof(codec);
1192
1193 /* find codec capabilities data length */
1194 len = 0;
1195 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1196 len += 1 + caps->len;
1197 caps = (void *)&caps->data[caps->len];
1198 }
1199
1200 /* copy codec capabilities data */
1201 if (len && copy_to_user(ptr, c->caps, len)) {
1202 err = -EFAULT;
1203 break;
1204 }
1205 ptr += len;
1206 }
1207
1208 hci_dev_unlock(hdev);
1209 hci_dev_put(hdev);
1210
1211 lock_sock(sk);
1212
1213 if (!err && put_user(buf_len, optlen))
1214 err = -EFAULT;
1215
1216 break;
1217
1218 default:
1219 err = -ENOPROTOOPT;
1220 break;
1221 }
1222
1223 release_sock(sk);
1224 return err;
1225 }
1226
1227 static int sco_sock_shutdown(struct socket *sock, int how)
1228 {
1229 struct sock *sk = sock->sk;
1230 int err = 0;
1231
1232 BT_DBG("sock %p, sk %p", sock, sk);
1233
1234 if (!sk)
1235 return 0;
1236
1237 sock_hold(sk);
1238 lock_sock(sk);
1239
1240 if (!sk->sk_shutdown) {
1241 sk->sk_shutdown = SHUTDOWN_MASK;
1242 sco_sock_clear_timer(sk);
1243 __sco_sock_close(sk);
1244
1245 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1246 !(current->flags & PF_EXITING))
1247 err = bt_sock_wait_state(sk, BT_CLOSED,
1248 sk->sk_lingertime);
1249 }
1250
1251 release_sock(sk);
1252 sock_put(sk);
1253
1254 return err;
1255 }
1256
1257 static int sco_sock_release(struct socket *sock)
1258 {
1259 struct sock *sk = sock->sk;
1260 int err = 0;
1261
1262 BT_DBG("sock %p, sk %p", sock, sk);
1263
1264 if (!sk)
1265 return 0;
1266
1267 sco_sock_close(sk);
1268
1269 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1270 !(current->flags & PF_EXITING)) {
1271 lock_sock(sk);
1272 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1273 release_sock(sk);
1274 }
1275
1276 sock_orphan(sk);
1277 sco_sock_kill(sk);
1278 return err;
1279 }
1280
1281 static void sco_conn_ready(struct sco_conn *conn)
1282 {
1283 struct sock *parent;
1284 struct sock *sk = conn->sk;
1285
1286 BT_DBG("conn %p", conn);
1287
1288 if (sk) {
1289 lock_sock(sk);
1290 sco_sock_clear_timer(sk);
1291 sk->sk_state = BT_CONNECTED;
1292 sk->sk_state_change(sk);
1293 release_sock(sk);
1294 } else {
1295 sco_conn_lock(conn);
1296
1297 if (!conn->hcon) {
1298 sco_conn_unlock(conn);
1299 return;
1300 }
1301
1302 parent = sco_get_sock_listen(&conn->hcon->src);
1303 if (!parent) {
1304 sco_conn_unlock(conn);
1305 return;
1306 }
1307
1308 lock_sock(parent);
1309
1310 sk = sco_sock_alloc(sock_net(parent), NULL,
1311 BTPROTO_SCO, GFP_ATOMIC, 0);
1312 if (!sk) {
1313 release_sock(parent);
1314 sco_conn_unlock(conn);
1315 return;
1316 }
1317
1318 sco_sock_init(sk, parent);
1319
1320 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1321 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1322
1323 hci_conn_hold(conn->hcon);
1324 __sco_chan_add(conn, sk, parent);
1325
1326 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1327 sk->sk_state = BT_CONNECT2;
1328 else
1329 sk->sk_state = BT_CONNECTED;
1330
1331 /* Wake up parent */
1332 parent->sk_data_ready(parent);
1333
1334 release_sock(parent);
1335
1336 sco_conn_unlock(conn);
1337 }
1338 }
1339
1340 /* ----- SCO interface with lower layer (HCI) ----- */
1341 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1342 {
1343 struct sock *sk;
1344 int lm = 0;
1345
1346 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1347
1348 /* Find listening sockets */
1349 read_lock(&sco_sk_list.lock);
1350 sk_for_each(sk, &sco_sk_list.head) {
1351 if (sk->sk_state != BT_LISTEN)
1352 continue;
1353
1354 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1355 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1356 lm |= HCI_LM_ACCEPT;
1357
1358 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1359 *flags |= HCI_PROTO_DEFER;
1360 break;
1361 }
1362 }
1363 read_unlock(&sco_sk_list.lock);
1364
1365 return lm;
1366 }
1367
1368 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1369 {
1370 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1371 return;
1372
1373 BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1374
1375 if (!status) {
1376 struct sco_conn *conn;
1377
1378 conn = sco_conn_add(hcon);
1379 if (conn)
1380 sco_conn_ready(conn);
1381 } else
1382 sco_conn_del(hcon, bt_to_errno(status));
1383 }
1384
1385 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1386 {
1387 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1388 return;
1389
1390 BT_DBG("hcon %p reason %d", hcon, reason);
1391
1392 sco_conn_del(hcon, bt_to_errno(reason));
1393 }
1394
1395 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1396 {
1397 struct sco_conn *conn = hcon->sco_data;
1398
1399 if (!conn)
1400 goto drop;
1401
1402 BT_DBG("conn %p len %u", conn, skb->len);
1403
1404 if (skb->len) {
1405 sco_recv_frame(conn, skb);
1406 return;
1407 }
1408
1409 drop:
1410 kfree_skb(skb);
1411 }
1412
1413 static struct hci_cb sco_cb = {
1414 .name = "SCO",
1415 .connect_cfm = sco_connect_cfm,
1416 .disconn_cfm = sco_disconn_cfm,
1417 };
1418
1419 static int sco_debugfs_show(struct seq_file *f, void *p)
1420 {
1421 struct sock *sk;
1422
1423 read_lock(&sco_sk_list.lock);
1424
1425 sk_for_each(sk, &sco_sk_list.head) {
1426 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1427 &sco_pi(sk)->dst, sk->sk_state);
1428 }
1429
1430 read_unlock(&sco_sk_list.lock);
1431
1432 return 0;
1433 }
1434
1435 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1436
1437 static struct dentry *sco_debugfs;
1438
1439 static const struct proto_ops sco_sock_ops = {
1440 .family = PF_BLUETOOTH,
1441 .owner = THIS_MODULE,
1442 .release = sco_sock_release,
1443 .bind = sco_sock_bind,
1444 .connect = sco_sock_connect,
1445 .listen = sco_sock_listen,
1446 .accept = sco_sock_accept,
1447 .getname = sco_sock_getname,
1448 .sendmsg = sco_sock_sendmsg,
1449 .recvmsg = sco_sock_recvmsg,
1450 .poll = bt_sock_poll,
1451 .ioctl = bt_sock_ioctl,
1452 .gettstamp = sock_gettstamp,
1453 .mmap = sock_no_mmap,
1454 .socketpair = sock_no_socketpair,
1455 .shutdown = sco_sock_shutdown,
1456 .setsockopt = sco_sock_setsockopt,
1457 .getsockopt = sco_sock_getsockopt
1458 };
1459
1460 static const struct net_proto_family sco_sock_family_ops = {
1461 .family = PF_BLUETOOTH,
1462 .owner = THIS_MODULE,
1463 .create = sco_sock_create,
1464 };
1465
1466 int __init sco_init(void)
1467 {
1468 int err;
1469
1470 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1471
1472 err = proto_register(&sco_proto, 0);
1473 if (err < 0)
1474 return err;
1475
1476 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1477 if (err < 0) {
1478 BT_ERR("SCO socket registration failed");
1479 goto error;
1480 }
1481
1482 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1483 if (err < 0) {
1484 BT_ERR("Failed to create SCO proc file");
1485 bt_sock_unregister(BTPROTO_SCO);
1486 goto error;
1487 }
1488
1489 BT_INFO("SCO socket layer initialized");
1490
1491 hci_register_cb(&sco_cb);
1492
1493 if (IS_ERR_OR_NULL(bt_debugfs))
1494 return 0;
1495
1496 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1497 NULL, &sco_debugfs_fops);
1498
1499 return 0;
1500
1501 error:
1502 proto_unregister(&sco_proto);
1503 return err;
1504 }
1505
1506 void sco_exit(void)
1507 {
1508 bt_procfs_cleanup(&init_net, "sco");
1509
1510 debugfs_remove(sco_debugfs);
1511
1512 hci_unregister_cb(&sco_cb);
1513
1514 bt_sock_unregister(BTPROTO_SCO);
1515
1516 proto_unregister(&sco_proto);
1517 }
1518
1519 module_param(disable_esco, bool, 0644);
1520 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
A mirror of Linus' kernel repository