/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated
   Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>
   Copyright (C) 2010 Google Inc.
   Copyright (C) 2011 ProFUSION Embedded Systems
   Copyright (c) 2012 Code Aurora Forum.  All rights reserved.

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth L2CAP core. */

#include <linux/module.h>

#include <linux/debugfs.h>
#include <linux/crc16.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/l2cap.h>
#include <net/bluetooth/smp.h>
#include <net/bluetooth/a2mp.h>

bool disable_ertm;

static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN;
static u8 l2cap_fixed_chan[8] = { L2CAP_FC_L2CAP, };

static LIST_HEAD(chan_list);
static DEFINE_RWLOCK(chan_list_lock);

static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
                                u8 code, u8 ident, u16 dlen, void *data);
static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len,
                                                                void *data);
static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data);
static void l2cap_send_disconn_req(struct l2cap_conn *conn,
                                   struct l2cap_chan *chan, int err);

static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control,
                    struct sk_buff_head *skbs, u8 event);

/* ---- L2CAP channels ---- */

static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, u16 cid)
{
        struct l2cap_chan *c;

        list_for_each_entry(c, &conn->chan_l, list) {
                if (c->dcid == cid)
                        return c;
        }
        return NULL;
}

static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)
{
        struct l2cap_chan *c;

        list_for_each_entry(c, &conn->chan_l, list) {
                if (c->scid == cid)
                        return c;
        }
        return NULL;
}

/* Find channel with given SCID.
 * Returns locked channel. */
static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)
{
        struct l2cap_chan *c;

        mutex_lock(&conn->chan_lock);
        c = __l2cap_get_chan_by_scid(conn, cid);
        if (c)
                l2cap_chan_lock(c);
        mutex_unlock(&conn->chan_lock);

        return c;
}

static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident)
{
        struct l2cap_chan *c;

        list_for_each_entry(c, &conn->chan_l, list) {
                if (c->ident == ident)
                        return c;
        }
        return NULL;
}

static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src)
{
        struct l2cap_chan *c;

        list_for_each_entry(c, &chan_list, global_l) {
                if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src))
                        return c;
        }
        return NULL;
}

int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm)
{
        int err;

        write_lock(&chan_list_lock);

        if (psm && __l2cap_global_chan_by_addr(psm, src)) {
                err = -EADDRINUSE;
                goto done;
        }

        if (psm) {
                chan->psm = psm;
                chan->sport = psm;
                err = 0;
        } else {
                u16 p;

                err = -EINVAL;
                for (p = 0x1001; p < 0x1100; p += 2)
                        if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) {
                                chan->psm   = cpu_to_le16(p);
                                chan->sport = cpu_to_le16(p);
                                err = 0;
                                break;
                        }
        }

done:
        write_unlock(&chan_list_lock);
        return err;
}

int l2cap_add_scid(struct l2cap_chan *chan,  __u16 scid)
{
        write_lock(&chan_list_lock);

        chan->scid = scid;

        write_unlock(&chan_list_lock);

        return 0;
}

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(conn, cid))
                        return cid;
        }

        return 0;
}

static void __l2cap_state_change(struct l2cap_chan *chan, int state)
{
        BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state),
                                                state_to_string(state));

        chan->state = state;
        chan->ops->state_change(chan, state);
}

static void l2cap_state_change(struct l2cap_chan *chan, int state)
{
        struct sock *sk = chan->sk;

        lock_sock(sk);
        __l2cap_state_change(chan, state);
        release_sock(sk);
}

static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err)
{
        struct sock *sk = chan->sk;

        sk->sk_err = err;
}

static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err)
{
        struct sock *sk = chan->sk;

        lock_sock(sk);
        __l2cap_chan_set_err(chan, err);
        release_sock(sk);
}

static void __set_retrans_timer(struct l2cap_chan *chan)
{
        if (!delayed_work_pending(&chan->monitor_timer) &&
            chan->retrans_timeout) {
                l2cap_set_timer(chan, &chan->retrans_timer,
                                msecs_to_jiffies(chan->retrans_timeout));
        }
}

static void __set_monitor_timer(struct l2cap_chan *chan)
{
        __clear_retrans_timer(chan);
        if (chan->monitor_timeout) {
                l2cap_set_timer(chan, &chan->monitor_timer,
                                msecs_to_jiffies(chan->monitor_timeout));
        }
}

static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head,
                                               u16 seq)
{
        struct sk_buff *skb;

        skb_queue_walk(head, skb) {
                if (bt_cb(skb)->control.txseq == seq)
                        return skb;
        }

        return NULL;
}

/* ---- L2CAP sequence number lists ---- */

/* For ERTM, ordered lists of sequence numbers must be tracked for
 * SREJ requests that are received and for frames that are to be
 * retransmitted. These seq_list functions implement a singly-linked
 * list in an array, where membership in the list can also be checked
 * in constant time. Items can also be added to the tail of the list
 * and removed from the head in constant time, without further memory
 * allocs or frees.
 */

static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size)
{
        size_t alloc_size, i;

        /* Allocated size is a power of 2 to map sequence numbers
         * (which may be up to 14 bits) in to a smaller array that is
         * sized for the negotiated ERTM transmit windows.
         */
        alloc_size = roundup_pow_of_two(size);

        seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL);
        if (!seq_list->list)
                return -ENOMEM;

        seq_list->mask = alloc_size - 1;
        seq_list->head = L2CAP_SEQ_LIST_CLEAR;
        seq_list->tail = L2CAP_SEQ_LIST_CLEAR;
        for (i = 0; i < alloc_size; i++)
                seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR;

        return 0;
}

static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list)
{
        kfree(seq_list->list);
}

static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list,
                                           u16 seq)
{
        /* Constant-time check for list membership */
        return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR;
}

static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq)
{
        u16 mask = seq_list->mask;

        if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) {
                /* In case someone tries to pop the head of an empty list */
                return L2CAP_SEQ_LIST_CLEAR;
        } else if (seq_list->head == seq) {
                /* Head can be removed in constant time */
                seq_list->head = seq_list->list[seq & mask];
                seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR;

                if (seq_list->head == L2CAP_SEQ_LIST_TAIL) {
                        seq_list->head = L2CAP_SEQ_LIST_CLEAR;
                        seq_list->tail = L2CAP_SEQ_LIST_CLEAR;
                }
        } else {
                /* Walk the list to find the sequence number */
                u16 prev = seq_list->head;
                while (seq_list->list[prev & mask] != seq) {
                        prev = seq_list->list[prev & mask];
                        if (prev == L2CAP_SEQ_LIST_TAIL)
                                return L2CAP_SEQ_LIST_CLEAR;
                }

                /* Unlink the number from the list and clear it */
                seq_list->list[prev & mask] = seq_list->list[seq & mask];
                seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR;
                if (seq_list->tail == seq)
                        seq_list->tail = prev;
        }
        return seq;
}

static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list)
{
        /* Remove the head in constant time */
        return l2cap_seq_list_remove(seq_list, seq_list->head);
}

static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list)
{
        u16 i;

        if (seq_list->head == L2CAP_SEQ_LIST_CLEAR)
                return;

        for (i = 0; i <= seq_list->mask; i++)
                seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR;

        seq_list->head = L2CAP_SEQ_LIST_CLEAR;
        seq_list->tail = L2CAP_SEQ_LIST_CLEAR;
}

static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq)
{
        u16 mask = seq_list->mask;

        /* All appends happen in constant time */

        if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR)
                return;

        if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR)
                seq_list->head = seq;
        else
                seq_list->list[seq_list->tail & mask] = seq;

        seq_list->tail = seq;
        seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL;
}

static void l2cap_chan_timeout(struct work_struct *work)
{
        struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
                                                        chan_timer.work);
        struct l2cap_conn *conn = chan->conn;
        int reason;

        BT_DBG("chan %p state %s", chan, state_to_string(chan->state));

        mutex_lock(&conn->chan_lock);
        l2cap_chan_lock(chan);

        if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG)
                reason = ECONNREFUSED;
        else if (chan->state == BT_CONNECT &&
                                        chan->sec_level != BT_SECURITY_SDP)
                reason = ECONNREFUSED;
        else
                reason = ETIMEDOUT;

        l2cap_chan_close(chan, reason);

        l2cap_chan_unlock(chan);

        chan->ops->close(chan);
        mutex_unlock(&conn->chan_lock);

        l2cap_chan_put(chan);
}

struct l2cap_chan *l2cap_chan_create(void)
{
        struct l2cap_chan *chan;

        chan = kzalloc(sizeof(*chan), GFP_ATOMIC);
        if (!chan)
                return NULL;

        mutex_init(&chan->lock);

        write_lock(&chan_list_lock);
        list_add(&chan->global_l, &chan_list);
        write_unlock(&chan_list_lock);

        INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout);

        chan->state = BT_OPEN;

        atomic_set(&chan->refcnt, 1);

        /* This flag is cleared in l2cap_chan_ready() */
        set_bit(CONF_NOT_COMPLETE, &chan->conf_state);

        BT_DBG("chan %p", chan);

        return chan;
}

void l2cap_chan_destroy(struct l2cap_chan *chan)
{
        write_lock(&chan_list_lock);
        list_del(&chan->global_l);
        write_unlock(&chan_list_lock);

        l2cap_chan_put(chan);
}

