Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / net / bluetooth / l2cap_core.c
index bd46cac..a378acc 100644 (file)
@@ -55,8 +55,6 @@
 #include <net/bluetooth/hci_core.h>
 #include <net/bluetooth/l2cap.h>
 
-#define VERSION "2.15"
-
 int disable_ertm;
 
 static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN;
@@ -70,170 +68,162 @@ struct bt_sock_list l2cap_sk_list = {
 
 static void l2cap_busy_work(struct work_struct *work);
 
-static void l2cap_sock_close(struct sock *sk);
-
-static int l2cap_build_conf_req(struct sock *sk, void *data);
 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
                                u8 code, u8 ident, u16 dlen, void *data);
+static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data);
 
 static int l2cap_ertm_data_rcv(struct sock *sk, struct sk_buff *skb);
 
-/* ---- L2CAP timers ---- */
-void l2cap_sock_set_timer(struct sock *sk, long timeout)
-{
-       BT_DBG("sk %p state %d timeout %ld", sk, sk->sk_state, timeout);
-       sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
-}
-
-static void l2cap_sock_clear_timer(struct sock *sk)
-{
-       BT_DBG("sock %p state %d", sk, sk->sk_state);
-       sk_stop_timer(sk, &sk->sk_timer);
-}
-
 /* ---- L2CAP channels ---- */
-static struct sock *__l2cap_get_chan_by_dcid(struct l2cap_chan_list *l, u16 cid)
+static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, u16 cid)
 {
-       struct sock *s;
-       for (s = l->head; s; s = l2cap_pi(s)->next_c) {
-               if (l2cap_pi(s)->dcid == cid)
-                       break;
+       struct l2cap_chan *c;
+
+       list_for_each_entry(c, &conn->chan_l, list) {
+               if (c->dcid == cid)
+                       return c;
        }
-       return s;
+       return NULL;
+
 }
 
-static struct sock *__l2cap_get_chan_by_scid(struct l2cap_chan_list *l, u16 cid)
+static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)
 {
-       struct sock *s;
-       for (s = l->head; s; s = l2cap_pi(s)->next_c) {
-               if (l2cap_pi(s)->scid == cid)
-                       break;
+       struct l2cap_chan *c;
+
+       list_for_each_entry(c, &conn->chan_l, list) {
+               if (c->scid == cid)
+                       return c;
        }
-       return s;
+       return NULL;
 }
 
 /* Find channel with given SCID.
  * Returns locked socket */
-static inline struct sock *l2cap_get_chan_by_scid(struct l2cap_chan_list *l, u16 cid)
+static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)
 {
-       struct sock *s;
-       read_lock(&l->lock);
-       s = __l2cap_get_chan_by_scid(l, cid);
-       if (s)
-               bh_lock_sock(s);
-       read_unlock(&l->lock);
-       return s;
+       struct l2cap_chan *c;
+
+       read_lock(&conn->chan_lock);
+       c = __l2cap_get_chan_by_scid(conn, cid);
+       if (c)
+               bh_lock_sock(c->sk);
+       read_unlock(&conn->chan_lock);
+       return c;
 }
 
-static struct sock *__l2cap_get_chan_by_ident(struct l2cap_chan_list *l, u8 ident)
+static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident)
 {
-       struct sock *s;
-       for (s = l->head; s; s = l2cap_pi(s)->next_c) {
-               if (l2cap_pi(s)->ident == ident)
-                       break;
+       struct l2cap_chan *c;
+
+       list_for_each_entry(c, &conn->chan_l, list) {
+               if (c->ident == ident)
+                       return c;
        }
-       return s;
+       return NULL;
 }
 
-static inline struct sock *l2cap_get_chan_by_ident(struct l2cap_chan_list *l, u8 ident)
+static inline struct l2cap_chan *l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident)
 {
-       struct sock *s;
-       read_lock(&l->lock);
-       s = __l2cap_get_chan_by_ident(l, ident);
-       if (s)
-               bh_lock_sock(s);
-       read_unlock(&l->lock);
-       return s;
+       struct l2cap_chan *c;
+
+       read_lock(&conn->chan_lock);
+       c = __l2cap_get_chan_by_ident(conn, ident);
+       if (c)
+               bh_lock_sock(c->sk);
+       read_unlock(&conn->chan_lock);
+       return c;
 }
 
-static u16 l2cap_alloc_cid(struct l2cap_chan_list *l)
+static u16 l2cap_alloc_cid(struct l2cap_conn *conn)
 {
        u16 cid = L2CAP_CID_DYN_START;
 
        for (; cid < L2CAP_CID_DYN_END; cid++) {
-               if (!__l2cap_get_chan_by_scid(l, cid))
+               if (!__l2cap_get_chan_by_scid(conn, cid))
                        return cid;
        }
 
        return 0;
 }
 
-static inline void __l2cap_chan_link(struct l2cap_chan_list *l, struct sock *sk)
+struct l2cap_chan *l2cap_chan_alloc(struct sock *sk)
 {
-       sock_hold(sk);
+       struct l2cap_chan *chan;
+
+       chan = kzalloc(sizeof(*chan), GFP_ATOMIC);
+       if (!chan)
+               return NULL;
 
-       if (l->head)
-               l2cap_pi(l->head)->prev_c = sk;
+       chan->sk = sk;
 
-       l2cap_pi(sk)->next_c = l->head;
-       l2cap_pi(sk)->prev_c = NULL;
-       l->head = sk;
+       return chan;
 }
 
-static inline void l2cap_chan_unlink(struct l2cap_chan_list *l, struct sock *sk)
+void l2cap_chan_free(struct l2cap_chan *chan)
 {
-       struct sock *next = l2cap_pi(sk)->next_c, *prev = l2cap_pi(sk)->prev_c;
-
-       write_lock_bh(&l->lock);
-       if (sk == l->head)
-               l->head = next;
-
-       if (next)
-               l2cap_pi(next)->prev_c = prev;
-       if (prev)
-               l2cap_pi(prev)->next_c = next;
-       write_unlock_bh(&l->lock);
-
-       __sock_put(sk);
+       kfree(chan);
 }
 
-static void __l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct sock *parent)
+static void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
 {
-       struct l2cap_chan_list *l = &conn->chan_list;
+       struct sock *sk = chan->sk;
 
        BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn,
-                       l2cap_pi(sk)->psm, l2cap_pi(sk)->dcid);
+                       chan->psm, chan->dcid);
 
        conn->disc_reason = 0x13;
 
-       l2cap_pi(sk)->conn = conn;
+       chan->conn = conn;
 
        if (sk->sk_type == SOCK_SEQPACKET || sk->sk_type == SOCK_STREAM) {
-               /* Alloc CID for connection-oriented socket */
-               l2cap_pi(sk)->scid = l2cap_alloc_cid(l);
+               if (conn->hcon->type == LE_LINK) {
+                       /* LE connection */
+                       chan->omtu = L2CAP_LE_DEFAULT_MTU;
+                       chan->scid = L2CAP_CID_LE_DATA;
+                       chan->dcid = L2CAP_CID_LE_DATA;
+               } else {
+                       /* Alloc CID for connection-oriented socket */
+                       chan->scid = l2cap_alloc_cid(conn);
+                       chan->omtu = L2CAP_DEFAULT_MTU;
+               }
        } else if (sk->sk_type == SOCK_DGRAM) {
                /* Connectionless socket */
-               l2cap_pi(sk)->scid = L2CAP_CID_CONN_LESS;
-               l2cap_pi(sk)->dcid = L2CAP_CID_CONN_LESS;
-               l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
+               chan->scid = L2CAP_CID_CONN_LESS;
+               chan->dcid = L2CAP_CID_CONN_LESS;
+               chan->omtu = L2CAP_DEFAULT_MTU;
        } else {
                /* Raw socket can send/recv signalling messages only */
-               l2cap_pi(sk)->scid = L2CAP_CID_SIGNALING;
-               l2cap_pi(sk)->dcid = L2CAP_CID_SIGNALING;
-               l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
+               chan->scid = L2CAP_CID_SIGNALING;
+               chan->dcid = L2CAP_CID_SIGNALING;
+               chan->omtu = L2CAP_DEFAULT_MTU;
        }
 
-       __l2cap_chan_link(l, sk);
+       sock_hold(sk);
 
-       if (parent)
-               bt_accept_enqueue(parent, sk);
+       list_add(&chan->list, &conn->chan_l);
 }
 
 /* Delete channel.
  * Must be called on the locked socket. */
-static void l2cap_chan_del(struct sock *sk, int err)
+void l2cap_chan_del(struct l2cap_chan *chan, int err)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+       struct sock *sk = chan->sk;
+       struct l2cap_conn *conn = chan->conn;
        struct sock *parent = bt_sk(sk)->parent;
 
        l2cap_sock_clear_timer(sk);
 
-       BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
+       BT_DBG("chan %p, conn %p, err %d", chan, conn, err);
 
        if (conn) {
-               /* Unlink from channel list */
-               l2cap_chan_unlink(&conn->chan_list, sk);
-               l2cap_pi(sk)->conn = NULL;
+               /* Delete from channel list */
+               write_lock_bh(&conn->chan_lock);
+               list_del(&chan->list);
+               write_unlock_bh(&conn->chan_lock);
+               __sock_put(sk);
+
+               chan->conn = NULL;
                hci_conn_put(conn->hcon);
        }
 
@@ -249,29 +239,35 @@ static void l2cap_chan_del(struct sock *sk, int err)
        } else
                sk->sk_state_change(sk);
 
-       skb_queue_purge(TX_QUEUE(sk));
+       if (!(chan->conf_state & L2CAP_CONF_OUTPUT_DONE &&
+                       chan->conf_state & L2CAP_CONF_INPUT_DONE))
+               return;
+
+       skb_queue_purge(&chan->tx_q);
 
-       if (l2cap_pi(sk)->mode == L2CAP_MODE_ERTM) {
+       if (chan->mode == L2CAP_MODE_ERTM) {
                struct srej_list *l, *tmp;
 
-               del_timer(&l2cap_pi(sk)->retrans_timer);
-               del_timer(&l2cap_pi(sk)->monitor_timer);
-               del_timer(&l2cap_pi(sk)->ack_timer);
+               del_timer(&chan->retrans_timer);
+               del_timer(&chan->monitor_timer);
+               del_timer(&chan->ack_timer);
 
-               skb_queue_purge(SREJ_QUEUE(sk));
-               skb_queue_purge(BUSY_QUEUE(sk));
+               skb_queue_purge(&chan->srej_q);
+               skb_queue_purge(&chan->busy_q);
 
-               list_for_each_entry_safe(l, tmp, SREJ_LIST(sk), list) {
+               list_for_each_entry_safe(l, tmp, &chan->srej_l, list) {
                        list_del(&l->list);
                        kfree(l);
                }
        }
 }
 
-static inline u8 l2cap_get_auth_type(struct sock *sk)
+static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan)
 {
+       struct sock *sk = chan->sk;
+
        if (sk->sk_type == SOCK_RAW) {
-               switch (l2cap_pi(sk)->sec_level) {
+               switch (chan->sec_level) {
                case BT_SECURITY_HIGH:
                        return HCI_AT_DEDICATED_BONDING_MITM;
                case BT_SECURITY_MEDIUM:
@@ -279,16 +275,16 @@ static inline u8 l2cap_get_auth_type(struct sock *sk)
                default:
                        return HCI_AT_NO_BONDING;
                }
-       } else if (l2cap_pi(sk)->psm == cpu_to_le16(0x0001)) {
-               if (l2cap_pi(sk)->sec_level == BT_SECURITY_LOW)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
+       } else if (chan->psm == cpu_to_le16(0x0001)) {
+               if (chan->sec_level == BT_SECURITY_LOW)
+                       chan->sec_level = BT_SECURITY_SDP;
 
-               if (l2cap_pi(sk)->sec_level == BT_SECURITY_HIGH)
+               if (chan->sec_level == BT_SECURITY_HIGH)
                        return HCI_AT_NO_BONDING_MITM;
                else
                        return HCI_AT_NO_BONDING;
        } else {
-               switch (l2cap_pi(sk)->sec_level) {
+               switch (chan->sec_level) {
                case BT_SECURITY_HIGH:
                        return HCI_AT_GENERAL_BONDING_MITM;
                case BT_SECURITY_MEDIUM:
@@ -300,18 +296,17 @@ static inline u8 l2cap_get_auth_type(struct sock *sk)
 }
 
 /* Service level security */
-static inline int l2cap_check_security(struct sock *sk)
+static inline int l2cap_check_security(struct l2cap_chan *chan)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+       struct l2cap_conn *conn = chan->conn;
        __u8 auth_type;
 
-       auth_type = l2cap_get_auth_type(sk);
+       auth_type = l2cap_get_auth_type(chan);
 
-       return hci_conn_security(conn->hcon, l2cap_pi(sk)->sec_level,
-                                                               auth_type);
+       return hci_conn_security(conn->hcon, chan->sec_level, auth_type);
 }
 
-static inline u8 l2cap_get_ident(struct l2cap_conn *conn)
+u8 l2cap_get_ident(struct l2cap_conn *conn)
 {
        u8 id;
 
@@ -333,7 +328,7 @@ static inline u8 l2cap_get_ident(struct l2cap_conn *conn)
        return id;
 }
 
-static inline void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data)
+void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data)
 {
        struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
        u8 flags;
@@ -351,11 +346,12 @@ static inline void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u1
        hci_send_acl(conn->hcon, skb, flags);
 }
 
-static inline void l2cap_send_sframe(struct l2cap_pinfo *pi, u16 control)
+static inline void l2cap_send_sframe(struct l2cap_chan *chan, u16 control)
 {
        struct sk_buff *skb;
        struct l2cap_hdr *lh;
-       struct l2cap_conn *conn = pi->conn;
+       struct l2cap_pinfo *pi = l2cap_pi(chan->sk);
+       struct l2cap_conn *conn = chan->conn;
        struct sock *sk = (struct sock *)pi;
        int count, hlen = L2CAP_HDR_SIZE + 2;
        u8 flags;
@@ -363,22 +359,22 @@ static inline void l2cap_send_sframe(struct l2cap_pinfo *pi, u16 control)
        if (sk->sk_state != BT_CONNECTED)
                return;
 
-       if (pi->fcs == L2CAP_FCS_CRC16)
+       if (chan->fcs == L2CAP_FCS_CRC16)
                hlen += 2;
 
-       BT_DBG("pi %p, control 0x%2.2x", pi, control);
+       BT_DBG("chan %p, control 0x%2.2x", chan, control);
 
        count = min_t(unsigned int, conn->mtu, hlen);
        control |= L2CAP_CTRL_FRAME_TYPE;
 
-       if (pi->conn_state & L2CAP_CONN_SEND_FBIT) {
+       if (chan->conn_state & L2CAP_CONN_SEND_FBIT) {
                control |= L2CAP_CTRL_FINAL;
-               pi->conn_state &= ~L2CAP_CONN_SEND_FBIT;
+               chan->conn_state &= ~L2CAP_CONN_SEND_FBIT;
        }
 
-       if (pi->conn_state & L2CAP_CONN_SEND_PBIT) {
+       if (chan->conn_state & L2CAP_CONN_SEND_PBIT) {
                control |= L2CAP_CTRL_POLL;
-               pi->conn_state &= ~L2CAP_CONN_SEND_PBIT;
+               chan->conn_state &= ~L2CAP_CONN_SEND_PBIT;
        }
 
        skb = bt_skb_alloc(count, GFP_ATOMIC);
@@ -387,10 +383,10 @@ static inline void l2cap_send_sframe(struct l2cap_pinfo *pi, u16 control)
 
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
        lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE);
-       lh->cid = cpu_to_le16(pi->dcid);
+       lh->cid = cpu_to_le16(chan->dcid);
        put_unaligned_le16(control, skb_put(skb, 2));
 
-       if (pi->fcs == L2CAP_FCS_CRC16) {
+       if (chan->fcs == L2CAP_FCS_CRC16) {
                u16 fcs = crc16(0, (u8 *)lh, count - 2);
                put_unaligned_le16(fcs, skb_put(skb, 2));
        }
@@ -400,45 +396,46 @@ static inline void l2cap_send_sframe(struct l2cap_pinfo *pi, u16 control)
        else
                flags = ACL_START;
 
-       hci_send_acl(pi->conn->hcon, skb, flags);
+       hci_send_acl(chan->conn->hcon, skb, flags);
 }
 
-static inline void l2cap_send_rr_or_rnr(struct l2cap_pinfo *pi, u16 control)
+static inline void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, u16 control)
 {
-       if (pi->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
                control |= L2CAP_SUPER_RCV_NOT_READY;
-               pi->conn_state |= L2CAP_CONN_RNR_SENT;
+               chan->conn_state |= L2CAP_CONN_RNR_SENT;
        } else
                control |= L2CAP_SUPER_RCV_READY;
 
-       control |= pi->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
+       control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
 
-       l2cap_send_sframe(pi, control);
+       l2cap_send_sframe(chan, control);
 }
 
-static inline int __l2cap_no_conn_pending(struct sock *sk)
+static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan)
 {
-       return !(l2cap_pi(sk)->conf_state & L2CAP_CONF_CONNECT_PEND);
+       return !(chan->conf_state & L2CAP_CONF_CONNECT_PEND);
 }
 
-static void l2cap_do_start(struct sock *sk)
+static void l2cap_do_start(struct l2cap_chan *chan)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+       struct l2cap_conn *conn = chan->conn;
 
        if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) {
                if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
                        return;
 
-               if (l2cap_check_security(sk) && __l2cap_no_conn_pending(sk)) {
+               if (l2cap_check_security(chan) &&
+                               __l2cap_no_conn_pending(chan)) {
                        struct l2cap_conn_req req;
-                       req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
-                       req.psm  = l2cap_pi(sk)->psm;
+                       req.scid = cpu_to_le16(chan->scid);
+                       req.psm  = chan->psm;
 
-                       l2cap_pi(sk)->ident = l2cap_get_ident(conn);
-                       l2cap_pi(sk)->conf_state |= L2CAP_CONF_CONNECT_PEND;
+                       chan->ident = l2cap_get_ident(conn);
+                       chan->conf_state |= L2CAP_CONF_CONNECT_PEND;
 
-                       l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
-                                       L2CAP_CONN_REQ, sizeof(req), &req);
+                       l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ,
+                                                       sizeof(req), &req);
                }
        } else {
                struct l2cap_info_req req;
@@ -471,23 +468,24 @@ static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask)
        }
 }
 
