1 // SPDX-License-Identifier: GPL-2.0
3 * BlueZ - Bluetooth protocol stack for Linux
5 * Copyright (C) 2022 Intel Corporation
6 * Copyright 2023-2024 NXP
9 #include <linux/module.h>
10 #include <linux/debugfs.h>
11 #include <linux/seq_file.h>
12 #include <linux/sched/signal.h>
14 #include <net/bluetooth/bluetooth.h>
15 #include <net/bluetooth/hci_core.h>
16 #include <net/bluetooth/iso.h>
19 static const struct proto_ops iso_sock_ops
;
21 static struct bt_sock_list iso_sk_list
= {
22 .lock
= __RW_LOCK_UNLOCKED(iso_sk_list
.lock
)
25 /* ---- ISO connections ---- */
27 struct hci_conn
*hcon
;
29 /* @lock: spinlock protecting changes to iso_conn fields */
33 struct delayed_work timeout_work
;
35 struct sk_buff
*rx_skb
;
40 #define iso_conn_lock(c) spin_lock(&(c)->lock)
41 #define iso_conn_unlock(c) spin_unlock(&(c)->lock)
43 static void iso_sock_close(struct sock
*sk
);
44 static void iso_sock_kill(struct sock
*sk
);
46 /* ----- ISO socket info ----- */
47 #define iso_pi(sk) ((struct iso_pinfo *)sk)
49 #define EIR_SERVICE_DATA_LENGTH 4
50 #define BASE_MAX_LENGTH (HCI_MAX_PER_AD_LENGTH - EIR_SERVICE_DATA_LENGTH)
51 #define EIR_BAA_SERVICE_UUID 0x1851
53 /* iso_pinfo flags values */
67 __u8 bc_bis
[ISO_MAX_NUM_BIS
];
70 struct bt_iso_qos qos
;
73 __u8 base
[BASE_MAX_LENGTH
];
74 struct iso_conn
*conn
;
77 static struct bt_iso_qos default_qos
;
79 static bool check_ucast_qos(struct bt_iso_qos
*qos
);
80 static bool check_bcast_qos(struct bt_iso_qos
*qos
);
81 static bool iso_match_sid(struct sock
*sk
, void *data
);
82 static bool iso_match_sync_handle(struct sock
*sk
, void *data
);
83 static bool iso_match_sync_handle_pa_report(struct sock
*sk
, void *data
);
84 static void iso_sock_disconn(struct sock
*sk
);
86 typedef bool (*iso_sock_match_t
)(struct sock
*sk
, void *data
);
88 static struct sock
*iso_get_sock(bdaddr_t
*src
, bdaddr_t
*dst
,
89 enum bt_sock_state state
,
90 iso_sock_match_t match
, void *data
);
92 /* ---- ISO timers ---- */
93 #define ISO_CONN_TIMEOUT (HZ * 40)
94 #define ISO_DISCONN_TIMEOUT (HZ * 2)
96 static void iso_sock_timeout(struct work_struct
*work
)
98 struct iso_conn
*conn
= container_of(work
, struct iso_conn
,
106 iso_conn_unlock(conn
);
111 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
114 sk
->sk_err
= ETIMEDOUT
;
115 sk
->sk_state_change(sk
);
120 static void iso_sock_set_timer(struct sock
*sk
, long timeout
)
122 if (!iso_pi(sk
)->conn
)
125 BT_DBG("sock %p state %d timeout %ld", sk
, sk
->sk_state
, timeout
);
126 cancel_delayed_work(&iso_pi(sk
)->conn
->timeout_work
);
127 schedule_delayed_work(&iso_pi(sk
)->conn
->timeout_work
, timeout
);
130 static void iso_sock_clear_timer(struct sock
*sk
)
132 if (!iso_pi(sk
)->conn
)
135 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
136 cancel_delayed_work(&iso_pi(sk
)->conn
->timeout_work
);
139 /* ---- ISO connections ---- */
140 static struct iso_conn
*iso_conn_add(struct hci_conn
*hcon
)
142 struct iso_conn
*conn
= hcon
->iso_data
;
150 conn
= kzalloc(sizeof(*conn
), GFP_KERNEL
);
154 spin_lock_init(&conn
->lock
);
155 INIT_DELAYED_WORK(&conn
->timeout_work
, iso_sock_timeout
);
157 hcon
->iso_data
= conn
;
161 BT_DBG("hcon %p conn %p", hcon
, conn
);
166 /* Delete channel. Must be called on the locked socket. */
167 static void iso_chan_del(struct sock
*sk
, int err
)
169 struct iso_conn
*conn
;
172 conn
= iso_pi(sk
)->conn
;
174 BT_DBG("sk %p, conn %p, err %d", sk
, conn
, err
);
179 iso_pi(sk
)->conn
= NULL
;
180 iso_conn_unlock(conn
);
183 hci_conn_drop(conn
->hcon
);
186 sk
->sk_state
= BT_CLOSED
;
189 parent
= bt_sk(sk
)->parent
;
191 bt_accept_unlink(sk
);
192 parent
->sk_data_ready(parent
);
194 sk
->sk_state_change(sk
);
197 sock_set_flag(sk
, SOCK_ZAPPED
);
200 static void iso_conn_del(struct hci_conn
*hcon
, int err
)
202 struct iso_conn
*conn
= hcon
->iso_data
;
208 BT_DBG("hcon %p conn %p, err %d", hcon
, conn
, err
);
215 iso_conn_unlock(conn
);
219 iso_sock_clear_timer(sk
);
220 iso_chan_del(sk
, err
);
225 /* Ensure no more work items will run before freeing conn. */
226 cancel_delayed_work_sync(&conn
->timeout_work
);
228 hcon
->iso_data
= NULL
;
232 static int __iso_chan_add(struct iso_conn
*conn
, struct sock
*sk
,
235 BT_DBG("conn %p", conn
);
237 if (iso_pi(sk
)->conn
== conn
&& conn
->sk
== sk
)
241 BT_ERR("conn->sk already set");
245 iso_pi(sk
)->conn
= conn
;
249 bt_accept_enqueue(parent
, sk
, true);
254 static int iso_chan_add(struct iso_conn
*conn
, struct sock
*sk
,
260 err
= __iso_chan_add(conn
, sk
, parent
);
261 iso_conn_unlock(conn
);
266 static inline u8
le_addr_type(u8 bdaddr_type
)
268 if (bdaddr_type
== BDADDR_LE_PUBLIC
)
269 return ADDR_LE_DEV_PUBLIC
;
271 return ADDR_LE_DEV_RANDOM
;
274 static int iso_connect_bis(struct sock
*sk
)
276 struct iso_conn
*conn
;
277 struct hci_conn
*hcon
;
278 struct hci_dev
*hdev
;
281 BT_DBG("%pMR", &iso_pi(sk
)->src
);
283 hdev
= hci_get_route(&iso_pi(sk
)->dst
, &iso_pi(sk
)->src
,
284 iso_pi(sk
)->src_type
);
286 return -EHOSTUNREACH
;
290 if (!bis_capable(hdev
)) {
295 /* Fail if user set invalid QoS */
296 if (iso_pi(sk
)->qos_user_set
&& !check_bcast_qos(&iso_pi(sk
)->qos
)) {
297 iso_pi(sk
)->qos
= default_qos
;
302 /* Fail if out PHYs are marked as disabled */
303 if (!iso_pi(sk
)->qos
.bcast
.out
.phy
) {
308 /* Just bind if DEFER_SETUP has been set */
309 if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
)) {
310 hcon
= hci_bind_bis(hdev
, &iso_pi(sk
)->dst
,
311 &iso_pi(sk
)->qos
, iso_pi(sk
)->base_len
,
318 hcon
= hci_connect_bis(hdev
, &iso_pi(sk
)->dst
,
319 le_addr_type(iso_pi(sk
)->dst_type
),
320 &iso_pi(sk
)->qos
, iso_pi(sk
)->base_len
,
328 conn
= iso_conn_add(hcon
);
337 err
= iso_chan_add(conn
, sk
, NULL
);
343 /* Update source addr of the socket */
344 bacpy(&iso_pi(sk
)->src
, &hcon
->src
);
346 if (hcon
->state
== BT_CONNECTED
) {
347 iso_sock_clear_timer(sk
);
348 sk
->sk_state
= BT_CONNECTED
;
349 } else if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
)) {
350 iso_sock_clear_timer(sk
);
351 sk
->sk_state
= BT_CONNECT
;
353 sk
->sk_state
= BT_CONNECT
;
354 iso_sock_set_timer(sk
, sk
->sk_sndtimeo
);
360 hci_dev_unlock(hdev
);
365 static int iso_connect_cis(struct sock
*sk
)
367 struct iso_conn
*conn
;
368 struct hci_conn
*hcon
;
369 struct hci_dev
*hdev
;
372 BT_DBG("%pMR -> %pMR", &iso_pi(sk
)->src
, &iso_pi(sk
)->dst
);
374 hdev
= hci_get_route(&iso_pi(sk
)->dst
, &iso_pi(sk
)->src
,
375 iso_pi(sk
)->src_type
);
377 return -EHOSTUNREACH
;
381 if (!cis_central_capable(hdev
)) {
386 /* Fail if user set invalid QoS */
387 if (iso_pi(sk
)->qos_user_set
&& !check_ucast_qos(&iso_pi(sk
)->qos
)) {
388 iso_pi(sk
)->qos
= default_qos
;
393 /* Fail if either PHYs are marked as disabled */
394 if (!iso_pi(sk
)->qos
.ucast
.in
.phy
&& !iso_pi(sk
)->qos
.ucast
.out
.phy
) {
399 /* Just bind if DEFER_SETUP has been set */
400 if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
)) {
401 hcon
= hci_bind_cis(hdev
, &iso_pi(sk
)->dst
,
402 le_addr_type(iso_pi(sk
)->dst_type
),
409 hcon
= hci_connect_cis(hdev
, &iso_pi(sk
)->dst
,
410 le_addr_type(iso_pi(sk
)->dst_type
),
418 conn
= iso_conn_add(hcon
);
427 err
= iso_chan_add(conn
, sk
, NULL
);
433 /* Update source addr of the socket */
434 bacpy(&iso_pi(sk
)->src
, &hcon
->src
);
436 if (hcon
->state
== BT_CONNECTED
) {
437 iso_sock_clear_timer(sk
);
438 sk
->sk_state
= BT_CONNECTED
;
439 } else if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
)) {
440 iso_sock_clear_timer(sk
);
441 sk
->sk_state
= BT_CONNECT
;
443 sk
->sk_state
= BT_CONNECT
;
444 iso_sock_set_timer(sk
, sk
->sk_sndtimeo
);
450 hci_dev_unlock(hdev
);
455 static struct bt_iso_qos
*iso_sock_get_qos(struct sock
*sk
)
457 if (sk
->sk_state
== BT_CONNECTED
|| sk
->sk_state
== BT_CONNECT2
)
458 return &iso_pi(sk
)->conn
->hcon
->iso_qos
;
460 return &iso_pi(sk
)->qos
;
463 static int iso_send_frame(struct sock
*sk
, struct sk_buff
*skb
)
465 struct iso_conn
*conn
= iso_pi(sk
)->conn
;
466 struct bt_iso_qos
*qos
= iso_sock_get_qos(sk
);
467 struct hci_iso_data_hdr
*hdr
;
470 BT_DBG("sk %p len %d", sk
, skb
->len
);
472 if (skb
->len
> qos
->ucast
.out
.sdu
)
477 /* Push ISO data header */
478 hdr
= skb_push(skb
, HCI_ISO_DATA_HDR_SIZE
);
479 hdr
->sn
= cpu_to_le16(conn
->tx_sn
++);
480 hdr
->slen
= cpu_to_le16(hci_iso_data_len_pack(len
,
481 HCI_ISO_STATUS_VALID
));
483 if (sk
->sk_state
== BT_CONNECTED
)
484 hci_send_iso(conn
->hcon
, skb
);
491 static void iso_recv_frame(struct iso_conn
*conn
, struct sk_buff
*skb
)
497 iso_conn_unlock(conn
);
502 BT_DBG("sk %p len %d", sk
, skb
->len
);
504 if (sk
->sk_state
!= BT_CONNECTED
)
507 if (!sock_queue_rcv_skb(sk
, skb
))
514 /* -------- Socket interface ---------- */
515 static struct sock
*__iso_get_sock_listen_by_addr(bdaddr_t
*src
, bdaddr_t
*dst
)
519 sk_for_each(sk
, &iso_sk_list
.head
) {
520 if (sk
->sk_state
!= BT_LISTEN
)
523 if (bacmp(&iso_pi(sk
)->dst
, dst
))
526 if (!bacmp(&iso_pi(sk
)->src
, src
))
533 static struct sock
*__iso_get_sock_listen_by_sid(bdaddr_t
*ba
, bdaddr_t
*bc
,
538 sk_for_each(sk
, &iso_sk_list
.head
) {
539 if (sk
->sk_state
!= BT_LISTEN
)
542 if (bacmp(&iso_pi(sk
)->src
, ba
))
545 if (bacmp(&iso_pi(sk
)->dst
, bc
))
548 if (iso_pi(sk
)->bc_sid
== sid
)
555 /* Find socket in given state:
556 * source bdaddr (Unicast)
557 * destination bdaddr (Broadcast only)
558 * match func - pass NULL to ignore
559 * match func data - pass -1 to ignore
560 * Returns closest match.
562 static struct sock
*iso_get_sock(bdaddr_t
*src
, bdaddr_t
*dst
,
563 enum bt_sock_state state
,
564 iso_sock_match_t match
, void *data
)
566 struct sock
*sk
= NULL
, *sk1
= NULL
;
568 read_lock(&iso_sk_list
.lock
);
570 sk_for_each(sk
, &iso_sk_list
.head
) {
571 if (sk
->sk_state
!= state
)
574 /* Match Broadcast destination */
575 if (bacmp(dst
, BDADDR_ANY
) && bacmp(&iso_pi(sk
)->dst
, dst
))
578 /* Use Match function if provided */
579 if (match
&& !match(sk
, data
))
583 if (!bacmp(&iso_pi(sk
)->src
, src
)) {
589 if (!bacmp(&iso_pi(sk
)->src
, BDADDR_ANY
)) {
601 read_unlock(&iso_sk_list
.lock
);
603 return sk
? sk
: sk1
;
606 static struct sock
*iso_get_sock_big(struct sock
*match_sk
, bdaddr_t
*src
,
607 bdaddr_t
*dst
, uint8_t big
)
609 struct sock
*sk
= NULL
;
611 read_lock(&iso_sk_list
.lock
);
613 sk_for_each(sk
, &iso_sk_list
.head
) {
617 /* Look for sockets that have already been
618 * connected to the BIG
620 if (sk
->sk_state
!= BT_CONNECTED
&&
621 sk
->sk_state
!= BT_CONNECT
)
624 /* Match Broadcast destination */
625 if (bacmp(&iso_pi(sk
)->dst
, dst
))
628 /* Match BIG handle */
629 if (iso_pi(sk
)->qos
.bcast
.big
!= big
)
632 /* Match source address */
633 if (bacmp(&iso_pi(sk
)->src
, src
))
640 read_unlock(&iso_sk_list
.lock
);
645 static void iso_sock_destruct(struct sock
*sk
)
649 skb_queue_purge(&sk
->sk_receive_queue
);
650 skb_queue_purge(&sk
->sk_write_queue
);
653 static void iso_sock_cleanup_listen(struct sock
*parent
)
657 BT_DBG("parent %p", parent
);
659 /* Close not yet accepted channels */
660 while ((sk
= bt_accept_dequeue(parent
, NULL
))) {
665 /* If listening socket has a hcon, properly disconnect it */
666 if (iso_pi(parent
)->conn
&& iso_pi(parent
)->conn
->hcon
) {
667 iso_sock_disconn(parent
);
671 parent
->sk_state
= BT_CLOSED
;
672 sock_set_flag(parent
, SOCK_ZAPPED
);
675 /* Kill socket (only if zapped and orphan)
676 * Must be called on unlocked socket.
678 static void iso_sock_kill(struct sock
*sk
)
680 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
||
681 sock_flag(sk
, SOCK_DEAD
))
684 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
686 /* Kill poor orphan */
687 bt_sock_unlink(&iso_sk_list
, sk
);
688 sock_set_flag(sk
, SOCK_DEAD
);
692 static void iso_sock_disconn(struct sock
*sk
)
695 struct hci_conn
*hcon
= iso_pi(sk
)->conn
->hcon
;
697 if (test_bit(HCI_CONN_BIG_CREATED
, &hcon
->flags
)) {
698 bis_sk
= iso_get_sock_big(sk
, &iso_pi(sk
)->src
,
700 iso_pi(sk
)->qos
.bcast
.big
);
702 /* If there are any other connected sockets for the
703 * same BIG, just delete the sk and leave the bis
704 * hcon active, in case later rebinding is needed.
707 hcon
->state
= BT_OPEN
;
708 iso_pi(sk
)->conn
->hcon
= NULL
;
709 iso_sock_clear_timer(sk
);
710 iso_chan_del(sk
, bt_to_errno(hcon
->abort_reason
));
716 sk
->sk_state
= BT_DISCONN
;
717 iso_sock_set_timer(sk
, ISO_DISCONN_TIMEOUT
);
718 iso_conn_lock(iso_pi(sk
)->conn
);
719 hci_conn_drop(iso_pi(sk
)->conn
->hcon
);
720 iso_pi(sk
)->conn
->hcon
= NULL
;
721 iso_conn_unlock(iso_pi(sk
)->conn
);
724 static void __iso_sock_close(struct sock
*sk
)
726 BT_DBG("sk %p state %d socket %p", sk
, sk
->sk_state
, sk
->sk_socket
);
728 switch (sk
->sk_state
) {
730 iso_sock_cleanup_listen(sk
);
736 if (iso_pi(sk
)->conn
->hcon
)
737 iso_sock_disconn(sk
);
739 iso_chan_del(sk
, ECONNRESET
);
743 if (iso_pi(sk
)->conn
->hcon
&&
744 (test_bit(HCI_CONN_PA_SYNC
, &iso_pi(sk
)->conn
->hcon
->flags
) ||
745 test_bit(HCI_CONN_PA_SYNC_FAILED
, &iso_pi(sk
)->conn
->hcon
->flags
)))
746 iso_sock_disconn(sk
);
748 iso_chan_del(sk
, ECONNRESET
);
751 iso_chan_del(sk
, ECONNRESET
);
755 sock_set_flag(sk
, SOCK_ZAPPED
);
760 /* Must be called on unlocked socket. */
761 static void iso_sock_close(struct sock
*sk
)
763 iso_sock_clear_timer(sk
);
765 __iso_sock_close(sk
);
770 static void iso_sock_init(struct sock
*sk
, struct sock
*parent
)
775 sk
->sk_type
= parent
->sk_type
;
776 bt_sk(sk
)->flags
= bt_sk(parent
)->flags
;
777 security_sk_clone(parent
, sk
);
781 static struct proto iso_proto
= {
783 .owner
= THIS_MODULE
,
784 .obj_size
= sizeof(struct iso_pinfo
)
787 #define DEFAULT_IO_QOS \
789 .interval = 10000u, \
792 .phy = BT_ISO_PHY_2M, \
796 static struct bt_iso_qos default_qos
= {
798 .big
= BT_ISO_QOS_BIG_UNSET
,
799 .bis
= BT_ISO_QOS_BIS_UNSET
,
803 .in
= DEFAULT_IO_QOS
,
804 .out
= DEFAULT_IO_QOS
,
809 .sync_timeout
= BT_ISO_SYNC_TIMEOUT
,
810 .sync_cte_type
= 0x00,
812 .timeout
= BT_ISO_SYNC_TIMEOUT
,
816 static struct sock
*iso_sock_alloc(struct net
*net
, struct socket
*sock
,
817 int proto
, gfp_t prio
, int kern
)
821 sk
= bt_sock_alloc(net
, sock
, &iso_proto
, proto
, prio
, kern
);
825 sk
->sk_destruct
= iso_sock_destruct
;
826 sk
->sk_sndtimeo
= ISO_CONN_TIMEOUT
;
828 /* Set address type as public as default src address is BDADDR_ANY */
829 iso_pi(sk
)->src_type
= BDADDR_LE_PUBLIC
;
831 iso_pi(sk
)->qos
= default_qos
;
832 iso_pi(sk
)->sync_handle
= -1;
834 bt_sock_link(&iso_sk_list
, sk
);
838 static int iso_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
843 BT_DBG("sock %p", sock
);
845 sock
->state
= SS_UNCONNECTED
;
847 if (sock
->type
!= SOCK_SEQPACKET
)
848 return -ESOCKTNOSUPPORT
;
850 sock
->ops
= &iso_sock_ops
;
852 sk
= iso_sock_alloc(net
, sock
, protocol
, GFP_ATOMIC
, kern
);
856 iso_sock_init(sk
, NULL
);
860 static int iso_sock_bind_bc(struct socket
*sock
, struct sockaddr
*addr
,
863 struct sockaddr_iso
*sa
= (struct sockaddr_iso
*)addr
;
864 struct sock
*sk
= sock
->sk
;
867 BT_DBG("sk %p bc_sid %u bc_num_bis %u", sk
, sa
->iso_bc
->bc_sid
,
868 sa
->iso_bc
->bc_num_bis
);
870 if (addr_len
!= sizeof(*sa
) + sizeof(*sa
->iso_bc
))
873 bacpy(&iso_pi(sk
)->dst
, &sa
->iso_bc
->bc_bdaddr
);
875 /* Check if the address type is of LE type */
876 if (!bdaddr_type_is_le(sa
->iso_bc
->bc_bdaddr_type
))
879 iso_pi(sk
)->dst_type
= sa
->iso_bc
->bc_bdaddr_type
;
881 if (sa
->iso_bc
->bc_sid
> 0x0f)
884 iso_pi(sk
)->bc_sid
= sa
->iso_bc
->bc_sid
;
886 if (sa
->iso_bc
->bc_num_bis
> ISO_MAX_NUM_BIS
)
889 iso_pi(sk
)->bc_num_bis
= sa
->iso_bc
->bc_num_bis
;
891 for (i
= 0; i
< iso_pi(sk
)->bc_num_bis
; i
++)
892 if (sa
->iso_bc
->bc_bis
[i
] < 0x01 ||
893 sa
->iso_bc
->bc_bis
[i
] > 0x1f)
896 memcpy(iso_pi(sk
)->bc_bis
, sa
->iso_bc
->bc_bis
,
897 iso_pi(sk
)->bc_num_bis
);
902 static int iso_sock_bind_pa_sk(struct sock
*sk
, struct sockaddr_iso
*sa
,
907 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
912 if (addr_len
!= sizeof(*sa
) + sizeof(*sa
->iso_bc
)) {
917 if (sa
->iso_bc
->bc_num_bis
> ISO_MAX_NUM_BIS
) {
922 iso_pi(sk
)->bc_num_bis
= sa
->iso_bc
->bc_num_bis
;
924 for (int i
= 0; i
< iso_pi(sk
)->bc_num_bis
; i
++)
925 if (sa
->iso_bc
->bc_bis
[i
] < 0x01 ||
926 sa
->iso_bc
->bc_bis
[i
] > 0x1f) {
931 memcpy(iso_pi(sk
)->bc_bis
, sa
->iso_bc
->bc_bis
,
932 iso_pi(sk
)->bc_num_bis
);
938 static int iso_sock_bind(struct socket
*sock
, struct sockaddr
*addr
,
941 struct sockaddr_iso
*sa
= (struct sockaddr_iso
*)addr
;
942 struct sock
*sk
= sock
->sk
;
945 BT_DBG("sk %p %pMR type %u", sk
, &sa
->iso_bdaddr
, sa
->iso_bdaddr_type
);
947 if (!addr
|| addr_len
< sizeof(struct sockaddr_iso
) ||
948 addr
->sa_family
!= AF_BLUETOOTH
)
953 /* Allow the user to bind a PA sync socket to a number
954 * of BISes to sync to.
956 if ((sk
->sk_state
== BT_CONNECT2
||
957 sk
->sk_state
== BT_CONNECTED
) &&
958 test_bit(BT_SK_PA_SYNC
, &iso_pi(sk
)->flags
)) {
959 err
= iso_sock_bind_pa_sk(sk
, sa
, addr_len
);
963 if (sk
->sk_state
!= BT_OPEN
) {
968 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
973 /* Check if the address type is of LE type */
974 if (!bdaddr_type_is_le(sa
->iso_bdaddr_type
)) {
979 bacpy(&iso_pi(sk
)->src
, &sa
->iso_bdaddr
);
980 iso_pi(sk
)->src_type
= sa
->iso_bdaddr_type
;
982 /* Check for Broadcast address */
983 if (addr_len
> sizeof(*sa
)) {
984 err
= iso_sock_bind_bc(sock
, addr
, addr_len
);
989 sk
->sk_state
= BT_BOUND
;
996 static int iso_sock_connect(struct socket
*sock
, struct sockaddr
*addr
,
999 struct sockaddr_iso
*sa
= (struct sockaddr_iso
*)addr
;
1000 struct sock
*sk
= sock
->sk
;
1003 BT_DBG("sk %p", sk
);
1005 if (alen
< sizeof(struct sockaddr_iso
) ||
1006 addr
->sa_family
!= AF_BLUETOOTH
)
1009 if (sk
->sk_state
!= BT_OPEN
&& sk
->sk_state
!= BT_BOUND
)
1012 if (sk
->sk_type
!= SOCK_SEQPACKET
)
1015 /* Check if the address type is of LE type */
1016 if (!bdaddr_type_is_le(sa
->iso_bdaddr_type
))
1021 bacpy(&iso_pi(sk
)->dst
, &sa
->iso_bdaddr
);
1022 iso_pi(sk
)->dst_type
= sa
->iso_bdaddr_type
;
1026 if (bacmp(&iso_pi(sk
)->dst
, BDADDR_ANY
))
1027 err
= iso_connect_cis(sk
);
1029 err
= iso_connect_bis(sk
);
1036 if (!test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
)) {
1037 err
= bt_sock_wait_state(sk
, BT_CONNECTED
,
1038 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
1045 static int iso_listen_bis(struct sock
*sk
)
1047 struct hci_dev
*hdev
;
1049 struct iso_conn
*conn
;
1050 struct hci_conn
*hcon
;
1052 BT_DBG("%pMR -> %pMR (SID 0x%2.2x)", &iso_pi(sk
)->src
,
1053 &iso_pi(sk
)->dst
, iso_pi(sk
)->bc_sid
);
1055 write_lock(&iso_sk_list
.lock
);
1057 if (__iso_get_sock_listen_by_sid(&iso_pi(sk
)->src
, &iso_pi(sk
)->dst
,
1058 iso_pi(sk
)->bc_sid
))
1061 write_unlock(&iso_sk_list
.lock
);
1066 hdev
= hci_get_route(&iso_pi(sk
)->dst
, &iso_pi(sk
)->src
,
1067 iso_pi(sk
)->src_type
);
1069 return -EHOSTUNREACH
;
1073 /* Fail if user set invalid QoS */
1074 if (iso_pi(sk
)->qos_user_set
&& !check_bcast_qos(&iso_pi(sk
)->qos
)) {
1075 iso_pi(sk
)->qos
= default_qos
;
1080 hcon
= hci_pa_create_sync(hdev
, &iso_pi(sk
)->dst
,
1081 le_addr_type(iso_pi(sk
)->dst_type
),
1082 iso_pi(sk
)->bc_sid
, &iso_pi(sk
)->qos
);
1084 err
= PTR_ERR(hcon
);
1088 conn
= iso_conn_add(hcon
);
1090 hci_conn_drop(hcon
);
1095 err
= iso_chan_add(conn
, sk
, NULL
);
1097 hci_conn_drop(hcon
);
1104 hci_dev_unlock(hdev
);
1108 static int iso_listen_cis(struct sock
*sk
)
1112 BT_DBG("%pMR", &iso_pi(sk
)->src
);
1114 write_lock(&iso_sk_list
.lock
);
1116 if (__iso_get_sock_listen_by_addr(&iso_pi(sk
)->src
, &iso_pi(sk
)->dst
))
1119 write_unlock(&iso_sk_list
.lock
);
1124 static int iso_sock_listen(struct socket
*sock
, int backlog
)
1126 struct sock
*sk
= sock
->sk
;
1129 BT_DBG("sk %p backlog %d", sk
, backlog
);
1133 if (sk
->sk_state
!= BT_BOUND
) {
1138 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1143 if (!bacmp(&iso_pi(sk
)->dst
, BDADDR_ANY
))
1144 err
= iso_listen_cis(sk
);
1146 err
= iso_listen_bis(sk
);
1151 sk
->sk_max_ack_backlog
= backlog
;
1152 sk
->sk_ack_backlog
= 0;
1154 sk
->sk_state
= BT_LISTEN
;
1161 static int iso_sock_accept(struct socket
*sock
, struct socket
*newsock
,
1162 struct proto_accept_arg
*arg
)
1164 DEFINE_WAIT_FUNC(wait
, woken_wake_function
);
1165 struct sock
*sk
= sock
->sk
, *ch
;
1171 timeo
= sock_rcvtimeo(sk
, arg
->flags
& O_NONBLOCK
);
1173 BT_DBG("sk %p timeo %ld", sk
, timeo
);
1175 /* Wait for an incoming connection. (wake-one). */
1176 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
1178 if (sk
->sk_state
!= BT_LISTEN
) {
1183 ch
= bt_accept_dequeue(sk
, newsock
);
1192 if (signal_pending(current
)) {
1193 err
= sock_intr_errno(timeo
);
1199 timeo
= wait_woken(&wait
, TASK_INTERRUPTIBLE
, timeo
);
1202 remove_wait_queue(sk_sleep(sk
), &wait
);
1207 newsock
->state
= SS_CONNECTED
;
1209 BT_DBG("new socket %p", ch
);
1216 static int iso_sock_getname(struct socket
*sock
, struct sockaddr
*addr
,
1219 struct sockaddr_iso
*sa
= (struct sockaddr_iso
*)addr
;
1220 struct sock
*sk
= sock
->sk
;
1222 BT_DBG("sock %p, sk %p", sock
, sk
);
1224 addr
->sa_family
= AF_BLUETOOTH
;
1227 bacpy(&sa
->iso_bdaddr
, &iso_pi(sk
)->dst
);
1228 sa
->iso_bdaddr_type
= iso_pi(sk
)->dst_type
;
1230 bacpy(&sa
->iso_bdaddr
, &iso_pi(sk
)->src
);
1231 sa
->iso_bdaddr_type
= iso_pi(sk
)->src_type
;
1234 return sizeof(struct sockaddr_iso
);
1237 static int iso_sock_sendmsg(struct socket
*sock
, struct msghdr
*msg
,
1240 struct sock
*sk
= sock
->sk
;
1241 struct sk_buff
*skb
, **frag
;
1245 BT_DBG("sock %p, sk %p", sock
, sk
);
1247 err
= sock_error(sk
);
1251 if (msg
->msg_flags
& MSG_OOB
)
1256 if (sk
->sk_state
!= BT_CONNECTED
) {
1261 mtu
= iso_pi(sk
)->conn
->hcon
->mtu
;
1265 skb
= bt_skb_sendmsg(sk
, msg
, len
, mtu
, HCI_ISO_DATA_HDR_SIZE
, 0);
1267 return PTR_ERR(skb
);
1271 BT_DBG("skb %p len %d", sk
, skb
->len
);
1273 /* Continuation fragments */
1274 frag
= &skb_shinfo(skb
)->frag_list
;
1276 struct sk_buff
*tmp
;
1278 tmp
= bt_skb_sendmsg(sk
, msg
, len
, mtu
, 0, 0);
1281 return PTR_ERR(tmp
);
1288 skb
->len
+= tmp
->len
;
1289 skb
->data_len
+= tmp
->len
;
1291 BT_DBG("frag %p len %d", *frag
, tmp
->len
);
1293 frag
= &(*frag
)->next
;
1298 if (sk
->sk_state
== BT_CONNECTED
)
1299 err
= iso_send_frame(sk
, skb
);
1310 static void iso_conn_defer_accept(struct hci_conn
*conn
)
1312 struct hci_cp_le_accept_cis cp
;
1313 struct hci_dev
*hdev
= conn
->hdev
;
1315 BT_DBG("conn %p", conn
);
1317 conn
->state
= BT_CONFIG
;
1319 cp
.handle
= cpu_to_le16(conn
->handle
);
1321 hci_send_cmd(hdev
, HCI_OP_LE_ACCEPT_CIS
, sizeof(cp
), &cp
);
1324 static void iso_conn_big_sync(struct sock
*sk
)
1327 struct hci_dev
*hdev
;
1329 hdev
= hci_get_route(&iso_pi(sk
)->dst
, &iso_pi(sk
)->src
,
1330 iso_pi(sk
)->src_type
);
1335 if (!test_and_set_bit(BT_SK_BIG_SYNC
, &iso_pi(sk
)->flags
)) {
1336 err
= hci_le_big_create_sync(hdev
, iso_pi(sk
)->conn
->hcon
,
1338 iso_pi(sk
)->sync_handle
,
1339 iso_pi(sk
)->bc_num_bis
,
1340 iso_pi(sk
)->bc_bis
);
1342 bt_dev_err(hdev
, "hci_le_big_create_sync: %d",
1347 static int iso_sock_recvmsg(struct socket
*sock
, struct msghdr
*msg
,
1348 size_t len
, int flags
)
1350 struct sock
*sk
= sock
->sk
;
1351 struct iso_pinfo
*pi
= iso_pi(sk
);
1353 BT_DBG("sk %p", sk
);
1355 if (test_and_clear_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
)) {
1357 switch (sk
->sk_state
) {
1359 if (pi
->conn
->hcon
&&
1360 test_bit(HCI_CONN_PA_SYNC
, &pi
->conn
->hcon
->flags
)) {
1361 iso_conn_big_sync(sk
);
1362 sk
->sk_state
= BT_LISTEN
;
1364 iso_conn_defer_accept(pi
->conn
->hcon
);
1365 sk
->sk_state
= BT_CONFIG
;
1370 if (test_bit(BT_SK_PA_SYNC
, &iso_pi(sk
)->flags
)) {
1371 iso_conn_big_sync(sk
);
1372 sk
->sk_state
= BT_LISTEN
;
1381 return iso_connect_cis(sk
);
1388 return bt_sock_recvmsg(sock
, msg
, len
, flags
);
1391 static bool check_io_qos(struct bt_iso_io_qos
*qos
)
1393 /* If no PHY is enable SDU must be 0 */
1394 if (!qos
->phy
&& qos
->sdu
)
1397 if (qos
->interval
&& (qos
->interval
< 0xff || qos
->interval
> 0xfffff))
1400 if (qos
->latency
&& (qos
->latency
< 0x05 || qos
->latency
> 0xfa0))
1403 if (qos
->phy
> BT_ISO_PHY_ANY
)
1409 static bool check_ucast_qos(struct bt_iso_qos
*qos
)
1411 if (qos
->ucast
.cig
> 0xef && qos
->ucast
.cig
!= BT_ISO_QOS_CIG_UNSET
)
1414 if (qos
->ucast
.cis
> 0xef && qos
->ucast
.cis
!= BT_ISO_QOS_CIS_UNSET
)
1417 if (qos
->ucast
.sca
> 0x07)
1420 if (qos
->ucast
.packing
> 0x01)
1423 if (qos
->ucast
.framing
> 0x01)
1426 if (!check_io_qos(&qos
->ucast
.in
))
1429 if (!check_io_qos(&qos
->ucast
.out
))
1435 static bool check_bcast_qos(struct bt_iso_qos
*qos
)
1437 if (!qos
->bcast
.sync_factor
)
1438 qos
->bcast
.sync_factor
= 0x01;
1440 if (qos
->bcast
.packing
> 0x01)
1443 if (qos
->bcast
.framing
> 0x01)
1446 if (!check_io_qos(&qos
->bcast
.in
))
1449 if (!check_io_qos(&qos
->bcast
.out
))
1452 if (qos
->bcast
.encryption
> 0x01)
1455 if (qos
->bcast
.options
> 0x07)
1458 if (qos
->bcast
.skip
> 0x01f3)
1461 if (!qos
->bcast
.sync_timeout
)
1462 qos
->bcast
.sync_timeout
= BT_ISO_SYNC_TIMEOUT
;
1464 if (qos
->bcast
.sync_timeout
< 0x000a || qos
->bcast
.sync_timeout
> 0x4000)
1467 if (qos
->bcast
.sync_cte_type
> 0x1f)
1470 if (qos
->bcast
.mse
> 0x1f)
1473 if (!qos
->bcast
.timeout
)
1474 qos
->bcast
.sync_timeout
= BT_ISO_SYNC_TIMEOUT
;
1476 if (qos
->bcast
.timeout
< 0x000a || qos
->bcast
.timeout
> 0x4000)
1482 static int iso_sock_setsockopt(struct socket
*sock
, int level
, int optname
,
1483 sockptr_t optval
, unsigned int optlen
)
1485 struct sock
*sk
= sock
->sk
;
1487 struct bt_iso_qos qos
= default_qos
;
1490 BT_DBG("sk %p", sk
);
1495 case BT_DEFER_SETUP
:
1496 if (sk
->sk_state
!= BT_BOUND
&& sk
->sk_state
!= BT_LISTEN
) {
1501 err
= bt_copy_from_sockptr(&opt
, sizeof(opt
), optval
, optlen
);
1506 set_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
);
1508 clear_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
);
1512 err
= bt_copy_from_sockptr(&opt
, sizeof(opt
), optval
, optlen
);
1517 set_bit(BT_SK_PKT_STATUS
, &bt_sk(sk
)->flags
);
1519 clear_bit(BT_SK_PKT_STATUS
, &bt_sk(sk
)->flags
);
1523 if (sk
->sk_state
!= BT_OPEN
&& sk
->sk_state
!= BT_BOUND
&&
1524 sk
->sk_state
!= BT_CONNECT2
&&
1525 (!test_bit(BT_SK_PA_SYNC
, &iso_pi(sk
)->flags
) ||
1526 sk
->sk_state
!= BT_CONNECTED
)) {
1531 err
= bt_copy_from_sockptr(&qos
, sizeof(qos
), optval
, optlen
);
1535 iso_pi(sk
)->qos
= qos
;
1536 iso_pi(sk
)->qos_user_set
= true;
1541 if (sk
->sk_state
!= BT_OPEN
&& sk
->sk_state
!= BT_BOUND
&&
1542 sk
->sk_state
!= BT_CONNECT2
) {
1547 if (optlen
> sizeof(iso_pi(sk
)->base
)) {
1552 err
= bt_copy_from_sockptr(iso_pi(sk
)->base
, optlen
, optval
,
1557 iso_pi(sk
)->base_len
= optlen
;
1570 static int iso_sock_getsockopt(struct socket
*sock
, int level
, int optname
,
1571 char __user
*optval
, int __user
*optlen
)
1573 struct sock
*sk
= sock
->sk
;
1575 struct bt_iso_qos
*qos
;
1579 BT_DBG("sk %p", sk
);
1581 if (get_user(len
, optlen
))
1587 case BT_DEFER_SETUP
:
1588 if (sk
->sk_state
== BT_CONNECTED
) {
1593 if (put_user(test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
),
1594 (u32 __user
*)optval
))
1600 if (put_user(test_bit(BT_SK_PKT_STATUS
, &bt_sk(sk
)->flags
),
1601 (int __user
*)optval
))
1606 qos
= iso_sock_get_qos(sk
);
1608 len
= min_t(unsigned int, len
, sizeof(*qos
));
1609 if (copy_to_user(optval
, qos
, len
))
1615 if (sk
->sk_state
== BT_CONNECTED
&&
1616 !bacmp(&iso_pi(sk
)->dst
, BDADDR_ANY
)) {
1617 base_len
= iso_pi(sk
)->conn
->hcon
->le_per_adv_data_len
;
1618 base
= iso_pi(sk
)->conn
->hcon
->le_per_adv_data
;
1620 base_len
= iso_pi(sk
)->base_len
;
1621 base
= iso_pi(sk
)->base
;
1624 len
= min_t(unsigned int, len
, base_len
);
1625 if (copy_to_user(optval
, base
, len
))
1627 if (put_user(len
, optlen
))
1641 static int iso_sock_shutdown(struct socket
*sock
, int how
)
1643 struct sock
*sk
= sock
->sk
;
1646 BT_DBG("sock %p, sk %p, how %d", sock
, sk
, how
);
1656 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1658 sk
->sk_shutdown
|= RCV_SHUTDOWN
;
1661 if (sk
->sk_shutdown
& SEND_SHUTDOWN
)
1663 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
1666 if (sk
->sk_shutdown
& SHUTDOWN_MASK
)
1668 sk
->sk_shutdown
|= SHUTDOWN_MASK
;
1672 iso_sock_clear_timer(sk
);
1673 __iso_sock_close(sk
);
1675 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
&&
1676 !(current
->flags
& PF_EXITING
))
1677 err
= bt_sock_wait_state(sk
, BT_CLOSED
, sk
->sk_lingertime
);
1686 static int iso_sock_release(struct socket
*sock
)
1688 struct sock
*sk
= sock
->sk
;
1691 BT_DBG("sock %p, sk %p", sock
, sk
);
1698 if (sock_flag(sk
, SOCK_LINGER
) && READ_ONCE(sk
->sk_lingertime
) &&
1699 !(current
->flags
& PF_EXITING
)) {
1701 err
= bt_sock_wait_state(sk
, BT_CLOSED
, sk
->sk_lingertime
);
1710 static void iso_sock_ready(struct sock
*sk
)
1712 BT_DBG("sk %p", sk
);
1718 iso_sock_clear_timer(sk
);
1719 sk
->sk_state
= BT_CONNECTED
;
1720 sk
->sk_state_change(sk
);
1724 struct iso_list_data
{
1725 struct hci_conn
*hcon
;
1729 static bool iso_match_big(struct sock
*sk
, void *data
)
1731 struct hci_evt_le_big_sync_estabilished
*ev
= data
;
1733 return ev
->handle
== iso_pi(sk
)->qos
.bcast
.big
;
1736 static bool iso_match_pa_sync_flag(struct sock
*sk
, void *data
)
1738 return test_bit(BT_SK_PA_SYNC
, &iso_pi(sk
)->flags
);
1741 static void iso_conn_ready(struct iso_conn
*conn
)
1743 struct sock
*parent
= NULL
;
1744 struct sock
*sk
= conn
->sk
;
1745 struct hci_ev_le_big_sync_estabilished
*ev
= NULL
;
1746 struct hci_ev_le_pa_sync_established
*ev2
= NULL
;
1747 struct hci_ev_le_per_adv_report
*ev3
= NULL
;
1748 struct hci_conn
*hcon
;
1750 BT_DBG("conn %p", conn
);
1753 iso_sock_ready(conn
->sk
);
1759 if (test_bit(HCI_CONN_BIG_SYNC
, &hcon
->flags
) ||
1760 test_bit(HCI_CONN_BIG_SYNC_FAILED
, &hcon
->flags
)) {
1761 ev
= hci_recv_event_data(hcon
->hdev
,
1762 HCI_EVT_LE_BIG_SYNC_ESTABILISHED
);
1764 /* Get reference to PA sync parent socket, if it exists */
1765 parent
= iso_get_sock(&hcon
->src
, &hcon
->dst
,
1767 iso_match_pa_sync_flag
,
1770 parent
= iso_get_sock(&hcon
->src
,
1774 } else if (test_bit(HCI_CONN_PA_SYNC_FAILED
, &hcon
->flags
)) {
1775 ev2
= hci_recv_event_data(hcon
->hdev
,
1776 HCI_EV_LE_PA_SYNC_ESTABLISHED
);
1778 parent
= iso_get_sock(&hcon
->src
,
1781 iso_match_sid
, ev2
);
1782 } else if (test_bit(HCI_CONN_PA_SYNC
, &hcon
->flags
)) {
1783 ev3
= hci_recv_event_data(hcon
->hdev
,
1784 HCI_EV_LE_PER_ADV_REPORT
);
1786 parent
= iso_get_sock(&hcon
->src
,
1789 iso_match_sync_handle_pa_report
,
1794 parent
= iso_get_sock(&hcon
->src
, BDADDR_ANY
,
1795 BT_LISTEN
, NULL
, NULL
);
1802 sk
= iso_sock_alloc(sock_net(parent
), NULL
,
1803 BTPROTO_ISO
, GFP_ATOMIC
, 0);
1805 release_sock(parent
);
1809 iso_sock_init(sk
, parent
);
1811 bacpy(&iso_pi(sk
)->src
, &hcon
->src
);
1813 /* Convert from HCI to three-value type */
1814 if (hcon
->src_type
== ADDR_LE_DEV_PUBLIC
)
1815 iso_pi(sk
)->src_type
= BDADDR_LE_PUBLIC
;
1817 iso_pi(sk
)->src_type
= BDADDR_LE_RANDOM
;
1819 /* If hcon has no destination address (BDADDR_ANY) it means it
1820 * was created by HCI_EV_LE_BIG_SYNC_ESTABILISHED or
1821 * HCI_EV_LE_PA_SYNC_ESTABLISHED so we need to initialize using
1822 * the parent socket destination address.
1824 if (!bacmp(&hcon
->dst
, BDADDR_ANY
)) {
1825 bacpy(&hcon
->dst
, &iso_pi(parent
)->dst
);
1826 hcon
->dst_type
= iso_pi(parent
)->dst_type
;
1827 hcon
->sync_handle
= iso_pi(parent
)->sync_handle
;
1831 iso_pi(sk
)->qos
= iso_pi(parent
)->qos
;
1832 hcon
->iso_qos
= iso_pi(sk
)->qos
;
1833 iso_pi(sk
)->bc_num_bis
= iso_pi(parent
)->bc_num_bis
;
1834 memcpy(iso_pi(sk
)->bc_bis
, iso_pi(parent
)->bc_bis
, ISO_MAX_NUM_BIS
);
1835 set_bit(BT_SK_PA_SYNC
, &iso_pi(sk
)->flags
);
1838 bacpy(&iso_pi(sk
)->dst
, &hcon
->dst
);
1839 iso_pi(sk
)->dst_type
= hcon
->dst_type
;
1840 iso_pi(sk
)->sync_handle
= iso_pi(parent
)->sync_handle
;
1841 memcpy(iso_pi(sk
)->base
, iso_pi(parent
)->base
, iso_pi(parent
)->base_len
);
1842 iso_pi(sk
)->base_len
= iso_pi(parent
)->base_len
;
1844 hci_conn_hold(hcon
);
1845 iso_chan_add(conn
, sk
, parent
);
1847 if ((ev
&& ((struct hci_evt_le_big_sync_estabilished
*)ev
)->status
) ||
1848 (ev2
&& ev2
->status
)) {
1849 /* Trigger error signal on child socket */
1850 sk
->sk_err
= ECONNREFUSED
;
1851 sk
->sk_error_report(sk
);
1854 if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(parent
)->flags
))
1855 sk
->sk_state
= BT_CONNECT2
;
1857 sk
->sk_state
= BT_CONNECTED
;
1859 /* Wake up parent */
1860 parent
->sk_data_ready(parent
);
1862 release_sock(parent
);
1867 static bool iso_match_sid(struct sock
*sk
, void *data
)
1869 struct hci_ev_le_pa_sync_established
*ev
= data
;
1871 return ev
->sid
== iso_pi(sk
)->bc_sid
;
1874 static bool iso_match_sync_handle(struct sock
*sk
, void *data
)
1876 struct hci_evt_le_big_info_adv_report
*ev
= data
;
1878 return le16_to_cpu(ev
->sync_handle
) == iso_pi(sk
)->sync_handle
;
1881 static bool iso_match_sync_handle_pa_report(struct sock
*sk
, void *data
)
1883 struct hci_ev_le_per_adv_report
*ev
= data
;
1885 return le16_to_cpu(ev
->sync_handle
) == iso_pi(sk
)->sync_handle
;
1888 /* ----- ISO interface with lower layer (HCI) ----- */
1890 int iso_connect_ind(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, __u8
*flags
)
1892 struct hci_ev_le_pa_sync_established
*ev1
;
1893 struct hci_evt_le_big_info_adv_report
*ev2
;
1894 struct hci_ev_le_per_adv_report
*ev3
;
1897 bt_dev_dbg(hdev
, "bdaddr %pMR", bdaddr
);
1899 /* Broadcast receiver requires handling of some events before it can
1900 * proceed to establishing a BIG sync:
1902 * 1. HCI_EV_LE_PA_SYNC_ESTABLISHED: The socket may specify a specific
1903 * SID to listen to and once sync is estabilished its handle needs to
1904 * be stored in iso_pi(sk)->sync_handle so it can be matched once
1905 * receiving the BIG Info.
1906 * 2. HCI_EVT_LE_BIG_INFO_ADV_REPORT: When connect_ind is triggered by a
1907 * a BIG Info it attempts to check if there any listening socket with
1908 * the same sync_handle and if it does then attempt to create a sync.
1909 * 3. HCI_EV_LE_PER_ADV_REPORT: When a PA report is received, it is stored
1910 * in iso_pi(sk)->base so it can be passed up to user, in the case of a
1913 ev1
= hci_recv_event_data(hdev
, HCI_EV_LE_PA_SYNC_ESTABLISHED
);
1915 sk
= iso_get_sock(&hdev
->bdaddr
, bdaddr
, BT_LISTEN
,
1916 iso_match_sid
, ev1
);
1917 if (sk
&& !ev1
->status
)
1918 iso_pi(sk
)->sync_handle
= le16_to_cpu(ev1
->handle
);
1923 ev2
= hci_recv_event_data(hdev
, HCI_EVT_LE_BIG_INFO_ADV_REPORT
);
1925 /* Check if BIGInfo report has already been handled */
1926 sk
= iso_get_sock(&hdev
->bdaddr
, bdaddr
, BT_CONNECTED
,
1927 iso_match_sync_handle
, ev2
);
1934 /* Try to get PA sync socket, if it exists */
1935 sk
= iso_get_sock(&hdev
->bdaddr
, bdaddr
, BT_CONNECT2
,
1936 iso_match_sync_handle
, ev2
);
1938 sk
= iso_get_sock(&hdev
->bdaddr
, bdaddr
,
1940 iso_match_sync_handle
,
1946 iso_pi(sk
)->qos
.bcast
.encryption
= ev2
->encryption
;
1948 if (ev2
->num_bis
< iso_pi(sk
)->bc_num_bis
)
1949 iso_pi(sk
)->bc_num_bis
= ev2
->num_bis
;
1951 if (!test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
) &&
1952 !test_and_set_bit(BT_SK_BIG_SYNC
, &iso_pi(sk
)->flags
)) {
1953 err
= hci_le_big_create_sync(hdev
, NULL
,
1955 iso_pi(sk
)->sync_handle
,
1956 iso_pi(sk
)->bc_num_bis
,
1957 iso_pi(sk
)->bc_bis
);
1959 bt_dev_err(hdev
, "hci_le_big_create_sync: %d",
1970 ev3
= hci_recv_event_data(hdev
, HCI_EV_LE_PER_ADV_REPORT
);
1972 size_t base_len
= 0;
1974 struct hci_conn
*hcon
;
1976 sk
= iso_get_sock(&hdev
->bdaddr
, bdaddr
, BT_LISTEN
,
1977 iso_match_sync_handle_pa_report
, ev3
);
1981 hcon
= iso_pi(sk
)->conn
->hcon
;
1985 if (ev3
->data_status
== LE_PA_DATA_TRUNCATED
) {
1986 /* The controller was unable to retrieve PA data. */
1987 memset(hcon
->le_per_adv_data
, 0,
1988 HCI_MAX_PER_AD_TOT_LEN
);
1989 hcon
->le_per_adv_data_len
= 0;
1990 hcon
->le_per_adv_data_offset
= 0;
1994 if (hcon
->le_per_adv_data_offset
+ ev3
->length
>
1995 HCI_MAX_PER_AD_TOT_LEN
)
1998 memcpy(hcon
->le_per_adv_data
+ hcon
->le_per_adv_data_offset
,
1999 ev3
->data
, ev3
->length
);
2000 hcon
->le_per_adv_data_offset
+= ev3
->length
;
2002 if (ev3
->data_status
== LE_PA_DATA_COMPLETE
) {
2003 /* All PA data has been received. */
2004 hcon
->le_per_adv_data_len
=
2005 hcon
->le_per_adv_data_offset
;
2006 hcon
->le_per_adv_data_offset
= 0;
2009 base
= eir_get_service_data(hcon
->le_per_adv_data
,
2010 hcon
->le_per_adv_data_len
,
2011 EIR_BAA_SERVICE_UUID
,
2014 if (!base
|| base_len
> BASE_MAX_LENGTH
)
2017 memcpy(iso_pi(sk
)->base
, base
, base_len
);
2018 iso_pi(sk
)->base_len
= base_len
;
2020 /* This is a PA data fragment. Keep pa_data_len set to 0
2021 * until all data has been reassembled.
2023 hcon
->le_per_adv_data_len
= 0;
2026 sk
= iso_get_sock(&hdev
->bdaddr
, BDADDR_ANY
,
2027 BT_LISTEN
, NULL
, NULL
);
2034 if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
))
2035 *flags
|= HCI_PROTO_DEFER
;
2039 return HCI_LM_ACCEPT
;
2042 static void iso_connect_cfm(struct hci_conn
*hcon
, __u8 status
)
2044 if (hcon
->type
!= ISO_LINK
) {
2045 if (hcon
->type
!= LE_LINK
)
2048 /* Check if LE link has failed */
2050 struct hci_link
*link
, *t
;
2052 list_for_each_entry_safe(link
, t
, &hcon
->link_list
,
2054 iso_conn_del(link
->conn
, bt_to_errno(status
));
2059 /* Create CIS if pending */
2060 hci_le_create_cis_pending(hcon
->hdev
);
2064 BT_DBG("hcon %p bdaddr %pMR status %d", hcon
, &hcon
->dst
, status
);
2066 /* Similar to the success case, if HCI_CONN_BIG_SYNC_FAILED or
2067 * HCI_CONN_PA_SYNC_FAILED is set, queue the failed connection
2068 * into the accept queue of the listening socket and wake up
2069 * userspace, to inform the user about the event.
2071 if (!status
|| test_bit(HCI_CONN_BIG_SYNC_FAILED
, &hcon
->flags
) ||
2072 test_bit(HCI_CONN_PA_SYNC_FAILED
, &hcon
->flags
)) {
2073 struct iso_conn
*conn
;
2075 conn
= iso_conn_add(hcon
);
2077 iso_conn_ready(conn
);
2079 iso_conn_del(hcon
, bt_to_errno(status
));
2083 static void iso_disconn_cfm(struct hci_conn
*hcon
, __u8 reason
)
2085 if (hcon
->type
!= ISO_LINK
)
2088 BT_DBG("hcon %p reason %d", hcon
, reason
);
2090 iso_conn_del(hcon
, bt_to_errno(reason
));
2093 void iso_recv(struct hci_conn
*hcon
, struct sk_buff
*skb
, u16 flags
)
2095 struct iso_conn
*conn
= hcon
->iso_data
;
2101 pb
= hci_iso_flags_pb(flags
);
2102 ts
= hci_iso_flags_ts(flags
);
2104 BT_DBG("conn %p len %d pb 0x%x ts 0x%x", conn
, skb
->len
, pb
, ts
);
2110 BT_ERR("Unexpected start frame (len %d)", skb
->len
);
2111 kfree_skb(conn
->rx_skb
);
2112 conn
->rx_skb
= NULL
;
2117 struct hci_iso_ts_data_hdr
*hdr
;
2119 /* TODO: add timestamp to the packet? */
2120 hdr
= skb_pull_data(skb
, HCI_ISO_TS_DATA_HDR_SIZE
);
2122 BT_ERR("Frame is too short (len %d)", skb
->len
);
2126 len
= __le16_to_cpu(hdr
->slen
);
2128 struct hci_iso_data_hdr
*hdr
;
2130 hdr
= skb_pull_data(skb
, HCI_ISO_DATA_HDR_SIZE
);
2132 BT_ERR("Frame is too short (len %d)", skb
->len
);
2136 len
= __le16_to_cpu(hdr
->slen
);
2139 flags
= hci_iso_data_flags(len
);
2140 len
= hci_iso_data_len(len
);
2142 BT_DBG("Start: total len %d, frag len %d flags 0x%4.4x", len
,
2145 if (len
== skb
->len
) {
2146 /* Complete frame received */
2147 hci_skb_pkt_status(skb
) = flags
& 0x03;
2148 iso_recv_frame(conn
, skb
);
2152 if (pb
== ISO_SINGLE
) {
2153 BT_ERR("Frame malformed (len %d, expected len %d)",
2158 if (skb
->len
> len
) {
2159 BT_ERR("Frame is too long (len %d, expected len %d)",
2164 /* Allocate skb for the complete frame (with header) */
2165 conn
->rx_skb
= bt_skb_alloc(len
, GFP_KERNEL
);
2169 hci_skb_pkt_status(conn
->rx_skb
) = flags
& 0x03;
2170 skb_copy_from_linear_data(skb
, skb_put(conn
->rx_skb
, skb
->len
),
2172 conn
->rx_len
= len
- skb
->len
;
2176 BT_DBG("Cont: frag len %d (expecting %d)", skb
->len
,
2179 if (!conn
->rx_len
) {
2180 BT_ERR("Unexpected continuation frame (len %d)",
2185 if (skb
->len
> conn
->rx_len
) {
2186 BT_ERR("Fragment is too long (len %d, expected %d)",
2187 skb
->len
, conn
->rx_len
);
2188 kfree_skb(conn
->rx_skb
);
2189 conn
->rx_skb
= NULL
;
2194 skb_copy_from_linear_data(skb
, skb_put(conn
->rx_skb
, skb
->len
),
2196 conn
->rx_len
-= skb
->len
;
2200 skb_copy_from_linear_data(skb
, skb_put(conn
->rx_skb
, skb
->len
),
2202 conn
->rx_len
-= skb
->len
;
2204 if (!conn
->rx_len
) {
2205 struct sk_buff
*rx_skb
= conn
->rx_skb
;
2207 /* Complete frame received. iso_recv_frame
2208 * takes ownership of the skb so set the global
2209 * rx_skb pointer to NULL first.
2211 conn
->rx_skb
= NULL
;
2212 iso_recv_frame(conn
, rx_skb
);
2221 static struct hci_cb iso_cb
= {
2223 .connect_cfm
= iso_connect_cfm
,
2224 .disconn_cfm
= iso_disconn_cfm
,
2227 static int iso_debugfs_show(struct seq_file
*f
, void *p
)
2231 read_lock(&iso_sk_list
.lock
);
2233 sk_for_each(sk
, &iso_sk_list
.head
) {
2234 seq_printf(f
, "%pMR %pMR %d\n", &iso_pi(sk
)->src
,
2235 &iso_pi(sk
)->dst
, sk
->sk_state
);
2238 read_unlock(&iso_sk_list
.lock
);
2243 DEFINE_SHOW_ATTRIBUTE(iso_debugfs
);
2245 static struct dentry
*iso_debugfs
;
2247 static const struct proto_ops iso_sock_ops
= {
2248 .family
= PF_BLUETOOTH
,
2249 .owner
= THIS_MODULE
,
2250 .release
= iso_sock_release
,
2251 .bind
= iso_sock_bind
,
2252 .connect
= iso_sock_connect
,
2253 .listen
= iso_sock_listen
,
2254 .accept
= iso_sock_accept
,
2255 .getname
= iso_sock_getname
,
2256 .sendmsg
= iso_sock_sendmsg
,
2257 .recvmsg
= iso_sock_recvmsg
,
2258 .poll
= bt_sock_poll
,
2259 .ioctl
= bt_sock_ioctl
,
2260 .mmap
= sock_no_mmap
,
2261 .socketpair
= sock_no_socketpair
,
2262 .shutdown
= iso_sock_shutdown
,
2263 .setsockopt
= iso_sock_setsockopt
,
2264 .getsockopt
= iso_sock_getsockopt
2267 static const struct net_proto_family iso_sock_family_ops
= {
2268 .family
= PF_BLUETOOTH
,
2269 .owner
= THIS_MODULE
,
2270 .create
= iso_sock_create
,
2273 static bool iso_inited
;
2275 bool iso_enabled(void)
2284 BUILD_BUG_ON(sizeof(struct sockaddr_iso
) > sizeof(struct sockaddr
));
2289 err
= proto_register(&iso_proto
, 0);
2293 err
= bt_sock_register(BTPROTO_ISO
, &iso_sock_family_ops
);
2295 BT_ERR("ISO socket registration failed");
2299 err
= bt_procfs_init(&init_net
, "iso", &iso_sk_list
, NULL
);
2301 BT_ERR("Failed to create ISO proc file");
2302 bt_sock_unregister(BTPROTO_ISO
);
2306 BT_INFO("ISO socket layer initialized");
2308 hci_register_cb(&iso_cb
);
2310 if (IS_ERR_OR_NULL(bt_debugfs
))
2314 iso_debugfs
= debugfs_create_file("iso", 0444, bt_debugfs
,
2315 NULL
, &iso_debugfs_fops
);
2323 proto_unregister(&iso_proto
);
2332 bt_procfs_cleanup(&init_net
, "iso");
2334 debugfs_remove(iso_debugfs
);
2337 hci_unregister_cb(&iso_cb
);
2339 bt_sock_unregister(BTPROTO_ISO
);
2341 proto_unregister(&iso_proto
);