void l2cap_chan_set_defaults(struct l2cap_chan *chan)
{
        chan->fcs  = L2CAP_FCS_CRC16;
        chan->max_tx = L2CAP_DEFAULT_MAX_TX;
        chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
        chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
        chan->ack_win = L2CAP_DEFAULT_TX_WINDOW;
        chan->sec_level = BT_SECURITY_LOW;

        set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
}

static void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
{
        BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn,
               __le16_to_cpu(chan->psm), chan->dcid);

        conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;

        chan->conn = conn;

        switch (chan->chan_type) {
        case L2CAP_CHAN_CONN_ORIENTED:
                if (conn->hcon->type == LE_LINK) {
                        /* LE connection */
                        chan->omtu = L2CAP_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;
                }
                break;

        case L2CAP_CHAN_CONN_LESS:
                /* Connectionless socket */
                chan->scid = L2CAP_CID_CONN_LESS;
                chan->dcid = L2CAP_CID_CONN_LESS;
                chan->omtu = L2CAP_DEFAULT_MTU;
                break;

        case L2CAP_CHAN_CONN_FIX_A2MP:
                chan->scid = L2CAP_CID_A2MP;
                chan->dcid = L2CAP_CID_A2MP;
                chan->omtu = L2CAP_A2MP_DEFAULT_MTU;
                chan->imtu = L2CAP_A2MP_DEFAULT_MTU;
                break;

        default:
                /* Raw socket can send/recv signalling messages only */
                chan->scid = L2CAP_CID_SIGNALING;
                chan->dcid = L2CAP_CID_SIGNALING;
                chan->omtu = L2CAP_DEFAULT_MTU;
        }

        chan->local_id          = L2CAP_BESTEFFORT_ID;
        chan->local_stype       = L2CAP_SERV_BESTEFFORT;
        chan->local_msdu        = L2CAP_DEFAULT_MAX_SDU_SIZE;
        chan->local_sdu_itime   = L2CAP_DEFAULT_SDU_ITIME;
        chan->local_acc_lat     = L2CAP_DEFAULT_ACC_LAT;
        chan->local_flush_to    = L2CAP_DEFAULT_FLUSH_TO;

        l2cap_chan_hold(chan);

        list_add(&chan->list, &conn->chan_l);
}

void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
{
        mutex_lock(&conn->chan_lock);
        __l2cap_chan_add(conn, chan);
        mutex_unlock(&conn->chan_lock);
}

void l2cap_chan_del(struct l2cap_chan *chan, int err)
{
        struct l2cap_conn *conn = chan->conn;

        __clear_chan_timer(chan);

        BT_DBG("chan %p, conn %p, err %d", chan, conn, err);

        if (conn) {
                /* Delete from channel list */
                list_del(&chan->list);

                l2cap_chan_put(chan);

                chan->conn = NULL;

                if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP)
                        hci_conn_put(conn->hcon);
        }

        if (chan->ops->teardown)
                chan->ops->teardown(chan, err);

        if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state))
                return;

        switch(chan->mode) {
        case L2CAP_MODE_BASIC:
                break;

        case L2CAP_MODE_ERTM:
                __clear_retrans_timer(chan);
                __clear_monitor_timer(chan);
                __clear_ack_timer(chan);

                skb_queue_purge(&chan->srej_q);

                l2cap_seq_list_free(&chan->srej_list);
                l2cap_seq_list_free(&chan->retrans_list);

                /* fall through */

        case L2CAP_MODE_STREAMING:
                skb_queue_purge(&chan->tx_q);
                break;
        }

        return;
}

void l2cap_chan_close(struct l2cap_chan *chan, int reason)
{
        struct l2cap_conn *conn = chan->conn;
        struct sock *sk = chan->sk;

        BT_DBG("chan %p state %s sk %p", chan,
                                        state_to_string(chan->state), sk);

        switch (chan->state) {
        case BT_LISTEN:
                if (chan->ops->teardown)
                        chan->ops->teardown(chan, 0);
                break;

        case BT_CONNECTED:
        case BT_CONFIG:
                if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED &&
                                        conn->hcon->type == ACL_LINK) {
                        __set_chan_timer(chan, sk->sk_sndtimeo);
                        l2cap_send_disconn_req(conn, chan, reason);
                } else
                        l2cap_chan_del(chan, reason);
                break;

        case BT_CONNECT2:
                if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED &&
                                        conn->hcon->type == ACL_LINK) {
                        struct l2cap_conn_rsp rsp;
                        __u16 result;

                        if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
                                result = L2CAP_CR_SEC_BLOCK;
                        else
                                result = L2CAP_CR_BAD_PSM;
                        l2cap_state_change(chan, BT_DISCONN);

                        rsp.scid   = cpu_to_le16(chan->dcid);
                        rsp.dcid   = cpu_to_le16(chan->scid);
                        rsp.result = cpu_to_le16(result);
                        rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO);
                        l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
                                                        sizeof(rsp), &rsp);
                }

                l2cap_chan_del(chan, reason);
                break;

        case BT_CONNECT:
        case BT_DISCONN:
                l2cap_chan_del(chan, reason);
                break;

        default:
                if (chan->ops->teardown)
                        chan->ops->teardown(chan, 0);
                break;
        }
}

static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan)
{
        if (chan->chan_type == L2CAP_CHAN_RAW) {
                switch (chan->sec_level) {
                case BT_SECURITY_HIGH:
                        return HCI_AT_DEDICATED_BONDING_MITM;
                case BT_SECURITY_MEDIUM:
                        return HCI_AT_DEDICATED_BONDING;
                default:
                        return HCI_AT_NO_BONDING;
                }
        } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) {
                if (chan->sec_level == BT_SECURITY_LOW)
                        chan->sec_level = BT_SECURITY_SDP;

                if (chan->sec_level == BT_SECURITY_HIGH)
                        return HCI_AT_NO_BONDING_MITM;
                else
                        return HCI_AT_NO_BONDING;
        } else {
                switch (chan->sec_level) {
                case BT_SECURITY_HIGH:
                        return HCI_AT_GENERAL_BONDING_MITM;
                case BT_SECURITY_MEDIUM:
                        return HCI_AT_GENERAL_BONDING;
                default:
                        return HCI_AT_NO_BONDING;
                }
        }
}

/* Service level security */
int l2cap_chan_check_security(struct l2cap_chan *chan)
{
        struct l2cap_conn *conn = chan->conn;
        __u8 auth_type;

        auth_type = l2cap_get_auth_type(chan);

        return hci_conn_security(conn->hcon, chan->sec_level, auth_type);
}

static u8 l2cap_get_ident(struct l2cap_conn *conn)
{
        u8 id;

        /* Get next available identificator.
         *    1 - 128 are used by kernel.
         *  129 - 199 are reserved.
         *  200 - 254 are used by utilities like l2ping, etc.
         */

        spin_lock(&conn->lock);

        if (++conn->tx_ident > 128)
                conn->tx_ident = 1;

        id = conn->tx_ident;

        spin_unlock(&conn->lock);

        return id;
}

static 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;

        BT_DBG("code 0x%2.2x", code);

        if (!skb)
                return;

        if (lmp_no_flush_capable(conn->hcon->hdev))
                flags = ACL_START_NO_FLUSH;
        else
                flags = ACL_START;

        bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON;
        skb->priority = HCI_PRIO_MAX;

        hci_send_acl(conn->hchan, skb, flags);
}

static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb)
{
        struct hci_conn *hcon = chan->conn->hcon;
        u16 flags;

        BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len,
                                                        skb->priority);

        if (!test_bit(FLAG_FLUSHABLE, &chan->flags) &&
                                        lmp_no_flush_capable(hcon->hdev))
                flags = ACL_START_NO_FLUSH;
        else
                flags = ACL_START;

        bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
        hci_send_acl(chan->conn->hchan, skb, flags);
}

static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control)
{
        control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT;
        control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT;

        if (enh & L2CAP_CTRL_FRAME_TYPE) {
                /* S-Frame */
                control->sframe = 1;
                control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT;
                control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT;

                control->sar = 0;
                control->txseq = 0;
        } else {
                /* I-Frame */
                control->sframe = 0;
                control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT;
                control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT;

                control->poll = 0;
                control->super = 0;
        }
}

static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control)
{
        control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT;
        control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT;

        if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) {
                /* S-Frame */
                control->sframe = 1;
                control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT;
                control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT;

                control->sar = 0;
                control->txseq = 0;
        } else {
                /* I-Frame */
                control->sframe = 0;
                control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT;
                control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT;

                control->poll = 0;
                control->super = 0;
        }
}

static inline void __unpack_control(struct l2cap_chan *chan,
                                    struct sk_buff *skb)
{
        if (test_bit(FLAG_EXT_CTRL, &chan->flags)) {
                __unpack_extended_control(get_unaligned_le32(skb->data),
                                          &bt_cb(skb)->control);
                skb_pull(skb, L2CAP_EXT_CTRL_SIZE);
        } else {
                __unpack_enhanced_control(get_unaligned_le16(skb->data),
                                          &bt_cb(skb)->control);
                skb_pull(skb, L2CAP_ENH_CTRL_SIZE);
        }
}

static u32 __pack_extended_control(struct l2cap_ctrl *control)
{
        u32 packed;

        packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT;
        packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT;

        if (control->sframe) {
                packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT;
                packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT;
                packed |= L2CAP_EXT_CTRL_FRAME_TYPE;
        } else {
                packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT;
                packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT;
        }

        return packed;
}