-static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct sock *sk, int err)
+void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err)
 {
+       struct sock *sk;
        struct l2cap_disconn_req req;
 
        if (!conn)
                return;
 
-       skb_queue_purge(TX_QUEUE(sk));
+       sk = chan->sk;
 
-       if (l2cap_pi(sk)->mode == L2CAP_MODE_ERTM) {
-               del_timer(&l2cap_pi(sk)->retrans_timer);
-               del_timer(&l2cap_pi(sk)->monitor_timer);
-               del_timer(&l2cap_pi(sk)->ack_timer);
+       if (chan->mode == L2CAP_MODE_ERTM) {
+               del_timer(&chan->retrans_timer);
+               del_timer(&chan->monitor_timer);
+               del_timer(&chan->ack_timer);
        }
 
-       req.dcid = cpu_to_le16(l2cap_pi(sk)->dcid);
-       req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
+       req.dcid = cpu_to_le16(chan->dcid);
+       req.scid = cpu_to_le16(chan->scid);
        l2cap_send_cmd(conn, l2cap_get_ident(conn),
                        L2CAP_DISCONN_REQ, sizeof(req), &req);
 
@@ -498,17 +496,15 @@ static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct sock *sk, int
 /* ---- L2CAP connections ---- */
 static void l2cap_conn_start(struct l2cap_conn *conn)
 {
-       struct l2cap_chan_list *l = &conn->chan_list;
-       struct sock_del_list del, *tmp1, *tmp2;
-       struct sock *sk;
+       struct l2cap_chan *chan, *tmp;
 
        BT_DBG("conn %p", conn);
 
-       INIT_LIST_HEAD(&del.list);
+       read_lock(&conn->chan_lock);
 
-       read_lock(&l->lock);
+       list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) {
+               struct sock *sk = chan->sk;
 
-       for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
                bh_lock_sock(sk);
 
                if (sk->sk_type != SOCK_SEQPACKET &&
@@ -520,40 +516,41 @@ static void l2cap_conn_start(struct l2cap_conn *conn)
                if (sk->sk_state == BT_CONNECT) {
                        struct l2cap_conn_req req;
 
-                       if (!l2cap_check_security(sk) ||
-                                       !__l2cap_no_conn_pending(sk)) {
+                       if (!l2cap_check_security(chan) ||
+                                       !__l2cap_no_conn_pending(chan)) {
                                bh_unlock_sock(sk);
                                continue;
                        }
 
-                       if (!l2cap_mode_supported(l2cap_pi(sk)->mode,
+                       if (!l2cap_mode_supported(chan->mode,
                                        conn->feat_mask)
-                                       && l2cap_pi(sk)->conf_state &
+                                       && chan->conf_state &
                                        L2CAP_CONF_STATE2_DEVICE) {
-                               tmp1 = kzalloc(sizeof(struct sock_del_list),
-                                               GFP_ATOMIC);
-                               tmp1->sk = sk;
-                               list_add_tail(&tmp1->list, &del.list);
+                               /* __l2cap_sock_close() calls list_del(chan)
+                                * so release the lock */
+                               read_unlock_bh(&conn->chan_lock);
+                                __l2cap_sock_close(sk, ECONNRESET);
+                               read_lock_bh(&conn->chan_lock);
                                bh_unlock_sock(sk);
                                continue;
                        }
 
-                       req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
-                       req.psm  = l2cap_pi(sk)->psm;
+                       req.scid = cpu_to_le16(chan->scid);
+                       req.psm  = chan->psm;
 
-                       l2cap_pi(sk)->ident = l2cap_get_ident(conn);
-                       l2cap_pi(sk)->conf_state |= L2CAP_CONF_CONNECT_PEND;
+                       chan->ident = l2cap_get_ident(conn);
+                       chan->conf_state |= L2CAP_CONF_CONNECT_PEND;
 
-                       l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
-                               L2CAP_CONN_REQ, sizeof(req), &req);
+                       l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ,
+                                                       sizeof(req), &req);
 
                } else if (sk->sk_state == BT_CONNECT2) {
                        struct l2cap_conn_rsp rsp;
                        char buf[128];
-                       rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
-                       rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
+                       rsp.scid = cpu_to_le16(chan->dcid);
+                       rsp.dcid = cpu_to_le16(chan->scid);
 
-                       if (l2cap_check_security(sk)) {
+                       if (l2cap_check_security(chan)) {
                                if (bt_sk(sk)->defer_setup) {
                                        struct sock *parent = bt_sk(sk)->parent;
                                        rsp.result = cpu_to_le16(L2CAP_CR_PEND);
@@ -570,77 +567,169 @@ static void l2cap_conn_start(struct l2cap_conn *conn)
                                rsp.status = cpu_to_le16(L2CAP_CS_AUTHEN_PEND);
                        }
 
-                       l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
-                                       L2CAP_CONN_RSP, sizeof(rsp), &rsp);
+                       l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
+                                                       sizeof(rsp), &rsp);
 
-                       if (l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT ||
+                       if (chan->conf_state & L2CAP_CONF_REQ_SENT ||
                                        rsp.result != L2CAP_CR_SUCCESS) {
                                bh_unlock_sock(sk);
                                continue;
                        }
 
-                       l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
+                       chan->conf_state |= L2CAP_CONF_REQ_SENT;
                        l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
-                                               l2cap_build_conf_req(sk, buf), buf);
-                       l2cap_pi(sk)->num_conf_req++;
+                                               l2cap_build_conf_req(chan, buf), buf);
+                       chan->num_conf_req++;
                }
 
                bh_unlock_sock(sk);
        }
 
-       read_unlock(&l->lock);
+       read_unlock(&conn->chan_lock);
+}
+
+/* Find socket with cid and source bdaddr.
+ * Returns closest match, locked.
+ */
+static struct sock *l2cap_get_sock_by_scid(int state, __le16 cid, bdaddr_t *src)
+{
+       struct sock *sk = NULL, *sk1 = NULL;
+       struct hlist_node *node;
+
+       read_lock(&l2cap_sk_list.lock);
 
-       list_for_each_entry_safe(tmp1, tmp2, &del.list, list) {
-               bh_lock_sock(tmp1->sk);
-               __l2cap_sock_close(tmp1->sk, ECONNRESET);
-               bh_unlock_sock(tmp1->sk);
-               list_del(&tmp1->list);
-               kfree(tmp1);
+       sk_for_each(sk, node, &l2cap_sk_list.head) {
+               struct l2cap_chan *chan = l2cap_pi(sk)->chan;
+
+               if (state && sk->sk_state != state)
+                       continue;
+
+               if (chan->scid == cid) {
+                       /* Exact match. */
+                       if (!bacmp(&bt_sk(sk)->src, src))
+                               break;
+
+                       /* Closest match */
+                       if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
+                               sk1 = sk;
+               }
        }
+
+       read_unlock(&l2cap_sk_list.lock);
+
+       return node ? sk : sk1;
+}
+
+static void l2cap_le_conn_ready(struct l2cap_conn *conn)
+{
+       struct sock *parent, *sk;
+       struct l2cap_chan *chan;
+
+       BT_DBG("");
+
+       /* Check if we have socket listening on cid */
+       parent = l2cap_get_sock_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA,
+                                                       conn->src);
+       if (!parent)
+               return;
+
+       bh_lock_sock(parent);
+
+       /* Check for backlog size */
+       if (sk_acceptq_is_full(parent)) {
+               BT_DBG("backlog full %d", parent->sk_ack_backlog);
+               goto clean;
+       }
+
+       sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP, GFP_ATOMIC);
+       if (!sk)
+               goto clean;
+
+       chan = l2cap_chan_alloc(sk);
+       if (!chan) {
+               l2cap_sock_kill(sk);
+               goto clean;
+       }
+
+       l2cap_pi(sk)->chan = chan;
+
+       write_lock_bh(&conn->chan_lock);
+
+       hci_conn_hold(conn->hcon);
+
+       l2cap_sock_init(sk, parent);
+
+       bacpy(&bt_sk(sk)->src, conn->src);
+       bacpy(&bt_sk(sk)->dst, conn->dst);
+
+       bt_accept_enqueue(parent, sk);
+
+       __l2cap_chan_add(conn, chan);
+
+       l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
+
+       sk->sk_state = BT_CONNECTED;
+       parent->sk_data_ready(parent, 0);
+
+       write_unlock_bh(&conn->chan_lock);
+
+clean:
+       bh_unlock_sock(parent);
 }
 
 static void l2cap_conn_ready(struct l2cap_conn *conn)
 {
-       struct l2cap_chan_list *l = &conn->chan_list;
-       struct sock *sk;
+       struct l2cap_chan *chan;
 
        BT_DBG("conn %p", conn);
 
-       read_lock(&l->lock);
+       if (!conn->hcon->out && conn->hcon->type == LE_LINK)
+               l2cap_le_conn_ready(conn);
+
+       read_lock(&conn->chan_lock);
+
+       list_for_each_entry(chan, &conn->chan_l, list) {
+               struct sock *sk = chan->sk;
 
-       for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
                bh_lock_sock(sk);
 
+               if (conn->hcon->type == LE_LINK) {
+                       l2cap_sock_clear_timer(sk);
+                       sk->sk_state = BT_CONNECTED;
+                       sk->sk_state_change(sk);
+               }
+
                if (sk->sk_type != SOCK_SEQPACKET &&
                                sk->sk_type != SOCK_STREAM) {
                        l2cap_sock_clear_timer(sk);
                        sk->sk_state = BT_CONNECTED;
                        sk->sk_state_change(sk);
                } else if (sk->sk_state == BT_CONNECT)
-                       l2cap_do_start(sk);
+                       l2cap_do_start(chan);
 
                bh_unlock_sock(sk);
        }
 
-       read_unlock(&l->lock);
+       read_unlock(&conn->chan_lock);
 }
 
 /* Notify sockets that we cannot guaranty reliability anymore */
 static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err)
 {
-       struct l2cap_chan_list *l = &conn->chan_list;
-       struct sock *sk;
+       struct l2cap_chan *chan;
 
        BT_DBG("conn %p", conn);
 
-       read_lock(&l->lock);
+       read_lock(&conn->chan_lock);
 
-       for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
-               if (l2cap_pi(sk)->force_reliable)
+       list_for_each_entry(chan, &conn->chan_l, list) {
+               struct sock *sk = chan->sk;
+
+               if (chan->force_reliable)
                        sk->sk_err = err;
        }
 
-       read_unlock(&l->lock);
+       read_unlock(&conn->chan_lock);
 }
 
 static void l2cap_info_timeout(unsigned long arg)
@@ -669,16 +758,23 @@ static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status)
 
        BT_DBG("hcon %p conn %p", hcon, conn);
 
-       conn->mtu = hcon->hdev->acl_mtu;
+       if (hcon->hdev->le_mtu && hcon->type == LE_LINK)
+               conn->mtu = hcon->hdev->le_mtu;
+       else
+               conn->mtu = hcon->hdev->acl_mtu;
+
        conn->src = &hcon->hdev->bdaddr;
        conn->dst = &hcon->dst;
 
        conn->feat_mask = 0;
 
        spin_lock_init(&conn->lock);
-       rwlock_init(&conn->chan_list.lock);
+       rwlock_init(&conn->chan_lock);
 
-       setup_timer(&conn->info_timer, l2cap_info_timeout,
+       INIT_LIST_HEAD(&conn->chan_l);
+
+       if (hcon->type != LE_LINK)
+               setup_timer(&conn->info_timer, l2cap_info_timeout,
                                                (unsigned long) conn);
 
        conn->disc_reason = 0x13;
@@ -689,6 +785,7 @@ static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status)
 static void l2cap_conn_del(struct hci_conn *hcon, int err)
 {
        struct l2cap_conn *conn = hcon->l2cap_data;
+       struct l2cap_chan *chan, *l;
        struct sock *sk;
 
        if (!conn)
@@ -699,9 +796,10 @@ static void l2cap_conn_del(struct hci_conn *hcon, int err)
        kfree_skb(conn->rx_skb);
 
        /* Kill channels */
-       while ((sk = conn->chan_list.head)) {
+       list_for_each_entry_safe(chan, l, &conn->chan_l, list) {
+               sk = chan->sk;
                bh_lock_sock(sk);
-               l2cap_chan_del(sk, err);
+               l2cap_chan_del(chan, err);
                bh_unlock_sock(sk);
                l2cap_sock_kill(sk);
        }
@@ -713,12 +811,11 @@ static void l2cap_conn_del(struct hci_conn *hcon, int err)
        kfree(conn);
 }
 
-static inline void l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct sock *parent)
+static inline void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
 {
-       struct l2cap_chan_list *l = &conn->chan_list;
-       write_lock_bh(&l->lock);
-       __l2cap_chan_add(conn, sk, parent);
-       write_unlock_bh(&l->lock);
+       write_lock_bh(&conn->chan_lock);
+       __l2cap_chan_add(conn, chan);
+       write_unlock_bh(&conn->chan_lock);
 }
 
 /* ---- Socket interface ---- */
@@ -734,10 +831,12 @@ static struct sock *l2cap_get_sock_by_psm(int state, __le16 psm, bdaddr_t *src)
        read_lock(&l2cap_sk_list.lock);
 
        sk_for_each(sk, node, &l2cap_sk_list.head) {
+               struct l2cap_chan *chan = l2cap_pi(sk)->chan;
+
                if (state && sk->sk_state != state)
                        continue;
 
-               if (l2cap_pi(sk)->psm == psm) {
+               if (chan->psm == psm) {
                        /* Exact match. */
                        if (!bacmp(&bt_sk(sk)->src, src))
                                break;
@@ -753,103 +852,9 @@ static struct sock *l2cap_get_sock_by_psm(int state, __le16 psm, bdaddr_t *src)
        return node ? sk : sk1;
 }
 
-static void l2cap_sock_cleanup_listen(struct sock *parent)
-{
-       struct sock *sk;
-
-       BT_DBG("parent %p", parent);
-
-       /* Close not yet accepted channels */
-       while ((sk = bt_accept_dequeue(parent, NULL)))
-               l2cap_sock_close(sk);
-
-       parent->sk_state = BT_CLOSED;
-       sock_set_flag(parent, SOCK_ZAPPED);
-}
-
-/* Kill socket (only if zapped and orphan)
- * Must be called on unlocked socket.
- */
-void l2cap_sock_kill(struct sock *sk)
-{
-       if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
-               return;
-
-       BT_DBG("sk %p state %d", sk, sk->sk_state);
-
-       /* Kill poor orphan */
-       bt_sock_unlink(&l2cap_sk_list, sk);
-       sock_set_flag(sk, SOCK_DEAD);
-       sock_put(sk);
-}
-
-void __l2cap_sock_close(struct sock *sk, int reason)
-{
-       BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
-
-       switch (sk->sk_state) {
-       case BT_LISTEN:
-               l2cap_sock_cleanup_listen(sk);
-               break;
-
-       case BT_CONNECTED:
-       case BT_CONFIG:
-               if (sk->sk_type == SOCK_SEQPACKET ||
-                               sk->sk_type == SOCK_STREAM) {
-                       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
-
-                       l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
-                       l2cap_send_disconn_req(conn, sk, reason);
-               } else
-                       l2cap_chan_del(sk, reason);
-               break;
-
-       case BT_CONNECT2:
-               if (sk->sk_type == SOCK_SEQPACKET ||
-                               sk->sk_type == SOCK_STREAM) {
-                       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
-                       struct l2cap_conn_rsp rsp;
-                       __u16 result;
-
-                       if (bt_sk(sk)->defer_setup)
-                               result = L2CAP_CR_SEC_BLOCK;
-                       else
-                               result = L2CAP_CR_BAD_PSM;
-                       sk->sk_state = BT_DISCONN;
-
-                       rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
-                       rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
-                       rsp.result = cpu_to_le16(result);
-                       rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
-                       l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
-                                       L2CAP_CONN_RSP, sizeof(rsp), &rsp);
-               } else
-                       l2cap_chan_del(sk, reason);
-               break;
-
-       case BT_CONNECT:
-       case BT_DISCONN:
-               l2cap_chan_del(sk, reason);
-               break;
-
-       default:
-               sock_set_flag(sk, SOCK_ZAPPED);
-               break;
-       }
-}
-
-/* Must be called on unlocked socket. */
-static void l2cap_sock_close(struct sock *sk)
-{
-       l2cap_sock_clear_timer(sk);
-       lock_sock(sk);
-       __l2cap_sock_close(sk, ECONNRESET);
-       release_sock(sk);
-       l2cap_sock_kill(sk);
-}
-
-static int l2cap_do_connect(struct sock *sk)
+int l2cap_chan_connect(struct l2cap_chan *chan)
 {
+       struct sock *sk = chan->sk;
        bdaddr_t *src = &bt_sk(sk)->src;
        bdaddr_t *dst = &bt_sk(sk)->dst;
        struct l2cap_conn *conn;
@@ -859,7 +864,7 @@ static int l2cap_do_connect(struct sock *sk)
        int err;
 
        BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst),
-                                                       l2cap_pi(sk)->psm);
+                                                       chan->psm);
 
        hdev = hci_get_route(dst, src);
        if (!hdev)
@@ -867,27 +872,31 @@ static int l2cap_do_connect(struct sock *sk)
 
        hci_dev_lock_bh(hdev);
 
-       err = -ENOMEM;
+       auth_type = l2cap_get_auth_type(chan);
 
-       auth_type = l2cap_get_auth_type(sk);
+       if (chan->dcid == L2CAP_CID_LE_DATA)
+               hcon = hci_connect(hdev, LE_LINK, dst,
+                                       chan->sec_level, auth_type);
+       else
+               hcon = hci_connect(hdev, ACL_LINK, dst,
+                                       chan->sec_level, auth_type);
 
-       hcon = hci_connect(hdev, ACL_LINK, dst,
-                                       l2cap_pi(sk)->sec_level, auth_type);
-       if (!hcon)
+       if (IS_ERR(hcon)) {
+               err = PTR_ERR(hcon);
                goto done;
+       }
 
        conn = l2cap_conn_add(hcon, 0);
        if (!conn) {
                hci_conn_put(hcon);
+               err = -ENOMEM;
                goto done;
        }
 
-       err = 0;
-
        /* Update source addr of the socket */
        bacpy(src, conn->src);
 
-       l2cap_chan_add(conn, sk, NULL);
+       l2cap_chan_add(conn, chan);
 
        sk->sk_state = BT_CONNECT;
        l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
@@ -896,111 +905,29 @@ static int l2cap_do_connect(struct sock *sk)
                if (sk->sk_type != SOCK_SEQPACKET &&
                                sk->sk_type != SOCK_STREAM) {
                        l2cap_sock_clear_timer(sk);
-                       if (l2cap_check_security(sk))
+                       if (l2cap_check_security(chan))
                                sk->sk_state = BT_CONNECTED;
                } else
-                       l2cap_do_start(sk);
+                       l2cap_do_start(chan);
        }
 
+       err = 0;
+
 done:
        hci_dev_unlock_bh(hdev);
        hci_dev_put(hdev);
        return err;
 }
 
