net/bluetooth/iso.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  * Copyright (C) 2022 Intel Corporation
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/debugfs.h>
  10 #include <linux/seq_file.h>
  11 #include <linux/sched/signal.h>
  12
  13 #include <net/bluetooth/bluetooth.h>
  14 #include <net/bluetooth/hci_core.h>
  15 #include <net/bluetooth/iso.h>
  16
  17 static const struct proto_ops iso_sock_ops;
  18
  19 static struct bt_sock_list iso_sk_list = {
  20         .lock = __RW_LOCK_UNLOCKED(iso_sk_list.lock)
  21 };
  22
  23 /* ---- ISO connections ---- */
  24 struct iso_conn {
  25         struct hci_conn *hcon;
  26
  27         /* @lock: spinlock protecting changes to iso_conn fields */
  28         spinlock_t      lock;
  29         struct sock     *sk;
  30
  31         struct delayed_work     timeout_work;
  32
  33         struct sk_buff  *rx_skb;
  34         __u32           rx_len;
  35         __u16           tx_sn;
  36 };
  37
  38 #define iso_conn_lock(c)        spin_lock(&(c)->lock)
  39 #define iso_conn_unlock(c)      spin_unlock(&(c)->lock)
  40
  41 static void iso_sock_close(struct sock *sk);
  42 static void iso_sock_kill(struct sock *sk);
  43
  44 /* ----- ISO socket info ----- */
  45 #define iso_pi(sk) ((struct iso_pinfo *)sk)
  46
  47 #define EIR_SERVICE_DATA_LENGTH 4
  48 #define BASE_MAX_LENGTH (HCI_MAX_PER_AD_LENGTH - EIR_SERVICE_DATA_LENGTH)
  49
  50 struct iso_pinfo {
  51         struct bt_sock          bt;
  52         bdaddr_t                src;
  53         __u8                    src_type;
  54         bdaddr_t                dst;
  55         __u8                    dst_type;
  56         __u8                    bc_sid;
  57         __u8                    bc_num_bis;
  58         __u8                    bc_bis[ISO_MAX_NUM_BIS];
  59         __u16                   sync_handle;
  60         __u32                   flags;
  61         struct bt_iso_qos       qos;
  62         __u8                    base_len;
  63         __u8                    base[BASE_MAX_LENGTH];
  64         struct iso_conn         *conn;
  65 };
  66
  67 /* ---- ISO timers ---- */
  68 #define ISO_CONN_TIMEOUT        (HZ * 40)
  69 #define ISO_DISCONN_TIMEOUT     (HZ * 2)
  70
  71 static void iso_sock_timeout(struct work_struct *work)
  72 {
  73         struct iso_conn *conn = container_of(work, struct iso_conn,
  74                                              timeout_work.work);
  75         struct sock *sk;
  76
  77         iso_conn_lock(conn);
  78         sk = conn->sk;
  79         if (sk)
  80                 sock_hold(sk);
  81         iso_conn_unlock(conn);
  82
  83         if (!sk)
  84                 return;
  85
  86         BT_DBG("sock %p state %d", sk, sk->sk_state);
  87
  88         lock_sock(sk);
  89         sk->sk_err = ETIMEDOUT;
  90         sk->sk_state_change(sk);
  91         release_sock(sk);
  92         sock_put(sk);
  93 }
  94
  95 static void iso_sock_set_timer(struct sock *sk, long timeout)
  96 {
  97         if (!iso_pi(sk)->conn)
  98                 return;
  99
 100         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
 101         cancel_delayed_work(&iso_pi(sk)->conn->timeout_work);
 102         schedule_delayed_work(&iso_pi(sk)->conn->timeout_work, timeout);
 103 }
 104
 105 static void iso_sock_clear_timer(struct sock *sk)
 106 {
 107         if (!iso_pi(sk)->conn)
 108                 return;
 109
 110         BT_DBG("sock %p state %d", sk, sk->sk_state);
 111         cancel_delayed_work(&iso_pi(sk)->conn->timeout_work);
 112 }
 113
 114 /* ---- ISO connections ---- */
 115 static struct iso_conn *iso_conn_add(struct hci_conn *hcon)
 116 {
 117         struct iso_conn *conn = hcon->iso_data;
 118
 119         if (conn)
 120                 return conn;
 121
 122         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
 123         if (!conn)
 124                 return NULL;
 125
 126         spin_lock_init(&conn->lock);
 127         INIT_DELAYED_WORK(&conn->timeout_work, iso_sock_timeout);
 128
 129         hcon->iso_data = conn;
 130         conn->hcon = hcon;
 131         conn->tx_sn = 0;
 132
 133         BT_DBG("hcon %p conn %p", hcon, conn);
 134
 135         return conn;
 136 }
 137
 138 /* Delete channel. Must be called on the locked socket. */
 139 static void iso_chan_del(struct sock *sk, int err)
 140 {
 141         struct iso_conn *conn;
 142         struct sock *parent;
 143
 144         conn = iso_pi(sk)->conn;
 145
 146         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 147
 148         if (conn) {
 149                 iso_conn_lock(conn);
 150                 conn->sk = NULL;
 151                 iso_pi(sk)->conn = NULL;
 152                 iso_conn_unlock(conn);
 153
 154                 if (conn->hcon)
 155                         hci_conn_drop(conn->hcon);
 156         }
 157
 158         sk->sk_state = BT_CLOSED;
 159         sk->sk_err   = err;
 160
 161         parent = bt_sk(sk)->parent;
 162         if (parent) {
 163                 bt_accept_unlink(sk);
 164                 parent->sk_data_ready(parent);
 165         } else {
 166                 sk->sk_state_change(sk);
 167         }
 168
 169         sock_set_flag(sk, SOCK_ZAPPED);
 170 }
 171
 172 static void iso_conn_del(struct hci_conn *hcon, int err)
 173 {
 174         struct iso_conn *conn = hcon->iso_data;
 175         struct sock *sk;
 176
 177         if (!conn)
 178                 return;
 179
 180         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 181
 182         /* Kill socket */
 183         iso_conn_lock(conn);
 184         sk = conn->sk;
 185         if (sk)
 186                 sock_hold(sk);
 187         iso_conn_unlock(conn);
 188
 189         if (sk) {
 190                 lock_sock(sk);
 191                 iso_sock_clear_timer(sk);
 192                 iso_chan_del(sk, err);
 193                 release_sock(sk);
 194                 sock_put(sk);
 195         }
 196
 197         /* Ensure no more work items will run before freeing conn. */
 198         cancel_delayed_work_sync(&conn->timeout_work);
 199
 200         hcon->iso_data = NULL;
 201         kfree(conn);
 202 }
 203
 204 static int __iso_chan_add(struct iso_conn *conn, struct sock *sk,
 205                           struct sock *parent)
 206 {
 207         BT_DBG("conn %p", conn);
 208
 209         if (iso_pi(sk)->conn == conn && conn->sk == sk)
 210                 return 0;
 211
 212         if (conn->sk) {
 213                 BT_ERR("conn->sk already set");
 214                 return -EBUSY;
 215         }
 216
 217         iso_pi(sk)->conn = conn;
 218         conn->sk = sk;
 219
 220         if (parent)
 221                 bt_accept_enqueue(parent, sk, true);
 222
 223         return 0;
 224 }
 225
 226 static int iso_chan_add(struct iso_conn *conn, struct sock *sk,
 227                         struct sock *parent)
 228 {
 229         int err;
 230
 231         iso_conn_lock(conn);
 232         err = __iso_chan_add(conn, sk, parent);
 233         iso_conn_unlock(conn);
 234
 235         return err;
 236 }
 237
 238 static inline u8 le_addr_type(u8 bdaddr_type)
 239 {
 240         if (bdaddr_type == BDADDR_LE_PUBLIC)
 241                 return ADDR_LE_DEV_PUBLIC;
 242         else
 243                 return ADDR_LE_DEV_RANDOM;
 244 }
 245
 246 static int iso_connect_bis(struct sock *sk)
 247 {
 248         struct iso_conn *conn;
 249         struct hci_conn *hcon;
 250         struct hci_dev  *hdev;
 251         int err;
 252
 253         BT_DBG("%pMR", &iso_pi(sk)->src);
 254
 255         hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src,
 256                              iso_pi(sk)->src_type);
 257         if (!hdev)
 258                 return -EHOSTUNREACH;
 259
 260         hci_dev_lock(hdev);
 261
 262         if (!bis_capable(hdev)) {
 263                 err = -EOPNOTSUPP;
 264                 goto unlock;
 265         }
 266
 267         /* Fail if out PHYs are marked as disabled */
 268         if (!iso_pi(sk)->qos.out.phy) {
 269                 err = -EINVAL;
 270                 goto unlock;
 271         }
 272
 273         hcon = hci_connect_bis(hdev, &iso_pi(sk)->dst, iso_pi(sk)->dst_type,
 274                                &iso_pi(sk)->qos, iso_pi(sk)->base_len,
 275                                iso_pi(sk)->base);
 276         if (IS_ERR(hcon)) {
 277                 err = PTR_ERR(hcon);
 278                 goto unlock;
 279         }
 280
 281         conn = iso_conn_add(hcon);
 282         if (!conn) {
 283                 hci_conn_drop(hcon);
 284                 err = -ENOMEM;
 285                 goto unlock;
 286         }
 287
 288         hci_dev_unlock(hdev);
 289         hci_dev_put(hdev);
 290
 291         err = iso_chan_add(conn, sk, NULL);
 292         if (err)
 293                 return err;
 294
 295         lock_sock(sk);
 296
 297         /* Update source addr of the socket */
 298         bacpy(&iso_pi(sk)->src, &hcon->src);
 299
 300         if (hcon->state == BT_CONNECTED) {
 301                 iso_sock_clear_timer(sk);
 302                 sk->sk_state = BT_CONNECTED;
 303         } else {
 304                 sk->sk_state = BT_CONNECT;
 305                 iso_sock_set_timer(sk, sk->sk_sndtimeo);
 306         }
 307
 308         release_sock(sk);
 309         return err;
 310
 311 unlock:
 312         hci_dev_unlock(hdev);
 313         hci_dev_put(hdev);
 314         return err;
 315 }
 316
 317 static int iso_connect_cis(struct sock *sk)
 318 {
 319         struct iso_conn *conn;
 320         struct hci_conn *hcon;
 321         struct hci_dev  *hdev;
 322         int err;
 323
 324         BT_DBG("%pMR -> %pMR", &iso_pi(sk)->src, &iso_pi(sk)->dst);
 325
 326         hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src,
 327                              iso_pi(sk)->src_type);
 328         if (!hdev)
 329                 return -EHOSTUNREACH;
 330
 331         hci_dev_lock(hdev);
 332
 333         if (!cis_central_capable(hdev)) {
 334                 err = -EOPNOTSUPP;
 335                 goto unlock;
 336         }
 337
 338         /* Fail if either PHYs are marked as disabled */
 339         if (!iso_pi(sk)->qos.in.phy && !iso_pi(sk)->qos.out.phy) {
 340                 err = -EINVAL;
 341                 goto unlock;
 342         }
 343
 344         /* Just bind if DEFER_SETUP has been set */
 345         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 346                 hcon = hci_bind_cis(hdev, &iso_pi(sk)->dst,
 347                                     le_addr_type(iso_pi(sk)->dst_type),
 348                                     &iso_pi(sk)->qos);
 349                 if (IS_ERR(hcon)) {
 350                         err = PTR_ERR(hcon);
 351                         goto unlock;
 352                 }
 353         } else {
 354                 hcon = hci_connect_cis(hdev, &iso_pi(sk)->dst,
 355                                        le_addr_type(iso_pi(sk)->dst_type),
 356                                        &iso_pi(sk)->qos);
 357                 if (IS_ERR(hcon)) {
 358                         err = PTR_ERR(hcon);
 359                         goto unlock;
 360                 }
 361         }
 362
 363         conn = iso_conn_add(hcon);
 364         if (!conn) {
 365                 hci_conn_drop(hcon);
 366                 err = -ENOMEM;
 367                 goto unlock;
 368         }
 369
 370         hci_dev_unlock(hdev);
 371         hci_dev_put(hdev);
 372
 373         err = iso_chan_add(conn, sk, NULL);
 374         if (err)
 375                 return err;
 376
 377         lock_sock(sk);
 378
 379         /* Update source addr of the socket */
 380         bacpy(&iso_pi(sk)->src, &hcon->src);
 381
 382         if (hcon->state == BT_CONNECTED) {
 383                 iso_sock_clear_timer(sk);
 384                 sk->sk_state = BT_CONNECTED;
 385         } else if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 386                 iso_sock_clear_timer(sk);
 387                 sk->sk_state = BT_CONNECT;
 388         } else {
 389                 sk->sk_state = BT_CONNECT;
 390                 iso_sock_set_timer(sk, sk->sk_sndtimeo);
 391         }
 392
 393         release_sock(sk);
 394         return err;
 395
 396 unlock:
 397         hci_dev_unlock(hdev);
 398         hci_dev_put(hdev);
 399         return err;
 400 }
 401
 402 static struct bt_iso_qos *iso_sock_get_qos(struct sock *sk)
 403 {
 404         if (sk->sk_state == BT_CONNECTED || sk->sk_state == BT_CONNECT2)
 405                 return &iso_pi(sk)->conn->hcon->iso_qos;
 406
 407         return &iso_pi(sk)->qos;
 408 }
 409
 410 static int iso_send_frame(struct sock *sk, struct sk_buff *skb)
 411 {
 412         struct iso_conn *conn = iso_pi(sk)->conn;
 413         struct bt_iso_qos *qos = iso_sock_get_qos(sk);
 414         struct hci_iso_data_hdr *hdr;
 415         int len = 0;
 416
 417         BT_DBG("sk %p len %d", sk, skb->len);
 418
 419         if (skb->len > qos->out.sdu)
 420                 return -EMSGSIZE;
 421
 422         len = skb->len;
 423
 424         /* Push ISO data header */
 425         hdr = skb_push(skb, HCI_ISO_DATA_HDR_SIZE);
 426         hdr->sn = cpu_to_le16(conn->tx_sn++);
 427         hdr->slen = cpu_to_le16(hci_iso_data_len_pack(len,
 428                                                       HCI_ISO_STATUS_VALID));
 429
 430         if (sk->sk_state == BT_CONNECTED)
 431                 hci_send_iso(conn->hcon, skb);
 432         else
 433                 len = -ENOTCONN;
 434
 435         return len;
 436 }
 437
 438 static void iso_recv_frame(struct iso_conn *conn, struct sk_buff *skb)
 439 {
 440         struct sock *sk;
 441
 442         iso_conn_lock(conn);
 443         sk = conn->sk;
 444         iso_conn_unlock(conn);
 445
 446         if (!sk)
 447                 goto drop;
 448
 449         BT_DBG("sk %p len %d", sk, skb->len);
 450
 451         if (sk->sk_state != BT_CONNECTED)
 452                 goto drop;
 453
 454         if (!sock_queue_rcv_skb(sk, skb))
 455                 return;
 456
 457 drop:
 458         kfree_skb(skb);
 459 }
 460
 461 /* -------- Socket interface ---------- */
 462 static struct sock *__iso_get_sock_listen_by_addr(bdaddr_t *ba)
 463 {
 464         struct sock *sk;
 465
 466         sk_for_each(sk, &iso_sk_list.head) {
 467                 if (sk->sk_state != BT_LISTEN)
 468                         continue;
 469
 470                 if (!bacmp(&iso_pi(sk)->src, ba))
 471                         return sk;
 472         }
 473
 474         return NULL;
 475 }
 476
 477 static struct sock *__iso_get_sock_listen_by_sid(bdaddr_t *ba, bdaddr_t *bc,
 478                                                  __u8 sid)
 479 {
 480         struct sock *sk;
 481
 482         sk_for_each(sk, &iso_sk_list.head) {
 483                 if (sk->sk_state != BT_LISTEN)
 484                         continue;
 485
 486                 if (bacmp(&iso_pi(sk)->src, ba))
 487                         continue;
 488
 489                 if (bacmp(&iso_pi(sk)->dst, bc))
 490                         continue;
 491
 492                 if (iso_pi(sk)->bc_sid == sid)
 493                         return sk;
 494         }
 495
 496         return NULL;
 497 }
 498
 499 typedef bool (*iso_sock_match_t)(struct sock *sk, void *data);
 500
 501 /* Find socket listening:
 502  * source bdaddr (Unicast)
 503  * destination bdaddr (Broadcast only)
 504  * match func - pass NULL to ignore
 505  * match func data - pass -1 to ignore
 506  * Returns closest match.
 507  */
 508 static struct sock *iso_get_sock_listen(bdaddr_t *src, bdaddr_t *dst,
 509                                         iso_sock_match_t match, void *data)
 510 {
 511         struct sock *sk = NULL, *sk1 = NULL;
 512
 513         read_lock(&iso_sk_list.lock);
 514
 515         sk_for_each(sk, &iso_sk_list.head) {
 516                 if (sk->sk_state != BT_LISTEN)
 517                         continue;
 518
 519                 /* Match Broadcast destination */
 520                 if (bacmp(dst, BDADDR_ANY) && bacmp(&iso_pi(sk)->dst, dst))
 521                         continue;
 522
 523                 /* Use Match function if provided */
 524                 if (match && !match(sk, data))
 525                         continue;
 526
 527                 /* Exact match. */
 528                 if (!bacmp(&iso_pi(sk)->src, src))
 529                         break;
 530
 531                 /* Closest match */
 532                 if (!bacmp(&iso_pi(sk)->src, BDADDR_ANY))
 533                         sk1 = sk;
 534         }
 535
 536         read_unlock(&iso_sk_list.lock);
 537
 538         return sk ? sk : sk1;
 539 }
 540
 541 static void iso_sock_destruct(struct sock *sk)
 542 {
 543         BT_DBG("sk %p", sk);
 544
 545         skb_queue_purge(&sk->sk_receive_queue);
 546         skb_queue_purge(&sk->sk_write_queue);
 547 }
 548
 549 static void iso_sock_cleanup_listen(struct sock *parent)
 550 {
 551         struct sock *sk;
 552
 553         BT_DBG("parent %p", parent);
 554
 555         /* Close not yet accepted channels */
 556         while ((sk = bt_accept_dequeue(parent, NULL))) {
 557                 iso_sock_close(sk);
 558                 iso_sock_kill(sk);
 559         }
 560
 561         parent->sk_state  = BT_CLOSED;
 562         sock_set_flag(parent, SOCK_ZAPPED);
 563 }
 564
 565 /* Kill socket (only if zapped and orphan)
 566  * Must be called on unlocked socket.
 567  */
 568 static void iso_sock_kill(struct sock *sk)
 569 {
 570         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket ||
 571             sock_flag(sk, SOCK_DEAD))
 572                 return;
 573
 574         BT_DBG("sk %p state %d", sk, sk->sk_state);
 575
 576         /* Kill poor orphan */
 577         bt_sock_unlink(&iso_sk_list, sk);
 578         sock_set_flag(sk, SOCK_DEAD);
 579         sock_put(sk);
 580 }
 581
 582 static void iso_conn_defer_reject(struct hci_conn *conn)
 583 {
 584         struct hci_cp_le_reject_cis cp;
 585
 586         BT_DBG("conn %p", conn);
 587
 588         memset(&cp, 0, sizeof(cp));
 589         cp.handle = cpu_to_le16(conn->handle);
 590         cp.reason = HCI_ERROR_REJ_BAD_ADDR;
 591         hci_send_cmd(conn->hdev, HCI_OP_LE_REJECT_CIS, sizeof(cp), &cp);
 592 }
 593
 594 static void __iso_sock_close(struct sock *sk)
 595 {
 596         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 597
 598         switch (sk->sk_state) {
 599         case BT_LISTEN:
 600                 iso_sock_cleanup_listen(sk);
 601                 break;
 602
 603         case BT_CONNECTED:
 604         case BT_CONFIG:
 605                 if (iso_pi(sk)->conn->hcon) {
 606                         sk->sk_state = BT_DISCONN;
 607                         iso_sock_set_timer(sk, ISO_DISCONN_TIMEOUT);
 608                         iso_conn_lock(iso_pi(sk)->conn);
 609                         hci_conn_drop(iso_pi(sk)->conn->hcon);
 610                         iso_pi(sk)->conn->hcon = NULL;
 611                         iso_conn_unlock(iso_pi(sk)->conn);
 612                 } else {
 613                         iso_chan_del(sk, ECONNRESET);
 614                 }
 615                 break;
 616
 617         case BT_CONNECT2:
 618                 if (iso_pi(sk)->conn->hcon)
 619                         iso_conn_defer_reject(iso_pi(sk)->conn->hcon);
 620                 iso_chan_del(sk, ECONNRESET);
 621                 break;
 622         case BT_CONNECT:
 623                 /* In case of DEFER_SETUP the hcon would be bound to CIG which
 624                  * needs to be removed so just call hci_conn_del so the cleanup
 625                  * callback do what is needed.
 626                  */
 627                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags) &&
 628                     iso_pi(sk)->conn->hcon) {
 629                         hci_conn_del(iso_pi(sk)->conn->hcon);
 630                         iso_pi(sk)->conn->hcon = NULL;
 631                 }
 632
 633                 iso_chan_del(sk, ECONNRESET);
 634                 break;
 635         case BT_DISCONN:
 636                 iso_chan_del(sk, ECONNRESET);
 637                 break;
 638
 639         default:
 640                 sock_set_flag(sk, SOCK_ZAPPED);
 641                 break;
 642         }
 643 }
 644
 645 /* Must be called on unlocked socket. */
 646 static void iso_sock_close(struct sock *sk)
 647 {
 648         iso_sock_clear_timer(sk);
 649         lock_sock(sk);
 650         __iso_sock_close(sk);
 651         release_sock(sk);
 652         iso_sock_kill(sk);
 653 }
 654
 655 static void iso_sock_init(struct sock *sk, struct sock *parent)
 656 {
 657         BT_DBG("sk %p", sk);
 658
 659         if (parent) {
 660                 sk->sk_type = parent->sk_type;
 661                 bt_sk(sk)->flags = bt_sk(parent)->flags;
 662                 security_sk_clone(parent, sk);
 663         }
 664 }
 665
 666 static struct proto iso_proto = {
 667         .name           = "ISO",
 668         .owner          = THIS_MODULE,
 669         .obj_size       = sizeof(struct iso_pinfo)
 670 };
 671
 672 #define DEFAULT_IO_QOS \
 673 { \
 674         .interval       = 10000u, \
 675         .latency        = 10u, \
 676         .sdu            = 40u, \
 677         .phy            = BT_ISO_PHY_2M, \
 678         .rtn            = 2u, \
 679 }
 680
 681 static struct bt_iso_qos default_qos = {
 682         .cig            = BT_ISO_QOS_CIG_UNSET,
 683         .cis            = BT_ISO_QOS_CIS_UNSET,
 684         .sca            = 0x00,
 685         .packing        = 0x00,
 686         .framing        = 0x00,
 687         .in             = DEFAULT_IO_QOS,
 688         .out            = DEFAULT_IO_QOS,
 689 };
 690
 691 static struct sock *iso_sock_alloc(struct net *net, struct socket *sock,
 692                                    int proto, gfp_t prio, int kern)
 693 {
 694         struct sock *sk;
 695
 696         sk = sk_alloc(net, PF_BLUETOOTH, prio, &iso_proto, kern);
 697         if (!sk)
 698                 return NULL;
 699
 700         sock_init_data(sock, sk);
 701         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 702
 703         sk->sk_destruct = iso_sock_destruct;
 704         sk->sk_sndtimeo = ISO_CONN_TIMEOUT;
 705
 706         sock_reset_flag(sk, SOCK_ZAPPED);
 707
 708         sk->sk_protocol = proto;
 709         sk->sk_state    = BT_OPEN;
 710
 711         /* Set address type as public as default src address is BDADDR_ANY */
 712         iso_pi(sk)->src_type = BDADDR_LE_PUBLIC;
 713
 714         iso_pi(sk)->qos = default_qos;
 715
 716         bt_sock_link(&iso_sk_list, sk);
 717         return sk;
 718 }
 719
 720 static int iso_sock_create(struct net *net, struct socket *sock, int protocol,
 721                            int kern)
 722 {
 723         struct sock *sk;
 724
 725         BT_DBG("sock %p", sock);
 726
 727         sock->state = SS_UNCONNECTED;
 728
 729         if (sock->type != SOCK_SEQPACKET)
 730                 return -ESOCKTNOSUPPORT;
 731
 732         sock->ops = &iso_sock_ops;
 733
 734         sk = iso_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
 735         if (!sk)
 736                 return -ENOMEM;
 737
 738         iso_sock_init(sk, NULL);
 739         return 0;
 740 }
 741
 742 static int iso_sock_bind_bc(struct socket *sock, struct sockaddr *addr,
 743                             int addr_len)
 744 {
 745         struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
 746         struct sock *sk = sock->sk;
 747         int i;
 748
 749         BT_DBG("sk %p bc_sid %u bc_num_bis %u", sk, sa->iso_bc->bc_sid,
 750                sa->iso_bc->bc_num_bis);
 751
 752         if (addr_len > sizeof(*sa) + sizeof(*sa->iso_bc) ||
 753             sa->iso_bc->bc_num_bis < 0x01 || sa->iso_bc->bc_num_bis > 0x1f)
 754                 return -EINVAL;
 755
 756         bacpy(&iso_pi(sk)->dst, &sa->iso_bc->bc_bdaddr);
 757         iso_pi(sk)->dst_type = sa->iso_bc->bc_bdaddr_type;
 758         iso_pi(sk)->sync_handle = -1;
 759         iso_pi(sk)->bc_sid = sa->iso_bc->bc_sid;
 760         iso_pi(sk)->bc_num_bis = sa->iso_bc->bc_num_bis;
 761
 762         for (i = 0; i < iso_pi(sk)->bc_num_bis; i++) {
 763                 if (sa->iso_bc->bc_bis[i] < 0x01 ||
 764                     sa->iso_bc->bc_bis[i] > 0x1f)
 765                         return -EINVAL;
 766
 767                 memcpy(iso_pi(sk)->bc_bis, sa->iso_bc->bc_bis,
 768                        iso_pi(sk)->bc_num_bis);
 769         }
 770
 771         return 0;
 772 }
 773
 774 static int iso_sock_bind(struct socket *sock, struct sockaddr *addr,
 775                          int addr_len)
 776 {
 777         struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
 778         struct sock *sk = sock->sk;
 779         int err = 0;
 780
 781         BT_DBG("sk %p %pMR type %u", sk, &sa->iso_bdaddr, sa->iso_bdaddr_type);
 782
 783         if (!addr || addr_len < sizeof(struct sockaddr_iso) ||
 784             addr->sa_family != AF_BLUETOOTH)
 785                 return -EINVAL;
 786
 787         lock_sock(sk);
 788
 789         if (sk->sk_state != BT_OPEN) {
 790                 err = -EBADFD;
 791                 goto done;
 792         }
 793
 794         if (sk->sk_type != SOCK_SEQPACKET) {
 795                 err = -EINVAL;
 796                 goto done;
 797         }
 798
 799         /* Check if the address type is of LE type */
 800         if (!bdaddr_type_is_le(sa->iso_bdaddr_type)) {
 801                 err = -EINVAL;
 802                 goto done;
 803         }
 804
 805         bacpy(&iso_pi(sk)->src, &sa->iso_bdaddr);
 806         iso_pi(sk)->src_type = sa->iso_bdaddr_type;
 807
 808         /* Check for Broadcast address */
 809         if (addr_len > sizeof(*sa)) {
 810                 err = iso_sock_bind_bc(sock, addr, addr_len);
 811                 if (err)
 812                         goto done;
 813         }
 814
 815         sk->sk_state = BT_BOUND;
 816
 817 done:
 818         release_sock(sk);
 819         return err;
 820 }
 821
 822 static int iso_sock_connect(struct socket *sock, struct sockaddr *addr,
 823                             int alen, int flags)
 824 {
 825         struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
 826         struct sock *sk = sock->sk;
 827         int err;
 828
 829         BT_DBG("sk %p", sk);
 830
 831         if (alen < sizeof(struct sockaddr_iso) ||
 832             addr->sa_family != AF_BLUETOOTH)
 833                 return -EINVAL;
 834
 835         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 836                 return -EBADFD;
 837
 838         if (sk->sk_type != SOCK_SEQPACKET)
 839                 return -EINVAL;
 840
 841         /* Check if the address type is of LE type */
 842         if (!bdaddr_type_is_le(sa->iso_bdaddr_type))
 843                 return -EINVAL;
 844
 845         lock_sock(sk);
 846
 847         bacpy(&iso_pi(sk)->dst, &sa->iso_bdaddr);
 848         iso_pi(sk)->dst_type = sa->iso_bdaddr_type;
 849
 850         release_sock(sk);
 851
 852         if (bacmp(&iso_pi(sk)->dst, BDADDR_ANY))
 853                 err = iso_connect_cis(sk);
 854         else
 855                 err = iso_connect_bis(sk);
 856
 857         if (err)
 858                 return err;
 859
 860         lock_sock(sk);
 861
 862         if (!test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 863                 err = bt_sock_wait_state(sk, BT_CONNECTED,
 864                                          sock_sndtimeo(sk, flags & O_NONBLOCK));
 865         }
 866
 867         release_sock(sk);
 868         return err;
 869 }
 870
 871 static int iso_listen_bis(struct sock *sk)
 872 {
 873         struct hci_dev *hdev;
 874         int err = 0;
 875
 876         BT_DBG("%pMR -> %pMR (SID 0x%2.2x)", &iso_pi(sk)->src,
 877                &iso_pi(sk)->dst, iso_pi(sk)->bc_sid);
 878
 879         write_lock(&iso_sk_list.lock);
 880
 881         if (__iso_get_sock_listen_by_sid(&iso_pi(sk)->src, &iso_pi(sk)->dst,
 882                                          iso_pi(sk)->bc_sid))
 883                 err = -EADDRINUSE;
 884
 885         write_unlock(&iso_sk_list.lock);
 886
 887         if (err)
 888                 return err;
 889
 890         hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src,
 891                              iso_pi(sk)->src_type);
 892         if (!hdev)
 893                 return -EHOSTUNREACH;
 894
 895         hci_dev_lock(hdev);
 896
 897         err = hci_pa_create_sync(hdev, &iso_pi(sk)->dst, iso_pi(sk)->dst_type,
 898                                  iso_pi(sk)->bc_sid);
 899
 900         hci_dev_unlock(hdev);
 901         hci_dev_put(hdev);
 902
 903         return err;
 904 }
 905
 906 static int iso_listen_cis(struct sock *sk)
 907 {
 908         int err = 0;
 909
 910         BT_DBG("%pMR", &iso_pi(sk)->src);
 911
 912         write_lock(&iso_sk_list.lock);
 913
 914         if (__iso_get_sock_listen_by_addr(&iso_pi(sk)->src))
 915                 err = -EADDRINUSE;
 916
 917         write_unlock(&iso_sk_list.lock);
 918
 919         return err;
 920 }
 921
 922 static int iso_sock_listen(struct socket *sock, int backlog)
 923 {
 924         struct sock *sk = sock->sk;
 925         int err = 0;
 926
 927         BT_DBG("sk %p backlog %d", sk, backlog);
 928
 929         lock_sock(sk);
 930
 931         if (sk->sk_state != BT_BOUND) {
 932                 err = -EBADFD;
 933                 goto done;
 934         }
 935
 936         if (sk->sk_type != SOCK_SEQPACKET) {
 937                 err = -EINVAL;
 938                 goto done;
 939         }
 940
 941         if (!bacmp(&iso_pi(sk)->dst, BDADDR_ANY))
 942                 err = iso_listen_cis(sk);
 943         else
 944                 err = iso_listen_bis(sk);
 945
 946         if (err)
 947                 goto done;
 948
 949         sk->sk_max_ack_backlog = backlog;
 950         sk->sk_ack_backlog = 0;
 951
 952         sk->sk_state = BT_LISTEN;
 953
 954 done:
 955         release_sock(sk);
 956         return err;
 957 }
 958
 959 static int iso_sock_accept(struct socket *sock, struct socket *newsock,
 960                            int flags, bool kern)
 961 {
 962         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 963         struct sock *sk = sock->sk, *ch;
 964         long timeo;
 965         int err = 0;
 966
 967         lock_sock(sk);
 968
 969         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 970
 971         BT_DBG("sk %p timeo %ld", sk, timeo);
 972
 973         /* Wait for an incoming connection. (wake-one). */
 974         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 975         while (1) {
 976                 if (sk->sk_state != BT_LISTEN) {
 977                         err = -EBADFD;
 978                         break;
 979                 }
 980
 981                 ch = bt_accept_dequeue(sk, newsock);
 982                 if (ch)
 983                         break;
 984
 985                 if (!timeo) {
 986                         err = -EAGAIN;
 987                         break;
 988                 }
 989
 990                 if (signal_pending(current)) {
 991                         err = sock_intr_errno(timeo);
 992                         break;
 993                 }
 994
 995                 release_sock(sk);
 996
 997                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
 998                 lock_sock(sk);
 999         }
1000         remove_wait_queue(sk_sleep(sk), &wait);
1001
1002         if (err)
1003                 goto done;
1004
1005         newsock->state = SS_CONNECTED;
1006
1007         BT_DBG("new socket %p", ch);
1008
1009 done:
1010         release_sock(sk);
1011         return err;
1012 }
1013
1014 static int iso_sock_getname(struct socket *sock, struct sockaddr *addr,
1015                             int peer)
1016 {
1017         struct sockaddr_iso *sa = (struct sockaddr_iso *)addr;
1018         struct sock *sk = sock->sk;
1019
1020         BT_DBG("sock %p, sk %p", sock, sk);
1021
1022         addr->sa_family = AF_BLUETOOTH;
1023
1024         if (peer) {
1025                 bacpy(&sa->iso_bdaddr, &iso_pi(sk)->dst);
1026                 sa->iso_bdaddr_type = iso_pi(sk)->dst_type;
1027         } else {
1028                 bacpy(&sa->iso_bdaddr, &iso_pi(sk)->src);
1029                 sa->iso_bdaddr_type = iso_pi(sk)->src_type;
1030         }
1031
1032         return sizeof(struct sockaddr_iso);
1033 }
1034
1035 static int iso_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1036                             size_t len)
1037 {
1038         struct sock *sk = sock->sk;
1039         struct iso_conn *conn = iso_pi(sk)->conn;
1040         struct sk_buff *skb, **frag;
1041         int err;
1042
1043         BT_DBG("sock %p, sk %p", sock, sk);
1044
1045         err = sock_error(sk);
1046         if (err)
1047                 return err;
1048
1049         if (msg->msg_flags & MSG_OOB)
1050                 return -EOPNOTSUPP;
1051
1052         if (sk->sk_state != BT_CONNECTED)
1053                 return -ENOTCONN;
1054
1055         skb = bt_skb_sendmsg(sk, msg, len, conn->hcon->hdev->iso_mtu,
1056                              HCI_ISO_DATA_HDR_SIZE, 0);
1057         if (IS_ERR(skb))
1058                 return PTR_ERR(skb);
1059
1060         len -= skb->len;
1061
1062         BT_DBG("skb %p len %d", sk, skb->len);
1063
1064         /* Continuation fragments */
1065         frag = &skb_shinfo(skb)->frag_list;
1066         while (len) {
1067                 struct sk_buff *tmp;
1068
1069                 tmp = bt_skb_sendmsg(sk, msg, len, conn->hcon->hdev->iso_mtu,
1070                                      0, 0);
1071                 if (IS_ERR(tmp)) {
1072                         kfree_skb(skb);
1073                         return PTR_ERR(tmp);
1074                 }
1075
1076                 *frag = tmp;
1077
1078                 len  -= tmp->len;
1079
1080                 skb->len += tmp->len;
1081                 skb->data_len += tmp->len;
1082
1083                 BT_DBG("frag %p len %d", *frag, tmp->len);
1084
1085                 frag = &(*frag)->next;
1086         }
1087
1088         lock_sock(sk);
1089
1090         if (sk->sk_state == BT_CONNECTED)
1091                 err = iso_send_frame(sk, skb);
1092         else
1093                 err = -ENOTCONN;
1094
1095         release_sock(sk);
1096
1097         if (err < 0)
1098                 kfree_skb(skb);
1099         return err;
1100 }
1101
1102 static void iso_conn_defer_accept(struct hci_conn *conn)
1103 {
1104         struct hci_cp_le_accept_cis cp;
1105         struct hci_dev *hdev = conn->hdev;
1106
1107         BT_DBG("conn %p", conn);
1108
1109         conn->state = BT_CONFIG;
1110
1111         cp.handle = cpu_to_le16(conn->handle);
1112
1113         hci_send_cmd(hdev, HCI_OP_LE_ACCEPT_CIS, sizeof(cp), &cp);
1114 }
1115
1116 static int iso_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1117                             size_t len, int flags)
1118 {
1119         struct sock *sk = sock->sk;
1120         struct iso_pinfo *pi = iso_pi(sk);
1121
1122         BT_DBG("sk %p", sk);
1123
1124         if (test_and_clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
1125                 switch (sk->sk_state) {
1126                 case BT_CONNECT2:
1127                         lock_sock(sk);
1128                         iso_conn_defer_accept(pi->conn->hcon);
1129                         sk->sk_state = BT_CONFIG;
1130                         release_sock(sk);
1131                         return 0;
1132                 case BT_CONNECT:
1133                         return iso_connect_cis(sk);
1134                 }
1135         }
1136
1137         return bt_sock_recvmsg(sock, msg, len, flags);
1138 }
1139
1140 static bool check_io_qos(struct bt_iso_io_qos *qos)
1141 {
1142         /* If no PHY is enable SDU must be 0 */
1143         if (!qos->phy && qos->sdu)
1144                 return false;
1145
1146         if (qos->interval && (qos->interval < 0xff || qos->interval > 0xfffff))
1147                 return false;
1148
1149         if (qos->latency && (qos->latency < 0x05 || qos->latency > 0xfa0))
1150                 return false;
1151
1152         if (qos->phy > BT_ISO_PHY_ANY)
1153                 return false;
1154
1155         return true;
1156 }
1157
1158 static bool check_qos(struct bt_iso_qos *qos)
1159 {
1160         if (qos->sca > 0x07)
1161                 return false;
1162
1163         if (qos->packing > 0x01)
1164                 return false;
1165
1166         if (qos->framing > 0x01)
1167                 return false;
1168
1169         if (!check_io_qos(&qos->in))
1170                 return false;
1171
1172         if (!check_io_qos(&qos->out))
1173                 return false;
1174
1175         return true;
1176 }
1177
1178 static int iso_sock_setsockopt(struct socket *sock, int level, int optname,
1179                                sockptr_t optval, unsigned int optlen)
1180 {
1181         struct sock *sk = sock->sk;
1182         int len, err = 0;
1183         struct bt_iso_qos qos;
1184         u32 opt;
1185
1186         BT_DBG("sk %p", sk);
1187
1188         lock_sock(sk);
1189
1190         switch (optname) {
1191         case BT_DEFER_SETUP:
1192                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1193                         err = -EINVAL;
1194                         break;
1195                 }
1196
1197                 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
1198                         err = -EFAULT;
1199                         break;
1200                 }
1201
1202                 if (opt)
1203                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
1204                 else
1205                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
1206                 break;
1207
1208         case BT_ISO_QOS:
1209                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
1210                     sk->sk_state != BT_CONNECT2) {
1211                         err = -EINVAL;
1212                         break;
1213                 }
1214
1215                 len = min_t(unsigned int, sizeof(qos), optlen);
1216                 if (len != sizeof(qos)) {
1217                         err = -EINVAL;
1218                         break;
1219                 }
1220
1221                 memset(&qos, 0, sizeof(qos));
1222
1223                 if (copy_from_sockptr(&qos, optval, len)) {
1224                         err = -EFAULT;
1225                         break;
1226                 }
1227
1228                 if (!check_qos(&qos)) {
1229                         err = -EINVAL;
1230                         break;
1231                 }
1232
1233                 iso_pi(sk)->qos = qos;
1234
1235                 break;
1236
1237         case BT_ISO_BASE:
1238                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
1239                     sk->sk_state != BT_CONNECT2) {
1240                         err = -EINVAL;
1241                         break;
1242                 }
1243
1244                 if (optlen > sizeof(iso_pi(sk)->base)) {
1245                         err = -EOVERFLOW;
1246                         break;
1247                 }
1248
1249                 len = min_t(unsigned int, sizeof(iso_pi(sk)->base), optlen);
1250
1251                 if (copy_from_sockptr(iso_pi(sk)->base, optval, len)) {
1252                         err = -EFAULT;
1253                         break;
1254                 }
1255
1256                 iso_pi(sk)->base_len = len;
1257
1258                 break;
1259
1260         default:
1261                 err = -ENOPROTOOPT;
1262                 break;
1263         }
1264
1265         release_sock(sk);
1266         return err;
1267 }
1268
1269 static int iso_sock_getsockopt(struct socket *sock, int level, int optname,
1270                                char __user *optval, int __user *optlen)
1271 {
1272         struct sock *sk = sock->sk;
1273         int len, err = 0;
1274         struct bt_iso_qos *qos;
1275         u8 base_len;
1276         u8 *base;
1277
1278         BT_DBG("sk %p", sk);
1279
1280         if (get_user(len, optlen))
1281                 return -EFAULT;
1282
1283         lock_sock(sk);
1284
1285         switch (optname) {
1286         case BT_DEFER_SETUP:
1287                 if (sk->sk_state == BT_CONNECTED) {
1288                         err = -EINVAL;
1289                         break;
1290                 }
1291
1292                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1293                              (u32 __user *)optval))
1294                         err = -EFAULT;
1295
1296                 break;
1297
1298         case BT_ISO_QOS:
1299                 qos = iso_sock_get_qos(sk);
1300
1301                 len = min_t(unsigned int, len, sizeof(*qos));
1302                 if (copy_to_user(optval, qos, len))
1303                         err = -EFAULT;
1304
1305                 break;
1306
1307         case BT_ISO_BASE:
1308                 if (sk->sk_state == BT_CONNECTED) {
1309                         base_len = iso_pi(sk)->conn->hcon->le_per_adv_data_len;
1310                         base = iso_pi(sk)->conn->hcon->le_per_adv_data;
1311                 } else {
1312                         base_len = iso_pi(sk)->base_len;
1313                         base = iso_pi(sk)->base;
1314                 }
1315
1316                 len = min_t(unsigned int, len, base_len);
1317                 if (copy_to_user(optval, base, len))
1318                         err = -EFAULT;
1319
1320                 break;
1321
1322         default:
1323                 err = -ENOPROTOOPT;
1324                 break;
1325         }
1326
1327         release_sock(sk);
1328         return err;
1329 }
1330
1331 static int iso_sock_shutdown(struct socket *sock, int how)
1332 {
1333         struct sock *sk = sock->sk;
1334         int err = 0;
1335
1336         BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
1337
1338         if (!sk)
1339                 return 0;
1340
1341         sock_hold(sk);
1342         lock_sock(sk);
1343
1344         switch (how) {
1345         case SHUT_RD:
1346                 if (sk->sk_shutdown & RCV_SHUTDOWN)
1347                         goto unlock;
1348                 sk->sk_shutdown |= RCV_SHUTDOWN;
1349                 break;
1350         case SHUT_WR:
1351                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1352                         goto unlock;
1353                 sk->sk_shutdown |= SEND_SHUTDOWN;
1354                 break;
1355         case SHUT_RDWR:
1356                 if (sk->sk_shutdown & SHUTDOWN_MASK)
1357                         goto unlock;
1358                 sk->sk_shutdown |= SHUTDOWN_MASK;
1359                 break;
1360         }
1361
1362         iso_sock_clear_timer(sk);
1363         __iso_sock_close(sk);
1364
1365         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1366             !(current->flags & PF_EXITING))
1367                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1368
1369 unlock:
1370         release_sock(sk);
1371         sock_put(sk);
1372
1373         return err;
1374 }
1375
1376 static int iso_sock_release(struct socket *sock)
1377 {
1378         struct sock *sk = sock->sk;
1379         int err = 0;
1380
1381         BT_DBG("sock %p, sk %p", sock, sk);
1382
1383         if (!sk)
1384                 return 0;
1385
1386         iso_sock_close(sk);
1387
1388         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1389             !(current->flags & PF_EXITING)) {
1390                 lock_sock(sk);
1391                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1392                 release_sock(sk);
1393         }
1394
1395         sock_orphan(sk);
1396         iso_sock_kill(sk);
1397         return err;
1398 }
1399
1400 static void iso_sock_ready(struct sock *sk)
1401 {
1402         BT_DBG("sk %p", sk);
1403
1404         if (!sk)
1405                 return;
1406
1407         lock_sock(sk);
1408         iso_sock_clear_timer(sk);
1409         sk->sk_state = BT_CONNECTED;
1410         sk->sk_state_change(sk);
1411         release_sock(sk);
1412 }
1413
1414 struct iso_list_data {
1415         struct hci_conn *hcon;
1416         int count;
1417 };
1418
1419 static bool iso_match_big(struct sock *sk, void *data)
1420 {
1421         struct hci_evt_le_big_sync_estabilished *ev = data;
1422
1423         return ev->handle == iso_pi(sk)->qos.big;
1424 }
1425
1426 static void iso_conn_ready(struct iso_conn *conn)
1427 {
1428         struct sock *parent;
1429         struct sock *sk = conn->sk;
1430         struct hci_ev_le_big_sync_estabilished *ev;
1431         struct hci_conn *hcon;
1432
1433         BT_DBG("conn %p", conn);
1434
1435         if (sk) {
1436                 iso_sock_ready(conn->sk);
1437         } else {
1438                 hcon = conn->hcon;
1439                 if (!hcon)
1440                         return;
1441
1442                 ev = hci_recv_event_data(hcon->hdev,
1443                                          HCI_EVT_LE_BIG_SYNC_ESTABILISHED);
1444                 if (ev)
1445                         parent = iso_get_sock_listen(&hcon->src,
1446                                                      &hcon->dst,
1447                                                      iso_match_big, ev);
1448                 else
1449                         parent = iso_get_sock_listen(&hcon->src,
1450                                                      BDADDR_ANY, NULL, NULL);
1451
1452                 if (!parent)
1453                         return;
1454
1455                 lock_sock(parent);
1456
1457                 sk = iso_sock_alloc(sock_net(parent), NULL,
1458                                     BTPROTO_ISO, GFP_ATOMIC, 0);
1459                 if (!sk) {
1460                         release_sock(parent);
1461                         return;
1462                 }
1463
1464                 iso_sock_init(sk, parent);
1465
1466                 bacpy(&iso_pi(sk)->src, &hcon->src);
1467                 iso_pi(sk)->src_type = hcon->src_type;
1468
1469                 /* If hcon has no destination address (BDADDR_ANY) it means it
1470                  * was created by HCI_EV_LE_BIG_SYNC_ESTABILISHED so we need to
1471                  * initialize using the parent socket destination address.
1472                  */
1473                 if (!bacmp(&hcon->dst, BDADDR_ANY)) {
1474                         bacpy(&hcon->dst, &iso_pi(parent)->dst);
1475                         hcon->dst_type = iso_pi(parent)->dst_type;
1476                         hcon->sync_handle = iso_pi(parent)->sync_handle;
1477                 }
1478
1479                 bacpy(&iso_pi(sk)->dst, &hcon->dst);
1480                 iso_pi(sk)->dst_type = hcon->dst_type;
1481
1482                 hci_conn_hold(hcon);
1483                 iso_chan_add(conn, sk, parent);
1484
1485                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1486                         sk->sk_state = BT_CONNECT2;
1487                 else
1488                         sk->sk_state = BT_CONNECTED;
1489
1490                 /* Wake up parent */
1491                 parent->sk_data_ready(parent);
1492
1493                 release_sock(parent);
1494         }
1495 }
1496
1497 static bool iso_match_sid(struct sock *sk, void *data)
1498 {
1499         struct hci_ev_le_pa_sync_established *ev = data;
1500
1501         return ev->sid == iso_pi(sk)->bc_sid;
1502 }
1503
1504 static bool iso_match_sync_handle(struct sock *sk, void *data)
1505 {
1506         struct hci_evt_le_big_info_adv_report *ev = data;
1507
1508         return le16_to_cpu(ev->sync_handle) == iso_pi(sk)->sync_handle;
1509 }
1510
1511 /* ----- ISO interface with lower layer (HCI) ----- */
1512
1513 int iso_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1514 {
1515         struct hci_ev_le_pa_sync_established *ev1;
1516         struct hci_evt_le_big_info_adv_report *ev2;
1517         struct sock *sk;
1518         int lm = 0;
1519
1520         bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
1521
1522         /* Broadcast receiver requires handling of some events before it can
1523          * proceed to establishing a BIG sync:
1524          *
1525          * 1. HCI_EV_LE_PA_SYNC_ESTABLISHED: The socket may specify a specific
1526          * SID to listen to and once sync is estabilished its handle needs to
1527          * be stored in iso_pi(sk)->sync_handle so it can be matched once
1528          * receiving the BIG Info.
1529          * 2. HCI_EVT_LE_BIG_INFO_ADV_REPORT: When connect_ind is triggered by a
1530          * a BIG Info it attempts to check if there any listening socket with
1531          * the same sync_handle and if it does then attempt to create a sync.
1532          */
1533         ev1 = hci_recv_event_data(hdev, HCI_EV_LE_PA_SYNC_ESTABLISHED);
1534         if (ev1) {
1535                 sk = iso_get_sock_listen(&hdev->bdaddr, bdaddr, iso_match_sid,
1536                                          ev1);
1537                 if (sk)
1538                         iso_pi(sk)->sync_handle = le16_to_cpu(ev1->handle);
1539
1540                 goto done;
1541         }
1542
1543         ev2 = hci_recv_event_data(hdev, HCI_EVT_LE_BIG_INFO_ADV_REPORT);
1544         if (ev2) {
1545                 sk = iso_get_sock_listen(&hdev->bdaddr, bdaddr,
1546                                          iso_match_sync_handle, ev2);
1547                 if (sk) {
1548                         int err;
1549
1550                         if (ev2->num_bis < iso_pi(sk)->bc_num_bis)
1551                                 iso_pi(sk)->bc_num_bis = ev2->num_bis;
1552
1553                         err = hci_le_big_create_sync(hdev,
1554                                                      &iso_pi(sk)->qos,
1555                                                      iso_pi(sk)->sync_handle,
1556                                                      iso_pi(sk)->bc_num_bis,
1557                                                      iso_pi(sk)->bc_bis);
1558                         if (err) {
1559                                 bt_dev_err(hdev, "hci_le_big_create_sync: %d",
1560                                            err);
1561                                 sk = NULL;
1562                         }
1563                 }
1564         } else {
1565                 sk = iso_get_sock_listen(&hdev->bdaddr, BDADDR_ANY, NULL, NULL);
1566         }
1567
1568 done:
1569         if (!sk)
1570                 return lm;
1571
1572         lm |= HCI_LM_ACCEPT;
1573
1574         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1575                 *flags |= HCI_PROTO_DEFER;
1576
1577         return lm;
1578 }
1579
1580 static void iso_connect_cfm(struct hci_conn *hcon, __u8 status)
1581 {
1582         if (hcon->type != ISO_LINK) {
1583                 if (hcon->type != LE_LINK)
1584                         return;
1585
1586                 /* Check if LE link has failed */
1587                 if (status) {
1588                         if (hcon->link)
1589                                 iso_conn_del(hcon->link, bt_to_errno(status));
1590                         return;
1591                 }
1592
1593                 /* Create CIS if pending */
1594                 hci_le_create_cis(hcon);
1595                 return;
1596         }
1597
1598         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1599
1600         if (!status) {
1601                 struct iso_conn *conn;
1602
1603                 conn = iso_conn_add(hcon);
1604                 if (conn)
1605                         iso_conn_ready(conn);
1606         } else {
1607                 iso_conn_del(hcon, bt_to_errno(status));
1608         }
1609 }
1610
1611 static void iso_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1612 {
1613         if (hcon->type != ISO_LINK)
1614                 return;
1615
1616         BT_DBG("hcon %p reason %d", hcon, reason);
1617
1618         iso_conn_del(hcon, bt_to_errno(reason));
1619 }
1620
1621 void iso_recv(struct hci_conn *hcon, struct sk_buff *skb, u16 flags)
1622 {
1623         struct iso_conn *conn = hcon->iso_data;
1624         __u16 pb, ts, len;
1625
1626         if (!conn)
1627                 goto drop;
1628
1629         pb     = hci_iso_flags_pb(flags);
1630         ts     = hci_iso_flags_ts(flags);
1631
1632         BT_DBG("conn %p len %d pb 0x%x ts 0x%x", conn, skb->len, pb, ts);
1633
1634         switch (pb) {
1635         case ISO_START:
1636         case ISO_SINGLE:
1637                 if (conn->rx_len) {
1638                         BT_ERR("Unexpected start frame (len %d)", skb->len);
1639                         kfree_skb(conn->rx_skb);
1640                         conn->rx_skb = NULL;
1641                         conn->rx_len = 0;
1642                 }
1643
1644                 if (ts) {
1645                         struct hci_iso_ts_data_hdr *hdr;
1646
1647                         /* TODO: add timestamp to the packet? */
1648                         hdr = skb_pull_data(skb, HCI_ISO_TS_DATA_HDR_SIZE);
1649                         if (!hdr) {
1650                                 BT_ERR("Frame is too short (len %d)", skb->len);
1651                                 goto drop;
1652                         }
1653
1654                         len = __le16_to_cpu(hdr->slen);
1655                 } else {
1656                         struct hci_iso_data_hdr *hdr;
1657
1658                         hdr = skb_pull_data(skb, HCI_ISO_DATA_HDR_SIZE);
1659                         if (!hdr) {
1660                                 BT_ERR("Frame is too short (len %d)", skb->len);
1661                                 goto drop;
1662                         }
1663
1664                         len = __le16_to_cpu(hdr->slen);
1665                 }
1666
1667                 flags  = hci_iso_data_flags(len);
1668                 len    = hci_iso_data_len(len);
1669
1670                 BT_DBG("Start: total len %d, frag len %d flags 0x%4.4x", len,
1671                        skb->len, flags);
1672
1673                 if (len == skb->len) {
1674                         /* Complete frame received */
1675                         iso_recv_frame(conn, skb);
1676                         return;
1677                 }
1678
1679                 if (pb == ISO_SINGLE) {
1680                         BT_ERR("Frame malformed (len %d, expected len %d)",
1681                                skb->len, len);
1682                         goto drop;
1683                 }
1684
1685                 if (skb->len > len) {
1686                         BT_ERR("Frame is too long (len %d, expected len %d)",
1687                                skb->len, len);
1688                         goto drop;
1689                 }
1690
1691                 /* Allocate skb for the complete frame (with header) */
1692                 conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL);
1693                 if (!conn->rx_skb)
1694                         goto drop;
1695
1696                 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
1697                                           skb->len);
1698                 conn->rx_len = len - skb->len;
1699                 break;
1700
1701         case ISO_CONT:
1702                 BT_DBG("Cont: frag len %d (expecting %d)", skb->len,
1703                        conn->rx_len);
1704
1705                 if (!conn->rx_len) {
1706                         BT_ERR("Unexpected continuation frame (len %d)",
1707                                skb->len);
1708                         goto drop;
1709                 }
1710
1711                 if (skb->len > conn->rx_len) {
1712                         BT_ERR("Fragment is too long (len %d, expected %d)",
1713                                skb->len, conn->rx_len);
1714                         kfree_skb(conn->rx_skb);
1715                         conn->rx_skb = NULL;
1716                         conn->rx_len = 0;
1717                         goto drop;
1718                 }
1719
1720                 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
1721                                           skb->len);
1722                 conn->rx_len -= skb->len;
1723                 return;
1724
1725         case ISO_END:
1726                 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
1727                                           skb->len);
1728                 conn->rx_len -= skb->len;
1729
1730                 if (!conn->rx_len) {
1731                         struct sk_buff *rx_skb = conn->rx_skb;
1732
1733                         /* Complete frame received. iso_recv_frame
1734                          * takes ownership of the skb so set the global
1735                          * rx_skb pointer to NULL first.
1736                          */
1737                         conn->rx_skb = NULL;
1738                         iso_recv_frame(conn, rx_skb);
1739                 }
1740                 break;
1741         }
1742
1743 drop:
1744         kfree_skb(skb);
1745 }
1746
1747 static struct hci_cb iso_cb = {
1748         .name           = "ISO",
1749         .connect_cfm    = iso_connect_cfm,
1750         .disconn_cfm    = iso_disconn_cfm,
1751 };
1752
1753 static int iso_debugfs_show(struct seq_file *f, void *p)
1754 {
1755         struct sock *sk;
1756
1757         read_lock(&iso_sk_list.lock);
1758
1759         sk_for_each(sk, &iso_sk_list.head) {
1760                 seq_printf(f, "%pMR %pMR %d\n", &iso_pi(sk)->src,
1761                            &iso_pi(sk)->dst, sk->sk_state);
1762         }
1763
1764         read_unlock(&iso_sk_list.lock);
1765
1766         return 0;
1767 }
1768
1769 DEFINE_SHOW_ATTRIBUTE(iso_debugfs);
1770
1771 static struct dentry *iso_debugfs;
1772
1773 static const struct proto_ops iso_sock_ops = {
1774         .family         = PF_BLUETOOTH,
1775         .owner          = THIS_MODULE,
1776         .release        = iso_sock_release,
1777         .bind           = iso_sock_bind,
1778         .connect        = iso_sock_connect,
1779         .listen         = iso_sock_listen,
1780         .accept         = iso_sock_accept,
1781         .getname        = iso_sock_getname,
1782         .sendmsg        = iso_sock_sendmsg,
1783         .recvmsg        = iso_sock_recvmsg,
1784         .poll           = bt_sock_poll,
1785         .ioctl          = bt_sock_ioctl,
1786         .mmap           = sock_no_mmap,
1787         .socketpair     = sock_no_socketpair,
1788         .shutdown       = iso_sock_shutdown,
1789         .setsockopt     = iso_sock_setsockopt,
1790         .getsockopt     = iso_sock_getsockopt
1791 };
1792
1793 static const struct net_proto_family iso_sock_family_ops = {
1794         .family = PF_BLUETOOTH,
1795         .owner  = THIS_MODULE,
1796         .create = iso_sock_create,
1797 };
1798
1799 static bool iso_inited;
1800
1801 bool iso_enabled(void)
1802 {
1803         return iso_inited;
1804 }
1805
1806 int iso_init(void)
1807 {
1808         int err;
1809
1810         BUILD_BUG_ON(sizeof(struct sockaddr_iso) > sizeof(struct sockaddr));
1811
1812         if (iso_inited)
1813                 return -EALREADY;
1814
1815         err = proto_register(&iso_proto, 0);
1816         if (err < 0)
1817                 return err;
1818
1819         err = bt_sock_register(BTPROTO_ISO, &iso_sock_family_ops);
1820         if (err < 0) {
1821                 BT_ERR("ISO socket registration failed");
1822                 goto error;
1823         }
1824
1825         err = bt_procfs_init(&init_net, "iso", &iso_sk_list, NULL);
1826         if (err < 0) {
1827                 BT_ERR("Failed to create ISO proc file");
1828                 bt_sock_unregister(BTPROTO_ISO);
1829                 goto error;
1830         }
1831
1832         BT_INFO("ISO socket layer initialized");
1833
1834         hci_register_cb(&iso_cb);
1835
1836         if (IS_ERR_OR_NULL(bt_debugfs))
1837                 return 0;
1838
1839         if (!iso_debugfs) {
1840                 iso_debugfs = debugfs_create_file("iso", 0444, bt_debugfs,
1841                                                   NULL, &iso_debugfs_fops);
1842         }
1843
1844         iso_inited = true;
1845
1846         return 0;
1847
1848 error:
1849         proto_unregister(&iso_proto);
1850         return err;
1851 }
1852
1853 int iso_exit(void)
1854 {
1855         if (!iso_inited)
1856                 return -EALREADY;
1857
1858         bt_procfs_cleanup(&init_net, "iso");
1859
1860         debugfs_remove(iso_debugfs);
1861         iso_debugfs = NULL;
1862
1863         hci_unregister_cb(&iso_cb);
1864
1865         bt_sock_unregister(BTPROTO_ISO);
1866
1867         proto_unregister(&iso_proto);
1868
1869         iso_inited = false;
1870
1871         return 0;
1872 }