static u16 __pack_enhanced_control(struct l2cap_ctrl *control)
{
        u16 packed;

        packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT;
        packed |= control->final << L2CAP_CTRL_FINAL_SHIFT;

        if (control->sframe) {
                packed |= control->poll << L2CAP_CTRL_POLL_SHIFT;
                packed |= control->super << L2CAP_CTRL_SUPER_SHIFT;
                packed |= L2CAP_CTRL_FRAME_TYPE;
        } else {
                packed |= control->sar << L2CAP_CTRL_SAR_SHIFT;
                packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT;
        }

        return packed;
}

static inline void __pack_control(struct l2cap_chan *chan,
                                  struct l2cap_ctrl *control,
                                  struct sk_buff *skb)
{
        if (test_bit(FLAG_EXT_CTRL, &chan->flags)) {
                put_unaligned_le32(__pack_extended_control(control),
                                   skb->data + L2CAP_HDR_SIZE);
        } else {
                put_unaligned_le16(__pack_enhanced_control(control),
                                   skb->data + L2CAP_HDR_SIZE);
        }
}

static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan)
{
        if (test_bit(FLAG_EXT_CTRL, &chan->flags))
                return L2CAP_EXT_HDR_SIZE;
        else
                return L2CAP_ENH_HDR_SIZE;
}

static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan,
                                               u32 control)
{
        struct sk_buff *skb;
        struct l2cap_hdr *lh;
        int hlen = __ertm_hdr_size(chan);

        if (chan->fcs == L2CAP_FCS_CRC16)
                hlen += L2CAP_FCS_SIZE;

        skb = bt_skb_alloc(hlen, GFP_KERNEL);

        if (!skb)
                return ERR_PTR(-ENOMEM);

        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
        lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE);
        lh->cid = cpu_to_le16(chan->dcid);

        if (test_bit(FLAG_EXT_CTRL, &chan->flags))
                put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE));
        else
                put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE));

        if (chan->fcs == L2CAP_FCS_CRC16) {
                u16 fcs = crc16(0, (u8 *)skb->data, skb->len);
                put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE));
        }

        skb->priority = HCI_PRIO_MAX;
        return skb;
}

static void l2cap_send_sframe(struct l2cap_chan *chan,
                              struct l2cap_ctrl *control)
{
        struct sk_buff *skb;
        u32 control_field;

        BT_DBG("chan %p, control %p", chan, control);

        if (!control->sframe)
                return;

        if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) &&
            !control->poll)
                control->final = 1;

        if (control->super == L2CAP_SUPER_RR)
                clear_bit(CONN_RNR_SENT, &chan->conn_state);
        else if (control->super == L2CAP_SUPER_RNR)
                set_bit(CONN_RNR_SENT, &chan->conn_state);

        if (control->super != L2CAP_SUPER_SREJ) {
                chan->last_acked_seq = control->reqseq;
                __clear_ack_timer(chan);
        }

        BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq,
               control->final, control->poll, control->super);

        if (test_bit(FLAG_EXT_CTRL, &chan->flags))
                control_field = __pack_extended_control(control);
        else
                control_field = __pack_enhanced_control(control);

        skb = l2cap_create_sframe_pdu(chan, control_field);
        if (!IS_ERR(skb))
                l2cap_do_send(chan, skb);
}

static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll)
{
        struct l2cap_ctrl control;

        BT_DBG("chan %p, poll %d", chan, poll);

        memset(&control, 0, sizeof(control));
        control.sframe = 1;
        control.poll = poll;

        if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state))
                control.super = L2CAP_SUPER_RNR;
        else
                control.super = L2CAP_SUPER_RR;

        control.reqseq = chan->buffer_seq;
        l2cap_send_sframe(chan, &control);
}

static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan)
{
        return !test_bit(CONF_CONNECT_PEND, &chan->conf_state);
}

static void l2cap_send_conn_req(struct l2cap_chan *chan)
{
        struct l2cap_conn *conn = chan->conn;
        struct l2cap_conn_req req;

        req.scid = cpu_to_le16(chan->scid);
        req.psm  = chan->psm;

        chan->ident = l2cap_get_ident(conn);

        set_bit(CONF_CONNECT_PEND, &chan->conf_state);

        l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req);
}

static void l2cap_chan_ready(struct l2cap_chan *chan)
{
        /* This clears all conf flags, including CONF_NOT_COMPLETE */
        chan->conf_state = 0;
        __clear_chan_timer(chan);

        chan->state = BT_CONNECTED;

        chan->ops->ready(chan);
}

static void l2cap_do_start(struct l2cap_chan *chan)
{
        struct l2cap_conn *conn = chan->conn;

        if (conn->hcon->type == LE_LINK) {
                l2cap_chan_ready(chan);
                return;
        }

        if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) {
                if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
                        return;

                if (l2cap_chan_check_security(chan) &&
                                __l2cap_no_conn_pending(chan))
                        l2cap_send_conn_req(chan);
        } else {
                struct l2cap_info_req req;
                req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK);

                conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
                conn->info_ident = l2cap_get_ident(conn);

                schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT);

                l2cap_send_cmd(conn, conn->info_ident,
                                        L2CAP_INFO_REQ, sizeof(req), &req);
        }
}

static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask)
{
        u32 local_feat_mask = l2cap_feat_mask;
        if (!disable_ertm)
                local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING;

        switch (mode) {
        case L2CAP_MODE_ERTM:
                return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask;
        case L2CAP_MODE_STREAMING:
                return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask;
        default:
                return 0x00;
        }

}

static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err)
{
        struct sock *sk = chan->sk;
        struct l2cap_disconn_req req;

        if (!conn)
                return;

        if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) {
                __clear_retrans_timer(chan);
                __clear_monitor_timer(chan);
                __clear_ack_timer(chan);
        }

        if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) {
                __l2cap_state_change(chan, BT_DISCONN);
                return;
        }

        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);

        lock_sock(sk);
        __l2cap_state_change(chan, BT_DISCONN);
        __l2cap_chan_set_err(chan, err);
        release_sock(sk);
}

/* ---- L2CAP connections ---- */
static void l2cap_conn_start(struct l2cap_conn *conn)
{
        struct l2cap_chan *chan, *tmp;

        BT_DBG("conn %p", conn);

        mutex_lock(&conn->chan_lock);

        list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) {
                struct sock *sk = chan->sk;

                l2cap_chan_lock(chan);

                if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
                        l2cap_chan_unlock(chan);
                        continue;
                }

                if (chan->state == BT_CONNECT) {
                        if (!l2cap_chan_check_security(chan) ||
                                        !__l2cap_no_conn_pending(chan)) {
                                l2cap_chan_unlock(chan);
                                continue;
                        }

                        if (!l2cap_mode_supported(chan->mode, conn->feat_mask)
                                        && test_bit(CONF_STATE2_DEVICE,
                                        &chan->conf_state)) {
                                l2cap_chan_close(chan, ECONNRESET);
                                l2cap_chan_unlock(chan);
                                continue;
                        }

                        l2cap_send_conn_req(chan);

                } else if (chan->state == BT_CONNECT2) {
                        struct l2cap_conn_rsp rsp;
                        char buf[128];
                        rsp.scid = cpu_to_le16(chan->dcid);
                        rsp.dcid = cpu_to_le16(chan->scid);

                        if (l2cap_chan_check_security(chan)) {
                                lock_sock(sk);
                                if (test_bit(BT_SK_DEFER_SETUP,
                                             &bt_sk(sk)->flags)) {
                                        struct sock *parent = bt_sk(sk)->parent;
                                        rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND);
                                        rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND);
                                        if (parent)
                                                parent->sk_data_ready(parent, 0);

                                } else {
                                        __l2cap_state_change(chan, BT_CONFIG);
                                        rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS);
                                        rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO);
                                }
                                release_sock(sk);
                        } else {
                                rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND);
                                rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND);
                        }

                        l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
                                                        sizeof(rsp), &rsp);

                        if (test_bit(CONF_REQ_SENT, &chan->conf_state) ||
                                        rsp.result != L2CAP_CR_SUCCESS) {
                                l2cap_chan_unlock(chan);
                                continue;
                        }

                        set_bit(CONF_REQ_SENT, &chan->conf_state);
                        l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
                                                l2cap_build_conf_req(chan, buf), buf);
                        chan->num_conf_req++;
                }

                l2cap_chan_unlock(chan);
        }

        mutex_unlock(&conn->chan_lock);
}

/* Find socket with cid and source/destination bdaddr.
 * Returns closest match, locked.
 */
static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid,
                                                    bdaddr_t *src,
                                                    bdaddr_t *dst)
{
        struct l2cap_chan *c, *c1 = NULL;

        read_lock(&chan_list_lock);

        list_for_each_entry(c, &chan_list, global_l) {
                struct sock *sk = c->sk;

                if (state && c->state != state)
                        continue;

                if (c->scid == cid) {
                        int src_match, dst_match;
                        int src_any, dst_any;

                        /* Exact match. */
                        src_match = !bacmp(&bt_sk(sk)->src, src);
                        dst_match = !bacmp(&bt_sk(sk)->dst, dst);
                        if (src_match && dst_match) {
                                read_unlock(&chan_list_lock);
                                return c;
                        }

                        /* Closest match */
                        src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY);
                        dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY);
                        if ((src_match && dst_any) || (src_any && dst_match) ||
                            (src_any && dst_any))
                                c1 = c;
                }
        }

        read_unlock(&chan_list_lock);

        return c1;
}