-int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
-{
-       struct sock *sk = sock->sk;
-       struct sockaddr_l2 la;
-       int len, err = 0;
-
-       BT_DBG("sk %p", sk);
-
-       if (!addr || alen < sizeof(addr->sa_family) ||
-           addr->sa_family != AF_BLUETOOTH)
-               return -EINVAL;
-
-       memset(&la, 0, sizeof(la));
-       len = min_t(unsigned int, sizeof(la), alen);
-       memcpy(&la, addr, len);
-
-       if (la.l2_cid)
-               return -EINVAL;
-
-       lock_sock(sk);
-
-       if ((sk->sk_type == SOCK_SEQPACKET || sk->sk_type == SOCK_STREAM)
-                       && !la.l2_psm) {
-               err = -EINVAL;
-               goto done;
-       }
-
-       switch (l2cap_pi(sk)->mode) {
-       case L2CAP_MODE_BASIC:
-               break;
-       case L2CAP_MODE_ERTM:
-       case L2CAP_MODE_STREAMING:
-               if (!disable_ertm)
-                       break;
-               /* fall through */
-       default:
-               err = -ENOTSUPP;
-               goto done;
-       }
-
-       switch (sk->sk_state) {
-       case BT_CONNECT:
-       case BT_CONNECT2:
-       case BT_CONFIG:
-               /* Already connecting */
-               goto wait;
-
-       case BT_CONNECTED:
-               /* Already connected */
-               err = -EISCONN;
-               goto done;
-
-       case BT_OPEN:
-       case BT_BOUND:
-               /* Can connect */
-               break;
-
-       default:
-               err = -EBADFD;
-               goto done;
-       }
-
-       /* PSM must be odd and lsb of upper byte must be 0 */
-       if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 &&
-               sk->sk_type != SOCK_RAW) {
-               err = -EINVAL;
-               goto done;
-       }
-
-       /* Set destination address and psm */
-       bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
-       l2cap_pi(sk)->psm = la.l2_psm;
-
-       err = l2cap_do_connect(sk);
-       if (err)
-               goto done;
-
-wait:
-       err = bt_sock_wait_state(sk, BT_CONNECTED,
-                       sock_sndtimeo(sk, flags & O_NONBLOCK));
-done:
-       release_sock(sk);
-       return err;
-}
-
-static int __l2cap_wait_ack(struct sock *sk)
+int __l2cap_wait_ack(struct sock *sk)
 {
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        DECLARE_WAITQUEUE(wait, current);
        int err = 0;
        int timeo = HZ/5;
 
        add_wait_queue(sk_sleep(sk), &wait);
-       while ((l2cap_pi(sk)->unacked_frames > 0 && l2cap_pi(sk)->conn)) {
+       while ((chan->unacked_frames > 0 && chan->conn)) {
                set_current_state(TASK_INTERRUPTIBLE);
 
                if (!timeo)
@@ -1026,68 +953,69 @@ static int __l2cap_wait_ack(struct sock *sk)
 
 static void l2cap_monitor_timeout(unsigned long arg)
 {
-       struct sock *sk = (void *) arg;
+       struct l2cap_chan *chan = (void *) arg;
+       struct sock *sk = chan->sk;
 
-       BT_DBG("sk %p", sk);
+       BT_DBG("chan %p", chan);
 
        bh_lock_sock(sk);
-       if (l2cap_pi(sk)->retry_count >= l2cap_pi(sk)->remote_max_tx) {
-               l2cap_send_disconn_req(l2cap_pi(sk)->conn, sk, ECONNABORTED);
+       if (chan->retry_count >= chan->remote_max_tx) {
+               l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED);
                bh_unlock_sock(sk);
                return;
        }
 
-       l2cap_pi(sk)->retry_count++;
+       chan->retry_count++;
        __mod_monitor_timer();
 
-       l2cap_send_rr_or_rnr(l2cap_pi(sk), L2CAP_CTRL_POLL);
+       l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_POLL);
        bh_unlock_sock(sk);
 }
 
 static void l2cap_retrans_timeout(unsigned long arg)
 {
-       struct sock *sk = (void *) arg;
+       struct l2cap_chan *chan = (void *) arg;
+       struct sock *sk = chan->sk;
 
-       BT_DBG("sk %p", sk);
+       BT_DBG("chan %p", chan);
 
        bh_lock_sock(sk);
-       l2cap_pi(sk)->retry_count = 1;
+       chan->retry_count = 1;
        __mod_monitor_timer();
 
-       l2cap_pi(sk)->conn_state |= L2CAP_CONN_WAIT_F;
+       chan->conn_state |= L2CAP_CONN_WAIT_F;
 
-       l2cap_send_rr_or_rnr(l2cap_pi(sk), L2CAP_CTRL_POLL);
+       l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_POLL);
        bh_unlock_sock(sk);
 }
 
-static void l2cap_drop_acked_frames(struct sock *sk)
+static void l2cap_drop_acked_frames(struct l2cap_chan *chan)
 {
        struct sk_buff *skb;
 
-       while ((skb = skb_peek(TX_QUEUE(sk))) &&
-                       l2cap_pi(sk)->unacked_frames) {
-               if (bt_cb(skb)->tx_seq == l2cap_pi(sk)->expected_ack_seq)
+       while ((skb = skb_peek(&chan->tx_q)) &&
+                       chan->unacked_frames) {
+               if (bt_cb(skb)->tx_seq == chan->expected_ack_seq)
                        break;
 
-               skb = skb_dequeue(TX_QUEUE(sk));
+               skb = skb_dequeue(&chan->tx_q);
                kfree_skb(skb);
 
-               l2cap_pi(sk)->unacked_frames--;
+               chan->unacked_frames--;
        }
 
-       if (!l2cap_pi(sk)->unacked_frames)
-               del_timer(&l2cap_pi(sk)->retrans_timer);
+       if (!chan->unacked_frames)
+               del_timer(&chan->retrans_timer);
 }
 
-static inline void l2cap_do_send(struct sock *sk, struct sk_buff *skb)
+void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
-       struct hci_conn *hcon = pi->conn->hcon;
+       struct hci_conn *hcon = chan->conn->hcon;
        u16 flags;
 
-       BT_DBG("sk %p, skb %p len %d", sk, skb, skb->len);
+       BT_DBG("chan %p, skb %p len %d", chan, skb, skb->len);
 
-       if (!pi->flushable && lmp_no_flush_capable(hcon->hdev))
+       if (!chan->flushable && lmp_no_flush_capable(hcon->hdev))
                flags = ACL_START_NO_FLUSH;
        else
                flags = ACL_START;
@@ -1095,35 +1023,33 @@ static inline void l2cap_do_send(struct sock *sk, struct sk_buff *skb)
        hci_send_acl(hcon, skb, flags);
 }
 
-static void l2cap_streaming_send(struct sock *sk)
+void l2cap_streaming_send(struct l2cap_chan *chan)
 {
        struct sk_buff *skb;
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        u16 control, fcs;
 
-       while ((skb = skb_dequeue(TX_QUEUE(sk)))) {
+       while ((skb = skb_dequeue(&chan->tx_q))) {
                control = get_unaligned_le16(skb->data + L2CAP_HDR_SIZE);
-               control |= pi->next_tx_seq << L2CAP_CTRL_TXSEQ_SHIFT;
+               control |= chan->next_tx_seq << L2CAP_CTRL_TXSEQ_SHIFT;
                put_unaligned_le16(control, skb->data + L2CAP_HDR_SIZE);
 
-               if (pi->fcs == L2CAP_FCS_CRC16) {
+               if (chan->fcs == L2CAP_FCS_CRC16) {
                        fcs = crc16(0, (u8 *)skb->data, skb->len - 2);
                        put_unaligned_le16(fcs, skb->data + skb->len - 2);
                }
 
-               l2cap_do_send(sk, skb);
+               l2cap_do_send(chan, skb);
 
-               pi->next_tx_seq = (pi->next_tx_seq + 1) % 64;
+               chan->next_tx_seq = (chan->next_tx_seq + 1) % 64;
        }
 }
 
-static void l2cap_retransmit_one_frame(struct sock *sk, u8 tx_seq)
+static void l2cap_retransmit_one_frame(struct l2cap_chan *chan, u8 tx_seq)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct sk_buff *skb, *tx_skb;
        u16 control, fcs;
 
-       skb = skb_peek(TX_QUEUE(sk));
+       skb = skb_peek(&chan->tx_q);
        if (!skb)
                return;
 
@@ -1131,54 +1057,55 @@ static void l2cap_retransmit_one_frame(struct sock *sk, u8 tx_seq)
                if (bt_cb(skb)->tx_seq == tx_seq)
                        break;
 
-               if (skb_queue_is_last(TX_QUEUE(sk), skb))
+               if (skb_queue_is_last(&chan->tx_q, skb))
                        return;
 
-       } while ((skb = skb_queue_next(TX_QUEUE(sk), skb)));
+       } while ((skb = skb_queue_next(&chan->tx_q, skb)));
 
-       if (pi->remote_max_tx &&
-                       bt_cb(skb)->retries == pi->remote_max_tx) {
-               l2cap_send_disconn_req(pi->conn, sk, ECONNABORTED);
+       if (chan->remote_max_tx &&
+                       bt_cb(skb)->retries == chan->remote_max_tx) {
+               l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED);
                return;
        }
 
        tx_skb = skb_clone(skb, GFP_ATOMIC);
        bt_cb(skb)->retries++;
        control = get_unaligned_le16(tx_skb->data + L2CAP_HDR_SIZE);
+       control &= L2CAP_CTRL_SAR;
 
-       if (pi->conn_state & L2CAP_CONN_SEND_FBIT) {
+       if (chan->conn_state & L2CAP_CONN_SEND_FBIT) {
                control |= L2CAP_CTRL_FINAL;
-               pi->conn_state &= ~L2CAP_CONN_SEND_FBIT;
+               chan->conn_state &= ~L2CAP_CONN_SEND_FBIT;
        }
 
-       control |= (pi->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
+       control |= (chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
                        | (tx_seq << L2CAP_CTRL_TXSEQ_SHIFT);
 
        put_unaligned_le16(control, tx_skb->data + L2CAP_HDR_SIZE);
 
-       if (pi->fcs == L2CAP_FCS_CRC16) {
+       if (chan->fcs == L2CAP_FCS_CRC16) {
                fcs = crc16(0, (u8 *)tx_skb->data, tx_skb->len - 2);
                put_unaligned_le16(fcs, tx_skb->data + tx_skb->len - 2);
        }
 
-       l2cap_do_send(sk, tx_skb);
+       l2cap_do_send(chan, tx_skb);
 }
 
-static int l2cap_ertm_send(struct sock *sk)
+int l2cap_ertm_send(struct l2cap_chan *chan)
 {
        struct sk_buff *skb, *tx_skb;
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
+       struct sock *sk = chan->sk;
        u16 control, fcs;
        int nsent = 0;
 
        if (sk->sk_state != BT_CONNECTED)
                return -ENOTCONN;
 
-       while ((skb = sk->sk_send_head) && (!l2cap_tx_window_full(sk))) {
+       while ((skb = chan->tx_send_head) && (!l2cap_tx_window_full(chan))) {
 
-               if (pi->remote_max_tx &&
-                               bt_cb(skb)->retries == pi->remote_max_tx) {
-                       l2cap_send_disconn_req(pi->conn, sk, ECONNABORTED);
+               if (chan->remote_max_tx &&
+                               bt_cb(skb)->retries == chan->remote_max_tx) {
+                       l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED);
                        break;
                }
 
@@ -1189,34 +1116,36 @@ static int l2cap_ertm_send(struct sock *sk)
                control = get_unaligned_le16(tx_skb->data + L2CAP_HDR_SIZE);
                control &= L2CAP_CTRL_SAR;
 
-               if (pi->conn_state & L2CAP_CONN_SEND_FBIT) {
+               if (chan->conn_state & L2CAP_CONN_SEND_FBIT) {
                        control |= L2CAP_CTRL_FINAL;
-                       pi->conn_state &= ~L2CAP_CONN_SEND_FBIT;
+                       chan->conn_state &= ~L2CAP_CONN_SEND_FBIT;
                }
-               control |= (pi->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
-                               | (pi->next_tx_seq << L2CAP_CTRL_TXSEQ_SHIFT);
+               control |= (chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
+                               | (chan->next_tx_seq << L2CAP_CTRL_TXSEQ_SHIFT);
                put_unaligned_le16(control, tx_skb->data + L2CAP_HDR_SIZE);
 
 
-               if (pi->fcs == L2CAP_FCS_CRC16) {
+               if (chan->fcs == L2CAP_FCS_CRC16) {
                        fcs = crc16(0, (u8 *)skb->data, tx_skb->len - 2);
                        put_unaligned_le16(fcs, skb->data + tx_skb->len - 2);
                }
 
-               l2cap_do_send(sk, tx_skb);
+               l2cap_do_send(chan, tx_skb);
 
                __mod_retrans_timer();
 
-               bt_cb(skb)->tx_seq = pi->next_tx_seq;
-               pi->next_tx_seq = (pi->next_tx_seq + 1) % 64;
+               bt_cb(skb)->tx_seq = chan->next_tx_seq;
+               chan->next_tx_seq = (chan->next_tx_seq + 1) % 64;
+
+               if (bt_cb(skb)->retries == 1)
+                       chan->unacked_frames++;
 
-               pi->unacked_frames++;
-               pi->frames_sent++;
+               chan->frames_sent++;
 
-               if (skb_queue_is_last(TX_QUEUE(sk), skb))
-                       sk->sk_send_head = NULL;
+               if (skb_queue_is_last(&chan->tx_q, skb))
+                       chan->tx_send_head = NULL;
                else
-                       sk->sk_send_head = skb_queue_next(TX_QUEUE(sk), skb);
+                       chan->tx_send_head = skb_queue_next(&chan->tx_q, skb);
 
                nsent++;
        }
@@ -1224,41 +1153,39 @@ static int l2cap_ertm_send(struct sock *sk)
        return nsent;
 }
 
-static int l2cap_retransmit_frames(struct sock *sk)
+static int l2cap_retransmit_frames(struct l2cap_chan *chan)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        int ret;
 
-       if (!skb_queue_empty(TX_QUEUE(sk)))
-               sk->sk_send_head = TX_QUEUE(sk)->next;
+       if (!skb_queue_empty(&chan->tx_q))
+               chan->tx_send_head = chan->tx_q.next;
 
-       pi->next_tx_seq = pi->expected_ack_seq;
-       ret = l2cap_ertm_send(sk);
+       chan->next_tx_seq = chan->expected_ack_seq;
+       ret = l2cap_ertm_send(chan);
        return ret;
 }
 
-static void l2cap_send_ack(struct l2cap_pinfo *pi)
+static void l2cap_send_ack(struct l2cap_chan *chan)
 {
-       struct sock *sk = (struct sock *)pi;
        u16 control = 0;
 
-       control |= pi->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
+       control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
 
-       if (pi->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
                control |= L2CAP_SUPER_RCV_NOT_READY;
-               pi->conn_state |= L2CAP_CONN_RNR_SENT;
-               l2cap_send_sframe(pi, control);
+               chan->conn_state |= L2CAP_CONN_RNR_SENT;
+               l2cap_send_sframe(chan, control);
                return;
        }
 
-       if (l2cap_ertm_send(sk) > 0)
+       if (l2cap_ertm_send(chan) > 0)
                return;
 
        control |= L2CAP_SUPER_RCV_READY;
-       l2cap_send_sframe(pi, control);
+       l2cap_send_sframe(chan, control);
 }
 
-static void l2cap_send_srejtail(struct sock *sk)
+static void l2cap_send_srejtail(struct l2cap_chan *chan)
 {
        struct srej_list *tail;
        u16 control;
@@ -1266,15 +1193,15 @@ static void l2cap_send_srejtail(struct sock *sk)
        control = L2CAP_SUPER_SELECT_REJECT;
        control |= L2CAP_CTRL_FINAL;
 
-       tail = list_entry(SREJ_LIST(sk)->prev, struct srej_list, list);
+       tail = list_entry((&chan->srej_l)->prev, struct srej_list, list);
        control |= tail->tx_seq << L2CAP_CTRL_REQSEQ_SHIFT;
 
-       l2cap_send_sframe(l2cap_pi(sk), control);
+       l2cap_send_sframe(chan, control);
 }
 
 static inline int l2cap_skbuff_fromiovec(struct sock *sk, struct msghdr *msg, int len, int count, struct sk_buff *skb)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+       struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
        struct sk_buff **frag;
        int err, sent = 0;
 
@@ -1304,9 +1231,10 @@ static inline int l2cap_skbuff_fromiovec(struct sock *sk, struct msghdr *msg, in
        return sent;
 }
 
-static struct sk_buff *l2cap_create_connless_pdu(struct sock *sk, struct msghdr *msg, size_t len)
+struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+       struct sock *sk = chan->sk;
+       struct l2cap_conn *conn = chan->conn;
        struct sk_buff *skb;
        int err, count, hlen = L2CAP_HDR_SIZE + 2;
        struct l2cap_hdr *lh;
@@ -1321,9 +1249,9 @@ static struct sk_buff *l2cap_create_connless_pdu(struct sock *sk, struct msghdr
 
        /* Create L2CAP header */
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
-       lh->cid = cpu_to_le16(l2cap_pi(sk)->dcid);
+       lh->cid = cpu_to_le16(chan->dcid);
        lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
-       put_unaligned_le16(l2cap_pi(sk)->psm, skb_put(skb, 2));
+       put_unaligned_le16(chan->psm, skb_put(skb, 2));
 
        err = l2cap_skbuff_fromiovec(sk, msg, len, count, skb);
        if (unlikely(err < 0)) {
@@ -1333,9 +1261,10 @@ static struct sk_buff *l2cap_create_connless_pdu(struct sock *sk, struct msghdr
        return skb;
 }
 
-static struct sk_buff *l2cap_create_basic_pdu(struct sock *sk, struct msghdr *msg, size_t len)
+struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+       struct sock *sk = chan->sk;
+       struct l2cap_conn *conn = chan->conn;
        struct sk_buff *skb;
        int err, count, hlen = L2CAP_HDR_SIZE;
        struct l2cap_hdr *lh;
@@ -1350,7 +1279,7 @@ static struct sk_buff *l2cap_create_basic_pdu(struct sock *sk, struct msghdr *ms
 
        /* Create L2CAP header */
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
-       lh->cid = cpu_to_le16(l2cap_pi(sk)->dcid);
+       lh->cid = cpu_to_le16(chan->dcid);
        lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
 
        err = l2cap_skbuff_fromiovec(sk, msg, len, count, skb);
@@ -1361,9 +1290,10 @@ static struct sk_buff *l2cap_create_basic_pdu(struct sock *sk, struct msghdr *ms
        return skb;
 }
 
-static struct sk_buff *l2cap_create_iframe_pdu(struct sock *sk, struct msghdr *msg, size_t len, u16 control, u16 sdulen)
+struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len, u16 control, u16 sdulen)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+       struct sock *sk = chan->sk;
+       struct l2cap_conn *conn = chan->conn;
        struct sk_buff *skb;
        int err, count, hlen = L2CAP_HDR_SIZE + 2;
        struct l2cap_hdr *lh;
@@ -1376,7 +1306,7 @@ static struct sk_buff *l2cap_create_iframe_pdu(struct sock *sk, struct msghdr *m
        if (sdulen)
                hlen += 2;
 
-       if (l2cap_pi(sk)->fcs == L2CAP_FCS_CRC16)
+       if (chan->fcs == L2CAP_FCS_CRC16)
                hlen += 2;
 
        count = min_t(unsigned int, (conn->mtu - hlen), len);
@@ -1387,7 +1317,7 @@ static struct sk_buff *l2cap_create_iframe_pdu(struct sock *sk, struct msghdr *m
 
        /* Create L2CAP header */
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
-       lh->cid = cpu_to_le16(l2cap_pi(sk)->dcid);
+       lh->cid = cpu_to_le16(chan->dcid);
        lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
        put_unaligned_le16(control, skb_put(skb, 2));
        if (sdulen)
@@ -1399,16 +1329,15 @@ static struct sk_buff *l2cap_create_iframe_pdu(struct sock *sk, struct msghdr *m
                return ERR_PTR(err);
        }
 
-       if (l2cap_pi(sk)->fcs == L2CAP_FCS_CRC16)
+       if (chan->fcs == L2CAP_FCS_CRC16)
                put_unaligned_le16(0, skb_put(skb, 2));
 
        bt_cb(skb)->retries = 0;
        return skb;
 }
 
-static inline int l2cap_sar_segment_sdu(struct sock *sk, struct msghdr *msg, size_t len)
+int l2cap_sar_segment_sdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct sk_buff *skb;
        struct sk_buff_head sar_queue;
        u16 control;
@@ -1416,26 +1345,26 @@ static inline int l2cap_sar_segment_sdu(struct sock *sk, struct msghdr *msg, siz
 
        skb_queue_head_init(&sar_queue);
        control = L2CAP_SDU_START;
-       skb = l2cap_create_iframe_pdu(sk, msg, pi->remote_mps, control, len);
+       skb = l2cap_create_iframe_pdu(chan, msg, chan->remote_mps, control, len);
        if (IS_ERR(skb))
                return PTR_ERR(skb);
 
        __skb_queue_tail(&sar_queue, skb);
-       len -= pi->remote_mps;
-       size += pi->remote_mps;
+       len -= chan->remote_mps;
+       size += chan->remote_mps;
 
        while (len > 0) {
                size_t buflen;
 
-               if (len > pi->remote_mps) {
+               if (len > chan->remote_mps) {
                        control = L2CAP_SDU_CONTINUE;
-                       buflen = pi->remote_mps;
+                       buflen = chan->remote_mps;
                } else {
                        control = L2CAP_SDU_END;
                        buflen = len;
                }
 
-               skb = l2cap_create_iframe_pdu(sk, msg, buflen, control, 0);
+               skb = l2cap_create_iframe_pdu(chan, msg, buflen, control, 0);
                if (IS_ERR(skb)) {
                        skb_queue_purge(&sar_queue);
                        return PTR_ERR(skb);
@@ -1445,514 +1374,21 @@ static inline int l2cap_sar_segment_sdu(struct sock *sk, struct msghdr *msg, siz
                len -= buflen;
                size += buflen;
        }
-       skb_queue_splice_tail(&sar_queue, TX_QUEUE(sk));
-       if (sk->sk_send_head == NULL)
-               sk->sk_send_head = sar_queue.next;
+       skb_queue_splice_tail(&sar_queue, &chan->tx_q);
+       if (chan->tx_send_head == NULL)
+               chan->tx_send_head = sar_queue.next;
 
        return size;
 }
 
-int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
-{
-       struct sock *sk = sock->sk;
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
-       struct sk_buff *skb;
-       u16 control;
-       int err;
-
-       BT_DBG("sock %p, sk %p", sock, sk);
-
-       err = sock_error(sk);
-       if (err)
-               return err;
-
-       if (msg->msg_flags & MSG_OOB)
-               return -EOPNOTSUPP;
-
-       lock_sock(sk);
-
-       if (sk->sk_state != BT_CONNECTED) {
-               err = -ENOTCONN;
-               goto done;
-       }
-
-       /* Connectionless channel */
-       if (sk->sk_type == SOCK_DGRAM) {
-               skb = l2cap_create_connless_pdu(sk, msg, len);
-               if (IS_ERR(skb)) {
-                       err = PTR_ERR(skb);
-               } else {
-                       l2cap_do_send(sk, skb);
-                       err = len;
-               }
-               goto done;
-       }
-
-       switch (pi->mode) {
-       case L2CAP_MODE_BASIC:
-               /* Check outgoing MTU */
-               if (len > pi->omtu) {
-                       err = -EMSGSIZE;
-                       goto done;
-               }
-
-               /* Create a basic PDU */
-               skb = l2cap_create_basic_pdu(sk, msg, len);
-               if (IS_ERR(skb)) {
-                       err = PTR_ERR(skb);
-                       goto done;
-               }
-
-               l2cap_do_send(sk, skb);
-               err = len;
-               break;
-
-       case L2CAP_MODE_ERTM:
-       case L2CAP_MODE_STREAMING:
-               /* Entire SDU fits into one PDU */
-               if (len <= pi->remote_mps) {
-                       control = L2CAP_SDU_UNSEGMENTED;
-                       skb = l2cap_create_iframe_pdu(sk, msg, len, control, 0);
-                       if (IS_ERR(skb)) {
-                               err = PTR_ERR(skb);
-                               goto done;
-                       }
-                       __skb_queue_tail(TX_QUEUE(sk), skb);
-
-                       if (sk->sk_send_head == NULL)
-                               sk->sk_send_head = skb;
-
-               } else {
-               /* Segment SDU into multiples PDUs */
-                       err = l2cap_sar_segment_sdu(sk, msg, len);
-                       if (err < 0)
-                               goto done;
-               }
-
-               if (pi->mode == L2CAP_MODE_STREAMING) {
-                       l2cap_streaming_send(sk);
-               } else {
-                       if ((pi->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
-                                       (pi->conn_state & L2CAP_CONN_WAIT_F)) {
-                               err = len;
-                               break;
-                       }
-                       err = l2cap_ertm_send(sk);
-               }
-
-               if (err >= 0)
-                       err = len;
-               break;
-
-       default:
-               BT_DBG("bad state %1.1x", pi->mode);
-               err = -EBADFD;
-       }
-
-done:
-       release_sock(sk);
-       return err;
-}
-
-int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
-{
-       struct sock *sk = sock->sk;
-
-       lock_sock(sk);
-
-       if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
-               struct l2cap_conn_rsp rsp;
-               struct l2cap_conn *conn = l2cap_pi(sk)->conn;
-               u8 buf[128];
-
-               sk->sk_state = BT_CONFIG;
-
-               rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
-               rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
-               rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
-               rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
-               l2cap_send_cmd(l2cap_pi(sk)->conn, l2cap_pi(sk)->ident,
-                                       L2CAP_CONN_RSP, sizeof(rsp), &rsp);
-
-               if (l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT) {
-                       release_sock(sk);
-                       return 0;
-               }
-
-               l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
-               l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
-                               l2cap_build_conf_req(sk, buf), buf);
-               l2cap_pi(sk)->num_conf_req++;
-
-               release_sock(sk);
-               return 0;
-       }
-
-       release_sock(sk);
-
-       if (sock->type == SOCK_STREAM)
-               return bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
-
-       return bt_sock_recvmsg(iocb, sock, msg, len, flags);
-}
-
-static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
-{
-       struct sock *sk = sock->sk;
-       struct l2cap_options opts;
-       int len, err = 0;
-       u32 opt;
-
-       BT_DBG("sk %p", sk);
-
-       lock_sock(sk);
-
-       switch (optname) {
-       case L2CAP_OPTIONS:
-               if (sk->sk_state == BT_CONNECTED) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               opts.imtu     = l2cap_pi(sk)->imtu;
-               opts.omtu     = l2cap_pi(sk)->omtu;
-               opts.flush_to = l2cap_pi(sk)->flush_to;
-               opts.mode     = l2cap_pi(sk)->mode;
-               opts.fcs      = l2cap_pi(sk)->fcs;
-               opts.max_tx   = l2cap_pi(sk)->max_tx;
-               opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
-
-               len = min_t(unsigned int, sizeof(opts), optlen);
-               if (copy_from_user((char *) &opts, optval, len)) {
-                       err = -EFAULT;
-                       break;
-               }
-
-               if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               l2cap_pi(sk)->mode = opts.mode;
-               switch (l2cap_pi(sk)->mode) {
-               case L2CAP_MODE_BASIC:
-                       l2cap_pi(sk)->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
-                       break;
-               case L2CAP_MODE_ERTM:
-               case L2CAP_MODE_STREAMING:
-                       if (!disable_ertm)
-                               break;
-                       /* fall through */
-               default:
-                       err = -EINVAL;
-                       break;
-               }
-
-               l2cap_pi(sk)->imtu = opts.imtu;
-               l2cap_pi(sk)->omtu = opts.omtu;
-               l2cap_pi(sk)->fcs  = opts.fcs;
-               l2cap_pi(sk)->max_tx = opts.max_tx;
-               l2cap_pi(sk)->tx_win = (__u8)opts.txwin_size;
-               break;
-
-       case L2CAP_LM:
-               if (get_user(opt, (u32 __user *) optval)) {
-                       err = -EFAULT;
-                       break;
-               }
-
-               if (opt & L2CAP_LM_AUTH)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_LOW;
-               if (opt & L2CAP_LM_ENCRYPT)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
-               if (opt & L2CAP_LM_SECURE)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_HIGH;
-
-               l2cap_pi(sk)->role_switch    = (opt & L2CAP_LM_MASTER);
-               l2cap_pi(sk)->force_reliable = (opt & L2CAP_LM_RELIABLE);
-               break;
-
-       default:
-               err = -ENOPROTOOPT;
-               break;
-       }
-
-       release_sock(sk);
-       return err;
-}
-
-int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
-{
-       struct sock *sk = sock->sk;
-       struct bt_security sec;
-       int len, err = 0;
-       u32 opt;
-
-       BT_DBG("sk %p", sk);
-
-       if (level == SOL_L2CAP)
-               return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
-
-       if (level != SOL_BLUETOOTH)
-               return -ENOPROTOOPT;
-
-       lock_sock(sk);
-
-       switch (optname) {
-       case BT_SECURITY:
-               if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
-                               && sk->sk_type != SOCK_RAW) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               sec.level = BT_SECURITY_LOW;
-
-               len = min_t(unsigned int, sizeof(sec), optlen);
-               if (copy_from_user((char *) &sec, optval, len)) {
-                       err = -EFAULT;
-                       break;
-               }
-
-               if (sec.level < BT_SECURITY_LOW ||
-                                       sec.level > BT_SECURITY_HIGH) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               l2cap_pi(sk)->sec_level = sec.level;
-               break;
-
-       case BT_DEFER_SETUP:
-               if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               if (get_user(opt, (u32 __user *) optval)) {
-                       err = -EFAULT;
-                       break;
-               }
-
-               bt_sk(sk)->defer_setup = opt;
-               break;
-
-       case BT_FLUSHABLE:
-               if (get_user(opt, (u32 __user *) optval)) {
-                       err = -EFAULT;
-                       break;
-               }
-
-               if (opt > BT_FLUSHABLE_ON) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               if (opt == BT_FLUSHABLE_OFF) {
-                       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
-                       /* proceed futher only when we have l2cap_conn and
-                          No Flush support in the LM */
-                       if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
-                               err = -EINVAL;
-                               break;
-                       }
-               }
-
-               l2cap_pi(sk)->flushable = opt;
-               break;
-
-       default:
-               err = -ENOPROTOOPT;
-               break;
-       }
-
-       release_sock(sk);
-       return err;
-}
-
-static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
-{
-       struct sock *sk = sock->sk;
-       struct l2cap_options opts;
-       struct l2cap_conninfo cinfo;
-       int len, err = 0;
-       u32 opt;
-
-       BT_DBG("sk %p", sk);
-
-       if (get_user(len, optlen))
-               return -EFAULT;
-
-       lock_sock(sk);
-
-       switch (optname) {
-       case L2CAP_OPTIONS:
-               opts.imtu     = l2cap_pi(sk)->imtu;
-               opts.omtu     = l2cap_pi(sk)->omtu;
-               opts.flush_to = l2cap_pi(sk)->flush_to;
-               opts.mode     = l2cap_pi(sk)->mode;
-               opts.fcs      = l2cap_pi(sk)->fcs;
-               opts.max_tx   = l2cap_pi(sk)->max_tx;
-               opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
-
-               len = min_t(unsigned int, len, sizeof(opts));
-               if (copy_to_user(optval, (char *) &opts, len))
-                       err = -EFAULT;
-
-               break;
-
-       case L2CAP_LM:
-               switch (l2cap_pi(sk)->sec_level) {
-               case BT_SECURITY_LOW:
-                       opt = L2CAP_LM_AUTH;
-                       break;
-               case BT_SECURITY_MEDIUM:
-                       opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
-                       break;
-               case BT_SECURITY_HIGH:
-                       opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
-                                                       L2CAP_LM_SECURE;
-                       break;
-               default:
-                       opt = 0;
-                       break;
-               }
-
-               if (l2cap_pi(sk)->role_switch)
-                       opt |= L2CAP_LM_MASTER;
-
-               if (l2cap_pi(sk)->force_reliable)
-                       opt |= L2CAP_LM_RELIABLE;
-
-               if (put_user(opt, (u32 __user *) optval))
-                       err = -EFAULT;
-               break;
-
-       case L2CAP_CONNINFO:
-               if (sk->sk_state != BT_CONNECTED &&
-                                       !(sk->sk_state == BT_CONNECT2 &&
-                                               bt_sk(sk)->defer_setup)) {
-                       err = -ENOTCONN;
-                       break;
-               }
-
-               cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;
-               memcpy(cinfo.dev_class, l2cap_pi(sk)->conn->hcon->dev_class, 3);
-
-               len = min_t(unsigned int, len, sizeof(cinfo));
-               if (copy_to_user(optval, (char *) &cinfo, len))
-                       err = -EFAULT;
-
-               break;
-
-       default:
-               err = -ENOPROTOOPT;
-               break;
-       }
-
-       release_sock(sk);
-       return err;
-}
-
-int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
-{
-       struct sock *sk = sock->sk;
-       struct bt_security sec;
-       int len, err = 0;
-
-       BT_DBG("sk %p", sk);
-
-       if (level == SOL_L2CAP)
-               return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
-
-       if (level != SOL_BLUETOOTH)
-               return -ENOPROTOOPT;
-
-       if (get_user(len, optlen))
-               return -EFAULT;
-
-       lock_sock(sk);
-
-       switch (optname) {
-       case BT_SECURITY:
-               if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
-                               && sk->sk_type != SOCK_RAW) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               sec.level = l2cap_pi(sk)->sec_level;
-
-               len = min_t(unsigned int, len, sizeof(sec));
-               if (copy_to_user(optval, (char *) &sec, len))
-                       err = -EFAULT;
-
-               break;
-
-       case BT_DEFER_SETUP:
-               if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
-                       err = -EINVAL;
-                       break;
-               }
-
-               if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
-                       err = -EFAULT;
-
-               break;
-
-       case BT_FLUSHABLE:
-               if (put_user(l2cap_pi(sk)->flushable, (u32 __user *) optval))
-                       err = -EFAULT;
-
-               break;
-
-       default:
-               err = -ENOPROTOOPT;
-               break;
-       }
-
-       release_sock(sk);
-       return err;
-}
-
-int l2cap_sock_shutdown(struct socket *sock, int how)
-{
-       struct sock *sk = sock->sk;
-       int err = 0;
-
-       BT_DBG("sock %p, sk %p", sock, sk);
-
-       if (!sk)
-               return 0;
-
-       lock_sock(sk);
-       if (!sk->sk_shutdown) {
-               if (l2cap_pi(sk)->mode == L2CAP_MODE_ERTM)
-                       err = __l2cap_wait_ack(sk);
-
-               sk->sk_shutdown = SHUTDOWN_MASK;
-               l2cap_sock_clear_timer(sk);
-               __l2cap_sock_close(sk, 0);
-
-               if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
-                       err = bt_sock_wait_state(sk, BT_CLOSED,
-                                                       sk->sk_lingertime);
-       }
-
-       if (!err && sk->sk_err)
-               err = -sk->sk_err;
-
-       release_sock(sk);
-       return err;
-}
-
 static void l2cap_chan_ready(struct sock *sk)
 {
        struct sock *parent = bt_sk(sk)->parent;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 
        BT_DBG("sk %p, parent %p", sk, parent);
 
-       l2cap_pi(sk)->conf_state = 0;
+       chan->conf_state = 0;
        l2cap_sock_clear_timer(sk);
 
        if (!parent) {
@@ -1972,14 +1408,14 @@ static void l2cap_chan_ready(struct sock *sk)
 /* Copy frame to all raw sockets on that connection */
 static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
 {
-       struct l2cap_chan_list *l = &conn->chan_list;
        struct sk_buff *nskb;
-       struct sock *sk;
+       struct l2cap_chan *chan;
 
        BT_DBG("conn %p", conn);
 
-       read_lock(&l->lock);
-       for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
+       read_lock(&conn->chan_lock);
+       list_for_each_entry(chan, &conn->chan_l, list) {
+               struct sock *sk = chan->sk;
                if (sk->sk_type != SOCK_RAW)
                        continue;
 
@@ -1993,7 +1429,7 @@ static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
                if (sock_queue_rcv_skb(sk, nskb))
                        kfree_skb(nskb);
        }
-       read_unlock(&l->lock);
+       read_unlock(&conn->chan_lock);
 }
 
 /* ---- L2CAP signalling commands ---- */
@@ -2017,7 +1453,11 @@ static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
 
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
        lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen);
-       lh->cid = cpu_to_le16(L2CAP_CID_SIGNALING);
+
+       if (conn->hcon->type == LE_LINK)
+               lh->cid = cpu_to_le16(L2CAP_CID_LE_SIGNALING);
+       else
+               lh->cid = cpu_to_le16(L2CAP_CID_SIGNALING);
 
        cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE);
        cmd->code  = code;
@@ -2121,32 +1561,35 @@ static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val)
 
 static void l2cap_ack_timeout(unsigned long arg)
 {
-       struct sock *sk = (void *) arg;
+       struct l2cap_chan *chan = (void *) arg;
 
-       bh_lock_sock(sk);
-       l2cap_send_ack(l2cap_pi(sk));
-       bh_unlock_sock(sk);
+       bh_lock_sock(chan->sk);
+       l2cap_send_ack(chan);
+       bh_unlock_sock(chan->sk);
 }
 
-static inline void l2cap_ertm_init(struct sock *sk)
+static inline void l2cap_ertm_init(struct l2cap_chan *chan)
 {
-       l2cap_pi(sk)->expected_ack_seq = 0;
-       l2cap_pi(sk)->unacked_frames = 0;
-       l2cap_pi(sk)->buffer_seq = 0;
-       l2cap_pi(sk)->num_acked = 0;
-       l2cap_pi(sk)->frames_sent = 0;
+       struct sock *sk = chan->sk;
 
-       setup_timer(&l2cap_pi(sk)->retrans_timer,
-                       l2cap_retrans_timeout, (unsigned long) sk);
-       setup_timer(&l2cap_pi(sk)->monitor_timer,
-                       l2cap_monitor_timeout, (unsigned long) sk);
-       setup_timer(&l2cap_pi(sk)->ack_timer,
-                       l2cap_ack_timeout, (unsigned long) sk);
+       chan->expected_ack_seq = 0;
+       chan->unacked_frames = 0;
+       chan->buffer_seq = 0;
+       chan->num_acked = 0;
+       chan->frames_sent = 0;
 
-       __skb_queue_head_init(SREJ_QUEUE(sk));
-       __skb_queue_head_init(BUSY_QUEUE(sk));
+       setup_timer(&chan->retrans_timer, l2cap_retrans_timeout,
+                                                       (unsigned long) chan);
+       setup_timer(&chan->monitor_timer, l2cap_monitor_timeout,
+                                                       (unsigned long) chan);
+       setup_timer(&chan->ack_timer, l2cap_ack_timeout, (unsigned long) chan);
 
-       INIT_WORK(&l2cap_pi(sk)->busy_work, l2cap_busy_work);
+       skb_queue_head_init(&chan->srej_q);
+       skb_queue_head_init(&chan->busy_q);
+
+       INIT_LIST_HEAD(&chan->srej_l);
+
+       INIT_WORK(&chan->busy_work, l2cap_busy_work);
 
        sk->sk_backlog_rcv = l2cap_ertm_data_rcv;
 }
@@ -2164,38 +1607,37 @@ static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask)
        }
 }
 
-static int l2cap_build_conf_req(struct sock *sk, void *data)
+static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct l2cap_conf_req *req = data;
-       struct l2cap_conf_rfc rfc = { .mode = pi->mode };
+       struct l2cap_conf_rfc rfc = { .mode = chan->mode };
        void *ptr = req->data;
 
-       BT_DBG("sk %p", sk);
+       BT_DBG("chan %p", chan);
 
-       if (pi->num_conf_req || pi->num_conf_rsp)
+       if (chan->num_conf_req || chan->num_conf_rsp)
                goto done;
 
-       switch (pi->mode) {
+       switch (chan->mode) {
        case L2CAP_MODE_STREAMING:
        case L2CAP_MODE_ERTM:
-               if (pi->conf_state & L2CAP_CONF_STATE2_DEVICE)
+               if (chan->conf_state & L2CAP_CONF_STATE2_DEVICE)
                        break;
 
                /* fall through */
        default:
-               pi->mode = l2cap_select_mode(rfc.mode, pi->conn->feat_mask);
+               chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask);
                break;
        }
 
 done:
-       if (pi->imtu != L2CAP_DEFAULT_MTU)
-               l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, pi->imtu);
+       if (chan->imtu != L2CAP_DEFAULT_MTU)
+               l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);
 
-       switch (pi->mode) {
+       switch (chan->mode) {
        case L2CAP_MODE_BASIC:
-               if (!(pi->conn->feat_mask & L2CAP_FEAT_ERTM) &&
-                               !(pi->conn->feat_mask & L2CAP_FEAT_STREAMING))
+               if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) &&
+                               !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING))
                        break;
 
                rfc.mode            = L2CAP_MODE_BASIC;
@@ -2211,24 +1653,24 @@ done:
 
        case L2CAP_MODE_ERTM:
                rfc.mode            = L2CAP_MODE_ERTM;
-               rfc.txwin_size      = pi->tx_win;
-               rfc.max_transmit    = pi->max_tx;
+               rfc.txwin_size      = chan->tx_win;
+               rfc.max_transmit    = chan->max_tx;
                rfc.retrans_timeout = 0;
                rfc.monitor_timeout = 0;
                rfc.max_pdu_size    = cpu_to_le16(L2CAP_DEFAULT_MAX_PDU_SIZE);
-               if (L2CAP_DEFAULT_MAX_PDU_SIZE > pi->conn->mtu - 10)
-                       rfc.max_pdu_size = cpu_to_le16(pi->conn->mtu - 10);
+               if (L2CAP_DEFAULT_MAX_PDU_SIZE > chan->conn->mtu - 10)
+                       rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
 
                l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
                                                        (unsigned long) &rfc);
 
-               if (!(pi->conn->feat_mask & L2CAP_FEAT_FCS))
+               if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS))
                        break;
 
