tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Bluetooth: ISO: Add broadcast support

This adds broadcast support for BTPROTO_ISO by extending the
sockaddr_iso with a new struct sockaddr_iso_bc where the socket user
can set the broadcast address when receiving, the SID and the BIS
indexes it wants to synchronize.

When using BTPROTO_ISO for broadcast the roles are:

Broadcaster -> uses connect with address set to BDADDR_ANY:
> tools/isotest -s 00:00:00:00:00:00

Broadcast Receiver -> uses listen with address set to broadcaster:
> tools/isotest -d 00:AA:01:00:00:00

Signed-off-by: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Luiz Augusto von Dentz f764a6c2 eca0ae4a

+371 -35
+2
include/net/bluetooth/bluetooth.h
··· 220 220 #define BT_CODEC_TRANSPARENT 0x03 221 221 #define BT_CODEC_MSBC 0x05 222 222 223 + #define BT_ISO_BASE 20 224 + 223 225 __printf(1, 2) 224 226 void bt_info(const char *fmt, ...); 225 227 __printf(1, 2)
+11
include/net/bluetooth/iso.h
··· 10 10 11 11 /* ISO defaults */ 12 12 #define ISO_DEFAULT_MTU 251 13 + #define ISO_MAX_NUM_BIS 0x1f 14 + 15 + /* ISO socket broadcast address */ 16 + struct sockaddr_iso_bc { 17 + bdaddr_t bc_bdaddr; 18 + __u8 bc_bdaddr_type; 19 + __u8 bc_sid; 20 + __u8 bc_num_bis; 21 + __u8 bc_bis[ISO_MAX_NUM_BIS]; 22 + }; 13 23 14 24 /* ISO socket address */ 15 25 struct sockaddr_iso { 16 26 sa_family_t iso_family; 17 27 bdaddr_t iso_bdaddr; 18 28 __u8 iso_bdaddr_type; 29 + struct sockaddr_iso_bc iso_bc[]; 19 30 }; 20 31 21 32 #endif /* __ISO_H */
+358 -35
net/bluetooth/iso.c
··· 50 50 __u8 src_type; 51 51 bdaddr_t dst; 52 52 __u8 dst_type; 53 + __u8 bc_sid; 54 + __u8 bc_num_bis; 55 + __u8 bc_bis[ISO_MAX_NUM_BIS]; 56 + __u16 sync_handle; 53 57 __u32 flags; 54 58 struct bt_iso_qos qos; 59 + __u8 base_len; 60 + __u8 base[HCI_MAX_PER_AD_LENGTH]; 55 61 struct iso_conn *conn; 56 62 }; 57 63 ··· 136 130 static void iso_chan_del(struct sock *sk, int err) 137 131 { 138 132 struct iso_conn *conn; 133 + struct sock *parent; 139 134 140 135 conn = iso_pi(sk)->conn; 141 136 ··· 154 147 155 148 sk->sk_state = BT_CLOSED; 156 149 sk->sk_err = err; 157 - sk->sk_state_change(sk); 150 + 151 + parent = bt_sk(sk)->parent; 152 + if (parent) { 153 + bt_accept_unlink(sk); 154 + parent->sk_data_ready(parent); 155 + } else { 156 + sk->sk_state_change(sk); 157 + } 158 158 159 159 sock_set_flag(sk, SOCK_ZAPPED); 160 160 } ··· 232 218 return err; 233 219 } 234 220 235 - static int iso_connect(struct sock *sk) 221 + static int iso_connect_bis(struct sock *sk) 222 + { 223 + struct iso_conn *conn; 224 + struct hci_conn *hcon; 225 + struct hci_dev *hdev; 226 + int err; 227 + 228 + BT_DBG("%pMR", &iso_pi(sk)->src); 229 + 230 + hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src, 231 + iso_pi(sk)->src_type); 232 + if (!hdev) 233 + return -EHOSTUNREACH; 234 + 235 + hci_dev_lock(hdev); 236 + 237 + if (!bis_capable(hdev)) { 238 + err = -EOPNOTSUPP; 239 + goto done; 240 + } 241 + 242 + /* Fail if out PHYs are marked as disabled */ 243 + if (!iso_pi(sk)->qos.out.phy) { 244 + err = -EINVAL; 245 + goto done; 246 + } 247 + 248 + hcon = hci_connect_bis(hdev, &iso_pi(sk)->dst, iso_pi(sk)->dst_type, 249 + &iso_pi(sk)->qos, iso_pi(sk)->base_len, 250 + iso_pi(sk)->base); 251 + if (IS_ERR(hcon)) { 252 + err = PTR_ERR(hcon); 253 + goto done; 254 + } 255 + 256 + conn = iso_conn_add(hcon); 257 + if (!conn) { 258 + hci_conn_drop(hcon); 259 + err = -ENOMEM; 260 + goto done; 261 + } 262 + 263 + /* Update source addr of the socket */ 264 + bacpy(&iso_pi(sk)->src, &hcon->src); 265 + 266 + err = iso_chan_add(conn, sk, NULL); 267 + if (err) 268 + goto done; 269 + 270 + if (hcon->state == BT_CONNECTED) { 271 + iso_sock_clear_timer(sk); 272 + sk->sk_state = BT_CONNECTED; 273 + } else { 274 + sk->sk_state = BT_CONNECT; 275 + iso_sock_set_timer(sk, sk->sk_sndtimeo); 276 + } 277 + 278 + done: 279 + hci_dev_unlock(hdev); 280 + hci_dev_put(hdev); 281 + return err; 282 + } 283 + 284 + static int iso_connect_cis(struct sock *sk) 236 285 { 237 286 struct iso_conn *conn; 238 287 struct hci_conn *hcon; ··· 436 359 return NULL; 437 360 } 438 361 439 - /* Find socket listening on source bdaddr. 362 + static struct sock *__iso_get_sock_listen_by_sid(bdaddr_t *ba, bdaddr_t *bc, 363 + __u8 sid) 364 + { 365 + struct sock *sk; 366 + 367 + sk_for_each(sk, &iso_sk_list.head) { 368 + if (sk->sk_state != BT_LISTEN) 369 + continue; 370 + 371 + if (bacmp(&iso_pi(sk)->src, ba)) 372 + continue; 373 + 374 + if (bacmp(&iso_pi(sk)->dst, bc)) 375 + continue; 376 + 377 + if (iso_pi(sk)->bc_sid == sid) 378 + return sk; 379 + } 380 + 381 + return NULL; 382 + } 383 + 384 + typedef bool (*iso_sock_match_t)(struct sock *sk, void *data); 385 + 386 + /* Find socket listening: 387 + * source bdaddr (Unicast) 388 + * destination bdaddr (Broadcast only) 389 + * match func - pass NULL to ignore 390 + * match func data - pass -1 to ignore 440 391 * Returns closest match. 441 392 */ 442 - static struct sock *iso_get_sock_listen(bdaddr_t *src) 393 + static struct sock *iso_get_sock_listen(bdaddr_t *src, bdaddr_t *dst, 394 + iso_sock_match_t match, void *data) 443 395 { 444 396 struct sock *sk = NULL, *sk1 = NULL; 445 397 ··· 476 370 477 371 sk_for_each(sk, &iso_sk_list.head) { 478 372 if (sk->sk_state != BT_LISTEN) 373 + continue; 374 + 375 + /* Match Broadcast destination */ 376 + if (bacmp(dst, BDADDR_ANY) && bacmp(&iso_pi(sk)->dst, dst)) 377 + continue; 378 + 379 + /* Use Match function if provided */ 380 + if (match && !match(sk, data)) 479 381 continue; 480 382 481 383 /* Exact match. */ ··· 701 587 return 0; 702 588 } 703 589 590 + static int iso_sock_bind_bc(struct socket *sock, struct sockaddr *addr, 591 + int addr_len) 592 + { 593 + struct sockaddr_iso *sa = (struct sockaddr_iso *)addr; 594 + struct sock *sk = sock->sk; 595 + int i; 596 + 597 + BT_DBG("sk %p bc_sid %u bc_num_bis %u", sk, sa->iso_bc->bc_sid, 598 + sa->iso_bc->bc_num_bis); 599 + 600 + if (addr_len > sizeof(*sa) + sizeof(*sa->iso_bc) || 601 + sa->iso_bc->bc_num_bis < 0x01 || sa->iso_bc->bc_num_bis > 0x1f) 602 + return -EINVAL; 603 + 604 + bacpy(&iso_pi(sk)->dst, &sa->iso_bc->bc_bdaddr); 605 + iso_pi(sk)->dst_type = sa->iso_bc->bc_bdaddr_type; 606 + iso_pi(sk)->sync_handle = -1; 607 + iso_pi(sk)->bc_sid = sa->iso_bc->bc_sid; 608 + iso_pi(sk)->bc_num_bis = sa->iso_bc->bc_num_bis; 609 + 610 + for (i = 0; i < iso_pi(sk)->bc_num_bis; i++) { 611 + if (sa->iso_bc->bc_bis[i] < 0x01 || 612 + sa->iso_bc->bc_bis[i] > 0x1f) 613 + return -EINVAL; 614 + 615 + memcpy(iso_pi(sk)->bc_bis, sa->iso_bc->bc_bis, 616 + iso_pi(sk)->bc_num_bis); 617 + } 618 + 619 + return 0; 620 + } 621 + 704 622 static int iso_sock_bind(struct socket *sock, struct sockaddr *addr, 705 623 int addr_len) 706 624 { ··· 766 620 767 621 bacpy(&iso_pi(sk)->src, &sa->iso_bdaddr); 768 622 iso_pi(sk)->src_type = sa->iso_bdaddr_type; 623 + 624 + /* Check for Broadcast address */ 625 + if (addr_len > sizeof(*sa)) { 626 + err = iso_sock_bind_bc(sock, addr, addr_len); 627 + if (err) 628 + goto done; 629 + } 769 630 770 631 sk->sk_state = BT_BOUND; 771 632 ··· 809 656 bacpy(&iso_pi(sk)->dst, &sa->iso_bdaddr); 810 657 iso_pi(sk)->dst_type = sa->iso_bdaddr_type; 811 658 812 - err = iso_connect(sk); 659 + if (bacmp(&iso_pi(sk)->dst, BDADDR_ANY)) 660 + err = iso_connect_cis(sk); 661 + else 662 + err = iso_connect_bis(sk); 663 + 813 664 if (err) 814 665 goto done; 815 666 ··· 827 670 return err; 828 671 } 829 672 673 + static int iso_listen_bis(struct sock *sk) 674 + { 675 + struct hci_dev *hdev; 676 + int err = 0; 677 + 678 + BT_DBG("%pMR -> %pMR (SID 0x%2.2x)", &iso_pi(sk)->src, 679 + &iso_pi(sk)->dst, iso_pi(sk)->bc_sid); 680 + 681 + write_lock(&iso_sk_list.lock); 682 + 683 + if (__iso_get_sock_listen_by_sid(&iso_pi(sk)->src, &iso_pi(sk)->dst, 684 + iso_pi(sk)->bc_sid)) 685 + err = -EADDRINUSE; 686 + 687 + write_unlock(&iso_sk_list.lock); 688 + 689 + if (err) 690 + return err; 691 + 692 + hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src, 693 + iso_pi(sk)->src_type); 694 + if (!hdev) 695 + return -EHOSTUNREACH; 696 + 697 + hci_dev_lock(hdev); 698 + 699 + err = hci_pa_create_sync(hdev, &iso_pi(sk)->dst, iso_pi(sk)->dst_type, 700 + iso_pi(sk)->bc_sid); 701 + 702 + hci_dev_unlock(hdev); 703 + 704 + return err; 705 + } 706 + 707 + static int iso_listen_cis(struct sock *sk) 708 + { 709 + int err = 0; 710 + 711 + BT_DBG("%pMR", &iso_pi(sk)->src); 712 + 713 + write_lock(&iso_sk_list.lock); 714 + 715 + if (__iso_get_sock_listen_by_addr(&iso_pi(sk)->src)) 716 + err = -EADDRINUSE; 717 + 718 + write_unlock(&iso_sk_list.lock); 719 + 720 + return err; 721 + } 722 + 830 723 static int iso_sock_listen(struct socket *sock, int backlog) 831 724 { 832 725 struct sock *sk = sock->sk; 833 - bdaddr_t *src = &iso_pi(sk)->src; 834 726 int err = 0; 835 727 836 728 BT_DBG("sk %p backlog %d", sk, backlog); ··· 896 690 goto done; 897 691 } 898 692 899 - write_lock(&iso_sk_list.lock); 693 + if (!bacmp(&iso_pi(sk)->dst, BDADDR_ANY)) 694 + err = iso_listen_cis(sk); 695 + else 696 + err = iso_listen_bis(sk); 900 697 901 - if (__iso_get_sock_listen_by_addr(src)) { 902 - err = -EADDRINUSE; 903 - goto unlock; 904 - } 698 + if (err) 699 + goto done; 905 700 906 701 sk->sk_max_ack_backlog = backlog; 907 702 sk->sk_ack_backlog = 0; 908 703 909 704 sk->sk_state = BT_LISTEN; 910 - 911 - unlock: 912 - write_unlock(&iso_sk_list.lock); 913 705 914 706 done: 915 707 release_sock(sk); ··· 1090 886 release_sock(sk); 1091 887 return 0; 1092 888 case BT_CONNECT: 1093 - err = iso_connect(sk); 889 + err = iso_connect_cis(sk); 1094 890 release_sock(sk); 1095 891 return err; 1096 892 } ··· 1121 917 1122 918 static bool check_qos(struct bt_iso_qos *qos) 1123 919 { 1124 - /* CIS shall not be set */ 1125 - if (qos->cis != BT_ISO_QOS_CIS_UNSET) 1126 - return false; 1127 - 1128 920 if (qos->sca > 0x07) 1129 921 return false; 1130 922 ··· 1196 996 1197 997 break; 1198 998 999 + case BT_ISO_BASE: 1000 + if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND && 1001 + sk->sk_state != BT_CONNECT2) { 1002 + err = -EINVAL; 1003 + break; 1004 + } 1005 + 1006 + if (optlen > sizeof(iso_pi(sk)->base)) { 1007 + err = -EOVERFLOW; 1008 + break; 1009 + } 1010 + 1011 + len = min_t(unsigned int, sizeof(iso_pi(sk)->base), optlen); 1012 + 1013 + if (copy_from_sockptr(iso_pi(sk)->base, optval, len)) { 1014 + err = -EFAULT; 1015 + break; 1016 + } 1017 + 1018 + iso_pi(sk)->base_len = len; 1019 + 1020 + break; 1021 + 1199 1022 default: 1200 1023 err = -ENOPROTOOPT; 1201 1024 break; ··· 1234 1011 struct sock *sk = sock->sk; 1235 1012 int len, err = 0; 1236 1013 struct bt_iso_qos qos; 1014 + u8 base_len; 1015 + u8 *base; 1237 1016 1238 1017 BT_DBG("sk %p", sk); 1239 1018 ··· 1265 1040 1266 1041 len = min_t(unsigned int, len, sizeof(qos)); 1267 1042 if (copy_to_user(optval, (char *)&qos, len)) 1043 + err = -EFAULT; 1044 + 1045 + break; 1046 + 1047 + case BT_ISO_BASE: 1048 + if (sk->sk_state == BT_CONNECTED) { 1049 + base_len = iso_pi(sk)->conn->hcon->le_per_adv_data_len; 1050 + base = iso_pi(sk)->conn->hcon->le_per_adv_data; 1051 + } else { 1052 + base_len = iso_pi(sk)->base_len; 1053 + base = iso_pi(sk)->base; 1054 + } 1055 + 1056 + len = min_t(unsigned int, len, base_len); 1057 + if (copy_to_user(optval, base, len)) 1268 1058 err = -EFAULT; 1269 1059 1270 1060 break; ··· 1366 1126 int count; 1367 1127 }; 1368 1128 1129 + static bool iso_match_big(struct sock *sk, void *data) 1130 + { 1131 + struct hci_evt_le_big_sync_estabilished *ev = data; 1132 + 1133 + return ev->handle == iso_pi(sk)->qos.big; 1134 + } 1135 + 1369 1136 static void iso_conn_ready(struct iso_conn *conn) 1370 1137 { 1371 1138 struct sock *parent; 1372 1139 struct sock *sk = conn->sk; 1140 + struct hci_ev_le_big_sync_estabilished *ev; 1373 1141 1374 1142 BT_DBG("conn %p", conn); 1375 1143 ··· 1391 1143 return; 1392 1144 } 1393 1145 1394 - parent = iso_get_sock_listen(&conn->hcon->src); 1146 + ev = hci_recv_event_data(conn->hcon->hdev, 1147 + HCI_EVT_LE_BIG_SYNC_ESTABILISHED); 1148 + if (ev) 1149 + parent = iso_get_sock_listen(&conn->hcon->src, 1150 + &conn->hcon->dst, 1151 + iso_match_big, ev); 1152 + else 1153 + parent = iso_get_sock_listen(&conn->hcon->src, 1154 + BDADDR_ANY, NULL, NULL); 1155 + 1395 1156 if (!parent) { 1396 1157 iso_conn_unlock(conn); 1397 1158 return; ··· 1420 1163 1421 1164 bacpy(&iso_pi(sk)->src, &conn->hcon->src); 1422 1165 iso_pi(sk)->src_type = conn->hcon->src_type; 1166 + 1167 + /* If hcon has no destination address (BDADDR_ANY) it means it 1168 + * was created by HCI_EV_LE_BIG_SYNC_ESTABILISHED so we need to 1169 + * initialize using the parent socket destination address. 1170 + */ 1171 + if (!bacmp(&conn->hcon->dst, BDADDR_ANY)) { 1172 + bacpy(&conn->hcon->dst, &iso_pi(parent)->dst); 1173 + conn->hcon->dst_type = iso_pi(parent)->dst_type; 1174 + conn->hcon->sync_handle = iso_pi(parent)->sync_handle; 1175 + } 1176 + 1423 1177 bacpy(&iso_pi(sk)->dst, &conn->hcon->dst); 1424 1178 iso_pi(sk)->dst_type = conn->hcon->dst_type; 1425 1179 ··· 1451 1183 } 1452 1184 } 1453 1185 1186 + static bool iso_match_sid(struct sock *sk, void *data) 1187 + { 1188 + struct hci_ev_le_pa_sync_established *ev = data; 1189 + 1190 + return ev->sid == iso_pi(sk)->bc_sid; 1191 + } 1192 + 1193 + static bool iso_match_sync_handle(struct sock *sk, void *data) 1194 + { 1195 + struct hci_evt_le_big_info_adv_report *ev = data; 1196 + 1197 + return le16_to_cpu(ev->sync_handle) == iso_pi(sk)->sync_handle; 1198 + } 1199 + 1454 1200 /* ----- ISO interface with lower layer (HCI) ----- */ 1201 + 1455 1202 int iso_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags) 1456 1203 { 1204 + struct hci_ev_le_pa_sync_established *ev1; 1205 + struct hci_evt_le_big_info_adv_report *ev2; 1457 1206 struct sock *sk; 1458 1207 int lm = 0; 1459 1208 1460 - BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 1209 + bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr); 1461 1210 1462 - /* Find listening sockets */ 1463 - read_lock(&iso_sk_list.lock); 1464 - sk_for_each(sk, &iso_sk_list.head) { 1465 - if (sk->sk_state != BT_LISTEN) 1466 - continue; 1211 + /* Broadcast receiver requires handling of some events before it can 1212 + * proceed to establishing a BIG sync: 1213 + * 1214 + * 1. HCI_EV_LE_PA_SYNC_ESTABLISHED: The socket may specify a specific 1215 + * SID to listen to and once sync is estabilished its handle needs to 1216 + * be stored in iso_pi(sk)->sync_handle so it can be matched once 1217 + * receiving the BIG Info. 1218 + * 2. HCI_EVT_LE_BIG_INFO_ADV_REPORT: When connect_ind is triggered by a 1219 + * a BIG Info it attempts to check if there any listening socket with 1220 + * the same sync_handle and if it does then attempt to create a sync. 1221 + */ 1222 + ev1 = hci_recv_event_data(hdev, HCI_EV_LE_PA_SYNC_ESTABLISHED); 1223 + if (ev1) { 1224 + sk = iso_get_sock_listen(&hdev->bdaddr, bdaddr, iso_match_sid, 1225 + ev1); 1226 + if (sk) 1227 + iso_pi(sk)->sync_handle = le16_to_cpu(ev1->handle); 1467 1228 1468 - if (!bacmp(&iso_pi(sk)->src, &hdev->bdaddr) || 1469 - !bacmp(&iso_pi(sk)->src, BDADDR_ANY)) { 1470 - lm |= HCI_LM_ACCEPT; 1471 - 1472 - if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 1473 - *flags |= HCI_PROTO_DEFER; 1474 - break; 1475 - } 1229 + goto done; 1476 1230 } 1477 - read_unlock(&iso_sk_list.lock); 1231 + 1232 + ev2 = hci_recv_event_data(hdev, HCI_EVT_LE_BIG_INFO_ADV_REPORT); 1233 + if (ev2) { 1234 + sk = iso_get_sock_listen(&hdev->bdaddr, bdaddr, 1235 + iso_match_sync_handle, ev2); 1236 + if (sk) { 1237 + int err; 1238 + 1239 + if (ev2->num_bis < iso_pi(sk)->bc_num_bis) 1240 + iso_pi(sk)->bc_num_bis = ev2->num_bis; 1241 + 1242 + err = hci_le_big_create_sync(hdev, 1243 + &iso_pi(sk)->qos, 1244 + iso_pi(sk)->sync_handle, 1245 + iso_pi(sk)->bc_num_bis, 1246 + iso_pi(sk)->bc_bis); 1247 + if (err) { 1248 + bt_dev_err(hdev, "hci_le_big_create_sync: %d", 1249 + err); 1250 + sk = NULL; 1251 + } 1252 + } 1253 + } else { 1254 + sk = iso_get_sock_listen(&hdev->bdaddr, BDADDR_ANY, NULL, NULL); 1255 + } 1256 + 1257 + done: 1258 + if (!sk) 1259 + return lm; 1260 + 1261 + lm |= HCI_LM_ACCEPT; 1262 + 1263 + if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 1264 + *flags |= HCI_PROTO_DEFER; 1478 1265 1479 1266 return lm; 1480 1267 }