static void l2cap_le_conn_ready(struct l2cap_conn *conn)
{
        struct sock *parent, *sk;
        struct l2cap_chan *chan, *pchan;

        BT_DBG("");

        /* Check if we have socket listening on cid */
        pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA,
                                          conn->src, conn->dst);
        if (!pchan)
                return;

        parent = pchan->sk;

        lock_sock(parent);

        chan = pchan->ops->new_connection(pchan);
        if (!chan)
                goto clean;

        sk = chan->sk;

        hci_conn_hold(conn->hcon);
        conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT;

        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_chan_ready(chan);

clean:
        release_sock(parent);
}

static void l2cap_conn_ready(struct l2cap_conn *conn)
{
        struct l2cap_chan *chan;
        struct hci_conn *hcon = conn->hcon;

        BT_DBG("conn %p", conn);

        if (!hcon->out && hcon->type == LE_LINK)
                l2cap_le_conn_ready(conn);

        if (hcon->out && hcon->type == LE_LINK)
                smp_conn_security(hcon, hcon->pending_sec_level);

        mutex_lock(&conn->chan_lock);

        list_for_each_entry(chan, &conn->chan_l, list) {

                l2cap_chan_lock(chan);

                if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) {
                        l2cap_chan_unlock(chan);
                        continue;
                }

                if (hcon->type == LE_LINK) {
                        if (smp_conn_security(hcon, chan->sec_level))
                                l2cap_chan_ready(chan);

                } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
                        struct sock *sk = chan->sk;
                        __clear_chan_timer(chan);
                        lock_sock(sk);
                        __l2cap_state_change(chan, BT_CONNECTED);
                        sk->sk_state_change(sk);
                        release_sock(sk);

                } else if (chan->state == BT_CONNECT)
                        l2cap_do_start(chan);

                l2cap_chan_unlock(chan);
        }

        mutex_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 *chan;

        BT_DBG("conn %p", conn);

        mutex_lock(&conn->chan_lock);

        list_for_each_entry(chan, &conn->chan_l, list) {
                if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
                        __l2cap_chan_set_err(chan, err);
        }

        mutex_unlock(&conn->chan_lock);
}

static void l2cap_info_timeout(struct work_struct *work)
{
        struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
                                                        info_timer.work);

        conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
        conn->info_ident = 0;

        l2cap_conn_start(conn);
}

static void l2cap_conn_del(struct hci_conn *hcon, int err)
{
        struct l2cap_conn *conn = hcon->l2cap_data;
        struct l2cap_chan *chan, *l;

        if (!conn)
                return;

        BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);

        kfree_skb(conn->rx_skb);

        mutex_lock(&conn->chan_lock);

        /* Kill channels */
        list_for_each_entry_safe(chan, l, &conn->chan_l, list) {
                l2cap_chan_hold(chan);
                l2cap_chan_lock(chan);

                l2cap_chan_del(chan, err);

                l2cap_chan_unlock(chan);

                chan->ops->close(chan);
                l2cap_chan_put(chan);
        }

        mutex_unlock(&conn->chan_lock);

        hci_chan_del(conn->hchan);

        if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)
                cancel_delayed_work_sync(&conn->info_timer);

        if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) {
                cancel_delayed_work_sync(&conn->security_timer);
                smp_chan_destroy(conn);
        }

        hcon->l2cap_data = NULL;
        kfree(conn);
}

static void security_timeout(struct work_struct *work)
{
        struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
                                                security_timer.work);

        BT_DBG("conn %p", conn);

        if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) {
                smp_chan_destroy(conn);
                l2cap_conn_del(conn->hcon, ETIMEDOUT);
        }
}

static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status)
{
        struct l2cap_conn *conn = hcon->l2cap_data;
        struct hci_chan *hchan;

        if (conn || status)
                return conn;

        hchan = hci_chan_create(hcon);
        if (!hchan)
                return NULL;

        conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC);
        if (!conn) {
                hci_chan_del(hchan);
                return NULL;
        }

        hcon->l2cap_data = conn;
        conn->hcon = hcon;
        conn->hchan = hchan;

        BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan);

        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);
        mutex_init(&conn->chan_lock);

        INIT_LIST_HEAD(&conn->chan_l);

        if (hcon->type == LE_LINK)
                INIT_DELAYED_WORK(&conn->security_timer, security_timeout);
        else
                INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout);

        conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;

        return conn;
}

/* ---- Socket interface ---- */

/* Find socket with psm and source / destination bdaddr.
 * Returns closest match.
 */
static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm,
                                                   bdaddr_t *src,
                                                   bdaddr_t *dst)
{
        struct l2cap_chan *c, *c1 = NULL;

        read_lock(&chan_list_lock);

        list_for_each_entry(c, &chan_list, global_l) {
                struct sock *sk = c->sk;

                if (state && c->state != state)
                        continue;

                if (c->psm == psm) {
                        int src_match, dst_match;
                        int src_any, dst_any;

                        /* Exact match. */
                        src_match = !bacmp(&bt_sk(sk)->src, src);
                        dst_match = !bacmp(&bt_sk(sk)->dst, dst);
                        if (src_match && dst_match) {
                                read_unlock(&chan_list_lock);
                                return c;
                        }

                        /* Closest match */
                        src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY);
                        dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY);
                        if ((src_match && dst_any) || (src_any && dst_match) ||
                            (src_any && dst_any))
                                c1 = c;
                }
        }

        read_unlock(&chan_list_lock);

        return c1;
}

int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid,
                       bdaddr_t *dst, u8 dst_type)
{
        struct sock *sk = chan->sk;
        bdaddr_t *src = &bt_sk(sk)->src;
        struct l2cap_conn *conn;
        struct hci_conn *hcon;
        struct hci_dev *hdev;
        __u8 auth_type;
        int err;

        BT_DBG("%s -> %s (type %u) psm 0x%2.2x", batostr(src), batostr(dst),
               dst_type, __le16_to_cpu(chan->psm));

        hdev = hci_get_route(dst, src);
        if (!hdev)
                return -EHOSTUNREACH;

        hci_dev_lock(hdev);

        l2cap_chan_lock(chan);

        /* PSM must be odd and lsb of upper byte must be 0 */
        if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid &&
                                        chan->chan_type != L2CAP_CHAN_RAW) {
                err = -EINVAL;
                goto done;
        }

        if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) {
                err = -EINVAL;
                goto done;
        }

        switch (chan->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 (chan->state) {
        case BT_CONNECT:
        case BT_CONNECT2:
        case BT_CONFIG:
                /* Already connecting */
                err = 0;
                goto done;

        case BT_CONNECTED:
                /* Already connected */
                err = -EISCONN;
                goto done;

        case BT_OPEN:
        case BT_BOUND:
                /* Can connect */
                break;

        default:
                err = -EBADFD;
                goto done;
        }

        /* Set destination address and psm */
        lock_sock(sk);
        bacpy(&bt_sk(sk)->dst, dst);
        release_sock(sk);

        chan->psm = psm;
        chan->dcid = cid;

        auth_type = l2cap_get_auth_type(chan);

        if (chan->dcid == L2CAP_CID_LE_DATA)
                hcon = hci_connect(hdev, LE_LINK, dst, dst_type,
                                   chan->sec_level, auth_type);
        else
                hcon = hci_connect(hdev, ACL_LINK, dst, dst_type,
                                   chan->sec_level, auth_type);

        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;
        }

        if (hcon->type == LE_LINK) {
                err = 0;

                if (!list_empty(&conn->chan_l)) {
                        err = -EBUSY;
                        hci_conn_put(hcon);
                }

                if (err)
                        goto done;
        }

        /* Update source addr of the socket */
        bacpy(src, conn->src);

        l2cap_chan_unlock(chan);
        l2cap_chan_add(conn, chan);
        l2cap_chan_lock(chan);

        l2cap_state_change(chan, BT_CONNECT);
        __set_chan_timer(chan, sk->sk_sndtimeo);

        if (hcon->state == BT_CONNECTED) {
                if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
                        __clear_chan_timer(chan);
                        if (l2cap_chan_check_security(chan))
                                l2cap_state_change(chan, BT_CONNECTED);
                } else
                        l2cap_do_start(chan);
        }

        err = 0;

done:
        l2cap_chan_unlock(chan);
        hci_dev_unlock(hdev);
        hci_dev_put(hdev);
        return err;
}

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);
        set_current_state(TASK_INTERRUPTIBLE);
        while (chan->unacked_frames > 0 && chan->conn) {
                if (!timeo)
                        timeo = HZ/5;

                if (signal_pending(current)) {
                        err = sock_intr_errno(timeo);
                        break;
                }

                release_sock(sk);
                timeo = schedule_timeout(timeo);
                lock_sock(sk);
                set_current_state(TASK_INTERRUPTIBLE);

                err = sock_error(sk);
                if (err)
                        break;
        }
        set_current_state(TASK_RUNNING);
        remove_wait_queue(sk_sleep(sk), &wait);
        return err;
}

static void l2cap_monitor_timeout(struct work_struct *work)
{
        struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
                                               monitor_timer.work);

        BT_DBG("chan %p", chan);

        l2cap_chan_lock(chan);

        if (!chan->conn) {
                l2cap_chan_unlock(chan);
                l2cap_chan_put(chan);
                return;
        }

        l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO);

        l2cap_chan_unlock(chan);
        l2cap_chan_put(chan);
}