-               if (pi->fcs == L2CAP_FCS_NONE ||
-                               pi->conf_state & L2CAP_CONF_NO_FCS_RECV) {
-                       pi->fcs = L2CAP_FCS_NONE;
-                       l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, pi->fcs);
+               if (chan->fcs == L2CAP_FCS_NONE ||
+                               chan->conf_state & L2CAP_CONF_NO_FCS_RECV) {
+                       chan->fcs = L2CAP_FCS_NONE;
+                       l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs);
                }
                break;
 
@@ -2239,47 +1681,42 @@ done:
                rfc.retrans_timeout = 0;
                rfc.monitor_timeout = 0;
                rfc.max_pdu_size    = cpu_to_le16(L2CAP_DEFAULT_MAX_PDU_SIZE);
-               if (L2CAP_DEFAULT_MAX_PDU_SIZE > pi->conn->mtu - 10)
-                       rfc.max_pdu_size = cpu_to_le16(pi->conn->mtu - 10);
+               if (L2CAP_DEFAULT_MAX_PDU_SIZE > chan->conn->mtu - 10)
+                       rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
 
                l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
                                                        (unsigned long) &rfc);
 
-               if (!(pi->conn->feat_mask & L2CAP_FEAT_FCS))
+               if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS))
                        break;
 
-               if (pi->fcs == L2CAP_FCS_NONE ||
-                               pi->conf_state & L2CAP_CONF_NO_FCS_RECV) {
-                       pi->fcs = L2CAP_FCS_NONE;
-                       l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, pi->fcs);
+               if (chan->fcs == L2CAP_FCS_NONE ||
+                               chan->conf_state & L2CAP_CONF_NO_FCS_RECV) {
+                       chan->fcs = L2CAP_FCS_NONE;
+                       l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs);
                }
                break;
        }
 
-       /* FIXME: Need actual value of the flush timeout */
-       //if (flush_to != L2CAP_DEFAULT_FLUSH_TO)
-       //   l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 2, pi->flush_to);
-
-       req->dcid  = cpu_to_le16(pi->dcid);
+       req->dcid  = cpu_to_le16(chan->dcid);
        req->flags = cpu_to_le16(0);
 
        return ptr - data;
 }
 
-static int l2cap_parse_conf_req(struct sock *sk, void *data)
+static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct l2cap_conf_rsp *rsp = data;
        void *ptr = rsp->data;
-       void *req = pi->conf_req;
-       int len = pi->conf_len;
+       void *req = chan->conf_req;
+       int len = chan->conf_len;
        int type, hint, olen;
        unsigned long val;
        struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC };
        u16 mtu = L2CAP_DEFAULT_MTU;
        u16 result = L2CAP_CONF_SUCCESS;
 
-       BT_DBG("sk %p", sk);
+       BT_DBG("chan %p", chan);
 
        while (len >= L2CAP_CONF_OPT_SIZE) {
                len -= l2cap_get_conf_opt(&req, &type, &olen, &val);
@@ -2293,7 +1730,7 @@ static int l2cap_parse_conf_req(struct sock *sk, void *data)
                        break;
 
                case L2CAP_CONF_FLUSH_TO:
-                       pi->flush_to = val;
+                       chan->flush_to = val;
                        break;
 
                case L2CAP_CONF_QOS:
@@ -2306,7 +1743,7 @@ static int l2cap_parse_conf_req(struct sock *sk, void *data)
 
                case L2CAP_CONF_FCS:
                        if (val == L2CAP_FCS_NONE)
-                               pi->conf_state |= L2CAP_CONF_NO_FCS_RECV;
+                               chan->conf_state |= L2CAP_CONF_NO_FCS_RECV;
 
                        break;
 
@@ -2320,30 +1757,30 @@ static int l2cap_parse_conf_req(struct sock *sk, void *data)
                }
        }
 
-       if (pi->num_conf_rsp || pi->num_conf_req > 1)
+       if (chan->num_conf_rsp || chan->num_conf_req > 1)
                goto done;
 
-       switch (pi->mode) {
+       switch (chan->mode) {
        case L2CAP_MODE_STREAMING:
        case L2CAP_MODE_ERTM:
-               if (!(pi->conf_state & L2CAP_CONF_STATE2_DEVICE)) {
-                       pi->mode = l2cap_select_mode(rfc.mode,
-                                       pi->conn->feat_mask);
+               if (!(chan->conf_state & L2CAP_CONF_STATE2_DEVICE)) {
+                       chan->mode = l2cap_select_mode(rfc.mode,
+                                       chan->conn->feat_mask);
                        break;
                }
 
-               if (pi->mode != rfc.mode)
+               if (chan->mode != rfc.mode)
                        return -ECONNREFUSED;
 
                break;
        }
 
 done:
-       if (pi->mode != rfc.mode) {
+       if (chan->mode != rfc.mode) {
                result = L2CAP_CONF_UNACCEPT;
-               rfc.mode = pi->mode;
+               rfc.mode = chan->mode;
 
-               if (pi->num_conf_rsp == 1)
+               if (chan->num_conf_rsp == 1)
                        return -ECONNREFUSED;
 
                l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
@@ -2358,32 +1795,32 @@ done:
                if (mtu < L2CAP_DEFAULT_MIN_MTU)
                        result = L2CAP_CONF_UNACCEPT;
                else {
-                       pi->omtu = mtu;
-                       pi->conf_state |= L2CAP_CONF_MTU_DONE;
+                       chan->omtu = mtu;
+                       chan->conf_state |= L2CAP_CONF_MTU_DONE;
                }
-               l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, pi->omtu);
+               l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu);
 
                switch (rfc.mode) {
                case L2CAP_MODE_BASIC:
-                       pi->fcs = L2CAP_FCS_NONE;
-                       pi->conf_state |= L2CAP_CONF_MODE_DONE;
+                       chan->fcs = L2CAP_FCS_NONE;
+                       chan->conf_state |= L2CAP_CONF_MODE_DONE;
                        break;
 
                case L2CAP_MODE_ERTM:
-                       pi->remote_tx_win = rfc.txwin_size;
-                       pi->remote_max_tx = rfc.max_transmit;
+                       chan->remote_tx_win = rfc.txwin_size;
+                       chan->remote_max_tx = rfc.max_transmit;
 
-                       if (le16_to_cpu(rfc.max_pdu_size) > pi->conn->mtu - 10)
-                               rfc.max_pdu_size = cpu_to_le16(pi->conn->mtu - 10);
+                       if (le16_to_cpu(rfc.max_pdu_size) > chan->conn->mtu - 10)
+                               rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
 
-                       pi->remote_mps = le16_to_cpu(rfc.max_pdu_size);
+                       chan->remote_mps = le16_to_cpu(rfc.max_pdu_size);
 
                        rfc.retrans_timeout =
                                le16_to_cpu(L2CAP_DEFAULT_RETRANS_TO);
                        rfc.monitor_timeout =
                                le16_to_cpu(L2CAP_DEFAULT_MONITOR_TO);
 
-                       pi->conf_state |= L2CAP_CONF_MODE_DONE;
+                       chan->conf_state |= L2CAP_CONF_MODE_DONE;
 
                        l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
                                        sizeof(rfc), (unsigned long) &rfc);
@@ -2391,12 +1828,12 @@ done:
                        break;
 
                case L2CAP_MODE_STREAMING:
-                       if (le16_to_cpu(rfc.max_pdu_size) > pi->conn->mtu - 10)
-                               rfc.max_pdu_size = cpu_to_le16(pi->conn->mtu - 10);
+                       if (le16_to_cpu(rfc.max_pdu_size) > chan->conn->mtu - 10)
+                               rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
 
-                       pi->remote_mps = le16_to_cpu(rfc.max_pdu_size);
+                       chan->remote_mps = le16_to_cpu(rfc.max_pdu_size);
 
-                       pi->conf_state |= L2CAP_CONF_MODE_DONE;
+                       chan->conf_state |= L2CAP_CONF_MODE_DONE;
 
                        l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
                                        sizeof(rfc), (unsigned long) &rfc);
@@ -2407,29 +1844,28 @@ done:
                        result = L2CAP_CONF_UNACCEPT;
 
                        memset(&rfc, 0, sizeof(rfc));
-                       rfc.mode = pi->mode;
+                       rfc.mode = chan->mode;
                }
 
                if (result == L2CAP_CONF_SUCCESS)
-                       pi->conf_state |= L2CAP_CONF_OUTPUT_DONE;
+                       chan->conf_state |= L2CAP_CONF_OUTPUT_DONE;
        }
-       rsp->scid   = cpu_to_le16(pi->dcid);
+       rsp->scid   = cpu_to_le16(chan->dcid);
        rsp->result = cpu_to_le16(result);
        rsp->flags  = cpu_to_le16(0x0000);
 
        return ptr - data;
 }
 
-static int l2cap_parse_conf_rsp(struct sock *sk, void *rsp, int len, void *data, u16 *result)
+static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, void *data, u16 *result)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct l2cap_conf_req *req = data;
        void *ptr = req->data;
        int type, olen;
        unsigned long val;
        struct l2cap_conf_rfc rfc;
 
-       BT_DBG("sk %p, rsp %p, len %d, req %p", sk, rsp, len, data);
+       BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data);
 
        while (len >= L2CAP_CONF_OPT_SIZE) {
                len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
@@ -2438,27 +1874,27 @@ static int l2cap_parse_conf_rsp(struct sock *sk, void *rsp, int len, void *data,
                case L2CAP_CONF_MTU:
                        if (val < L2CAP_DEFAULT_MIN_MTU) {
                                *result = L2CAP_CONF_UNACCEPT;
-                               pi->imtu = L2CAP_DEFAULT_MIN_MTU;
+                               chan->imtu = L2CAP_DEFAULT_MIN_MTU;
                        } else
-                               pi->imtu = val;
-                       l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, pi->imtu);
+                               chan->imtu = val;
+                       l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);
                        break;
 
                case L2CAP_CONF_FLUSH_TO:
-                       pi->flush_to = val;
+                       chan->flush_to = val;
                        l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO,
-                                                       2, pi->flush_to);
+                                                       2, chan->flush_to);
                        break;
 
                case L2CAP_CONF_RFC:
                        if (olen == sizeof(rfc))
                                memcpy(&rfc, (void *)val, olen);
 
-                       if ((pi->conf_state & L2CAP_CONF_STATE2_DEVICE) &&
-                                                       rfc.mode != pi->mode)
+                       if ((chan->conf_state & L2CAP_CONF_STATE2_DEVICE) &&
+                                                       rfc.mode != chan->mode)
                                return -ECONNREFUSED;
 
-                       pi->fcs = 0;
+                       chan->fcs = 0;
 
                        l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
                                        sizeof(rfc), (unsigned long) &rfc);
@@ -2466,53 +1902,74 @@ static int l2cap_parse_conf_rsp(struct sock *sk, void *rsp, int len, void *data,
                }
        }
 
-       if (pi->mode == L2CAP_MODE_BASIC && pi->mode != rfc.mode)
+       if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode)
                return -ECONNREFUSED;
 
-       pi->mode = rfc.mode;
+       chan->mode = rfc.mode;
 
        if (*result == L2CAP_CONF_SUCCESS) {
                switch (rfc.mode) {
                case L2CAP_MODE_ERTM:
-                       pi->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
-                       pi->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
-                       pi->mps    = le16_to_cpu(rfc.max_pdu_size);
+                       chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
+                       chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
+                       chan->mps    = le16_to_cpu(rfc.max_pdu_size);
                        break;
                case L2CAP_MODE_STREAMING:
-                       pi->mps    = le16_to_cpu(rfc.max_pdu_size);
+                       chan->mps    = le16_to_cpu(rfc.max_pdu_size);
                }
        }
 
-       req->dcid   = cpu_to_le16(pi->dcid);
+       req->dcid   = cpu_to_le16(chan->dcid);
        req->flags  = cpu_to_le16(0x0000);
 
        return ptr - data;
 }
 
-static int l2cap_build_conf_rsp(struct sock *sk, void *data, u16 result, u16 flags)
+static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, u16 result, u16 flags)
 {
        struct l2cap_conf_rsp *rsp = data;
        void *ptr = rsp->data;
 
-       BT_DBG("sk %p", sk);
+       BT_DBG("chan %p", chan);
 
-       rsp->scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
+       rsp->scid   = cpu_to_le16(chan->dcid);
        rsp->result = cpu_to_le16(result);
        rsp->flags  = cpu_to_le16(flags);
 
        return ptr - data;
 }
 
-static void l2cap_conf_rfc_get(struct sock *sk, void *rsp, int len)
+void __l2cap_connect_rsp_defer(struct l2cap_chan *chan)
+{
+       struct l2cap_conn_rsp rsp;
+       struct l2cap_conn *conn = chan->conn;
+       u8 buf[128];
+
+       rsp.scid   = cpu_to_le16(chan->dcid);
+       rsp.dcid   = cpu_to_le16(chan->scid);
+       rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
+       rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
+       l2cap_send_cmd(conn, chan->ident,
+                               L2CAP_CONN_RSP, sizeof(rsp), &rsp);
+
+       if (chan->conf_state & L2CAP_CONF_REQ_SENT)
+               return;
+
+       chan->conf_state |= L2CAP_CONF_REQ_SENT;
+       l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
+                       l2cap_build_conf_req(chan, buf), buf);
+       chan->num_conf_req++;
+}
+
+static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        int type, olen;
        unsigned long val;
        struct l2cap_conf_rfc rfc;
 
-       BT_DBG("sk %p, rsp %p, len %d", sk, rsp, len);
+       BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len);
 
-       if ((pi->mode != L2CAP_MODE_ERTM) && (pi->mode != L2CAP_MODE_STREAMING))
+       if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING))
                return;
 
        while (len >= L2CAP_CONF_OPT_SIZE) {
@@ -2529,12 +1986,12 @@ static void l2cap_conf_rfc_get(struct sock *sk, void *rsp, int len)
 done:
        switch (rfc.mode) {
        case L2CAP_MODE_ERTM:
-               pi->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
-               pi->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
-               pi->mps    = le16_to_cpu(rfc.max_pdu_size);
+               chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
+               chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
+               chan->mps    = le16_to_cpu(rfc.max_pdu_size);
                break;
        case L2CAP_MODE_STREAMING:
-               pi->mps    = le16_to_cpu(rfc.max_pdu_size);
+               chan->mps    = le16_to_cpu(rfc.max_pdu_size);
        }
 }
 
@@ -2560,9 +2017,9 @@ static inline int l2cap_command_rej(struct l2cap_conn *conn, struct l2cap_cmd_hd
 
 static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
 {
-       struct l2cap_chan_list *list = &conn->chan_list;
        struct l2cap_conn_req *req = (struct l2cap_conn_req *) data;
        struct l2cap_conn_rsp rsp;
+       struct l2cap_chan *chan = NULL;
        struct sock *parent, *sk = NULL;
        int result, status = L2CAP_CS_NO_INFO;
 
@@ -2600,11 +2057,19 @@ static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hd
        if (!sk)
                goto response;
 
-       write_lock_bh(&list->lock);
+       chan = l2cap_chan_alloc(sk);
+       if (!chan) {
+               l2cap_sock_kill(sk);
+               goto response;
+       }
+
+       l2cap_pi(sk)->chan = chan;
+
+       write_lock_bh(&conn->chan_lock);
 
        /* Check if we already have channel with that dcid */
-       if (__l2cap_get_chan_by_dcid(list, scid)) {
-               write_unlock_bh(&list->lock);
+       if (__l2cap_get_chan_by_dcid(conn, scid)) {
+               write_unlock_bh(&conn->chan_lock);
                sock_set_flag(sk, SOCK_ZAPPED);
                l2cap_sock_kill(sk);
                goto response;
@@ -2615,18 +2080,21 @@ static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hd
        l2cap_sock_init(sk, parent);
        bacpy(&bt_sk(sk)->src, conn->src);
        bacpy(&bt_sk(sk)->dst, conn->dst);
-       l2cap_pi(sk)->psm  = psm;
-       l2cap_pi(sk)->dcid = scid;
+       chan->psm  = psm;
+       chan->dcid = scid;
+
+       bt_accept_enqueue(parent, sk);
+
+       __l2cap_chan_add(conn, chan);
 
-       __l2cap_chan_add(conn, sk, parent);
-       dcid = l2cap_pi(sk)->scid;
+       dcid = chan->scid;
 
        l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
 
-       l2cap_pi(sk)->ident = cmd->ident;
+       chan->ident = cmd->ident;
 
        if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) {
-               if (l2cap_check_security(sk)) {
+               if (l2cap_check_security(chan)) {
                        if (bt_sk(sk)->defer_setup) {
                                sk->sk_state = BT_CONNECT2;
                                result = L2CAP_CR_PEND;
@@ -2648,7 +2116,7 @@ static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hd
                status = L2CAP_CS_NO_INFO;
        }
 
-       write_unlock_bh(&list->lock);
+       write_unlock_bh(&conn->chan_lock);
 
 response:
        bh_unlock_sock(parent);
@@ -2674,13 +2142,13 @@ sendresp:
                                        L2CAP_INFO_REQ, sizeof(info), &info);
        }
 
-       if (sk && !(l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT) &&
+       if (chan && !(chan->conf_state & L2CAP_CONF_REQ_SENT) &&
                                result == L2CAP_CR_SUCCESS) {
                u8 buf[128];
-               l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
+               chan->conf_state |= L2CAP_CONF_REQ_SENT;
                l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
-                                       l2cap_build_conf_req(sk, buf), buf);
-               l2cap_pi(sk)->num_conf_req++;
+                                       l2cap_build_conf_req(chan, buf), buf);
+               chan->num_conf_req++;
        }
 
        return 0;
@@ -2690,6 +2158,7 @@ static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hd
 {
        struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data;
        u16 scid, dcid, result, status;
+       struct l2cap_chan *chan;
        struct sock *sk;
        u8 req[128];
 
@@ -2701,34 +2170,36 @@ static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hd
        BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", dcid, scid, result, status);
 
        if (scid) {
-               sk = l2cap_get_chan_by_scid(&conn->chan_list, scid);
-               if (!sk)
+               chan = l2cap_get_chan_by_scid(conn, scid);
+               if (!chan)
                        return -EFAULT;
        } else {
-               sk = l2cap_get_chan_by_ident(&conn->chan_list, cmd->ident);
-               if (!sk)
+               chan = l2cap_get_chan_by_ident(conn, cmd->ident);
+               if (!chan)
                        return -EFAULT;
        }
 
+       sk = chan->sk;
+
        switch (result) {
        case L2CAP_CR_SUCCESS:
                sk->sk_state = BT_CONFIG;
-               l2cap_pi(sk)->ident = 0;
-               l2cap_pi(sk)->dcid = dcid;
-               l2cap_pi(sk)->conf_state &= ~L2CAP_CONF_CONNECT_PEND;
+               chan->ident = 0;
+               chan->dcid = dcid;
+               chan->conf_state &= ~L2CAP_CONF_CONNECT_PEND;
 
-               if (l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT)
+               if (chan->conf_state & L2CAP_CONF_REQ_SENT)
                        break;
 
-               l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
+               chan->conf_state |= L2CAP_CONF_REQ_SENT;
 
                l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
-                                       l2cap_build_conf_req(sk, req), req);
-               l2cap_pi(sk)->num_conf_req++;
+                                       l2cap_build_conf_req(chan, req), req);
+               chan->num_conf_req++;
                break;
 
        case L2CAP_CR_PEND:
-               l2cap_pi(sk)->conf_state |= L2CAP_CONF_CONNECT_PEND;
+               chan->conf_state |= L2CAP_CONF_CONNECT_PEND;
                break;
 
        default:
@@ -2740,7 +2211,7 @@ static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hd
                        break;
                }
 
-               l2cap_chan_del(sk, ECONNREFUSED);
+               l2cap_chan_del(chan, ECONNREFUSED);
                break;
        }
 
@@ -2748,15 +2219,17 @@ static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hd
        return 0;
 }
 
-static inline void set_default_fcs(struct l2cap_pinfo *pi)
+static inline void set_default_fcs(struct l2cap_chan *chan)
 {
+       struct l2cap_pinfo *pi = l2cap_pi(chan->sk);
+
        /* FCS is enabled only in ERTM or streaming mode, if one or both
         * sides request it.
         */
-       if (pi->mode != L2CAP_MODE_ERTM && pi->mode != L2CAP_MODE_STREAMING)
-               pi->fcs = L2CAP_FCS_NONE;
-       else if (!(pi->conf_state & L2CAP_CONF_NO_FCS_RECV))
-               pi->fcs = L2CAP_FCS_CRC16;
+       if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING)
+               chan->fcs = L2CAP_FCS_NONE;
+       else if (!(pi->chan->conf_state & L2CAP_CONF_NO_FCS_RECV))
+               chan->fcs = L2CAP_FCS_CRC16;
 }
 
 static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data)
@@ -2764,6 +2237,7 @@ static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr
        struct l2cap_conf_req *req = (struct l2cap_conf_req *) data;
        u16 dcid, flags;
        u8 rsp[64];
+       struct l2cap_chan *chan;
        struct sock *sk;
        int len;
 
@@ -2772,10 +2246,12 @@ static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr
 
        BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags);
 
-       sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid);
-       if (!sk)
+       chan = l2cap_get_chan_by_scid(conn, dcid);
+       if (!chan)
                return -ENOENT;
 
+       sk = chan->sk;
+
        if (sk->sk_state != BT_CONFIG) {
                struct l2cap_cmd_rej rej;
 
@@ -2787,62 +2263,62 @@ static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr
 
        /* Reject if config buffer is too small. */
        len = cmd_len - sizeof(*req);
-       if (l2cap_pi(sk)->conf_len + len > sizeof(l2cap_pi(sk)->conf_req)) {
+       if (chan->conf_len + len > sizeof(chan->conf_req)) {
                l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
-                               l2cap_build_conf_rsp(sk, rsp,
+                               l2cap_build_conf_rsp(chan, rsp,
                                        L2CAP_CONF_REJECT, flags), rsp);
                goto unlock;
        }
 
        /* Store config. */
-       memcpy(l2cap_pi(sk)->conf_req + l2cap_pi(sk)->conf_len, req->data, len);
-       l2cap_pi(sk)->conf_len += len;
+       memcpy(chan->conf_req + chan->conf_len, req->data, len);
+       chan->conf_len += len;
 
        if (flags & 0x0001) {
                /* Incomplete config. Send empty response. */
                l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
-                               l2cap_build_conf_rsp(sk, rsp,
+                               l2cap_build_conf_rsp(chan, rsp,
                                        L2CAP_CONF_SUCCESS, 0x0001), rsp);
                goto unlock;
        }
 
        /* Complete config. */
-       len = l2cap_parse_conf_req(sk, rsp);
+       len = l2cap_parse_conf_req(chan, rsp);
        if (len < 0) {
-               l2cap_send_disconn_req(conn, sk, ECONNRESET);
+               l2cap_send_disconn_req(conn, chan, ECONNRESET);
                goto unlock;
        }
 
        l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp);
-       l2cap_pi(sk)->num_conf_rsp++;
+       chan->num_conf_rsp++;
 
        /* Reset config buffer. */
-       l2cap_pi(sk)->conf_len = 0;
+       chan->conf_len = 0;
 
-       if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_OUTPUT_DONE))
+       if (!(chan->conf_state & L2CAP_CONF_OUTPUT_DONE))
                goto unlock;
 
-       if (l2cap_pi(sk)->conf_state & L2CAP_CONF_INPUT_DONE) {
-               set_default_fcs(l2cap_pi(sk));
+       if (chan->conf_state & L2CAP_CONF_INPUT_DONE) {
+               set_default_fcs(chan);
 
                sk->sk_state = BT_CONNECTED;
 
-               l2cap_pi(sk)->next_tx_seq = 0;
-               l2cap_pi(sk)->expected_tx_seq = 0;
-               __skb_queue_head_init(TX_QUEUE(sk));
-               if (l2cap_pi(sk)->mode == L2CAP_MODE_ERTM)
-                       l2cap_ertm_init(sk);
+               chan->next_tx_seq = 0;
+               chan->expected_tx_seq = 0;
+               skb_queue_head_init(&chan->tx_q);
+               if (chan->mode == L2CAP_MODE_ERTM)
+                       l2cap_ertm_init(chan);
 
                l2cap_chan_ready(sk);
                goto unlock;
        }
 
-       if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT)) {
+       if (!(chan->conf_state & L2CAP_CONF_REQ_SENT)) {
                u8 buf[64];
-               l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
+               chan->conf_state |= L2CAP_CONF_REQ_SENT;
                l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
-                                       l2cap_build_conf_req(sk, buf), buf);
-               l2cap_pi(sk)->num_conf_req++;
+                                       l2cap_build_conf_req(chan, buf), buf);
+               chan->num_conf_req++;
        }
 
 unlock:
@@ -2854,6 +2330,7 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
 {
        struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data;
        u16 scid, flags, result;
+       struct l2cap_chan *chan;
        struct sock *sk;
        int len = cmd->len - sizeof(*rsp);
 
@@ -2864,36 +2341,38 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
        BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x",
                        scid, flags, result);
 
-       sk = l2cap_get_chan_by_scid(&conn->chan_list, scid);
-       if (!sk)
+       chan = l2cap_get_chan_by_scid(conn, scid);
+       if (!chan)
                return 0;
 
+       sk = chan->sk;
+
        switch (result) {
        case L2CAP_CONF_SUCCESS:
-               l2cap_conf_rfc_get(sk, rsp->data, len);
+               l2cap_conf_rfc_get(chan, rsp->data, len);
                break;
 
        case L2CAP_CONF_UNACCEPT:
-               if (l2cap_pi(sk)->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) {
+               if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) {
                        char req[64];
 
                        if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) {
-                               l2cap_send_disconn_req(conn, sk, ECONNRESET);
+                               l2cap_send_disconn_req(conn, chan, ECONNRESET);
                                goto done;
                        }
 
                        /* throw out any old stored conf requests */
                        result = L2CAP_CONF_SUCCESS;
-                       len = l2cap_parse_conf_rsp(sk, rsp->data,
-                                                       len, req, &result);
+                       len = l2cap_parse_conf_rsp(chan, rsp->data, len,
+                                                               req, &result);
                        if (len < 0) {
-                               l2cap_send_disconn_req(conn, sk, ECONNRESET);
+                               l2cap_send_disconn_req(conn, chan, ECONNRESET);
                                goto done;
                        }
 
                        l2cap_send_cmd(conn, l2cap_get_ident(conn),
                                                L2CAP_CONF_REQ, len, req);
-                       l2cap_pi(sk)->num_conf_req++;
+                       chan->num_conf_req++;
                        if (result != L2CAP_CONF_SUCCESS)
                                goto done;
                        break;
@@ -2902,24 +2381,24 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
        default:
                sk->sk_err = ECONNRESET;
                l2cap_sock_set_timer(sk, HZ * 5);
-               l2cap_send_disconn_req(conn, sk, ECONNRESET);
+               l2cap_send_disconn_req(conn, chan, ECONNRESET);
                goto done;
        }
 
        if (flags & 0x01)
                goto done;
 
-       l2cap_pi(sk)->conf_state |= L2CAP_CONF_INPUT_DONE;
+       chan->conf_state |= L2CAP_CONF_INPUT_DONE;
 
-       if (l2cap_pi(sk)->conf_state & L2CAP_CONF_OUTPUT_DONE) {
-               set_default_fcs(l2cap_pi(sk));
+       if (chan->conf_state & L2CAP_CONF_OUTPUT_DONE) {
+               set_default_fcs(chan);
 
                sk->sk_state = BT_CONNECTED;
-               l2cap_pi(sk)->next_tx_seq = 0;
-               l2cap_pi(sk)->expected_tx_seq = 0;
-               __skb_queue_head_init(TX_QUEUE(sk));
-               if (l2cap_pi(sk)->mode ==  L2CAP_MODE_ERTM)
-                       l2cap_ertm_init(sk);
+               chan->next_tx_seq = 0;
+               chan->expected_tx_seq = 0;
+               skb_queue_head_init(&chan->tx_q);
+               if (chan->mode ==  L2CAP_MODE_ERTM)
+                       l2cap_ertm_init(chan);
 
                l2cap_chan_ready(sk);
        }
@@ -2934,6 +2413,7 @@ static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd
        struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data;
        struct l2cap_disconn_rsp rsp;
        u16 dcid, scid;
+       struct l2cap_chan *chan;
        struct sock *sk;
 
        scid = __le16_to_cpu(req->scid);
@@ -2941,12 +2421,14 @@ static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd
 
        BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
 
-       sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid);
-       if (!sk)
+       chan = l2cap_get_chan_by_scid(conn, dcid);
+       if (!chan)
                return 0;
 
-       rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
-       rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
+       sk = chan->sk;
+
+       rsp.dcid = cpu_to_le16(chan->scid);
+       rsp.scid = cpu_to_le16(chan->dcid);
        l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
 
        sk->sk_shutdown = SHUTDOWN_MASK;
@@ -2960,7 +2442,7 @@ static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd
                return 0;
        }
 
-       l2cap_chan_del(sk, ECONNRESET);
+       l2cap_chan_del(chan, ECONNRESET);
        bh_unlock_sock(sk);
 
        l2cap_sock_kill(sk);
@@ -2971,6 +2453,7 @@ static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd
 {
        struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data;
        u16 dcid, scid;
+       struct l2cap_chan *chan;
        struct sock *sk;
 
        scid = __le16_to_cpu(rsp->scid);
@@ -2978,10 +2461,12 @@ static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd
 
        BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
 
-       sk = l2cap_get_chan_by_scid(&conn->chan_list, scid);
-       if (!sk)
+       chan = l2cap_get_chan_by_scid(conn, scid);
+       if (!chan)
                return 0;
 
+       sk = chan->sk;
+
        /* don't delete l2cap channel if sk is owned by user */
        if (sock_owned_by_user(sk)) {
                sk->sk_state = BT_DISCONN;
@@ -2991,7 +2476,7 @@ static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd
                return 0;
        }
 
-       l2cap_chan_del(sk, 0);
+       l2cap_chan_del(chan, 0);
        bh_unlock_sock(sk);
 
        l2cap_sock_kill(sk);
@@ -3048,6 +2533,11 @@ static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cm
 
        BT_DBG("type 0x%4.4x result 0x%2.2x", type, result);
 
+       /* L2CAP Info req/rsp are unbound to channels, add extra checks */
+       if (cmd->ident != conn->info_ident ||
+                       conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)
+               return 0;
+
        del_timer(&conn->info_timer);
 
        if (result != L2CAP_IR_SUCCESS) {
@@ -3086,12 +2576,153 @@ static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cm
        return 0;
 }
 
-static inline void l2cap_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
+static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency,
+                                                       u16 to_multiplier)
+{
+       u16 max_latency;
+
+       if (min > max || min < 6 || max > 3200)
+               return -EINVAL;
+
+       if (to_multiplier < 10 || to_multiplier > 3200)
+               return -EINVAL;
+
+       if (max >= to_multiplier * 8)
+               return -EINVAL;
+
+       max_latency = (to_multiplier * 8 / max) - 1;
+       if (latency > 499 || latency > max_latency)
+               return -EINVAL;
+
+       return 0;
+}
+
+static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn,
+                                       struct l2cap_cmd_hdr *cmd, u8 *data)
+{
+       struct hci_conn *hcon = conn->hcon;
+       struct l2cap_conn_param_update_req *req;
+       struct l2cap_conn_param_update_rsp rsp;
+       u16 min, max, latency, to_multiplier, cmd_len;
+       int err;
+
+       if (!(hcon->link_mode & HCI_LM_MASTER))
+               return -EINVAL;
+
+       cmd_len = __le16_to_cpu(cmd->len);
+       if (cmd_len != sizeof(struct l2cap_conn_param_update_req))
+               return -EPROTO;
+
+       req = (struct l2cap_conn_param_update_req *) data;
+       min             = __le16_to_cpu(req->min);
+       max             = __le16_to_cpu(req->max);
+       latency         = __le16_to_cpu(req->latency);
+       to_multiplier   = __le16_to_cpu(req->to_multiplier);
+
+       BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x",
+                                               min, max, latency, to_multiplier);
+
+       memset(&rsp, 0, sizeof(rsp));
+
+       err = l2cap_check_conn_param(min, max, latency, to_multiplier);
+       if (err)
+               rsp.result = cpu_to_le16(L2CAP_CONN_PARAM_REJECTED);
+       else
+               rsp.result = cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED);
+
+       l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP,
+                                                       sizeof(rsp), &rsp);
+
+       if (!err)
+               hci_le_conn_update(hcon, min, max, latency, to_multiplier);
+
+       return 0;
+}
+
+static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn,
+                       struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data)
+{
+       int err = 0;
+
+       switch (cmd->code) {
+       case L2CAP_COMMAND_REJ:
+               l2cap_command_rej(conn, cmd, data);
+               break;
+
+       case L2CAP_CONN_REQ:
+               err = l2cap_connect_req(conn, cmd, data);
+               break;
+
+       case L2CAP_CONN_RSP:
+               err = l2cap_connect_rsp(conn, cmd, data);
+               break;
+
+       case L2CAP_CONF_REQ:
+               err = l2cap_config_req(conn, cmd, cmd_len, data);
+               break;
+
+       case L2CAP_CONF_RSP:
+               err = l2cap_config_rsp(conn, cmd, data);
+               break;
+
+       case L2CAP_DISCONN_REQ:
+               err = l2cap_disconnect_req(conn, cmd, data);
+               break;
+
+       case L2CAP_DISCONN_RSP:
+               err = l2cap_disconnect_rsp(conn, cmd, data);
+               break;
+
+       case L2CAP_ECHO_REQ:
+               l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data);
+               break;
+
+       case L2CAP_ECHO_RSP:
+               break;
+
+       case L2CAP_INFO_REQ:
+               err = l2cap_information_req(conn, cmd, data);
+               break;
+
+       case L2CAP_INFO_RSP:
+               err = l2cap_information_rsp(conn, cmd, data);
+               break;
+
+       default:
+               BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code);
+               err = -EINVAL;
+               break;
+       }
+
+       return err;
+}
+
+static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn,
+                                       struct l2cap_cmd_hdr *cmd, u8 *data)
+{
+       switch (cmd->code) {
+       case L2CAP_COMMAND_REJ:
+               return 0;
+
+       case L2CAP_CONN_PARAM_UPDATE_REQ:
+               return l2cap_conn_param_update_req(conn, cmd, data);
+
+       case L2CAP_CONN_PARAM_UPDATE_RSP:
+               return 0;
+
+       default:
+               BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code);
+               return -EINVAL;
+       }
+}
+
+static inline void l2cap_sig_channel(struct l2cap_conn *conn,
+                                                       struct sk_buff *skb)
 {
        u8 *data = skb->data;
        int len = skb->len;
        struct l2cap_cmd_hdr cmd;
-       int err = 0;
+       int err;
 
        l2cap_raw_recv(conn, skb);
 
@@ -3110,59 +2741,15 @@ static inline void l2cap_sig_channel(struct l2cap_conn *conn, struct sk_buff *sk
                        break;
                }
 
-               switch (cmd.code) {
-               case L2CAP_COMMAND_REJ:
-                       l2cap_command_rej(conn, &cmd, data);
-                       break;
-
-               case L2CAP_CONN_REQ:
-                       err = l2cap_connect_req(conn, &cmd, data);
-                       break;
-
-               case L2CAP_CONN_RSP:
-                       err = l2cap_connect_rsp(conn, &cmd, data);
-                       break;
-
-               case L2CAP_CONF_REQ:
-                       err = l2cap_config_req(conn, &cmd, cmd_len, data);
-                       break;
-
-               case L2CAP_CONF_RSP:
-                       err = l2cap_config_rsp(conn, &cmd, data);
-                       break;
-
-               case L2CAP_DISCONN_REQ:
-                       err = l2cap_disconnect_req(conn, &cmd, data);
-                       break;
-
-               case L2CAP_DISCONN_RSP:
-                       err = l2cap_disconnect_rsp(conn, &cmd, data);
-                       break;
-
-               case L2CAP_ECHO_REQ:
-                       l2cap_send_cmd(conn, cmd.ident, L2CAP_ECHO_RSP, cmd_len, data);
-                       break;
-
-               case L2CAP_ECHO_RSP:
-                       break;
-
-               case L2CAP_INFO_REQ:
-                       err = l2cap_information_req(conn, &cmd, data);
-                       break;
-
-               case L2CAP_INFO_RSP:
-                       err = l2cap_information_rsp(conn, &cmd, data);
-                       break;
-
-               default:
-                       BT_ERR("Unknown signaling command 0x%2.2x", cmd.code);
-                       err = -EINVAL;
-                       break;
-               }
+               if (conn->hcon->type == LE_LINK)
+                       err = l2cap_le_sig_cmd(conn, &cmd, data);
+               else
+                       err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data);
 
                if (err) {
                        struct l2cap_cmd_rej rej;
-                       BT_DBG("error %d", err);
+
+                       BT_ERR("Wrong link type (%d)", err);
 
                        /* FIXME: Map err to a valid reason */
                        rej.reason = cpu_to_le16(0);
@@ -3176,12 +2763,12 @@ static inline void l2cap_sig_channel(struct l2cap_conn *conn, struct sk_buff *sk
        kfree_skb(skb);
 }
 
-static int l2cap_check_fcs(struct l2cap_pinfo *pi,  struct sk_buff *skb)
+static int l2cap_check_fcs(struct l2cap_chan *chan,  struct sk_buff *skb)
 {
        u16 our_fcs, rcv_fcs;
        int hdr_size = L2CAP_HDR_SIZE + 2;
 
-       if (pi->fcs == L2CAP_FCS_CRC16) {
+       if (chan->fcs == L2CAP_FCS_CRC16) {
                skb_trim(skb, skb->len - 2);
                rcv_fcs = get_unaligned_le16(skb->data + skb->len);
                our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size);
@@ -3192,49 +2779,47 @@ static int l2cap_check_fcs(struct l2cap_pinfo *pi,  struct sk_buff *skb)
        return 0;
 }
 
-static inline void l2cap_send_i_or_rr_or_rnr(struct sock *sk)
+static inline void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        u16 control = 0;
 
-       pi->frames_sent = 0;
+       chan->frames_sent = 0;
 
-       control |= pi->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
+       control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
 
-       if (pi->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
                control |= L2CAP_SUPER_RCV_NOT_READY;
-               l2cap_send_sframe(pi, control);
-               pi->conn_state |= L2CAP_CONN_RNR_SENT;
+               l2cap_send_sframe(chan, control);
+               chan->conn_state |= L2CAP_CONN_RNR_SENT;
        }
 
-       if (pi->conn_state & L2CAP_CONN_REMOTE_BUSY)
-               l2cap_retransmit_frames(sk);
+       if (chan->conn_state & L2CAP_CONN_REMOTE_BUSY)
+               l2cap_retransmit_frames(chan);
 
-       l2cap_ertm_send(sk);
+       l2cap_ertm_send(chan);
 
-       if (!(pi->conn_state & L2CAP_CONN_LOCAL_BUSY) &&
-                       pi->frames_sent == 0) {
+       if (!(chan->conn_state & L2CAP_CONN_LOCAL_BUSY) &&
+                       chan->frames_sent == 0) {
                control |= L2CAP_SUPER_RCV_READY;
-               l2cap_send_sframe(pi, control);
+               l2cap_send_sframe(chan, control);
        }
 }
 
-static int l2cap_add_to_srej_queue(struct sock *sk, struct sk_buff *skb, u8 tx_seq, u8 sar)
+static int l2cap_add_to_srej_queue(struct l2cap_chan *chan, struct sk_buff *skb, u8 tx_seq, u8 sar)
 {
        struct sk_buff *next_skb;
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        int tx_seq_offset, next_tx_seq_offset;
 
        bt_cb(skb)->tx_seq = tx_seq;
        bt_cb(skb)->sar = sar;
 
-       next_skb = skb_peek(SREJ_QUEUE(sk));
+       next_skb = skb_peek(&chan->srej_q);
        if (!next_skb) {
-               __skb_queue_tail(SREJ_QUEUE(sk), skb);
+               __skb_queue_tail(&chan->srej_q, skb);
                return 0;
        }
 
-       tx_seq_offset = (tx_seq - pi->buffer_seq) % 64;
+       tx_seq_offset = (tx_seq - chan->buffer_seq) % 64;
        if (tx_seq_offset < 0)
                tx_seq_offset += 64;
 
@@ -3243,53 +2828,52 @@ static int l2cap_add_to_srej_queue(struct sock *sk, struct sk_buff *skb, u8 tx_s
                        return -EINVAL;
 
                next_tx_seq_offset = (bt_cb(next_skb)->tx_seq -
-                                               pi->buffer_seq) % 64;
+                                               chan->buffer_seq) % 64;
                if (next_tx_seq_offset < 0)
                        next_tx_seq_offset += 64;
 
                if (next_tx_seq_offset > tx_seq_offset) {
-                       __skb_queue_before(SREJ_QUEUE(sk), next_skb, skb);
+                       __skb_queue_before(&chan->srej_q, next_skb, skb);
                        return 0;
                }
 
-               if (skb_queue_is_last(SREJ_QUEUE(sk), next_skb))
+               if (skb_queue_is_last(&chan->srej_q, next_skb))
                        break;
 
-       } while ((next_skb = skb_queue_next(SREJ_QUEUE(sk), next_skb)));
+       } while ((next_skb = skb_queue_next(&chan->srej_q, next_skb)));
 
-       __skb_queue_tail(SREJ_QUEUE(sk), skb);
+       __skb_queue_tail(&chan->srej_q, skb);
 
        return 0;
 }
 
