blob: 4322c833e74891d20a627f21e64cdedd67cd806f [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 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
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth SCO sockets. */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Marcel Holtmannaef7d972010-03-21 05:27:45 +010028#include <linux/debugfs.h>
29#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31#include <net/bluetooth/bluetooth.h>
32#include <net/bluetooth/hci_core.h>
33#include <net/bluetooth/sco.h>
34
Rusty Russelleb939922011-12-19 14:08:01 +000035static bool disable_esco;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080037static const struct proto_ops sco_sock_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39static struct bt_sock_list sco_sk_list = {
Robert P. J. Dayd5fb2962008-03-28 16:17:38 -070040 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041};
42
Marcel Holtmannfc8f5252014-07-11 06:19:42 +020043/* ---- SCO connections ---- */
44struct sco_conn {
45 struct hci_conn *hcon;
46
47 spinlock_t lock;
48 struct sock *sk;
49
50 unsigned int mtu;
51};
52
53#define sco_conn_lock(c) spin_lock(&c->lock);
54#define sco_conn_unlock(c) spin_unlock(&c->lock);
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056static void sco_sock_close(struct sock *sk);
57static void sco_sock_kill(struct sock *sk);
58
Marcel Holtmann2a0dccb2014-07-11 06:19:41 +020059/* ----- SCO socket info ----- */
60#define sco_pi(sk) ((struct sco_pinfo *) sk)
61
62struct sco_pinfo {
63 struct bt_sock bt;
64 bdaddr_t src;
65 bdaddr_t dst;
66 __u32 flags;
67 __u16 setting;
68 struct sco_conn *conn;
69};
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071/* ---- SCO timers ---- */
Marcel Holtmann068d69e2014-07-11 06:19:44 +020072#define SCO_CONN_TIMEOUT (HZ * 40)
73#define SCO_DISCONN_TIMEOUT (HZ * 2)
74
Linus Torvalds1da177e2005-04-16 15:20:36 -070075static void sco_sock_timeout(unsigned long arg)
76{
77 struct sock *sk = (struct sock *) arg;
78
79 BT_DBG("sock %p state %d", sk, sk->sk_state);
80
81 bh_lock_sock(sk);
82 sk->sk_err = ETIMEDOUT;
83 sk->sk_state_change(sk);
84 bh_unlock_sock(sk);
85
86 sco_sock_kill(sk);
87 sock_put(sk);
88}
89
90static void sco_sock_set_timer(struct sock *sk, long timeout)
91{
92 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
93 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
94}
95
96static void sco_sock_clear_timer(struct sock *sk)
97{
98 BT_DBG("sock %p state %d", sk, sk->sk_state);
99 sk_stop_timer(sk, &sk->sk_timer);
100}
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102/* ---- SCO connections ---- */
Lukasz Rymanowski519e42b2012-04-19 16:12:28 +0200103static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
105 struct hci_dev *hdev = hcon->hdev;
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200106 struct sco_conn *conn = hcon->sco_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Lukasz Rymanowski519e42b2012-04-19 16:12:28 +0200108 if (conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 return conn;
110
Claudio Takahasic10cc5a2013-04-11 11:35:45 -0300111 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200112 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
115 spin_lock_init(&conn->lock);
116
117 hcon->sco_data = conn;
118 conn->hcon = hcon;
119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 if (hdev->sco_mtu > 0)
121 conn->mtu = hdev->sco_mtu;
122 else
123 conn->mtu = 60;
124
125 BT_DBG("hcon %p conn %p", hcon, conn);
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 return conn;
128}
129
Marcel Holtmanne03ab512014-07-13 19:54:49 +0200130/* Delete channel.
131 * Must be called on the locked socket. */
132static void sco_chan_del(struct sock *sk, int err)
133{
134 struct sco_conn *conn;
135
136 conn = sco_pi(sk)->conn;
137
138 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
139
140 if (conn) {
141 sco_conn_lock(conn);
142 conn->sk = NULL;
143 sco_pi(sk)->conn = NULL;
144 sco_conn_unlock(conn);
145
146 if (conn->hcon)
147 hci_conn_drop(conn->hcon);
148 }
149
150 sk->sk_state = BT_CLOSED;
151 sk->sk_err = err;
152 sk->sk_state_change(sk);
153
154 sock_set_flag(sk, SOCK_ZAPPED);
155}
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157static int sco_conn_del(struct hci_conn *hcon, int err)
158{
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200159 struct sco_conn *conn = hcon->sco_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 struct sock *sk;
161
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200162 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 return 0;
164
165 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
166
167 /* Kill socket */
Marcel Holtmanneb5a4de2014-07-14 01:30:15 +0200168 sco_conn_lock(conn);
169 sk = conn->sk;
170 sco_conn_unlock(conn);
171
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200172 if (sk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 bh_lock_sock(sk);
174 sco_sock_clear_timer(sk);
175 sco_chan_del(sk, err);
176 bh_unlock_sock(sk);
177 sco_sock_kill(sk);
178 }
179
180 hcon->sco_data = NULL;
181 kfree(conn);
182 return 0;
183}
184
Marcel Holtmann015b01c2014-07-13 19:54:48 +0200185static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
186{
187 BT_DBG("conn %p", conn);
188
189 sco_pi(sk)->conn = conn;
190 conn->sk = sk;
191
192 if (parent)
193 bt_accept_enqueue(parent, sk);
194}
195
Gustavo Padovan6039aa732012-05-23 04:04:18 -0300196static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
197 struct sock *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
199 int err = 0;
200
201 sco_conn_lock(conn);
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300202 if (conn->sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 err = -EBUSY;
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300204 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 __sco_chan_add(conn, sk, parent);
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 sco_conn_unlock(conn);
208 return err;
209}
210
211static int sco_connect(struct sock *sk)
212{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 struct sco_conn *conn;
214 struct hci_conn *hcon;
215 struct hci_dev *hdev;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200216 int err, type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Marcel Holtmanneea96362013-10-13 10:34:01 -0700218 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Marcel Holtmanneea96362013-10-13 10:34:01 -0700220 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src);
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200221 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 return -EHOSTUNREACH;
223
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300224 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Marcel Holtmann7cb127d2008-07-14 20:13:53 +0200226 if (lmp_esco_capable(hdev) && !disable_esco)
227 type = ESCO_LINK;
228 else
229 type = SCO_LINK;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200230
Frédéric Dalleau79dc0082013-08-19 14:24:01 +0200231 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
232 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
233 err = -EOPNOTSUPP;
234 goto done;
235 }
236
Marcel Holtmanneea96362013-10-13 10:34:01 -0700237 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
Marcel Holtmann041987c2013-10-13 10:15:22 -0700238 sco_pi(sk)->setting);
Ville Tervo30e76272011-02-22 16:10:53 -0300239 if (IS_ERR(hcon)) {
240 err = PTR_ERR(hcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 goto done;
Ville Tervo30e76272011-02-22 16:10:53 -0300242 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Lukasz Rymanowski519e42b2012-04-19 16:12:28 +0200244 conn = sco_conn_add(hcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 if (!conn) {
David Herrmann76a68ba2013-04-06 20:28:37 +0200246 hci_conn_drop(hcon);
Ville Tervo30e76272011-02-22 16:10:53 -0300247 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 goto done;
249 }
250
251 /* Update source addr of the socket */
Marcel Holtmanneea96362013-10-13 10:34:01 -0700252 bacpy(&sco_pi(sk)->src, &hcon->src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254 err = sco_chan_add(conn, sk, NULL);
255 if (err)
256 goto done;
257
258 if (hcon->state == BT_CONNECTED) {
259 sco_sock_clear_timer(sk);
260 sk->sk_state = BT_CONNECTED;
261 } else {
262 sk->sk_state = BT_CONNECT;
263 sco_sock_set_timer(sk, sk->sk_sndtimeo);
264 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266done:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300267 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 hci_dev_put(hdev);
269 return err;
270}
271
Gustavo Padovan6039aa732012-05-23 04:04:18 -0300272static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
274 struct sco_conn *conn = sco_pi(sk)->conn;
275 struct sk_buff *skb;
Mikel Astiz088ce082012-04-11 08:48:48 +0200276 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 /* Check outgoing MTU */
279 if (len > conn->mtu)
280 return -EINVAL;
281
282 BT_DBG("sk %p len %d", sk, len);
283
Mikel Astiz088ce082012-04-11 08:48:48 +0200284 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300285 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return err;
287
Al Viro6ce8e9c2014-04-06 21:25:44 -0400288 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300289 kfree_skb(skb);
290 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 }
292
Gustavo F. Padovan0d861d82010-05-01 16:15:35 -0300293 hci_send_sco(conn->hcon, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Mikel Astiz088ce082012-04-11 08:48:48 +0200295 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
Gustavo Padovan6039aa732012-05-23 04:04:18 -0300298static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299{
Marcel Holtmanneb5a4de2014-07-14 01:30:15 +0200300 struct sock *sk;
301
302 sco_conn_lock(conn);
303 sk = conn->sk;
304 sco_conn_unlock(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 if (!sk)
307 goto drop;
308
309 BT_DBG("sk %p len %d", sk, skb->len);
310
311 if (sk->sk_state != BT_CONNECTED)
312 goto drop;
313
314 if (!sock_queue_rcv_skb(sk, skb))
315 return;
316
317drop:
318 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319}
320
321/* -------- Socket interface ---------- */
Marcel Holtmannfb334052012-04-19 14:37:58 +0200322static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Marcel Holtmannfb334052012-04-19 14:37:58 +0200324 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Sasha Levinb67bfe02013-02-27 17:06:00 -0800326 sk_for_each(sk, &sco_sk_list.head) {
Marcel Holtmannfb334052012-04-19 14:37:58 +0200327 if (sk->sk_state != BT_LISTEN)
328 continue;
329
Marcel Holtmanneea96362013-10-13 10:34:01 -0700330 if (!bacmp(&sco_pi(sk)->src, ba))
Marcel Holtmannfb334052012-04-19 14:37:58 +0200331 return sk;
332 }
333
334 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335}
336
337/* Find socket listening on source bdaddr.
338 * Returns closest match.
339 */
340static struct sock *sco_get_sock_listen(bdaddr_t *src)
341{
342 struct sock *sk = NULL, *sk1 = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344 read_lock(&sco_sk_list.lock);
345
Sasha Levinb67bfe02013-02-27 17:06:00 -0800346 sk_for_each(sk, &sco_sk_list.head) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 if (sk->sk_state != BT_LISTEN)
348 continue;
349
350 /* Exact match. */
Marcel Holtmanneea96362013-10-13 10:34:01 -0700351 if (!bacmp(&sco_pi(sk)->src, src))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 break;
353
354 /* Closest match */
Marcel Holtmanneea96362013-10-13 10:34:01 -0700355 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 sk1 = sk;
357 }
358
359 read_unlock(&sco_sk_list.lock);
360
Sasha Levinb67bfe02013-02-27 17:06:00 -0800361 return sk ? sk : sk1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362}
363
364static void sco_sock_destruct(struct sock *sk)
365{
366 BT_DBG("sk %p", sk);
367
368 skb_queue_purge(&sk->sk_receive_queue);
369 skb_queue_purge(&sk->sk_write_queue);
370}
371
372static void sco_sock_cleanup_listen(struct sock *parent)
373{
374 struct sock *sk;
375
376 BT_DBG("parent %p", parent);
377
378 /* Close not yet accepted channels */
379 while ((sk = bt_accept_dequeue(parent, NULL))) {
380 sco_sock_close(sk);
381 sco_sock_kill(sk);
382 }
383
384 parent->sk_state = BT_CLOSED;
385 sock_set_flag(parent, SOCK_ZAPPED);
386}
387
388/* Kill socket (only if zapped and orphan)
389 * Must be called on unlocked socket.
390 */
391static void sco_sock_kill(struct sock *sk)
392{
393 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
394 return;
395
396 BT_DBG("sk %p state %d", sk, sk->sk_state);
397
398 /* Kill poor orphan */
399 bt_sock_unlink(&sco_sk_list, sk);
400 sock_set_flag(sk, SOCK_DEAD);
401 sock_put(sk);
402}
403
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200404static void __sco_sock_close(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200406 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
408 switch (sk->sk_state) {
409 case BT_LISTEN:
410 sco_sock_cleanup_listen(sk);
411 break;
412
413 case BT_CONNECTED:
414 case BT_CONFIG:
Gustavo Padovanb7e98b52013-01-03 19:59:28 -0200415 if (sco_pi(sk)->conn->hcon) {
Luiz Augusto von Dentz4a777082011-05-12 11:13:15 +0300416 sk->sk_state = BT_DISCONN;
417 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
David Herrmann76a68ba2013-04-06 20:28:37 +0200418 hci_conn_drop(sco_pi(sk)->conn->hcon);
Luiz Augusto von Dentz4a777082011-05-12 11:13:15 +0300419 sco_pi(sk)->conn->hcon = NULL;
420 } else
421 sco_chan_del(sk, ECONNRESET);
422 break;
423
Vinicius Costa Gomeseb20ff92013-03-13 19:46:20 -0300424 case BT_CONNECT2:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 case BT_CONNECT:
426 case BT_DISCONN:
427 sco_chan_del(sk, ECONNRESET);
428 break;
429
430 default:
431 sock_set_flag(sk, SOCK_ZAPPED);
432 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700433 }
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200434}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200436/* Must be called on unlocked socket. */
437static void sco_sock_close(struct sock *sk)
438{
439 sco_sock_clear_timer(sk);
440 lock_sock(sk);
441 __sco_sock_close(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 sco_sock_kill(sk);
444}
445
446static void sco_sock_init(struct sock *sk, struct sock *parent)
447{
448 BT_DBG("sk %p", sk);
449
Paul Moore6230c9b2011-10-07 09:40:59 +0000450 if (parent) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 sk->sk_type = parent->sk_type;
Frédéric Dalleau20714bf2012-11-21 10:51:12 +0100452 bt_sk(sk)->flags = bt_sk(parent)->flags;
Paul Moore6230c9b2011-10-07 09:40:59 +0000453 security_sk_clone(parent, sk);
454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455}
456
457static struct proto sco_proto = {
458 .name = "SCO",
459 .owner = THIS_MODULE,
460 .obj_size = sizeof(struct sco_pinfo)
461};
462
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700463static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464{
465 struct sock *sk;
466
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700467 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 if (!sk)
469 return NULL;
470
471 sock_init_data(sock, sk);
472 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
473
474 sk->sk_destruct = sco_sock_destruct;
475 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
476
477 sock_reset_flag(sk, SOCK_ZAPPED);
478
479 sk->sk_protocol = proto;
480 sk->sk_state = BT_OPEN;
481
Frédéric Dalleauad10b1a2013-08-19 14:23:56 +0200482 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
483
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800484 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 bt_sock_link(&sco_sk_list, sk);
487 return sk;
488}
489
Eric Paris3f378b62009-11-05 22:18:14 -0800490static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
491 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
493 struct sock *sk;
494
495 BT_DBG("sock %p", sock);
496
497 sock->state = SS_UNCONNECTED;
498
499 if (sock->type != SOCK_SEQPACKET)
500 return -ESOCKTNOSUPPORT;
501
502 sock->ops = &sco_sock_ops;
503
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700504 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
Marcel Holtmann74da6262006-10-15 17:31:14 +0200505 if (!sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return -ENOMEM;
507
508 sco_sock_init(sk, NULL);
509 return 0;
510}
511
512static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
513{
514 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
515 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 int err = 0;
517
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300518 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 if (!addr || addr->sa_family != AF_BLUETOOTH)
521 return -EINVAL;
522
523 lock_sock(sk);
524
525 if (sk->sk_state != BT_OPEN) {
526 err = -EBADFD;
527 goto done;
528 }
529
Marcel Holtmann8ed21f72012-04-19 13:43:53 +0200530 if (sk->sk_type != SOCK_SEQPACKET) {
531 err = -EINVAL;
532 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 }
534
Marcel Holtmanneea96362013-10-13 10:34:01 -0700535 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
Marcel Holtmann8ed21f72012-04-19 13:43:53 +0200536
537 sk->sk_state = BT_BOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539done:
540 release_sock(sk);
541 return err;
542}
543
544static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
545{
546 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
547 struct sock *sk = sock->sk;
Claudio Takahasi92f185c2013-04-11 11:35:46 -0300548 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 BT_DBG("sk %p", sk);
551
Changli Gao6503d962010-03-31 22:58:26 +0000552 if (alen < sizeof(struct sockaddr_sco) ||
553 addr->sa_family != AF_BLUETOOTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 return -EINVAL;
555
556 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
557 return -EBADFD;
558
559 if (sk->sk_type != SOCK_SEQPACKET)
560 return -EINVAL;
561
562 lock_sock(sk);
563
564 /* Set destination address and psm */
Marcel Holtmanneea96362013-10-13 10:34:01 -0700565 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +0200567 err = sco_connect(sk);
568 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 goto done;
570
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900571 err = bt_sock_wait_state(sk, BT_CONNECTED,
Gustavo Padovanbe7c2b92012-05-17 00:36:21 -0300572 sock_sndtimeo(sk, flags & O_NONBLOCK));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
574done:
575 release_sock(sk);
576 return err;
577}
578
579static int sco_sock_listen(struct socket *sock, int backlog)
580{
581 struct sock *sk = sock->sk;
Marcel Holtmanneea96362013-10-13 10:34:01 -0700582 bdaddr_t *src = &sco_pi(sk)->src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 int err = 0;
584
585 BT_DBG("sk %p backlog %d", sk, backlog);
586
587 lock_sock(sk);
588
Marcel Holtmann7d5d7752012-04-19 13:43:52 +0200589 if (sk->sk_state != BT_BOUND) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 err = -EBADFD;
591 goto done;
592 }
593
Marcel Holtmann7d5d7752012-04-19 13:43:52 +0200594 if (sk->sk_type != SOCK_SEQPACKET) {
595 err = -EINVAL;
596 goto done;
597 }
598
Marcel Holtmannfb334052012-04-19 14:37:58 +0200599 write_lock(&sco_sk_list.lock);
600
601 if (__sco_get_sock_listen_by_addr(src)) {
602 err = -EADDRINUSE;
603 goto unlock;
604 }
605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 sk->sk_max_ack_backlog = backlog;
607 sk->sk_ack_backlog = 0;
Marcel Holtmannfb334052012-04-19 14:37:58 +0200608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 sk->sk_state = BT_LISTEN;
610
Marcel Holtmannfb334052012-04-19 14:37:58 +0200611unlock:
612 write_unlock(&sco_sk_list.lock);
613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614done:
615 release_sock(sk);
616 return err;
617}
618
619static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
620{
Peter Hurleydfb2fae2015-01-23 12:16:53 -0500621 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 struct sock *sk = sock->sk, *ch;
623 long timeo;
624 int err = 0;
625
626 lock_sock(sk);
627
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
629
630 BT_DBG("sk %p timeo %ld", sk, timeo);
631
632 /* Wait for an incoming connection. (wake-one). */
Eric Dumazetaa395142010-04-20 13:03:51 +0000633 add_wait_queue_exclusive(sk_sleep(sk), &wait);
Peter Hurley552b0d32011-07-24 00:11:01 -0400634 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 if (sk->sk_state != BT_LISTEN) {
636 err = -EBADFD;
637 break;
638 }
639
Peter Hurley552b0d32011-07-24 00:11:01 -0400640 ch = bt_accept_dequeue(sk, newsock);
641 if (ch)
642 break;
643
644 if (!timeo) {
645 err = -EAGAIN;
646 break;
647 }
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 if (signal_pending(current)) {
650 err = sock_intr_errno(timeo);
651 break;
652 }
Peter Hurley552b0d32011-07-24 00:11:01 -0400653
654 release_sock(sk);
Peter Hurleydfb2fae2015-01-23 12:16:53 -0500655
656 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
Peter Hurley552b0d32011-07-24 00:11:01 -0400657 lock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 }
Eric Dumazetaa395142010-04-20 13:03:51 +0000659 remove_wait_queue(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
661 if (err)
662 goto done;
663
664 newsock->state = SS_CONNECTED;
665
666 BT_DBG("new socket %p", ch);
667
668done:
669 release_sock(sk);
670 return err;
671}
672
673static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
674{
675 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
676 struct sock *sk = sock->sk;
677
678 BT_DBG("sock %p, sk %p", sock, sk);
679
680 addr->sa_family = AF_BLUETOOTH;
681 *len = sizeof(struct sockaddr_sco);
682
683 if (peer)
Marcel Holtmanneea96362013-10-13 10:34:01 -0700684 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 else
Marcel Holtmanneea96362013-10-13 10:34:01 -0700686 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
688 return 0;
689}
690
Ying Xue1b784142015-03-02 15:37:48 +0800691static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
692 size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
694 struct sock *sk = sock->sk;
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -0300695 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 BT_DBG("sock %p, sk %p", sock, sk);
698
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800699 err = sock_error(sk);
700 if (err)
701 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
703 if (msg->msg_flags & MSG_OOB)
704 return -EOPNOTSUPP;
705
706 lock_sock(sk);
707
708 if (sk->sk_state == BT_CONNECTED)
709 err = sco_send_frame(sk, msg, len);
710 else
711 err = -ENOTCONN;
712
713 release_sock(sk);
714 return err;
715}
716
Frédéric Dalleau2f69a822013-08-19 14:23:58 +0200717static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
Frédéric Dalleaufa5513b2013-04-16 17:28:58 +0200718{
719 struct hci_dev *hdev = conn->hdev;
720
721 BT_DBG("conn %p", conn);
722
723 conn->state = BT_CONFIG;
724
725 if (!lmp_esco_capable(hdev)) {
726 struct hci_cp_accept_conn_req cp;
727
728 bacpy(&cp.bdaddr, &conn->dst);
Frédéric Dalleau33f24042013-08-19 14:23:55 +0200729 cp.role = 0x00; /* Ignored */
Frédéric Dalleaufa5513b2013-04-16 17:28:58 +0200730
731 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
732 } else {
733 struct hci_cp_accept_sync_conn_req cp;
734
735 bacpy(&cp.bdaddr, &conn->dst);
736 cp.pkt_type = cpu_to_le16(conn->pkt_type);
737
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700738 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
739 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
Frédéric Dalleau2f69a822013-08-19 14:23:58 +0200740 cp.content_format = cpu_to_le16(setting);
741
742 switch (setting & SCO_AIRMODE_MASK) {
743 case SCO_AIRMODE_TRANSP:
744 if (conn->pkt_type & ESCO_2EV3)
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700745 cp.max_latency = cpu_to_le16(0x0008);
Frédéric Dalleau2f69a822013-08-19 14:23:58 +0200746 else
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700747 cp.max_latency = cpu_to_le16(0x000D);
Frédéric Dalleau2f69a822013-08-19 14:23:58 +0200748 cp.retrans_effort = 0x02;
749 break;
750 case SCO_AIRMODE_CVSD:
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700751 cp.max_latency = cpu_to_le16(0xffff);
Frédéric Dalleau2f69a822013-08-19 14:23:58 +0200752 cp.retrans_effort = 0xff;
753 break;
754 }
Frédéric Dalleaufa5513b2013-04-16 17:28:58 +0200755
756 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
757 sizeof(cp), &cp);
758 }
759}
760
Ying Xue1b784142015-03-02 15:37:48 +0800761static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
762 size_t len, int flags)
Frédéric Dalleau20714bf2012-11-21 10:51:12 +0100763{
764 struct sock *sk = sock->sk;
765 struct sco_pinfo *pi = sco_pi(sk);
766
767 lock_sock(sk);
768
769 if (sk->sk_state == BT_CONNECT2 &&
770 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
Frédéric Dalleau2f69a822013-08-19 14:23:58 +0200771 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
Frédéric Dalleau20714bf2012-11-21 10:51:12 +0100772 sk->sk_state = BT_CONFIG;
773
774 release_sock(sk);
775 return 0;
776 }
777
778 release_sock(sk);
779
Ying Xue1b784142015-03-02 15:37:48 +0800780 return bt_sock_recvmsg(sock, msg, len, flags);
Frédéric Dalleau20714bf2012-11-21 10:51:12 +0100781}
782
David S. Millerb7058842009-09-30 16:12:20 -0700783static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784{
785 struct sock *sk = sock->sk;
Frédéric Dalleauad10b1a2013-08-19 14:23:56 +0200786 int len, err = 0;
787 struct bt_voice voice;
Frédéric Dalleaub96e9c62012-11-21 10:51:11 +0100788 u32 opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 BT_DBG("sk %p", sk);
791
792 lock_sock(sk);
793
794 switch (optname) {
Frédéric Dalleaub96e9c62012-11-21 10:51:11 +0100795
796 case BT_DEFER_SETUP:
797 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
798 err = -EINVAL;
799 break;
800 }
801
802 if (get_user(opt, (u32 __user *) optval)) {
803 err = -EFAULT;
804 break;
805 }
806
807 if (opt)
808 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
809 else
810 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
811 break;
812
Frédéric Dalleauad10b1a2013-08-19 14:23:56 +0200813 case BT_VOICE:
814 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
815 sk->sk_state != BT_CONNECT2) {
816 err = -EINVAL;
817 break;
818 }
819
820 voice.setting = sco_pi(sk)->setting;
821
822 len = min_t(unsigned int, sizeof(voice), optlen);
823 if (copy_from_user((char *) &voice, optval, len)) {
824 err = -EFAULT;
825 break;
826 }
827
828 /* Explicitly check for these values */
829 if (voice.setting != BT_VOICE_TRANSPARENT &&
830 voice.setting != BT_VOICE_CVSD_16BIT) {
831 err = -EINVAL;
832 break;
833 }
834
835 sco_pi(sk)->setting = voice.setting;
836 break;
837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 default:
839 err = -ENOPROTOOPT;
840 break;
841 }
842
843 release_sock(sk);
844 return err;
845}
846
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100847static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
849 struct sock *sk = sock->sk;
850 struct sco_options opts;
851 struct sco_conninfo cinfo;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900852 int len, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
854 BT_DBG("sk %p", sk);
855
856 if (get_user(len, optlen))
857 return -EFAULT;
858
859 lock_sock(sk);
860
861 switch (optname) {
862 case SCO_OPTIONS:
Johan Hedberg9d225d22013-08-08 14:53:56 +0300863 if (sk->sk_state != BT_CONNECTED &&
864 !(sk->sk_state == BT_CONNECT2 &&
865 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 err = -ENOTCONN;
867 break;
868 }
869
870 opts.mtu = sco_pi(sk)->conn->mtu;
871
872 BT_DBG("mtu %d", opts.mtu);
873
874 len = min_t(unsigned int, len, sizeof(opts));
875 if (copy_to_user(optval, (char *)&opts, len))
876 err = -EFAULT;
877
878 break;
879
880 case SCO_CONNINFO:
Johan Hedberg9d225d22013-08-08 14:53:56 +0300881 if (sk->sk_state != BT_CONNECTED &&
882 !(sk->sk_state == BT_CONNECT2 &&
883 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 err = -ENOTCONN;
885 break;
886 }
887
Vasiliy Kulikovc4c896e2011-02-14 13:54:26 +0300888 memset(&cinfo, 0, sizeof(cinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
890 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
891
892 len = min_t(unsigned int, len, sizeof(cinfo));
893 if (copy_to_user(optval, (char *)&cinfo, len))
894 err = -EFAULT;
895
896 break;
897
898 default:
899 err = -ENOPROTOOPT;
900 break;
901 }
902
903 release_sock(sk);
904 return err;
905}
906
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100907static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
908{
909 struct sock *sk = sock->sk;
910 int len, err = 0;
Frédéric Dalleauad10b1a2013-08-19 14:23:56 +0200911 struct bt_voice voice;
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100912
913 BT_DBG("sk %p", sk);
914
915 if (level == SOL_SCO)
916 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
917
918 if (get_user(len, optlen))
919 return -EFAULT;
920
921 lock_sock(sk);
922
923 switch (optname) {
Frédéric Dalleaub96e9c62012-11-21 10:51:11 +0100924
925 case BT_DEFER_SETUP:
926 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
927 err = -EINVAL;
928 break;
929 }
930
931 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
932 (u32 __user *) optval))
933 err = -EFAULT;
934
935 break;
936
Frédéric Dalleauad10b1a2013-08-19 14:23:56 +0200937 case BT_VOICE:
938 voice.setting = sco_pi(sk)->setting;
939
940 len = min_t(unsigned int, len, sizeof(voice));
941 if (copy_to_user(optval, (char *)&voice, len))
942 err = -EFAULT;
943
944 break;
945
Marcel Holtmannd58daf42009-01-15 21:52:14 +0100946 default:
947 err = -ENOPROTOOPT;
948 break;
949 }
950
951 release_sock(sk);
952 return err;
953}
954
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200955static int sco_sock_shutdown(struct socket *sock, int how)
956{
957 struct sock *sk = sock->sk;
958 int err = 0;
959
960 BT_DBG("sock %p, sk %p", sock, sk);
961
962 if (!sk)
963 return 0;
964
965 lock_sock(sk);
966 if (!sk->sk_shutdown) {
967 sk->sk_shutdown = SHUTDOWN_MASK;
968 sco_sock_clear_timer(sk);
969 __sco_sock_close(sk);
970
Vladimir Davydov093facf2014-07-15 12:25:28 +0400971 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
972 !(current->flags & PF_EXITING))
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200973 err = bt_sock_wait_state(sk, BT_CLOSED,
Gustavo Padovanbe7c2b92012-05-17 00:36:21 -0300974 sk->sk_lingertime);
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +0200975 }
976 release_sock(sk);
977 return err;
978}
979
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980static int sco_sock_release(struct socket *sock)
981{
982 struct sock *sk = sock->sk;
983 int err = 0;
984
985 BT_DBG("sock %p, sk %p", sock, sk);
986
987 if (!sk)
988 return 0;
989
990 sco_sock_close(sk);
991
Vladimir Davydov093facf2014-07-15 12:25:28 +0400992 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
993 !(current->flags & PF_EXITING)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 lock_sock(sk);
995 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
996 release_sock(sk);
997 }
998
999 sock_orphan(sk);
1000 sco_sock_kill(sk);
1001 return err;
1002}
1003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004static void sco_conn_ready(struct sco_conn *conn)
1005{
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +02001006 struct sock *parent;
1007 struct sock *sk = conn->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
1009 BT_DBG("conn %p", conn);
1010
Andrei Emeltchenko735cbc42010-12-01 16:58:22 +02001011 if (sk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 sco_sock_clear_timer(sk);
1013 bh_lock_sock(sk);
1014 sk->sk_state = BT_CONNECTED;
1015 sk->sk_state_change(sk);
1016 bh_unlock_sock(sk);
1017 } else {
Andre Guedes40528082013-01-29 19:59:56 -03001018 sco_conn_lock(conn);
1019
Marcel Holtmann041987c2013-10-13 10:15:22 -07001020 parent = sco_get_sock_listen(&conn->hcon->src);
Andre Guedes40528082013-01-29 19:59:56 -03001021 if (!parent) {
1022 sco_conn_unlock(conn);
1023 return;
1024 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
1026 bh_lock_sock(parent);
1027
Gustavo F. Padovanb9dbdbc2010-05-01 16:15:35 -03001028 sk = sco_sock_alloc(sock_net(parent), NULL,
Gustavo Padovanbe7c2b92012-05-17 00:36:21 -03001029 BTPROTO_SCO, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (!sk) {
1031 bh_unlock_sock(parent);
Andre Guedes40528082013-01-29 19:59:56 -03001032 sco_conn_unlock(conn);
1033 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 }
1035
1036 sco_sock_init(sk, parent);
1037
Marcel Holtmanneea96362013-10-13 10:34:01 -07001038 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1039 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040
1041 hci_conn_hold(conn->hcon);
1042 __sco_chan_add(conn, sk, parent);
1043
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001044 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1045 sk->sk_state = BT_CONNECT2;
1046 else
1047 sk->sk_state = BT_CONNECTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048
1049 /* Wake up parent */
David S. Miller676d2362014-04-11 16:15:36 -04001050 parent->sk_data_ready(parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
1052 bh_unlock_sock(parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
Andre Guedes40528082013-01-29 19:59:56 -03001054 sco_conn_unlock(conn);
1055 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056}
1057
1058/* ----- SCO interface with lower layer (HCI) ----- */
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001059int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060{
Gustavo Padovanfc5fef62012-05-23 04:04:19 -03001061 struct sock *sk;
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +01001062 int lm = 0;
1063
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001064 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +01001066 /* Find listening sockets */
1067 read_lock(&sco_sk_list.lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -08001068 sk_for_each(sk, &sco_sk_list.head) {
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +01001069 if (sk->sk_state != BT_LISTEN)
1070 continue;
1071
Marcel Holtmanneea96362013-10-13 10:34:01 -07001072 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1073 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +01001074 lm |= HCI_LM_ACCEPT;
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001075
1076 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1077 *flags |= HCI_PROTO_DEFER;
Marcel Holtmann71aeeaa2009-01-15 21:57:02 +01001078 break;
1079 }
1080 }
1081 read_unlock(&sco_sk_list.lock);
1082
1083 return lm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084}
1085
Johan Hedberg539c4962015-02-18 14:53:57 +02001086static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087{
Johan Hedberg539c4962015-02-18 14:53:57 +02001088 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1089 return;
1090
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001091 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
Johan Hedberg539c4962015-02-18 14:53:57 +02001092
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 if (!status) {
1094 struct sco_conn *conn;
1095
Lukasz Rymanowski519e42b2012-04-19 16:12:28 +02001096 conn = sco_conn_add(hcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 if (conn)
1098 sco_conn_ready(conn);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001099 } else
Joe Perchese1750722011-06-29 18:18:29 -07001100 sco_conn_del(hcon, bt_to_errno(status));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101}
1102
Johan Hedberg3a6d5762015-02-18 14:53:58 +02001103static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104{
Johan Hedberg3a6d5762015-02-18 14:53:58 +02001105 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1106 return;
1107
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 BT_DBG("hcon %p reason %d", hcon, reason);
1109
Joe Perchese1750722011-06-29 18:18:29 -07001110 sco_conn_del(hcon, bt_to_errno(reason));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111}
1112
Ulisses Furquim686ebf22011-12-21 10:11:33 -02001113int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114{
1115 struct sco_conn *conn = hcon->sco_data;
1116
1117 if (!conn)
1118 goto drop;
1119
1120 BT_DBG("conn %p len %d", conn, skb->len);
1121
1122 if (skb->len) {
1123 sco_recv_frame(conn, skb);
1124 return 0;
1125 }
1126
1127drop:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001128 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 return 0;
1130}
1131
Johan Hedberg539c4962015-02-18 14:53:57 +02001132static struct hci_cb sco_cb = {
1133 .name = "SCO",
1134 .connect_cfm = sco_connect_cfm,
Johan Hedberg3a6d5762015-02-18 14:53:58 +02001135 .disconn_cfm = sco_disconn_cfm,
Johan Hedberg539c4962015-02-18 14:53:57 +02001136};
1137
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001138static int sco_debugfs_show(struct seq_file *f, void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139{
1140 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
Gustavo F. Padovanee65d192011-12-27 15:28:46 -02001142 read_lock(&sco_sk_list.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Sasha Levinb67bfe02013-02-27 17:06:00 -08001144 sk_for_each(sk, &sco_sk_list.head) {
Marcel Holtmanneea96362013-10-13 10:34:01 -07001145 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1146 &sco_pi(sk)->dst, sk->sk_state);
Marcel Holtmannbe9d1222005-11-08 09:57:38 -08001147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Gustavo F. Padovanee65d192011-12-27 15:28:46 -02001149 read_unlock(&sco_sk_list.lock);
Marcel Holtmannbe9d1222005-11-08 09:57:38 -08001150
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001151 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152}
1153
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001154static int sco_debugfs_open(struct inode *inode, struct file *file)
1155{
1156 return single_open(file, sco_debugfs_show, inode->i_private);
1157}
1158
1159static const struct file_operations sco_debugfs_fops = {
1160 .open = sco_debugfs_open,
1161 .read = seq_read,
1162 .llseek = seq_lseek,
1163 .release = single_release,
1164};
1165
1166static struct dentry *sco_debugfs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001168static const struct proto_ops sco_sock_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 .family = PF_BLUETOOTH,
1170 .owner = THIS_MODULE,
1171 .release = sco_sock_release,
1172 .bind = sco_sock_bind,
1173 .connect = sco_sock_connect,
1174 .listen = sco_sock_listen,
1175 .accept = sco_sock_accept,
1176 .getname = sco_sock_getname,
1177 .sendmsg = sco_sock_sendmsg,
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001178 .recvmsg = sco_sock_recvmsg,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 .poll = bt_sock_poll,
Marcel Holtmann3241ad82008-07-14 20:13:50 +02001180 .ioctl = bt_sock_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 .mmap = sock_no_mmap,
1182 .socketpair = sock_no_socketpair,
Marcel Holtmannfd0b3ff2009-06-16 00:01:49 +02001183 .shutdown = sco_sock_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 .setsockopt = sco_sock_setsockopt,
1185 .getsockopt = sco_sock_getsockopt
1186};
1187
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +00001188static const struct net_proto_family sco_sock_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 .family = PF_BLUETOOTH,
1190 .owner = THIS_MODULE,
1191 .create = sco_sock_create,
1192};
1193
Gustavo F. Padovan64274512011-02-07 20:08:52 -02001194int __init sco_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195{
1196 int err;
1197
Marcel Holtmann15762fa2015-01-11 15:21:06 -08001198 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 err = proto_register(&sco_proto, 0);
1201 if (err < 0)
1202 return err;
1203
1204 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1205 if (err < 0) {
1206 BT_ERR("SCO socket registration failed");
1207 goto error;
1208 }
1209
Al Virob0316612013-04-04 19:14:33 -04001210 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
Masatake YAMATOde9b9212012-07-26 01:30:12 +09001211 if (err < 0) {
1212 BT_ERR("Failed to create SCO proc file");
1213 bt_sock_unregister(BTPROTO_SCO);
1214 goto error;
1215 }
1216
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 BT_INFO("SCO socket layer initialized");
1218
Johan Hedberg539c4962015-02-18 14:53:57 +02001219 hci_register_cb(&sco_cb);
1220
Marcel Holtmann1120e4b2013-10-17 17:24:16 -07001221 if (IS_ERR_OR_NULL(bt_debugfs))
1222 return 0;
1223
1224 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1225 NULL, &sco_debugfs_fops);
1226
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 return 0;
1228
1229error:
1230 proto_unregister(&sco_proto);
1231 return err;
1232}
1233
Alexander Aring0402d9f22015-03-07 20:52:28 +01001234void sco_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235{
Masatake YAMATOde9b9212012-07-26 01:30:12 +09001236 bt_procfs_cleanup(&init_net, "sco");
1237
Marcel Holtmannaef7d972010-03-21 05:27:45 +01001238 debugfs_remove(sco_debugfs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
Johan Hedberg539c4962015-02-18 14:53:57 +02001240 hci_unregister_cb(&sco_cb);
1241
David Herrmann5e9d7f82013-02-24 19:36:51 +01001242 bt_sock_unregister(BTPROTO_SCO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 proto_unregister(&sco_proto);
1245}
1246
Marcel Holtmann7cb127d2008-07-14 20:13:53 +02001247module_param(disable_esco, bool, 0644);
1248MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");