static void l2cap_retrans_timeout(struct work_struct *work)
{
        struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
                                               retrans_timer.work);

        BT_DBG("chan %p", chan);

        l2cap_chan_lock(chan);

        if (!chan->conn) {
                l2cap_chan_unlock(chan);
                l2cap_chan_put(chan);
                return;
        }

        l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO);
        l2cap_chan_unlock(chan);
        l2cap_chan_put(chan);
}

static void l2cap_streaming_send(struct l2cap_chan *chan,
                                 struct sk_buff_head *skbs)
{
        struct sk_buff *skb;
        struct l2cap_ctrl *control;

        BT_DBG("chan %p, skbs %p", chan, skbs);

        skb_queue_splice_tail_init(skbs, &chan->tx_q);

        while (!skb_queue_empty(&chan->tx_q)) {

                skb = skb_dequeue(&chan->tx_q);

                bt_cb(skb)->control.retries = 1;
                control = &bt_cb(skb)->control;

                control->reqseq = 0;
                control->txseq = chan->next_tx_seq;

                __pack_control(chan, control, skb);

                if (chan->fcs == L2CAP_FCS_CRC16) {
                        u16 fcs = crc16(0, (u8 *) skb->data, skb->len);
                        put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE));
                }

                l2cap_do_send(chan, skb);

                BT_DBG("Sent txseq %u", control->txseq);

                chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq);
                chan->frames_sent++;
        }
}

static int l2cap_ertm_send(struct l2cap_chan *chan)
{
        struct sk_buff *skb, *tx_skb;
        struct l2cap_ctrl *control;
        int sent = 0;

        BT_DBG("chan %p", chan);

        if (chan->state != BT_CONNECTED)
                return -ENOTCONN;

        if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
                return 0;

        while (chan->tx_send_head &&
               chan->unacked_frames < chan->remote_tx_win &&
               chan->tx_state == L2CAP_TX_STATE_XMIT) {

                skb = chan->tx_send_head;

                bt_cb(skb)->control.retries = 1;
                control = &bt_cb(skb)->control;

                if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
                        control->final = 1;

                control->reqseq = chan->buffer_seq;
                chan->last_acked_seq = chan->buffer_seq;
                control->txseq = chan->next_tx_seq;

                __pack_control(chan, control, skb);

                if (chan->fcs == L2CAP_FCS_CRC16) {
                        u16 fcs = crc16(0, (u8 *) skb->data, skb->len);
                        put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE));
                }

                /* Clone after data has been modified. Data is assumed to be
                   read-only (for locking purposes) on cloned sk_buffs.
                 */
                tx_skb = skb_clone(skb, GFP_KERNEL);

                if (!tx_skb)
                        break;

                __set_retrans_timer(chan);

                chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq);
                chan->unacked_frames++;
                chan->frames_sent++;
                sent++;

                if (skb_queue_is_last(&chan->tx_q, skb))
                        chan->tx_send_head = NULL;
                else
                        chan->tx_send_head = skb_queue_next(&chan->tx_q, skb);

                l2cap_do_send(chan, tx_skb);
                BT_DBG("Sent txseq %u", control->txseq);
        }

        BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent,
               chan->unacked_frames, skb_queue_len(&chan->tx_q));

        return sent;
}

static void l2cap_ertm_resend(struct l2cap_chan *chan)
{
        struct l2cap_ctrl control;
        struct sk_buff *skb;
        struct sk_buff *tx_skb;
        u16 seq;

        BT_DBG("chan %p", chan);

        if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
                return;

        while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) {
                seq = l2cap_seq_list_pop(&chan->retrans_list);

                skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq);
                if (!skb) {
                        BT_DBG("Error: Can't retransmit seq %d, frame missing",
                                seq);
                        continue;
                }

                bt_cb(skb)->control.retries++;
                control = bt_cb(skb)->control;

                if (chan->max_tx != 0 &&
                    bt_cb(skb)->control.retries > chan->max_tx) {
                        BT_DBG("Retry limit exceeded (%d)", chan->max_tx);
                        l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
                        l2cap_seq_list_clear(&chan->retrans_list);
                        break;
                }

                control.reqseq = chan->buffer_seq;
                if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
                        control.final = 1;
                else
                        control.final = 0;

                if (skb_cloned(skb)) {
                        /* Cloned sk_buffs are read-only, so we need a
                         * writeable copy
                         */
                        tx_skb = skb_copy(skb, GFP_ATOMIC);
                } else {
                        tx_skb = skb_clone(skb, GFP_ATOMIC);
                }

                if (!tx_skb) {
                        l2cap_seq_list_clear(&chan->retrans_list);
                        break;
                }

                /* Update skb contents */
                if (test_bit(FLAG_EXT_CTRL, &chan->flags)) {
                        put_unaligned_le32(__pack_extended_control(&control),
                                           tx_skb->data + L2CAP_HDR_SIZE);
                } else {
                        put_unaligned_le16(__pack_enhanced_control(&control),
                                           tx_skb->data + L2CAP_HDR_SIZE);
                }

                if (chan->fcs == L2CAP_FCS_CRC16) {
                        u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len);
                        put_unaligned_le16(fcs, skb_put(tx_skb,
                                                        L2CAP_FCS_SIZE));
                }

                l2cap_do_send(chan, tx_skb);

                BT_DBG("Resent txseq %d", control.txseq);

                chan->last_acked_seq = chan->buffer_seq;
        }
}

static void l2cap_retransmit(struct l2cap_chan *chan,
                             struct l2cap_ctrl *control)
{
        BT_DBG("chan %p, control %p", chan, control);

        l2cap_seq_list_append(&chan->retrans_list, control->reqseq);
        l2cap_ertm_resend(chan);
}

static void l2cap_retransmit_all(struct l2cap_chan *chan,
                                 struct l2cap_ctrl *control)
{
        struct sk_buff *skb;

        BT_DBG("chan %p, control %p", chan, control);

        if (control->poll)
                set_bit(CONN_SEND_FBIT, &chan->conn_state);

        l2cap_seq_list_clear(&chan->retrans_list);

        if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
                return;

        if (chan->unacked_frames) {
                skb_queue_walk(&chan->tx_q, skb) {
                        if (bt_cb(skb)->control.txseq == control->reqseq ||
                                skb == chan->tx_send_head)
                                break;
                }

                skb_queue_walk_from(&chan->tx_q, skb) {
                        if (skb == chan->tx_send_head)
                                break;

                        l2cap_seq_list_append(&chan->retrans_list,
                                              bt_cb(skb)->control.txseq);
                }

                l2cap_ertm_resend(chan);
        }
}

static void l2cap_send_ack(struct l2cap_chan *chan)
{
        struct l2cap_ctrl control;
        u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq,
                                         chan->last_acked_seq);
        int threshold;

        BT_DBG("chan %p last_acked_seq %d buffer_seq %d",
               chan, chan->last_acked_seq, chan->buffer_seq);

        memset(&control, 0, sizeof(control));
        control.sframe = 1;

        if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) &&
            chan->rx_state == L2CAP_RX_STATE_RECV) {
                __clear_ack_timer(chan);
                control.super = L2CAP_SUPER_RNR;
                control.reqseq = chan->buffer_seq;
                l2cap_send_sframe(chan, &control);
        } else {
                if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) {
                        l2cap_ertm_send(chan);
                        /* If any i-frames were sent, they included an ack */
                        if (chan->buffer_seq == chan->last_acked_seq)
                                frames_to_ack = 0;
                }

                /* Ack now if the window is 3/4ths full.
                 * Calculate without mul or div
                 */
                threshold = chan->ack_win;
                threshold += threshold << 1;
                threshold >>= 2;

                BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack,
                       threshold);

                if (frames_to_ack >= threshold) {
                        __clear_ack_timer(chan);
                        control.super = L2CAP_SUPER_RR;
                        control.reqseq = chan->buffer_seq;
                        l2cap_send_sframe(chan, &control);
                        frames_to_ack = 0;
                }

                if (frames_to_ack)
                        __set_ack_timer(chan);
        }
}

static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan,
                                         struct msghdr *msg, int len,
                                         int count, struct sk_buff *skb)
{
        struct l2cap_conn *conn = chan->conn;
        struct sk_buff **frag;
        int sent = 0;

        if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count))
                return -EFAULT;

        sent += count;
        len  -= count;

        /* Continuation fragments (no L2CAP header) */
        frag = &skb_shinfo(skb)->frag_list;
        while (len) {
                struct sk_buff *tmp;

                count = min_t(unsigned int, conn->mtu, len);

                tmp = chan->ops->alloc_skb(chan, count,
                                           msg->msg_flags & MSG_DONTWAIT);
                if (IS_ERR(tmp))
                        return PTR_ERR(tmp);

                *frag = tmp;

                if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count))
                        return -EFAULT;

                (*frag)->priority = skb->priority;

                sent += count;
                len  -= count;

                skb->len += (*frag)->len;
                skb->data_len += (*frag)->len;

                frag = &(*frag)->next;
        }

        return sent;
}

