#define LE_LINK                0x80
 #define CIS_LINK       0x82
 #define BIS_LINK       0x83
+#define PA_LINK                0x84
 #define INVALID_LINK   0xff
 
 /* LMP features */
 
                break;
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                h->iso_num++;
                break;
        }
                break;
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                h->iso_num--;
                break;
        }
                return h->sco_num;
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                return h->iso_num;
        default:
                return 0;
        rcu_read_lock();
 
        list_for_each_entry_rcu(c, &h->list, list) {
-               if (c->type != BIS_LINK)
+               if (c->type != PA_LINK)
                        continue;
 
                if (!test_bit(HCI_CONN_CREATE_PA_SYNC, &c->flags))
        rcu_read_lock();
 
        list_for_each_entry_rcu(c, &h->list, list) {
-               if (c->type != BIS_LINK)
+               if (c->type != PA_LINK)
                        continue;
 
                if (handle == c->iso_qos.bcast.big && num_bis == c->num_bis) {
        rcu_read_lock();
 
        list_for_each_entry_rcu(c, &h->list, list) {
-               if (c->type != BIS_LINK)
+               if (c->type != PA_LINK)
                        continue;
 
                /* Ignore the listen hcon, we are looking
 
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                return iso_connect_ind(hdev, bdaddr, flags);
 
        default:
 
        d->sync_handle = conn->sync_handle;
 
        if (test_and_clear_bit(HCI_CONN_PA_SYNC, &conn->flags)) {
-               hci_conn_hash_list_flag(hdev, find_bis, BIS_LINK,
+               hci_conn_hash_list_flag(hdev, find_bis, PA_LINK,
                                        HCI_CONN_PA_SYNC, d);
 
                if (!d->count)
                break;
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                if (hdev->iso_mtu)
                        /* Dedicated ISO Buffer exists */
                        break;
                break;
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                /* conn->src should reflect the local identity address */
                hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
 
        }
 
        hci_conn_init_sysfs(conn);
-
        return conn;
 }
 
                break;
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                if ((conn->state != BT_CONNECTED &&
                    !test_bit(HCI_CONN_CREATE_CIS, &conn->flags)) ||
                    test_bit(HCI_CONN_BIG_CREATED, &conn->flags))
        } else {
                /* Unacked ISO frames */
                if (conn->type == CIS_LINK ||
-                   conn->type == BIS_LINK) {
+                   conn->type == BIS_LINK ||
+                   conn->type == PA_LINK) {
                        if (hdev->iso_pkts)
                                hdev->iso_cnt += conn->sent;
                        else if (hdev->le_pkts)
 
        bt_dev_dbg(hdev, "dst %pMR type %d sid %d", dst, dst_type, sid);
 
-       conn = hci_conn_add_unset(hdev, BIS_LINK, dst, HCI_ROLE_SLAVE);
+       conn = hci_conn_add_unset(hdev, PA_LINK, dst, HCI_ROLE_SLAVE);
        if (IS_ERR(conn))
                return conn;
 
         * the start periodic advertising and create BIG commands have
         * been queued
         */
-       hci_conn_hash_list_state(hdev, bis_mark_per_adv, BIS_LINK,
+       hci_conn_hash_list_state(hdev, bis_mark_per_adv, PA_LINK,
                                 BT_BOUND, &data);
 
        /* Queue start periodic advertising and create BIG */
        switch (conn->type) {
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
        case ACL_LINK:
        case LE_LINK:
                break;
 
        case HCI_ACLDATA_PKT:
                /* Detect if ISO packet has been sent as ACL */
                if (hci_conn_num(hdev, CIS_LINK) ||
-                   hci_conn_num(hdev, BIS_LINK)) {
+                   hci_conn_num(hdev, BIS_LINK) ||
+                       hci_conn_num(hdev, PA_LINK)) {
                        __u16 handle = __le16_to_cpu(hci_acl_hdr(skb)->handle);
                        __u8 type;
 
                        type = hci_conn_lookup_type(hdev, hci_handle(handle));
-                       if (type == CIS_LINK || type == BIS_LINK)
+                       if (type == CIS_LINK || type == BIS_LINK ||
+                           type == PA_LINK)
                                hci_skb_pkt_type(skb) = HCI_ISODATA_PKT;
                }
                break;
                break;
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
                cnt = hdev->iso_mtu ? hdev->iso_cnt :
                        hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
                break;
 }
 
 static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type,
-                                    __u8 type2, int *quote)
+                                    int *quote)
 {
        struct hci_conn_hash *h = &hdev->conn_hash;
        struct hci_conn *conn = NULL, *c;
        rcu_read_lock();
 
        list_for_each_entry_rcu(c, &h->list, list) {
-               if ((c->type != type && c->type != type2) ||
+               if (c->type != type ||
                    skb_queue_empty(&c->data_q))
                        continue;
 
        else
                cnt = &hdev->sco_cnt;
 
-       while (*cnt && (conn = hci_low_sent(hdev, type, type, "e))) {
+       while (*cnt && (conn = hci_low_sent(hdev, type, "e))) {
                while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
                        BT_DBG("skb %p len %d", skb, skb->len);
                        hci_send_conn_frame(hdev, conn, skb);
                hci_prio_recalculate(hdev, LE_LINK);
 }
 
-/* Schedule CIS */
-static void hci_sched_iso(struct hci_dev *hdev)
+/* Schedule iso */
+static void hci_sched_iso(struct hci_dev *hdev, __u8 type)
 {
        struct hci_conn *conn;
        struct sk_buff *skb;
 
        BT_DBG("%s", hdev->name);
 
-       if (!hci_conn_num(hdev, CIS_LINK) &&
-           !hci_conn_num(hdev, BIS_LINK))
+       if (!hci_conn_num(hdev, type))
                return;
 
        cnt = hdev->iso_pkts ? &hdev->iso_cnt :
                hdev->le_pkts ? &hdev->le_cnt : &hdev->acl_cnt;
-       while (*cnt && (conn = hci_low_sent(hdev, CIS_LINK, BIS_LINK,
-                                           "e))) {
+       while (*cnt && (conn = hci_low_sent(hdev, type, "e))) {
                while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
                        BT_DBG("skb %p len %d", skb, skb->len);
                        hci_send_conn_frame(hdev, conn, skb);
                /* Schedule queues and send stuff to HCI driver */
                hci_sched_sco(hdev, SCO_LINK);
                hci_sched_sco(hdev, ESCO_LINK);
-               hci_sched_iso(hdev);
+               hci_sched_iso(hdev, CIS_LINK);
+               hci_sched_iso(hdev, BIS_LINK);
+               hci_sched_iso(hdev, PA_LINK);
                hci_sched_acl(hdev);
                hci_sched_le(hdev);
        }
 
 
                case CIS_LINK:
                case BIS_LINK:
+               case PA_LINK:
                        if (hdev->iso_pkts) {
                                hdev->iso_cnt += count;
                                if (hdev->iso_cnt > hdev->iso_pkts)
        conn->sync_handle = le16_to_cpu(ev->handle);
        conn->sid = HCI_SID_INVALID;
 
-       mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, BIS_LINK,
+       mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, PA_LINK,
                                      &flags);
        if (!(mask & HCI_LM_ACCEPT)) {
                hci_le_pa_term_sync(hdev, ev->handle);
                goto unlock;
 
        /* Add connection to indicate PA sync event */
-       pa_sync = hci_conn_add_unset(hdev, BIS_LINK, BDADDR_ANY,
+       pa_sync = hci_conn_add_unset(hdev, PA_LINK, BDADDR_ANY,
                                     HCI_ROLE_SLAVE);
 
        if (IS_ERR(pa_sync))
 
        hci_dev_lock(hdev);
 
-       mask |= hci_proto_connect_ind(hdev, BDADDR_ANY, BIS_LINK, &flags);
+       mask |= hci_proto_connect_ind(hdev, BDADDR_ANY, PA_LINK, &flags);
        if (!(mask & HCI_LM_ACCEPT))
                goto unlock;
 
 
                if (sent) {
                        struct hci_conn *conn;
 
-                       conn = hci_conn_hash_lookup_ba(hdev, BIS_LINK,
+                       conn = hci_conn_hash_lookup_ba(hdev, PA_LINK,
                                                       &sent->bdaddr);
                        if (conn) {
                                struct bt_iso_qos *qos = &conn->iso_qos;
 {
        struct hci_cp_disconnect cp;
 
-       if (conn->type == BIS_LINK) {
+       if (conn->type == BIS_LINK || conn->type == PA_LINK) {
                /* This is a BIS connection, hci_conn_del will
                 * do the necessary cleanup.
                 */
                return HCI_ERROR_LOCAL_HOST_TERM;
        }
 
-       if (conn->type == BIS_LINK) {
+       if (conn->type == BIS_LINK || conn->type == PA_LINK) {
                /* There is no way to cancel a BIS without terminating the BIG
                 * which is done later on connection cleanup.
                 */
        if (conn->type == CIS_LINK)
                return hci_le_reject_cis_sync(hdev, conn, reason);
 
-       if (conn->type == BIS_LINK)
+       if (conn->type == BIS_LINK || conn->type == PA_LINK)
                return -EINVAL;
 
        if (conn->type == SCO_LINK || conn->type == ESCO_LINK)
                goto unlock;
 
        /* Add connection to indicate PA sync error */
-       pa_sync = hci_conn_add_unset(hdev, BIS_LINK, BDADDR_ANY,
+       pa_sync = hci_conn_add_unset(hdev, PA_LINK, BDADDR_ANY,
                                     HCI_ROLE_SLAVE);
 
        if (IS_ERR(pa_sync))
 
 
 static void iso_connect_cfm(struct hci_conn *hcon, __u8 status)
 {
-       if (hcon->type != CIS_LINK && hcon->type != BIS_LINK) {
+       if (hcon->type != CIS_LINK && hcon->type != BIS_LINK &&
+           hcon->type != PA_LINK) {
                if (hcon->type != LE_LINK)
                        return;
 
 
 static void iso_disconn_cfm(struct hci_conn *hcon, __u8 reason)
 {
-       if (hcon->type != CIS_LINK && hcon->type != BIS_LINK)
+       if (hcon->type != CIS_LINK && hcon->type !=  BIS_LINK &&
+           hcon->type != PA_LINK)
                return;
 
        BT_DBG("hcon %p reason %d", hcon, reason);
 
        switch (link_type) {
        case CIS_LINK:
        case BIS_LINK:
+       case PA_LINK:
        case LE_LINK:
                switch (addr_type) {
                case ADDR_LE_DEV_PUBLIC: