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