static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan,
                                                 struct msghdr *msg, size_t len,
                                                 u32 priority)
{
        struct l2cap_conn *conn = chan->conn;
        struct sk_buff *skb;
        int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE;
        struct l2cap_hdr *lh;

        BT_DBG("chan %p len %zu priority %u", chan, len, priority);

        count = min_t(unsigned int, (conn->mtu - hlen), len);

        skb = chan->ops->alloc_skb(chan, count + hlen,
                                   msg->msg_flags & MSG_DONTWAIT);
        if (IS_ERR(skb))
                return skb;

        skb->priority = priority;

        /* Create L2CAP header */
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
        lh->cid = cpu_to_le16(chan->dcid);
        lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE);
        put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE));

        err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb);
        if (unlikely(err < 0)) {
                kfree_skb(skb);
                return ERR_PTR(err);
        }
        return skb;
}

static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan,
                                              struct msghdr *msg, size_t len,
                                              u32 priority)
{
        struct l2cap_conn *conn = chan->conn;
        struct sk_buff *skb;
        int err, count;
        struct l2cap_hdr *lh;

        BT_DBG("chan %p len %zu", chan, len);

        count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len);

        skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE,
                                   msg->msg_flags & MSG_DONTWAIT);
        if (IS_ERR(skb))

                return skb;

        skb->priority = priority;

        /* Create L2CAP header */
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
        lh->cid = cpu_to_le16(chan->dcid);
        lh->len = cpu_to_le16(len);

        err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb);
        if (unlikely(err < 0)) {
                kfree_skb(skb);
                return ERR_PTR(err);
        }
        return skb;
}

static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan,
                                               struct msghdr *msg, size_t len,
                                               u16 sdulen)
{
        struct l2cap_conn *conn = chan->conn;
        struct sk_buff *skb;
        int err, count, hlen;
        struct l2cap_hdr *lh;

        BT_DBG("chan %p len %zu", chan, len);

        if (!conn)
                return ERR_PTR(-ENOTCONN);

        hlen = __ertm_hdr_size(chan);

        if (sdulen)
                hlen += L2CAP_SDULEN_SIZE;

        if (chan->fcs == L2CAP_FCS_CRC16)
                hlen += L2CAP_FCS_SIZE;

        count = min_t(unsigned int, (conn->mtu - hlen), len);

        skb = chan->ops->alloc_skb(chan, count + hlen,
                                   msg->msg_flags & MSG_DONTWAIT);
        if (IS_ERR(skb))
                return skb;

        /* Create L2CAP header */
        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
        lh->cid = cpu_to_le16(chan->dcid);
        lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));

        /* Control header is populated later */
        if (test_bit(FLAG_EXT_CTRL, &chan->flags))
                put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE));
        else
                put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE));

        if (sdulen)
                put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE));

        err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb);
        if (unlikely(err < 0)) {
                kfree_skb(skb);
                return ERR_PTR(err);
        }

        bt_cb(skb)->control.fcs = chan->fcs;
        bt_cb(skb)->control.retries = 0;
        return skb;
}

static int l2cap_segment_sdu(struct l2cap_chan *chan,
                             struct sk_buff_head *seg_queue,
                             struct msghdr *msg, size_t len)
{
        struct sk_buff *skb;
        u16 sdu_len;
        size_t pdu_len;
        u8 sar;

        BT_DBG("chan %p, msg %p, len %zu", chan, msg, len);

        /* It is critical that ERTM PDUs fit in a single HCI fragment,
         * so fragmented skbs are not used.  The HCI layer's handling
         * of fragmented skbs is not compatible with ERTM's queueing.
         */

        /* PDU size is derived from the HCI MTU */
        pdu_len = chan->conn->mtu;

        pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD);

        /* Adjust for largest possible L2CAP overhead. */
        if (chan->fcs)
                pdu_len -= L2CAP_FCS_SIZE;

        pdu_len -= __ertm_hdr_size(chan);

        /* Remote device may have requested smaller PDUs */
        pdu_len = min_t(size_t, pdu_len, chan->remote_mps);

        if (len <= pdu_len) {
                sar = L2CAP_SAR_UNSEGMENTED;
                sdu_len = 0;
                pdu_len = len;
        } else {
                sar = L2CAP_SAR_START;
                sdu_len = len;
                pdu_len -= L2CAP_SDULEN_SIZE;
        }

        while (len > 0) {
                skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len);

                if (IS_ERR(skb)) {
                        __skb_queue_purge(seg_queue);
                        return PTR_ERR(skb);
                }

                bt_cb(skb)->control.sar = sar;
                __skb_queue_tail(seg_queue, skb);

                len -= pdu_len;
                if (sdu_len) {
                        sdu_len = 0;
                        pdu_len += L2CAP_SDULEN_SIZE;
                }

                if (len <= pdu_len) {
                        sar = L2CAP_SAR_END;
                        pdu_len = len;
                } else {
                        sar = L2CAP_SAR_CONTINUE;
                }
        }

        return 0;
}

int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len,
                                                                u32 priority)
{
        struct sk_buff *skb;
        int err;
        struct sk_buff_head seg_queue;

        /* Connectionless channel */
        if (chan->chan_type == L2CAP_CHAN_CONN_LESS) {
                skb = l2cap_create_connless_pdu(chan, msg, len, priority);
                if (IS_ERR(skb))
                        return PTR_ERR(skb);

                l2cap_do_send(chan, skb);
                return len;
        }

        switch (chan->mode) {
        case L2CAP_MODE_BASIC:
                /* Check outgoing MTU */
                if (len > chan->omtu)
                        return -EMSGSIZE;

                /* Create a basic PDU */
                skb = l2cap_create_basic_pdu(chan, msg, len, priority);
                if (IS_ERR(skb))
                        return PTR_ERR(skb);

                l2cap_do_send(chan, skb);
                err = len;
                break;

        case L2CAP_MODE_ERTM:
        case L2CAP_MODE_STREAMING:
                /* Check outgoing MTU */
                if (len > chan->omtu) {
                        err = -EMSGSIZE;
                        break;
                }

                __skb_queue_head_init(&seg_queue);

                /* Do segmentation before calling in to the state machine,
                 * since it's possible to block while waiting for memory
                 * allocation.
                 */
                err = l2cap_segment_sdu(chan, &seg_queue, msg, len);

                /* The channel could have been closed while segmenting,
                 * check that it is still connected.
                 */
                if (chan->state != BT_CONNECTED) {
                        __skb_queue_purge(&seg_queue);
                        err = -ENOTCONN;
                }

                if (err)
                        break;

                if (chan->mode == L2CAP_MODE_ERTM)
                        l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST);
                else
                        l2cap_streaming_send(chan, &seg_queue);

                err = len;

                /* If the skbs were not queued for sending, they'll still be in
                 * seg_queue and need to be purged.
                 */
                __skb_queue_purge(&seg_queue);
                break;

        default:
                BT_DBG("bad state %1.1x", chan->mode);
                err = -EBADFD;
        }

        return err;
}

static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq)
{
        struct l2cap_ctrl control;
        u16 seq;

        BT_DBG("chan %p, txseq %u", chan, txseq);

        memset(&control, 0, sizeof(control));
        control.sframe = 1;
        control.super = L2CAP_SUPER_SREJ;

        for (seq = chan->expected_tx_seq; seq != txseq;
             seq = __next_seq(chan, seq)) {
                if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) {
                        control.reqseq = seq;
                        l2cap_send_sframe(chan, &control);
                        l2cap_seq_list_append(&chan->srej_list, seq);
                }
        }

        chan->expected_tx_seq = __next_seq(chan, txseq);
}

static void l2cap_send_srej_tail(struct l2cap_chan *chan)
{
        struct l2cap_ctrl control;

        BT_DBG("chan %p", chan);

        if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR)
                return;

        memset(&control, 0, sizeof(control));
        control.sframe = 1;
        control.super = L2CAP_SUPER_SREJ;
        control.reqseq = chan->srej_list.tail;
        l2cap_send_sframe(chan, &control);
}

static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq)
{
        struct l2cap_ctrl control;
        u16 initial_head;
        u16 seq;

        BT_DBG("chan %p, txseq %u", chan, txseq);

        memset(&control, 0, sizeof(control));
        control.sframe = 1;
        control.super = L2CAP_SUPER_SREJ;

        /* Capture initial list head to allow only one pass through the list. */
        initial_head = chan->srej_list.head;

        do {
                seq = l2cap_seq_list_pop(&chan->srej_list);
                if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR)
                        break;

                control.reqseq = seq;
                l2cap_send_sframe(chan, &control);
                l2cap_seq_list_append(&chan->srej_list, seq);
        } while (chan->srej_list.head != initial_head);
}

static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq)
{
        struct sk_buff *acked_skb;
        u16 ackseq;

        BT_DBG("chan %p, reqseq %u", chan, reqseq);

        if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq)
                return;

        BT_DBG("expected_ack_seq %u, unacked_frames %u",
               chan->expected_ack_seq, chan->unacked_frames);

        for (ackseq = chan->expected_ack_seq; ackseq != reqseq;
             ackseq = __next_seq(chan, ackseq)) {

                acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq);
                if (acked_skb) {
                        skb_unlink(acked_skb, &chan->tx_q);
                        kfree_skb(acked_skb);
                        chan->unacked_frames--;
                }
        }

        chan->expected_ack_seq = reqseq;

        if (chan->unacked_frames == 0)
                __clear_retrans_timer(chan);

        BT_DBG("unacked_frames %u", chan->unacked_frames);
}