-static int l2cap_ertm_reassembly_sdu(struct sock *sk, struct sk_buff *skb, u16 control)
+static int l2cap_ertm_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *skb, u16 control)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct sk_buff *_skb;
        int err;
 
        switch (control & L2CAP_CTRL_SAR) {
        case L2CAP_SDU_UNSEGMENTED:
-               if (pi->conn_state & L2CAP_CONN_SAR_SDU)
+               if (chan->conn_state & L2CAP_CONN_SAR_SDU)
                        goto drop;
 
-               err = sock_queue_rcv_skb(sk, skb);
+               err = sock_queue_rcv_skb(chan->sk, skb);
                if (!err)
                        return err;
 
                break;
 
        case L2CAP_SDU_START:
-               if (pi->conn_state & L2CAP_CONN_SAR_SDU)
+               if (chan->conn_state & L2CAP_CONN_SAR_SDU)
                        goto drop;
 
-               pi->sdu_len = get_unaligned_le16(skb->data);
+               chan->sdu_len = get_unaligned_le16(skb->data);
 
-               if (pi->sdu_len > pi->imtu)
+               if (chan->sdu_len > chan->imtu)
                        goto disconnect;
 
-               pi->sdu = bt_skb_alloc(pi->sdu_len, GFP_ATOMIC);
-               if (!pi->sdu)
+               chan->sdu = bt_skb_alloc(chan->sdu_len, GFP_ATOMIC);
+               if (!chan->sdu)
                        return -ENOMEM;
 
                /* pull sdu_len bytes only after alloc, because of Local Busy
@@ -3297,63 +2881,63 @@ static int l2cap_ertm_reassembly_sdu(struct sock *sk, struct sk_buff *skb, u16 c
                 * only once, i.e., when alloc does not fail */
                skb_pull(skb, 2);
 
-               memcpy(skb_put(pi->sdu, skb->len), skb->data, skb->len);
+               memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
-               pi->conn_state |= L2CAP_CONN_SAR_SDU;
-               pi->partial_sdu_len = skb->len;
+               chan->conn_state |= L2CAP_CONN_SAR_SDU;
+               chan->partial_sdu_len = skb->len;
                break;
 
        case L2CAP_SDU_CONTINUE:
-               if (!(pi->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
                        goto disconnect;
 
-               if (!pi->sdu)
+               if (!chan->sdu)
                        goto disconnect;
 
-               pi->partial_sdu_len += skb->len;
-               if (pi->partial_sdu_len > pi->sdu_len)
+               chan->partial_sdu_len += skb->len;
+               if (chan->partial_sdu_len > chan->sdu_len)
                        goto drop;
 
-               memcpy(skb_put(pi->sdu, skb->len), skb->data, skb->len);
+               memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
                break;
 
        case L2CAP_SDU_END:
-               if (!(pi->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
                        goto disconnect;
 
-               if (!pi->sdu)
+               if (!chan->sdu)
                        goto disconnect;
 
-               if (!(pi->conn_state & L2CAP_CONN_SAR_RETRY)) {
-                       pi->partial_sdu_len += skb->len;
+               if (!(chan->conn_state & L2CAP_CONN_SAR_RETRY)) {
+                       chan->partial_sdu_len += skb->len;
 
-                       if (pi->partial_sdu_len > pi->imtu)
+                       if (chan->partial_sdu_len > chan->imtu)
                                goto drop;
 
-                       if (pi->partial_sdu_len != pi->sdu_len)
+                       if (chan->partial_sdu_len != chan->sdu_len)
                                goto drop;
 
-                       memcpy(skb_put(pi->sdu, skb->len), skb->data, skb->len);
+                       memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
                }
 
-               _skb = skb_clone(pi->sdu, GFP_ATOMIC);
+               _skb = skb_clone(chan->sdu, GFP_ATOMIC);
                if (!_skb) {
-                       pi->conn_state |= L2CAP_CONN_SAR_RETRY;
+                       chan->conn_state |= L2CAP_CONN_SAR_RETRY;
                        return -ENOMEM;
                }
 
-               err = sock_queue_rcv_skb(sk, _skb);
+               err = sock_queue_rcv_skb(chan->sk, _skb);
                if (err < 0) {
                        kfree_skb(_skb);
-                       pi->conn_state |= L2CAP_CONN_SAR_RETRY;
+                       chan->conn_state |= L2CAP_CONN_SAR_RETRY;
                        return err;
                }
 
-               pi->conn_state &= ~L2CAP_CONN_SAR_RETRY;
-               pi->conn_state &= ~L2CAP_CONN_SAR_SDU;
+               chan->conn_state &= ~L2CAP_CONN_SAR_RETRY;
+               chan->conn_state &= ~L2CAP_CONN_SAR_SDU;
 
-               kfree_skb(pi->sdu);
+               kfree_skb(chan->sdu);
                break;
        }
 
@@ -3361,51 +2945,50 @@ static int l2cap_ertm_reassembly_sdu(struct sock *sk, struct sk_buff *skb, u16 c
        return 0;
 
 drop:
-       kfree_skb(pi->sdu);
-       pi->sdu = NULL;
+       kfree_skb(chan->sdu);
+       chan->sdu = NULL;
 
 disconnect:
-       l2cap_send_disconn_req(pi->conn, sk, ECONNRESET);
+       l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
        kfree_skb(skb);
        return 0;
 }
 
-static int l2cap_try_push_rx_skb(struct sock *sk)
+static int l2cap_try_push_rx_skb(struct l2cap_chan *chan)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct sk_buff *skb;
        u16 control;
        int err;
 
-       while ((skb = skb_dequeue(BUSY_QUEUE(sk)))) {
+       while ((skb = skb_dequeue(&chan->busy_q))) {
                control = bt_cb(skb)->sar << L2CAP_CTRL_SAR_SHIFT;
-               err = l2cap_ertm_reassembly_sdu(sk, skb, control);
+               err = l2cap_ertm_reassembly_sdu(chan, skb, control);
                if (err < 0) {
-                       skb_queue_head(BUSY_QUEUE(sk), skb);
+                       skb_queue_head(&chan->busy_q, skb);
                        return -EBUSY;
                }
 
-               pi->buffer_seq = (pi->buffer_seq + 1) % 64;
+               chan->buffer_seq = (chan->buffer_seq + 1) % 64;
        }
 
-       if (!(pi->conn_state & L2CAP_CONN_RNR_SENT))
+       if (!(chan->conn_state & L2CAP_CONN_RNR_SENT))
                goto done;
 
-       control = pi->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
+       control = chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
        control |= L2CAP_SUPER_RCV_READY | L2CAP_CTRL_POLL;
-       l2cap_send_sframe(pi, control);
-       l2cap_pi(sk)->retry_count = 1;
+       l2cap_send_sframe(chan, control);
+       chan->retry_count = 1;
 
-       del_timer(&pi->retrans_timer);
+       del_timer(&chan->retrans_timer);
        __mod_monitor_timer();
 
-       l2cap_pi(sk)->conn_state |= L2CAP_CONN_WAIT_F;
+       chan->conn_state |= L2CAP_CONN_WAIT_F;
 
 done:
-       pi->conn_state &= ~L2CAP_CONN_LOCAL_BUSY;
-       pi->conn_state &= ~L2CAP_CONN_RNR_SENT;
+       chan->conn_state &= ~L2CAP_CONN_LOCAL_BUSY;
+       chan->conn_state &= ~L2CAP_CONN_RNR_SENT;
 
-       BT_DBG("sk %p, Exit local busy", sk);
+       BT_DBG("chan %p, Exit local busy", chan);
 
        return 0;
 }
@@ -3413,21 +2996,21 @@ done:
 static void l2cap_busy_work(struct work_struct *work)
 {
        DECLARE_WAITQUEUE(wait, current);
-       struct l2cap_pinfo *pi =
-               container_of(work, struct l2cap_pinfo, busy_work);
-       struct sock *sk = (struct sock *)pi;
+       struct l2cap_chan *chan =
+               container_of(work, struct l2cap_chan, busy_work);
+       struct sock *sk = chan->sk;
        int n_tries = 0, timeo = HZ/5, err;
        struct sk_buff *skb;
 
        lock_sock(sk);
 
        add_wait_queue(sk_sleep(sk), &wait);
-       while ((skb = skb_peek(BUSY_QUEUE(sk)))) {
+       while ((skb = skb_peek(&chan->busy_q))) {
                set_current_state(TASK_INTERRUPTIBLE);
 
                if (n_tries++ > L2CAP_LOCAL_BUSY_TRIES) {
                        err = -EBUSY;
-                       l2cap_send_disconn_req(pi->conn, sk, EBUSY);
+                       l2cap_send_disconn_req(chan->conn, chan, EBUSY);
                        break;
                }
 
@@ -3447,7 +3030,7 @@ static void l2cap_busy_work(struct work_struct *work)
                if (err)
                        break;
 
-               if (l2cap_try_push_rx_skb(sk) == 0)
+               if (l2cap_try_push_rx_skb(chan) == 0)
                        break;
        }
 
@@ -3457,48 +3040,46 @@ static void l2cap_busy_work(struct work_struct *work)
        release_sock(sk);
 }
 
-static int l2cap_push_rx_skb(struct sock *sk, struct sk_buff *skb, u16 control)
+static int l2cap_push_rx_skb(struct l2cap_chan *chan, struct sk_buff *skb, u16 control)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        int sctrl, err;
 
-       if (pi->conn_state & L2CAP_CONN_LOCAL_BUSY) {
+       if (chan->conn_state & L2CAP_CONN_LOCAL_BUSY) {
                bt_cb(skb)->sar = control >> L2CAP_CTRL_SAR_SHIFT;
-               __skb_queue_tail(BUSY_QUEUE(sk), skb);
-               return l2cap_try_push_rx_skb(sk);
+               __skb_queue_tail(&chan->busy_q, skb);
+               return l2cap_try_push_rx_skb(chan);
 
 
        }
 
-       err = l2cap_ertm_reassembly_sdu(sk, skb, control);
+       err = l2cap_ertm_reassembly_sdu(chan, skb, control);
        if (err >= 0) {
-               pi->buffer_seq = (pi->buffer_seq + 1) % 64;
+               chan->buffer_seq = (chan->buffer_seq + 1) % 64;
                return err;
        }
 
        /* Busy Condition */
-       BT_DBG("sk %p, Enter local busy", sk);
+       BT_DBG("chan %p, Enter local busy", chan);
 
-       pi->conn_state |= L2CAP_CONN_LOCAL_BUSY;
+       chan->conn_state |= L2CAP_CONN_LOCAL_BUSY;
        bt_cb(skb)->sar = control >> L2CAP_CTRL_SAR_SHIFT;
-       __skb_queue_tail(BUSY_QUEUE(sk), skb);
+       __skb_queue_tail(&chan->busy_q, skb);
 
-       sctrl = pi->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
+       sctrl = chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
        sctrl |= L2CAP_SUPER_RCV_NOT_READY;
-       l2cap_send_sframe(pi, sctrl);
+       l2cap_send_sframe(chan, sctrl);
 
-       pi->conn_state |= L2CAP_CONN_RNR_SENT;
+       chan->conn_state |= L2CAP_CONN_RNR_SENT;
 
-       del_timer(&pi->ack_timer);
+       del_timer(&chan->ack_timer);
 
-       queue_work(_busy_wq, &pi->busy_work);
+       queue_work(_busy_wq, &chan->busy_work);
 
        return err;
 }
 
-static int l2cap_streaming_reassembly_sdu(struct sock *sk, struct sk_buff *skb, u16 control)
+static int l2cap_streaming_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *skb, u16 control)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct sk_buff *_skb;
        int err = -EINVAL;
 
@@ -3509,80 +3090,80 @@ static int l2cap_streaming_reassembly_sdu(struct sock *sk, struct sk_buff *skb,
 
        switch (control & L2CAP_CTRL_SAR) {
        case L2CAP_SDU_UNSEGMENTED:
-               if (pi->conn_state & L2CAP_CONN_SAR_SDU) {
-                       kfree_skb(pi->sdu);
+               if (chan->conn_state & L2CAP_CONN_SAR_SDU) {
+                       kfree_skb(chan->sdu);
                        break;
                }
 
-               err = sock_queue_rcv_skb(sk, skb);
+               err = sock_queue_rcv_skb(chan->sk, skb);
                if (!err)
                        return 0;
 
                break;
 
        case L2CAP_SDU_START:
-               if (pi->conn_state & L2CAP_CONN_SAR_SDU) {
-                       kfree_skb(pi->sdu);
+               if (chan->conn_state & L2CAP_CONN_SAR_SDU) {
+                       kfree_skb(chan->sdu);
                        break;
                }
 
-               pi->sdu_len = get_unaligned_le16(skb->data);
+               chan->sdu_len = get_unaligned_le16(skb->data);
                skb_pull(skb, 2);
 
-               if (pi->sdu_len > pi->imtu) {
+               if (chan->sdu_len > chan->imtu) {
                        err = -EMSGSIZE;
                        break;
                }
 
-               pi->sdu = bt_skb_alloc(pi->sdu_len, GFP_ATOMIC);
-               if (!pi->sdu) {
+               chan->sdu = bt_skb_alloc(chan->sdu_len, GFP_ATOMIC);
+               if (!chan->sdu) {
                        err = -ENOMEM;
                        break;
                }
 
-               memcpy(skb_put(pi->sdu, skb->len), skb->data, skb->len);
+               memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
-               pi->conn_state |= L2CAP_CONN_SAR_SDU;
-               pi->partial_sdu_len = skb->len;
+               chan->conn_state |= L2CAP_CONN_SAR_SDU;
+               chan->partial_sdu_len = skb->len;
                err = 0;
                break;
 
        case L2CAP_SDU_CONTINUE:
-               if (!(pi->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
                        break;
 
-               memcpy(skb_put(pi->sdu, skb->len), skb->data, skb->len);
+               memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
-               pi->partial_sdu_len += skb->len;
-               if (pi->partial_sdu_len > pi->sdu_len)
-                       kfree_skb(pi->sdu);
+               chan->partial_sdu_len += skb->len;
+               if (chan->partial_sdu_len > chan->sdu_len)
+                       kfree_skb(chan->sdu);
                else
                        err = 0;
 
                break;
 
        case L2CAP_SDU_END:
-               if (!(pi->conn_state & L2CAP_CONN_SAR_SDU))
+               if (!(chan->conn_state & L2CAP_CONN_SAR_SDU))
                        break;
 
-               memcpy(skb_put(pi->sdu, skb->len), skb->data, skb->len);
+               memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
 
-               pi->conn_state &= ~L2CAP_CONN_SAR_SDU;
-               pi->partial_sdu_len += skb->len;
+               chan->conn_state &= ~L2CAP_CONN_SAR_SDU;
+               chan->partial_sdu_len += skb->len;
 
-               if (pi->partial_sdu_len > pi->imtu)
+               if (chan->partial_sdu_len > chan->imtu)
                        goto drop;
 
-               if (pi->partial_sdu_len == pi->sdu_len) {
-                       _skb = skb_clone(pi->sdu, GFP_ATOMIC);
-                       err = sock_queue_rcv_skb(sk, _skb);
+               if (chan->partial_sdu_len == chan->sdu_len) {
+                       _skb = skb_clone(chan->sdu, GFP_ATOMIC);
+                       err = sock_queue_rcv_skb(chan->sk, _skb);
                        if (err < 0)
                                kfree_skb(_skb);
                }
                err = 0;
 
 drop:
-               kfree_skb(pi->sdu);
+               kfree_skb(chan->sdu);
                break;
        }
 
@@ -3590,31 +3171,30 @@ drop:
        return err;
 }
 
-static void l2cap_check_srej_gap(struct sock *sk, u8 tx_seq)
+static void l2cap_check_srej_gap(struct l2cap_chan *chan, u8 tx_seq)
 {
        struct sk_buff *skb;
        u16 control;
 
-       while ((skb = skb_peek(SREJ_QUEUE(sk)))) {
+       while ((skb = skb_peek(&chan->srej_q))) {
                if (bt_cb(skb)->tx_seq != tx_seq)
                        break;
 
-               skb = skb_dequeue(SREJ_QUEUE(sk));
+               skb = skb_dequeue(&chan->srej_q);
                control = bt_cb(skb)->sar << L2CAP_CTRL_SAR_SHIFT;
-               l2cap_ertm_reassembly_sdu(sk, skb, control);
-               l2cap_pi(sk)->buffer_seq_srej =
-                       (l2cap_pi(sk)->buffer_seq_srej + 1) % 64;
+               l2cap_ertm_reassembly_sdu(chan, skb, control);
+               chan->buffer_seq_srej =
+                       (chan->buffer_seq_srej + 1) % 64;
                tx_seq = (tx_seq + 1) % 64;
        }
 }
 
-static void l2cap_resend_srejframe(struct sock *sk, u8 tx_seq)
+static void l2cap_resend_srejframe(struct l2cap_chan *chan, u8 tx_seq)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct srej_list *l, *tmp;
        u16 control;
 
-       list_for_each_entry_safe(l, tmp, SREJ_LIST(sk), list) {
+       list_for_each_entry_safe(l, tmp, &chan->srej_l, list) {
                if (l->tx_seq == tx_seq) {
                        list_del(&l->list);
                        kfree(l);
@@ -3622,107 +3202,105 @@ static void l2cap_resend_srejframe(struct sock *sk, u8 tx_seq)
                }
                control = L2CAP_SUPER_SELECT_REJECT;
                control |= l->tx_seq << L2CAP_CTRL_REQSEQ_SHIFT;
-               l2cap_send_sframe(pi, control);
+               l2cap_send_sframe(chan, control);
                list_del(&l->list);
-               list_add_tail(&l->list, SREJ_LIST(sk));
+               list_add_tail(&l->list, &chan->srej_l);
        }
 }
 
-static void l2cap_send_srejframe(struct sock *sk, u8 tx_seq)
+static void l2cap_send_srejframe(struct l2cap_chan *chan, u8 tx_seq)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        struct srej_list *new;
        u16 control;
 
-       while (tx_seq != pi->expected_tx_seq) {
+       while (tx_seq != chan->expected_tx_seq) {
                control = L2CAP_SUPER_SELECT_REJECT;
-               control |= pi->expected_tx_seq << L2CAP_CTRL_REQSEQ_SHIFT;
-               l2cap_send_sframe(pi, control);
+               control |= chan->expected_tx_seq << L2CAP_CTRL_REQSEQ_SHIFT;
+               l2cap_send_sframe(chan, control);
 
                new = kzalloc(sizeof(struct srej_list), GFP_ATOMIC);
-               new->tx_seq = pi->expected_tx_seq;
-               pi->expected_tx_seq = (pi->expected_tx_seq + 1) % 64;
-               list_add_tail(&new->list, SREJ_LIST(sk));
+               new->tx_seq = chan->expected_tx_seq;
+               chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
+               list_add_tail(&new->list, &chan->srej_l);
        }
-       pi->expected_tx_seq = (pi->expected_tx_seq + 1) % 64;
+       chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
 }
 
-static inline int l2cap_data_channel_iframe(struct sock *sk, u16 rx_control, struct sk_buff *skb)
+static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_control, struct sk_buff *skb)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        u8 tx_seq = __get_txseq(rx_control);
        u8 req_seq = __get_reqseq(rx_control);
        u8 sar = rx_control >> L2CAP_CTRL_SAR_SHIFT;
        int tx_seq_offset, expected_tx_seq_offset;
-       int num_to_ack = (pi->tx_win/6) + 1;
+       int num_to_ack = (chan->tx_win/6) + 1;
        int err = 0;
 
-       BT_DBG("sk %p len %d tx_seq %d rx_control 0x%4.4x", sk, skb->len, tx_seq,
-                                                               rx_control);
+       BT_DBG("chan %p len %d tx_seq %d rx_control 0x%4.4x", chan, skb->len,
+                                                       tx_seq, rx_control);
 
        if (L2CAP_CTRL_FINAL & rx_control &&
-                       l2cap_pi(sk)->conn_state & L2CAP_CONN_WAIT_F) {
-               del_timer(&pi->monitor_timer);
-               if (pi->unacked_frames > 0)
+                       chan->conn_state & L2CAP_CONN_WAIT_F) {
+               del_timer(&chan->monitor_timer);
+               if (chan->unacked_frames > 0)
                        __mod_retrans_timer();
-               pi->conn_state &= ~L2CAP_CONN_WAIT_F;
+               chan->conn_state &= ~L2CAP_CONN_WAIT_F;
        }
 
-       pi->expected_ack_seq = req_seq;
-       l2cap_drop_acked_frames(sk);
+       chan->expected_ack_seq = req_seq;
+       l2cap_drop_acked_frames(chan);
 
-       if (tx_seq == pi->expected_tx_seq)
+       if (tx_seq == chan->expected_tx_seq)
                goto expected;
 
-       tx_seq_offset = (tx_seq - pi->buffer_seq) % 64;
+       tx_seq_offset = (tx_seq - chan->buffer_seq) % 64;
        if (tx_seq_offset < 0)
                tx_seq_offset += 64;
 
        /* invalid tx_seq */
-       if (tx_seq_offset >= pi->tx_win) {
-               l2cap_send_disconn_req(pi->conn, sk, ECONNRESET);
+       if (tx_seq_offset >= chan->tx_win) {
+               l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
                goto drop;
        }
 
-       if (pi->conn_state == L2CAP_CONN_LOCAL_BUSY)
+       if (chan->conn_state == L2CAP_CONN_LOCAL_BUSY)
                goto drop;
 
-       if (pi->conn_state & L2CAP_CONN_SREJ_SENT) {
+       if (chan->conn_state & L2CAP_CONN_SREJ_SENT) {
                struct srej_list *first;
 
-               first = list_first_entry(SREJ_LIST(sk),
+               first = list_first_entry(&chan->srej_l,
                                struct srej_list, list);
                if (tx_seq == first->tx_seq) {
-                       l2cap_add_to_srej_queue(sk, skb, tx_seq, sar);
-                       l2cap_check_srej_gap(sk, tx_seq);
+                       l2cap_add_to_srej_queue(chan, skb, tx_seq, sar);
+                       l2cap_check_srej_gap(chan, tx_seq);
 
                        list_del(&first->list);
                        kfree(first);
 
-                       if (list_empty(SREJ_LIST(sk))) {
-                               pi->buffer_seq = pi->buffer_seq_srej;
-                               pi->conn_state &= ~L2CAP_CONN_SREJ_SENT;
-                               l2cap_send_ack(pi);
-                               BT_DBG("sk %p, Exit SREJ_SENT", sk);
+                       if (list_empty(&chan->srej_l)) {
+                               chan->buffer_seq = chan->buffer_seq_srej;
+                               chan->conn_state &= ~L2CAP_CONN_SREJ_SENT;
+                               l2cap_send_ack(chan);
+                               BT_DBG("chan %p, Exit SREJ_SENT", chan);
                        }
                } else {
                        struct srej_list *l;
 
                        /* duplicated tx_seq */
-                       if (l2cap_add_to_srej_queue(sk, skb, tx_seq, sar) < 0)
+                       if (l2cap_add_to_srej_queue(chan, skb, tx_seq, sar) < 0)
                                goto drop;
 
-                       list_for_each_entry(l, SREJ_LIST(sk), list) {
+                       list_for_each_entry(l, &chan->srej_l, list) {
                                if (l->tx_seq == tx_seq) {
-                                       l2cap_resend_srejframe(sk, tx_seq);
+                                       l2cap_resend_srejframe(chan, tx_seq);
                                        return 0;
                                }
                        }
-                       l2cap_send_srejframe(sk, tx_seq);
+                       l2cap_send_srejframe(chan, tx_seq);
                }
        } else {
                expected_tx_seq_offset =
-                       (pi->expected_tx_seq - pi->buffer_seq) % 64;
+                       (chan->expected_tx_seq - chan->buffer_seq) % 64;
                if (expected_tx_seq_offset < 0)
                        expected_tx_seq_offset += 64;
 
@@ -3730,51 +3308,51 @@ static inline int l2cap_data_channel_iframe(struct sock *sk, u16 rx_control, str
                if (tx_seq_offset < expected_tx_seq_offset)
                        goto drop;
 
-               pi->conn_state |= L2CAP_CONN_SREJ_SENT;
+               chan->conn_state |= L2CAP_CONN_SREJ_SENT;
 
-               BT_DBG("sk %p, Enter SREJ", sk);
+               BT_DBG("chan %p, Enter SREJ", chan);
 
-               INIT_LIST_HEAD(SREJ_LIST(sk));
-               pi->buffer_seq_srej = pi->buffer_seq;
+               INIT_LIST_HEAD(&chan->srej_l);
+               chan->buffer_seq_srej = chan->buffer_seq;
 
-               __skb_queue_head_init(SREJ_QUEUE(sk));
-               __skb_queue_head_init(BUSY_QUEUE(sk));
-               l2cap_add_to_srej_queue(sk, skb, tx_seq, sar);
+               __skb_queue_head_init(&chan->srej_q);
+               __skb_queue_head_init(&chan->busy_q);
+               l2cap_add_to_srej_queue(chan, skb, tx_seq, sar);
 
-               pi->conn_state |= L2CAP_CONN_SEND_PBIT;
+               chan->conn_state |= L2CAP_CONN_SEND_PBIT;
 
-               l2cap_send_srejframe(sk, tx_seq);
+               l2cap_send_srejframe(chan, tx_seq);
 
-               del_timer(&pi->ack_timer);
+               del_timer(&chan->ack_timer);
        }
        return 0;
 
 expected:
-       pi->expected_tx_seq = (pi->expected_tx_seq + 1) % 64;
+       chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
 
-       if (pi->conn_state & L2CAP_CONN_SREJ_SENT) {
+       if (chan->conn_state & L2CAP_CONN_SREJ_SENT) {
                bt_cb(skb)->tx_seq = tx_seq;
                bt_cb(skb)->sar = sar;
-               __skb_queue_tail(SREJ_QUEUE(sk), skb);
+               __skb_queue_tail(&chan->srej_q, skb);
                return 0;
        }
 
-       err = l2cap_push_rx_skb(sk, skb, rx_control);
+       err = l2cap_push_rx_skb(chan, skb, rx_control);
        if (err < 0)
                return 0;
 
        if (rx_control & L2CAP_CTRL_FINAL) {
-               if (pi->conn_state & L2CAP_CONN_REJ_ACT)
-                       pi->conn_state &= ~L2CAP_CONN_REJ_ACT;
+               if (chan->conn_state & L2CAP_CONN_REJ_ACT)
+                       chan->conn_state &= ~L2CAP_CONN_REJ_ACT;
                else
-                       l2cap_retransmit_frames(sk);
+                       l2cap_retransmit_frames(chan);
        }
 
        __mod_ack_timer();
 
-       pi->num_acked = (pi->num_acked + 1) % num_to_ack;
-       if (pi->num_acked == num_to_ack - 1)
-               l2cap_send_ack(pi);
+       chan->num_acked = (chan->num_acked + 1) % num_to_ack;
+       if (chan->num_acked == num_to_ack - 1)
+               l2cap_send_ack(chan);
 
        return 0;
 
@@ -3783,165 +3361,160 @@ drop:
        return 0;
 }
 
-static inline void l2cap_data_channel_rrframe(struct sock *sk, u16 rx_control)
+static inline void l2cap_data_channel_rrframe(struct l2cap_chan *chan, u16 rx_control)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
-
-       BT_DBG("sk %p, req_seq %d ctrl 0x%4.4x", sk, __get_reqseq(rx_control),
+       BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, __get_reqseq(rx_control),
                                                rx_control);
 
-       pi->expected_ack_seq = __get_reqseq(rx_control);
-       l2cap_drop_acked_frames(sk);
+       chan->expected_ack_seq = __get_reqseq(rx_control);
+       l2cap_drop_acked_frames(chan);
 
        if (rx_control & L2CAP_CTRL_POLL) {
-               pi->conn_state |= L2CAP_CONN_SEND_FBIT;
-               if (pi->conn_state & L2CAP_CONN_SREJ_SENT) {
-                       if ((pi->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
-                                       (pi->unacked_frames > 0))
+               chan->conn_state |= L2CAP_CONN_SEND_FBIT;
+               if (chan->conn_state & L2CAP_CONN_SREJ_SENT) {
+                       if ((chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
+                                       (chan->unacked_frames > 0))
                                __mod_retrans_timer();
 
-                       pi->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
-                       l2cap_send_srejtail(sk);
+                       chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+                       l2cap_send_srejtail(chan);
                } else {
-                       l2cap_send_i_or_rr_or_rnr(sk);
+                       l2cap_send_i_or_rr_or_rnr(chan);
                }
 
        } else if (rx_control & L2CAP_CTRL_FINAL) {
-               pi->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+               chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
 
-               if (pi->conn_state & L2CAP_CONN_REJ_ACT)
-                       pi->conn_state &= ~L2CAP_CONN_REJ_ACT;
+               if (chan->conn_state & L2CAP_CONN_REJ_ACT)
+                       chan->conn_state &= ~L2CAP_CONN_REJ_ACT;
                else
-                       l2cap_retransmit_frames(sk);
+                       l2cap_retransmit_frames(chan);
 
        } else {
-               if ((pi->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
-                               (pi->unacked_frames > 0))
+               if ((chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
+                               (chan->unacked_frames > 0))
                        __mod_retrans_timer();
 
-               pi->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
-               if (pi->conn_state & L2CAP_CONN_SREJ_SENT)
-                       l2cap_send_ack(pi);
+               chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+               if (chan->conn_state & L2CAP_CONN_SREJ_SENT)
+                       l2cap_send_ack(chan);
                else
-                       l2cap_ertm_send(sk);
+                       l2cap_ertm_send(chan);
        }
 }
 
-static inline void l2cap_data_channel_rejframe(struct sock *sk, u16 rx_control)
+static inline void l2cap_data_channel_rejframe(struct l2cap_chan *chan, u16 rx_control)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        u8 tx_seq = __get_reqseq(rx_control);
 
-       BT_DBG("sk %p, req_seq %d ctrl 0x%4.4x", sk, tx_seq, rx_control);
+       BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
 
-       pi->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+       chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
 
-       pi->expected_ack_seq = tx_seq;
-       l2cap_drop_acked_frames(sk);
+       chan->expected_ack_seq = tx_seq;
+       l2cap_drop_acked_frames(chan);
 
        if (rx_control & L2CAP_CTRL_FINAL) {
-               if (pi->conn_state & L2CAP_CONN_REJ_ACT)
-                       pi->conn_state &= ~L2CAP_CONN_REJ_ACT;
+               if (chan->conn_state & L2CAP_CONN_REJ_ACT)
+                       chan->conn_state &= ~L2CAP_CONN_REJ_ACT;
                else
-                       l2cap_retransmit_frames(sk);
+                       l2cap_retransmit_frames(chan);
        } else {
-               l2cap_retransmit_frames(sk);
+               l2cap_retransmit_frames(chan);
 
-               if (pi->conn_state & L2CAP_CONN_WAIT_F)
-                       pi->conn_state |= L2CAP_CONN_REJ_ACT;
+               if (chan->conn_state & L2CAP_CONN_WAIT_F)
+                       chan->conn_state |= L2CAP_CONN_REJ_ACT;
        }
 }
-static inline void l2cap_data_channel_srejframe(struct sock *sk, u16 rx_control)
+static inline void l2cap_data_channel_srejframe(struct l2cap_chan *chan, u16 rx_control)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        u8 tx_seq = __get_reqseq(rx_control);
 
-       BT_DBG("sk %p, req_seq %d ctrl 0x%4.4x", sk, tx_seq, rx_control);
+       BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
 
-       pi->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
+       chan->conn_state &= ~L2CAP_CONN_REMOTE_BUSY;
 
        if (rx_control & L2CAP_CTRL_POLL) {
-               pi->expected_ack_seq = tx_seq;
-               l2cap_drop_acked_frames(sk);
+               chan->expected_ack_seq = tx_seq;
+               l2cap_drop_acked_frames(chan);
 
-               pi->conn_state |= L2CAP_CONN_SEND_FBIT;
-               l2cap_retransmit_one_frame(sk, tx_seq);
+               chan->conn_state |= L2CAP_CONN_SEND_FBIT;
+               l2cap_retransmit_one_frame(chan, tx_seq);
 
-               l2cap_ertm_send(sk);
+               l2cap_ertm_send(chan);
 
-               if (pi->conn_state & L2CAP_CONN_WAIT_F) {
-                       pi->srej_save_reqseq = tx_seq;
-                       pi->conn_state |= L2CAP_CONN_SREJ_ACT;
+               if (chan->conn_state & L2CAP_CONN_WAIT_F) {
+                       chan->srej_save_reqseq = tx_seq;
+                       chan->conn_state |= L2CAP_CONN_SREJ_ACT;
                }
        } else if (rx_control & L2CAP_CTRL_FINAL) {
-               if ((pi->conn_state & L2CAP_CONN_SREJ_ACT) &&
-                               pi->srej_save_reqseq == tx_seq)
-                       pi->conn_state &= ~L2CAP_CONN_SREJ_ACT;
+               if ((chan->conn_state & L2CAP_CONN_SREJ_ACT) &&
+                               chan->srej_save_reqseq == tx_seq)
+                       chan->conn_state &= ~L2CAP_CONN_SREJ_ACT;
                else
-                       l2cap_retransmit_one_frame(sk, tx_seq);
+                       l2cap_retransmit_one_frame(chan, tx_seq);
        } else {
-               l2cap_retransmit_one_frame(sk, tx_seq);
-               if (pi->conn_state & L2CAP_CONN_WAIT_F) {
-                       pi->srej_save_reqseq = tx_seq;
-                       pi->conn_state |= L2CAP_CONN_SREJ_ACT;
+               l2cap_retransmit_one_frame(chan, tx_seq);
+               if (chan->conn_state & L2CAP_CONN_WAIT_F) {
+                       chan->srej_save_reqseq = tx_seq;
+                       chan->conn_state |= L2CAP_CONN_SREJ_ACT;
                }
        }
 }
 
-static inline void l2cap_data_channel_rnrframe(struct sock *sk, u16 rx_control)
+static inline void l2cap_data_channel_rnrframe(struct l2cap_chan *chan, u16 rx_control)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
        u8 tx_seq = __get_reqseq(rx_control);
 
-       BT_DBG("sk %p, req_seq %d ctrl 0x%4.4x", sk, tx_seq, rx_control);
+       BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
 
-       pi->conn_state |= L2CAP_CONN_REMOTE_BUSY;
-       pi->expected_ack_seq = tx_seq;
-       l2cap_drop_acked_frames(sk);
+       chan->conn_state |= L2CAP_CONN_REMOTE_BUSY;
+       chan->expected_ack_seq = tx_seq;
+       l2cap_drop_acked_frames(chan);
 
        if (rx_control & L2CAP_CTRL_POLL)
-               pi->conn_state |= L2CAP_CONN_SEND_FBIT;
+               chan->conn_state |= L2CAP_CONN_SEND_FBIT;
 
-       if (!(pi->conn_state & L2CAP_CONN_SREJ_SENT)) {
-               del_timer(&pi->retrans_timer);
+       if (!(chan->conn_state & L2CAP_CONN_SREJ_SENT)) {
+               del_timer(&chan->retrans_timer);
                if (rx_control & L2CAP_CTRL_POLL)
-                       l2cap_send_rr_or_rnr(pi, L2CAP_CTRL_FINAL);
+                       l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_FINAL);
                return;
        }
 
        if (rx_control & L2CAP_CTRL_POLL)
-               l2cap_send_srejtail(sk);
+               l2cap_send_srejtail(chan);
        else
-               l2cap_send_sframe(pi, L2CAP_SUPER_RCV_READY);
+               l2cap_send_sframe(chan, L2CAP_SUPER_RCV_READY);
 }
 
-static inline int l2cap_data_channel_sframe(struct sock *sk, u16 rx_control, struct sk_buff *skb)
+static inline int l2cap_data_channel_sframe(struct l2cap_chan *chan, u16 rx_control, struct sk_buff *skb)
 {
-       BT_DBG("sk %p rx_control 0x%4.4x len %d", sk, rx_control, skb->len);
+       BT_DBG("chan %p rx_control 0x%4.4x len %d", chan, rx_control, skb->len);
 
        if (L2CAP_CTRL_FINAL & rx_control &&
-                       l2cap_pi(sk)->conn_state & L2CAP_CONN_WAIT_F) {
-               del_timer(&l2cap_pi(sk)->monitor_timer);
-               if (l2cap_pi(sk)->unacked_frames > 0)
+                       chan->conn_state & L2CAP_CONN_WAIT_F) {
+               del_timer(&chan->monitor_timer);
+               if (chan->unacked_frames > 0)
                        __mod_retrans_timer();
-               l2cap_pi(sk)->conn_state &= ~L2CAP_CONN_WAIT_F;
+               chan->conn_state &= ~L2CAP_CONN_WAIT_F;
        }
 
        switch (rx_control & L2CAP_CTRL_SUPERVISE) {
        case L2CAP_SUPER_RCV_READY:
-               l2cap_data_channel_rrframe(sk, rx_control);
+               l2cap_data_channel_rrframe(chan, rx_control);
                break;
 
        case L2CAP_SUPER_REJECT:
-               l2cap_data_channel_rejframe(sk, rx_control);
+               l2cap_data_channel_rejframe(chan, rx_control);
                break;
 
        case L2CAP_SUPER_SELECT_REJECT:
-               l2cap_data_channel_srejframe(sk, rx_control);
+               l2cap_data_channel_srejframe(chan, rx_control);
                break;
 
        case L2CAP_SUPER_RCV_NOT_READY:
-               l2cap_data_channel_rnrframe(sk, rx_control);
+               l2cap_data_channel_rnrframe(chan, rx_control);
                break;
        }
 
@@ -3951,7 +3524,7 @@ static inline int l2cap_data_channel_sframe(struct sock *sk, u16 rx_control, str
 
 static int l2cap_ertm_data_rcv(struct sock *sk, struct sk_buff *skb)
 {
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        u16 control;
        u8 req_seq;
        int len, next_tx_seq_offset, req_seq_offset;
@@ -3965,51 +3538,51 @@ static int l2cap_ertm_data_rcv(struct sock *sk, struct sk_buff *skb)
         * Receiver will miss it and start proper recovery
         * procedures and ask retransmission.
         */
-       if (l2cap_check_fcs(pi, skb))
+       if (l2cap_check_fcs(chan, skb))
                goto drop;
 
        if (__is_sar_start(control) && __is_iframe(control))
                len -= 2;
 
-       if (pi->fcs == L2CAP_FCS_CRC16)
+       if (chan->fcs == L2CAP_FCS_CRC16)
                len -= 2;
 
-       if (len > pi->mps) {
-               l2cap_send_disconn_req(pi->conn, sk, ECONNRESET);
+       if (len > chan->mps) {
+               l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
                goto drop;
        }
 
        req_seq = __get_reqseq(control);
-       req_seq_offset = (req_seq - pi->expected_ack_seq) % 64;
+       req_seq_offset = (req_seq - chan->expected_ack_seq) % 64;
        if (req_seq_offset < 0)
                req_seq_offset += 64;
 
        next_tx_seq_offset =
-               (pi->next_tx_seq - pi->expected_ack_seq) % 64;
+               (chan->next_tx_seq - chan->expected_ack_seq) % 64;
        if (next_tx_seq_offset < 0)
                next_tx_seq_offset += 64;
 
        /* check for invalid req-seq */
        if (req_seq_offset > next_tx_seq_offset) {
-               l2cap_send_disconn_req(pi->conn, sk, ECONNRESET);
+               l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
                goto drop;
        }
 
        if (__is_iframe(control)) {
                if (len < 0) {
-                       l2cap_send_disconn_req(pi->conn, sk, ECONNRESET);
+                       l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
                        goto drop;
                }
 
-               l2cap_data_channel_iframe(sk, control, skb);
+               l2cap_data_channel_iframe(chan, control, skb);
        } else {
                if (len != 0) {
                        BT_ERR("%d", len);
-                       l2cap_send_disconn_req(pi->conn, sk, ECONNRESET);
+                       l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
                        goto drop;
                }
 
-               l2cap_data_channel_sframe(sk, control, skb);
+               l2cap_data_channel_sframe(chan, control, skb);
        }
 
        return 0;
@@ -4021,33 +3594,35 @@ drop:
 
 static inline int l2cap_data_channel(struct l2cap_conn *conn, u16 cid, struct sk_buff *skb)
 {
-       struct sock *sk;
+       struct l2cap_chan *chan;
+       struct sock *sk = NULL;
        struct l2cap_pinfo *pi;
        u16 control;
        u8 tx_seq;
        int len;
 
-       sk = l2cap_get_chan_by_scid(&conn->chan_list, cid);
-       if (!sk) {
+       chan = l2cap_get_chan_by_scid(conn, cid);
+       if (!chan) {
                BT_DBG("unknown cid 0x%4.4x", cid);
                goto drop;
        }
 
+       sk = chan->sk;
        pi = l2cap_pi(sk);
 
-       BT_DBG("sk %p, len %d", sk, skb->len);
+       BT_DBG("chan %p, len %d", chan, skb->len);
 
        if (sk->sk_state != BT_CONNECTED)
                goto drop;
 
-       switch (pi->mode) {
+       switch (chan->mode) {
        case L2CAP_MODE_BASIC:
                /* If socket recv buffers overflows we drop data here
                 * which is *bad* because L2CAP has to be reliable.
                 * But we don't have any other choice. L2CAP doesn't
                 * provide flow control mechanism. */
 
-               if (pi->imtu < skb->len)
+               if (chan->imtu < skb->len)
                        goto drop;
 
                if (!sock_queue_rcv_skb(sk, skb))
@@ -4069,31 +3644,31 @@ static inline int l2cap_data_channel(struct l2cap_conn *conn, u16 cid, struct sk
                skb_pull(skb, 2);
                len = skb->len;
 
-               if (l2cap_check_fcs(pi, skb))
+               if (l2cap_check_fcs(chan, skb))
                        goto drop;
 
                if (__is_sar_start(control))
                        len -= 2;
 
-               if (pi->fcs == L2CAP_FCS_CRC16)
+               if (chan->fcs == L2CAP_FCS_CRC16)
                        len -= 2;
 
-               if (len > pi->mps || len < 0 || __is_sframe(control))
+               if (len > chan->mps || len < 0 || __is_sframe(control))
                        goto drop;
 
                tx_seq = __get_txseq(control);
 
-               if (pi->expected_tx_seq == tx_seq)
-                       pi->expected_tx_seq = (pi->expected_tx_seq + 1) % 64;
+               if (chan->expected_tx_seq == tx_seq)
+                       chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
                else
-                       pi->expected_tx_seq = (tx_seq + 1) % 64;
+                       chan->expected_tx_seq = (tx_seq + 1) % 64;
 
-               l2cap_streaming_reassembly_sdu(sk, skb, control);
+               l2cap_streaming_reassembly_sdu(chan, skb, control);
 
                goto done;
 
        default:
-               BT_DBG("sk %p: bad mode 0x%2.2x", sk, pi->mode);
+               BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode);
                break;
        }
 
@@ -4122,7 +3697,37 @@ static inline int l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, str
        if (sk->sk_state != BT_BOUND && sk->sk_state != BT_CONNECTED)
                goto drop;
 
-       if (l2cap_pi(sk)->imtu < skb->len)
+       if (l2cap_pi(sk)->chan->imtu < skb->len)
+               goto drop;
+
+       if (!sock_queue_rcv_skb(sk, skb))
+               goto done;
+
+drop:
+       kfree_skb(skb);
+
+done:
+       if (sk)
+               bh_unlock_sock(sk);
+       return 0;
+}
+
+static inline int l2cap_att_channel(struct l2cap_conn *conn, __le16 cid, struct sk_buff *skb)
+{
+       struct sock *sk;
+
+       sk = l2cap_get_sock_by_scid(0, cid, conn->src);
+       if (!sk)
+               goto drop;
+
+       bh_lock_sock(sk);
+
+       BT_DBG("sk %p, len %d", sk, skb->len);
+
+       if (sk->sk_state != BT_BOUND && sk->sk_state != BT_CONNECTED)
+               goto drop;
+
+       if (l2cap_pi(sk)->chan->imtu < skb->len)
                goto drop;
 
        if (!sock_queue_rcv_skb(sk, skb))
@@ -4155,6 +3760,7 @@ static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
        BT_DBG("len %d, cid 0x%4.4x", len, cid);
 
        switch (cid) {
+       case L2CAP_CID_LE_SIGNALING:
        case L2CAP_CID_SIGNALING:
                l2cap_sig_channel(conn, skb);
                break;
@@ -4165,6 +3771,10 @@ static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
                l2cap_conless_channel(conn, psm, skb);
                break;
 
+       case L2CAP_CID_LE_DATA:
+               l2cap_att_channel(conn, cid, skb);
+               break;
+
        default:
                l2cap_data_channel(conn, cid, skb);
                break;
@@ -4187,17 +3797,19 @@ static int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
        /* Find listening sockets and check their link_mode */
        read_lock(&l2cap_sk_list.lock);
        sk_for_each(sk, node, &l2cap_sk_list.head) {
+               struct l2cap_chan *chan = l2cap_pi(sk)->chan;
+
                if (sk->sk_state != BT_LISTEN)
                        continue;
 
                if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) {
                        lm1 |= HCI_LM_ACCEPT;
-                       if (l2cap_pi(sk)->role_switch)
+                       if (chan->role_switch)
                                lm1 |= HCI_LM_MASTER;
                        exact++;
                } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
                        lm2 |= HCI_LM_ACCEPT;
-                       if (l2cap_pi(sk)->role_switch)
+                       if (chan->role_switch)
                                lm2 |= HCI_LM_MASTER;
                }
        }
@@ -4212,7 +3824,7 @@ static int l2cap_connect_cfm(struct hci_conn *hcon, u8 status)
 
        BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 
-       if (hcon->type != ACL_LINK)
+       if (!(hcon->type == ACL_LINK || hcon->type == LE_LINK))
                return -EINVAL;
 
        if (!status) {
@@ -4241,7 +3853,7 @@ static int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason)
 {
        BT_DBG("hcon %p reason %d", hcon, reason);
 
-       if (hcon->type != ACL_LINK)
+       if (!(hcon->type == ACL_LINK || hcon->type == LE_LINK))
                return -EINVAL;
 
        l2cap_conn_del(hcon, bt_err(reason));
@@ -4249,49 +3861,50 @@ static int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason)
        return 0;
 }
 
-static inline void l2cap_check_encryption(struct sock *sk, u8 encrypt)
+static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt)
 {
+       struct sock *sk = chan->sk;
+
        if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM)
                return;
 
        if (encrypt == 0x00) {
-               if (l2cap_pi(sk)->sec_level == BT_SECURITY_MEDIUM) {
+               if (chan->sec_level == BT_SECURITY_MEDIUM) {
                        l2cap_sock_clear_timer(sk);
                        l2cap_sock_set_timer(sk, HZ * 5);
-               } else if (l2cap_pi(sk)->sec_level == BT_SECURITY_HIGH)
+               } else if (chan->sec_level == BT_SECURITY_HIGH)
                        __l2cap_sock_close(sk, ECONNREFUSED);
        } else {
-               if (l2cap_pi(sk)->sec_level == BT_SECURITY_MEDIUM)
+               if (chan->sec_level == BT_SECURITY_MEDIUM)
                        l2cap_sock_clear_timer(sk);
        }
 }
 
 static int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
 {
-       struct l2cap_chan_list *l;
        struct l2cap_conn *conn = hcon->l2cap_data;
-       struct sock *sk;
+       struct l2cap_chan *chan;
 
        if (!conn)
                return 0;
 
-       l = &conn->chan_list;
-
        BT_DBG("conn %p", conn);
 
-       read_lock(&l->lock);
+       read_lock(&conn->chan_lock);
+
+       list_for_each_entry(chan, &conn->chan_l, list) {
+               struct sock *sk = chan->sk;
 
-       for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
                bh_lock_sock(sk);
 
-               if (l2cap_pi(sk)->conf_state & L2CAP_CONF_CONNECT_PEND) {
+               if (chan->conf_state & L2CAP_CONF_CONNECT_PEND) {
                        bh_unlock_sock(sk);
                        continue;
                }
 
                if (!status && (sk->sk_state == BT_CONNECTED ||
                                                sk->sk_state == BT_CONFIG)) {
-                       l2cap_check_encryption(sk, encrypt);
+                       l2cap_check_encryption(chan, encrypt);
                        bh_unlock_sock(sk);
                        continue;
                }
@@ -4299,13 +3912,13 @@ static int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
                if (sk->sk_state == BT_CONNECT) {
                        if (!status) {
                                struct l2cap_conn_req req;
-                               req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
-                               req.psm  = l2cap_pi(sk)->psm;
+                               req.scid = cpu_to_le16(chan->scid);
+                               req.psm  = chan->psm;
 
-                               l2cap_pi(sk)->ident = l2cap_get_ident(conn);
-                               l2cap_pi(sk)->conf_state |= L2CAP_CONF_CONNECT_PEND;
+                               chan->ident = l2cap_get_ident(conn);
+                               chan->conf_state |= L2CAP_CONF_CONNECT_PEND;
 
-                               l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
+                               l2cap_send_cmd(conn, chan->ident,
                                        L2CAP_CONN_REQ, sizeof(req), &req);
                        } else {
                                l2cap_sock_clear_timer(sk);
@@ -4324,18 +3937,18 @@ static int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
                                result = L2CAP_CR_SEC_BLOCK;
                        }
 
-                       rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
-                       rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
+                       rsp.scid   = cpu_to_le16(chan->dcid);
+                       rsp.dcid   = cpu_to_le16(chan->scid);
                        rsp.result = cpu_to_le16(result);
                        rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
-                       l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
-                                       L2CAP_CONN_RSP, sizeof(rsp), &rsp);
+                       l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
+                                                       sizeof(rsp), &rsp);
                }
 
                bh_unlock_sock(sk);
        }
 
-       read_unlock(&l->lock);
+       read_unlock(&conn->chan_lock);
 
        return 0;
 }
@@ -4354,7 +3967,7 @@ static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 fl
 
        if (!(flags & ACL_CONT)) {
                struct l2cap_hdr *hdr;
-               struct sock *sk;
+               struct l2cap_chan *chan;
                u16 cid;
                int len;
 
@@ -4392,18 +4005,21 @@ static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 fl
                        goto drop;
                }
 
-               sk = l2cap_get_chan_by_scid(&conn->chan_list, cid);
+               chan = l2cap_get_chan_by_scid(conn, cid);
 
-               if (sk && l2cap_pi(sk)->imtu < len - L2CAP_HDR_SIZE) {
-                       BT_ERR("Frame exceeding recv MTU (len %d, MTU %d)",
-                                       len, l2cap_pi(sk)->imtu);
-                       bh_unlock_sock(sk);
-                       l2cap_conn_unreliable(conn, ECOMM);
-                       goto drop;
-               }
+               if (chan && chan->sk) {
+                       struct sock *sk = chan->sk;
 
-               if (sk)
+                       if (chan->imtu < len - L2CAP_HDR_SIZE) {
+                               BT_ERR("Frame exceeding recv MTU (len %d, "
+                                                       "MTU %d)", len,
+                                                       chan->imtu);
+                               bh_unlock_sock(sk);
+                               l2cap_conn_unreliable(conn, ECOMM);
+                               goto drop;
+                       }
                        bh_unlock_sock(sk);
+               }
 
                /* Allocate skb for the complete frame (with header) */
                conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC);
@@ -4457,13 +4073,15 @@ static int l2cap_debugfs_show(struct seq_file *f, void *p)
 
        sk_for_each(sk, node, &l2cap_sk_list.head) {
                struct l2cap_pinfo *pi = l2cap_pi(sk);
+               struct l2cap_chan *chan = pi->chan;
 
-               seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d\n",
+               seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n",
                                        batostr(&bt_sk(sk)->src),
                                        batostr(&bt_sk(sk)->dst),
-                                       sk->sk_state, __le16_to_cpu(pi->psm),
-                                       pi->scid, pi->dcid,
-                                       pi->imtu, pi->omtu, pi->sec_level);
+                                       sk->sk_state, __le16_to_cpu(chan->psm),
+                                       chan->scid, chan->dcid,
+                                       chan->imtu, chan->omtu, chan->sec_level,
+                                       chan->mode);
        }
 
        read_unlock_bh(&l2cap_sk_list.lock);
@@ -4496,7 +4114,7 @@ static struct hci_proto l2cap_hci_proto = {
        .recv_acldata   = l2cap_recv_acldata
 };
 
-static int __init l2cap_init(void)
+int __init l2cap_init(void)
 {
        int err;
 
@@ -4524,9 +4142,6 @@ static int __init l2cap_init(void)
                        BT_ERR("Failed to create L2CAP debug file");
        }
 
-       BT_INFO("L2CAP ver %s", VERSION);
-       BT_INFO("L2CAP socket layer initialized");
-
        return 0;
 
 error:
@@ -4535,7 +4150,7 @@ error:
        return err;
 }
 
-static void __exit l2cap_exit(void)
+void l2cap_exit(void)
 {
        debugfs_remove(l2cap_debugfs);
 
@@ -4548,22 +4163,5 @@ static void __exit l2cap_exit(void)
        l2cap_cleanup_sockets();
 }
 
-void l2cap_load(void)
-{
-       /* Dummy function to trigger automatic L2CAP module loading by
-        * other modules that use L2CAP sockets but don't use any other
-        * symbols from it. */
-}
-EXPORT_SYMBOL(l2cap_load);
-
-module_init(l2cap_init);
-module_exit(l2cap_exit);
-
 module_param(disable_ertm, bool, 0644);
 MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode");
-
-MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
-MODULE_DESCRIPTION("Bluetooth L2CAP ver " VERSION);
-MODULE_VERSION(VERSION);
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("bt-proto-0");