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