static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan)
{
        BT_DBG("chan %p", chan);

        chan->expected_tx_seq = chan->buffer_seq;
        l2cap_seq_list_clear(&chan->srej_list);
        skb_queue_purge(&chan->srej_q);
        chan->rx_state = L2CAP_RX_STATE_RECV;
}

static void l2cap_tx_state_xmit(struct l2cap_chan *chan,
                                struct l2cap_ctrl *control,
                                struct sk_buff_head *skbs, u8 event)
{
        BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs,
               event);

        switch (event) {
        case L2CAP_EV_DATA_REQUEST:
                if (chan->tx_send_head == NULL)
                        chan->tx_send_head = skb_peek(skbs);

                skb_queue_splice_tail_init(skbs, &chan->tx_q);
                l2cap_ertm_send(chan);
                break;
        case L2CAP_EV_LOCAL_BUSY_DETECTED:
                BT_DBG("Enter LOCAL_BUSY");
                set_bit(CONN_LOCAL_BUSY, &chan->conn_state);

                if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) {
                        /* The SREJ_SENT state must be aborted if we are to
                         * enter the LOCAL_BUSY state.
                         */
                        l2cap_abort_rx_srej_sent(chan);
                }

                l2cap_send_ack(chan);

                break;
        case L2CAP_EV_LOCAL_BUSY_CLEAR:
                BT_DBG("Exit LOCAL_BUSY");
                clear_bit(CONN_LOCAL_BUSY, &chan->conn_state);

                if (test_bit(CONN_RNR_SENT, &chan->conn_state)) {
                        struct l2cap_ctrl local_control;

                        memset(&local_control, 0, sizeof(local_control));
                        local_control.sframe = 1;
                        local_control.super = L2CAP_SUPER_RR;
                        local_control.poll = 1;
                        local_control.reqseq = chan->buffer_seq;
                        l2cap_send_sframe(chan, &local_control);

                        chan->retry_count = 1;
                        __set_monitor_timer(chan);
                        chan->tx_state = L2CAP_TX_STATE_WAIT_F;
                }
                break;
        case L2CAP_EV_RECV_REQSEQ_AND_FBIT:
                l2cap_process_reqseq(chan, control->reqseq);
                break;
        case L2CAP_EV_EXPLICIT_POLL:
                l2cap_send_rr_or_rnr(chan, 1);
                chan->retry_count = 1;
                __set_monitor_timer(chan);
                __clear_ack_timer(chan);
                chan->tx_state = L2CAP_TX_STATE_WAIT_F;
                break;
        case L2CAP_EV_RETRANS_TO:
                l2cap_send_rr_or_rnr(chan, 1);
                chan->retry_count = 1;
                __set_monitor_timer(chan);
                chan->tx_state = L2CAP_TX_STATE_WAIT_F;
                break;
        case L2CAP_EV_RECV_FBIT:
                /* Nothing to process */
                break;
        default:
                break;
        }
}

static void l2cap_tx_state_wait_f(struct l2cap_chan *chan,
                                  struct l2cap_ctrl *control,
                                  struct sk_buff_head *skbs, u8 event)
{
        BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs,
               event);

        switch (event) {
        case L2CAP_EV_DATA_REQUEST:
                if (chan->tx_send_head == NULL)
                        chan->tx_send_head = skb_peek(skbs);
                /* Queue data, but don't send. */
                skb_queue_splice_tail_init(skbs, &chan->tx_q);
                break;
        case L2CAP_EV_LOCAL_BUSY_DETECTED:
                BT_DBG("Enter LOCAL_BUSY");
                set_bit(CONN_LOCAL_BUSY, &chan->conn_state);

                if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) {
                        /* The SREJ_SENT state must be aborted if we are to
                         * enter the LOCAL_BUSY state.
                         */
                        l2cap_abort_rx_srej_sent(chan);
                }

                l2cap_send_ack(chan);

                break;
        case L2CAP_EV_LOCAL_BUSY_CLEAR:
                BT_DBG("Exit LOCAL_BUSY");
                clear_bit(CONN_LOCAL_BUSY, &chan->conn_state);

                if (test_bit(CONN_RNR_SENT, &chan->conn_state)) {
                        struct l2cap_ctrl local_control;
                        memset(&local_control, 0, sizeof(local_control));
                        local_control.sframe = 1;
                        local_control.super = L2CAP_SUPER_RR;
                        local_control.poll = 1;
                        local_control.reqseq = chan->buffer_seq;
                        l2cap_send_sframe(chan, &local_control);

                        chan->retry_count = 1;
                        __set_monitor_timer(chan);
                        chan->tx_state = L2CAP_TX_STATE_WAIT_F;
                }
                break;
        case L2CAP_EV_RECV_REQSEQ_AND_FBIT:
                l2cap_process_reqseq(chan, control->reqseq);

                /* Fall through */

        case L2CAP_EV_RECV_FBIT:
                if (control && control->final) {
                        __clear_monitor_timer(chan);
                        if (chan->unacked_frames > 0)
                                __set_retrans_timer(chan);
                        chan->retry_count = 0;
                        chan->tx_state = L2CAP_TX_STATE_XMIT;
                        BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state);
                }
                break;
        case L2CAP_EV_EXPLICIT_POLL:
                /* Ignore */
                break;
        case L2CAP_EV_MONITOR_TO:
                if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) {
                        l2cap_send_rr_or_rnr(chan, 1);
                        __set_monitor_timer(chan);
                        chan->retry_count++;
                } else {
                        l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED);
                }
                break;
        default:
                break;
        }
}

static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control,
                     struct sk_buff_head *skbs, u8 event)
{
        BT_DBG("chan %p, control %p, skbs %p, event %d, state %d",
               chan, control, skbs, event, chan->tx_state);

        switch (chan->tx_state) {
        case L2CAP_TX_STATE_XMIT:
                l2cap_tx_state_xmit(chan, control, skbs, event);
                break;
        case L2CAP_TX_STATE_WAIT_F:
                l2cap_tx_state_wait_f(chan, control, skbs, event);
                break;
        default:
                /* Ignore event */
                break;
        }
}

static void l2cap_pass_to_tx(struct l2cap_chan *chan,
                             struct l2cap_ctrl *control)
{
        BT_DBG("chan %p, control %p", chan, control);
        l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT);
}

static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan,
                                  struct l2cap_ctrl *control)
{
        BT_DBG("chan %p, control %p", chan, control);
        l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT);
}

/* Copy frame to all raw sockets on that connection */
static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
{
        struct sk_buff *nskb;
        struct l2cap_chan *chan;

        BT_DBG("conn %p", conn);

        mutex_lock(&conn->chan_lock);

        list_for_each_entry(chan, &conn->chan_l, list) {
                struct sock *sk = chan->sk;
                if (chan->chan_type != L2CAP_CHAN_RAW)
                        continue;

                /* Don't send frame to the socket it came from */
                if (skb->sk == sk)
                        continue;
                nskb = skb_clone(skb, GFP_ATOMIC);
                if (!nskb)
                        continue;

                if (chan->ops->recv(chan, nskb))
                        kfree_skb(nskb);
        }

        mutex_unlock(&conn->chan_lock);
}

/* ---- L2CAP signalling commands ---- */
static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code,
                                       u8 ident, u16 dlen, void *data)
{
        struct sk_buff *skb, **frag;
        struct l2cap_cmd_hdr *cmd;
        struct l2cap_hdr *lh;
        int len, count;

        BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u",
               conn, code, ident, dlen);

        len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen;
        count = min_t(unsigned int, conn->mtu, len);

        skb = bt_skb_alloc(count, GFP_ATOMIC);
        if (!skb)
                return NULL;

        lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
        lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen);

        if (conn->hcon->type == LE_LINK)
                lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING);
        else
                lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING);

        cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE);
        cmd->code  = code;
        cmd->ident = ident;
        cmd->len   = cpu_to_le16(dlen);

        if (dlen) {
                count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE;
                memcpy(skb_put(skb, count), data, count);
                data += count;
        }

        len -= skb->len;

        /* Continuation fragments (no L2CAP header) */
        frag = &skb_shinfo(skb)->frag_list;
        while (len) {
                count = min_t(unsigned int, conn->mtu, len);

                *frag = bt_skb_alloc(count, GFP_ATOMIC);
                if (!*frag)
                        goto fail;

                memcpy(skb_put(*frag, count), data, count);

                len  -= count;
                data += count;

                frag = &(*frag)->next;
        }

        return skb;

fail:
        kfree_skb(skb);
        return NULL;
}

static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val)
{
        struct l2cap_conf_opt *opt = *ptr;
        int len;

        len = L2CAP_CONF_OPT_SIZE + opt->len;
        *ptr += len;

        *type = opt->type;
        *olen = opt->len;

        switch (opt->len) {
        case 1:
                *val = *((u8 *) opt->val);
                break;

        case 2:
                *val = get_unaligned_le16(opt->val);
                break;

        case 4:
                *val = get_unaligned_le32(opt->val);
                break;

        default:
                *val = (unsigned long) opt->val;
                break;
        }

        BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val);
        return len;
}

static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val)
{
        struct l2cap_conf_opt *opt = *ptr;

        BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val);

        opt->type = type;
        opt->len  = len;

        switch (len) {
        case 1:
                *((u8 *) opt->val)  = val;
                break;

        case 2:
                put_unaligned_le16(val, opt->val);
                break;

        case 4:
                put_unaligned_le32(val, opt->val);
                break;

        default:
                memcpy(opt->val, (void *) val, len);
                break;
        }

        *ptr += L2CAP_CONF_OPT_SIZE + len;
}

static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan)
{
        struct l2cap_conf_efs efs;

        switch (chan->mode) {
        case L2CAP_MODE_ERTM:
                efs.id          = chan->local_id;
                efs.stype       = chan->local_stype;
                efs.msdu        = cpu_to_le16(chan->local_msdu);
                efs.sdu_itime   = cpu_to_le32(chan->local_sdu_itime);
                efs.acc_lat     = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT);
                efs.flush_to    = __constant_cpu_to_le32(L2CAP_DEFAULT_FLUSH_TO);
                break;

        case L2CAP_MODE_STREAMING:
                efs.id          = 1;
                efs.stype       = L2CAP_SERV_BESTEFFORT;
                efs.msdu        = cpu_to_le16(chan->local_msdu);
                efs.sdu_itime   = cpu_to_le32(chan->local_sdu_itime);
                efs.acc_lat     = 0;
                efs.flush_to    = 0;
                break;

        default:
                return;
        }

        l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs),
                                                        (unsigned long) &efs);
}

static void l2cap_ack_timeout(struct work_struct *work)
{
        struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
                                               ack_timer.work);
        u16 frames_to_ack;

        BT_DBG("chan %p", chan);

        l2cap_chan_lock(chan);

        frames_to_ack = __seq_offset(chan, chan->buffer_seq,
                                     chan->last_acked_seq);

        if (frames_to_ack)
                l2cap_send_rr_or_rnr(chan, 0);

        l2cap_chan_unlock(chan);
        l2cap_chan_put(chan);
}

int l2cap_ertm_init(struct l2cap_chan *chan)
{
        int err;

        chan->next_tx_seq = 0;
        chan->expected_tx_seq = 0;
        chan->expected_ack_seq = 0;
        chan->unacked_frames = 0;
        chan->buffer_seq = 0;
        chan->frames_sent = 0;
        chan->last_acked_seq = 0;
        chan->sdu = NULL;
        chan->sdu_last_frag = NULL;
        chan->sdu_len = 0;

        skb_queue_head_init(&chan->tx_q);

        if (chan->mode != L2CAP_MODE_ERTM)
                return 0;

        chan->rx_state = L2CAP_RX_STATE_RECV;
        chan->tx_state = L2CAP_TX_STATE_XMIT;

        INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout);
        INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout);
        INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout);

        skb_queue_head_init(&chan->srej_q);

        err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win);
        if (err < 0)
                return err;

        err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win);
        if (err < 0)
                l2cap_seq_list_free(&chan->srej_list);

        return err;
}

static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask)
{
        switch (mode) {
        case L2CAP_MODE_STREAMING:
        case L2CAP_MODE_ERTM:
                if (l2cap_mode_supported(mode, remote_feat_mask))
                        return mode;
                /* fall through */
        default:
                return L2CAP_MODE_BASIC;
        }
}

static inline bool __l2cap_ews_supported(struct l2cap_chan *chan)
{
        return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW;
}

static inline bool __l2cap_efs_supported(struct l2cap_chan *chan)
{
        return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW;
}

static inline void l2cap_txwin_setup(struct l2cap_chan *chan)
{
        if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW &&
                                                __l2cap_ews_supported(chan)) {
                /* use extended control field */
                set_bit(FLAG_EXT_CTRL, &chan->flags);
                chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW;
        } else {
                chan->tx_win = min_t(u16, chan->tx_win,
                                                L2CAP_DEFAULT_TX_WINDOW);
                chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
        }
        chan->ack_win = chan->tx_win;
}

static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data)
{
        struct l2cap_conf_req *req = data;
        struct l2cap_conf_rfc rfc = { .mode = chan->mode };
        void *ptr = req->data;
        u16 size;

        BT_DBG("chan %p", chan);

        if (chan->num_conf_req || chan->num_conf_rsp)
                goto done;

        switch (chan->mode) {
        case L2CAP_MODE_STREAMING:
        case L2CAP_MODE_ERTM:
                if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state))
                        break;

                if (__l2cap_efs_supported(chan))
                        set_bit(FLAG_EFS_ENABLE, &chan->flags);

                /* fall through */
        default:
                chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask);
                break;
        }

done:
        if (chan->imtu != L2CAP_DEFAULT_MTU)
                l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);

        switch (chan->mode) {
        case L2CAP_MODE_BASIC:
                if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) &&
                                !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING))
                        break;

                rfc.mode            = L2CAP_MODE_BASIC;
                rfc.txwin_size      = 0;
                rfc.max_transmit    = 0;
                rfc.retrans_timeout = 0;
                rfc.monitor_timeout = 0;
                rfc.max_pdu_size    = 0;

                l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
                                                        (unsigned long) &rfc);
                break;

        case L2CAP_MODE_ERTM:
                rfc.mode            = L2CAP_MODE_ERTM;
                rfc.max_transmit    = chan->max_tx;
                rfc.retrans_timeout = 0;
                rfc.monitor_timeout = 0;

                size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu -
                                                L2CAP_EXT_HDR_SIZE -
                                                L2CAP_SDULEN_SIZE -
                                                L2CAP_FCS_SIZE);
                rfc.max_pdu_size = cpu_to_le16(size);

                l2cap_txwin_setup(chan);

                rfc.txwin_size = min_t(u16, chan->tx_win,
                                                L2CAP_DEFAULT_TX_WINDOW);

                l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
                                                        (unsigned long) &rfc);

                if (test_bit(FLAG_EFS_ENABLE, &chan->flags))
                        l2cap_add_opt_efs(&ptr, chan);

                if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS))
                        break;

                if (chan->fcs == L2CAP_FCS_NONE ||
                                test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) {
                        chan->fcs = L2CAP_FCS_NONE;
                        l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs);
                }

                if (test_bit(FLAG_EXT_CTRL, &chan->flags))
                        l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2,
                                                                chan->tx_win);
                break;

        case L2CAP_MODE_STREAMING:
                l2cap_txwin_setup(chan);
                rfc.mode            = L2CAP_MODE_STREAMING;
                rfc.txwin_size      = 0;
                rfc.max_transmit    = 0;
                rfc.retrans_timeout = 0;
                rfc.monitor_timeout = 0;

                size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu -
                                                L2CAP_EXT_HDR_SIZE -
                                                L2CAP_SDULEN_SIZE -
                                                L2CAP_FCS_SIZE);
                rfc.max_pdu_size = cpu_to_le16(size);

                l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
                                                        (unsigned long) &rfc);

                if (test_bit(FLAG_EFS_ENABLE, &chan->flags))
                        l2cap_add_opt_efs(&ptr, chan);

                if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS))
                        break;

                if (chan->fcs == L2CAP_FCS_NONE ||
                                test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) {
                        chan->fcs = L2CAP_FCS_NONE;
                        l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs);
                }
                break;
        }

        req->dcid  = cpu_to_le16(chan->dcid);
        req->flags = __constant_cpu_to_le16(0);

        return ptr - data;
}

static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data)
{
        struct l2cap_conf_rsp *rsp = data;
        void *ptr = rsp->data;
        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 };
        struct l2cap_conf_efs efs;
        u8 remote_efs = 0;
        u16 mtu = L2CAP_DEFAULT_MTU;
        u16 result = L2CAP_CONF_SUCCESS;
        u16 size;

        BT_DBG("chan %p", chan);

        while (len >= L2CAP_CONF_OPT_SIZE) {
                len -= l2cap_get_conf_opt(&req, &type, &olen, &val);

                hint  = type & L2CAP_CONF_HINT;
                type &= L2CAP_CONF_MASK;

                switch (type) {
                case L2CAP_CONF_MTU:
                        mtu = val;
                        break;

                case L2CAP_CONF_FLUSH_TO:
                        chan->flush_to = val;
                        break;

                case L2CAP_CONF_QOS:
                        break;

                case L2CAP_CONF_RFC:
                        if (olen == sizeof(rfc))
                                memcpy(&rfc, (void *) val, olen);
                        break;

                case L2CAP_CONF_FCS:
                        if (val == L2CAP_FCS_NONE)
                                set_bit(CONF_NO_FCS_RECV, &chan->conf_state);
                        break;

                case L2CAP_CONF_EFS:
                        remote_efs = 1;
                        if (olen == sizeof(efs))
                                memcpy(&efs, (void *) val, olen);
                        break;

                case L2CAP_CONF_EWS:
                        if (!enable_hs)
                                return -ECONNREFUSED;

                        set_bit(FLAG_EXT_CTRL, &chan->flags);
                        set_bit(CONF_EWS_RECV, &chan->conf_state);
                        chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW;
                        chan->remote_tx_win = val;
                        break;

                default:
                        if (hint)
                                break;

                        result = L2CAP_CONF_UNKNOWN;
                        *((u8 *) ptr++) = type;
                        break;
                }
        }

        if (chan->num_conf_rsp || chan->num_conf_req > 1)
                goto done;

        switch (chan->mode) {
        case L2CAP_MODE_STREAMING:
        case L2CAP_MODE_ERTM:
                if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) {
                        chan->mode = l2cap_select_mode(rfc.mode,
                                        chan->conn->feat_mask);
                        break;
                }

                if (remote_efs) {