10a708f8fSGustavo F. Padovan /* 20a708f8fSGustavo F. Padovan BlueZ - Bluetooth protocol stack for Linux 30a708f8fSGustavo F. Padovan Copyright (C) 2000-2001 Qualcomm Incorporated 40a708f8fSGustavo F. Padovan Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org> 50a708f8fSGustavo F. Padovan Copyright (C) 2010 Google Inc. 6590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 7422e925bSMat Martineau Copyright (c) 2012 Code Aurora Forum. All rights reserved. 80a708f8fSGustavo F. Padovan 90a708f8fSGustavo F. Padovan Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 100a708f8fSGustavo F. Padovan 110a708f8fSGustavo F. Padovan This program is free software; you can redistribute it and/or modify 120a708f8fSGustavo F. Padovan it under the terms of the GNU General Public License version 2 as 130a708f8fSGustavo F. Padovan published by the Free Software Foundation; 140a708f8fSGustavo F. Padovan 150a708f8fSGustavo F. Padovan THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 160a708f8fSGustavo F. Padovan OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 170a708f8fSGustavo F. Padovan FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 180a708f8fSGustavo F. Padovan IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 190a708f8fSGustavo F. Padovan CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 200a708f8fSGustavo F. Padovan WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 210a708f8fSGustavo F. Padovan ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 220a708f8fSGustavo F. Padovan OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 230a708f8fSGustavo F. Padovan 240a708f8fSGustavo F. Padovan ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 250a708f8fSGustavo F. Padovan COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 260a708f8fSGustavo F. Padovan SOFTWARE IS DISCLAIMED. 270a708f8fSGustavo F. Padovan */ 280a708f8fSGustavo F. Padovan 29bb58f747SGustavo F. Padovan /* Bluetooth L2CAP core. */ 300a708f8fSGustavo F. Padovan 310a708f8fSGustavo F. Padovan #include <linux/module.h> 320a708f8fSGustavo F. Padovan 330a708f8fSGustavo F. Padovan #include <linux/debugfs.h> 340a708f8fSGustavo F. Padovan #include <linux/crc16.h> 350a708f8fSGustavo F. Padovan 360a708f8fSGustavo F. Padovan #include <net/bluetooth/bluetooth.h> 370a708f8fSGustavo F. Padovan #include <net/bluetooth/hci_core.h> 380a708f8fSGustavo F. Padovan #include <net/bluetooth/l2cap.h> 39b501d6a1SAnderson Briglia #include <net/bluetooth/smp.h> 4097e8e89dSAndrei Emeltchenko #include <net/bluetooth/a2mp.h> 410a708f8fSGustavo F. Padovan 42d1de6d46SMat Martineau bool disable_ertm; 430a708f8fSGustavo F. Padovan 440a708f8fSGustavo F. Padovan static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN; 4550a147cdSMat Martineau static u8 l2cap_fixed_chan[8] = { L2CAP_FC_L2CAP, }; 460a708f8fSGustavo F. Padovan 47b5ad8b7fSJohannes Berg static LIST_HEAD(chan_list); 48b5ad8b7fSJohannes Berg static DEFINE_RWLOCK(chan_list_lock); 490a708f8fSGustavo F. Padovan 500a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 510a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data); 524519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 534519de9aSGustavo F. Padovan void *data); 54710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data); 554519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 564519de9aSGustavo F. Padovan struct l2cap_chan *chan, int err); 570a708f8fSGustavo F. Padovan 58d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 59608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event); 60608bcc6dSMat Martineau 610a708f8fSGustavo F. Padovan /* ---- L2CAP channels ---- */ 6271ba0e56SGustavo F. Padovan 632d792818SGustavo Padovan static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, 642d792818SGustavo Padovan u16 cid) 650a708f8fSGustavo F. Padovan { 663df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 67baa7e1faSGustavo F. Padovan 683df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 693df91ea2SAndrei Emeltchenko if (c->dcid == cid) 703df91ea2SAndrei Emeltchenko return c; 710a708f8fSGustavo F. Padovan } 723df91ea2SAndrei Emeltchenko return NULL; 73baa7e1faSGustavo F. Padovan } 740a708f8fSGustavo F. Padovan 752d792818SGustavo Padovan static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, 762d792818SGustavo Padovan u16 cid) 770a708f8fSGustavo F. Padovan { 783df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 79baa7e1faSGustavo F. Padovan 803df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 813df91ea2SAndrei Emeltchenko if (c->scid == cid) 823df91ea2SAndrei Emeltchenko return c; 830a708f8fSGustavo F. Padovan } 843df91ea2SAndrei Emeltchenko return NULL; 85baa7e1faSGustavo F. Padovan } 860a708f8fSGustavo F. Padovan 870a708f8fSGustavo F. Padovan /* Find channel with given SCID. 88ef191adeSMat Martineau * Returns locked channel. */ 892d792818SGustavo Padovan static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, 902d792818SGustavo Padovan u16 cid) 910a708f8fSGustavo F. Padovan { 9248454079SGustavo F. Padovan struct l2cap_chan *c; 93baa7e1faSGustavo F. Padovan 943df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 95baa7e1faSGustavo F. Padovan c = __l2cap_get_chan_by_scid(conn, cid); 96ef191adeSMat Martineau if (c) 97ef191adeSMat Martineau l2cap_chan_lock(c); 983df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 993df91ea2SAndrei Emeltchenko 10048454079SGustavo F. Padovan return c; 1010a708f8fSGustavo F. Padovan } 1020a708f8fSGustavo F. Padovan 1032d792818SGustavo Padovan static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, 1042d792818SGustavo Padovan u8 ident) 1050a708f8fSGustavo F. Padovan { 1063df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 107baa7e1faSGustavo F. Padovan 1083df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 1093df91ea2SAndrei Emeltchenko if (c->ident == ident) 1103df91ea2SAndrei Emeltchenko return c; 1110a708f8fSGustavo F. Padovan } 1123df91ea2SAndrei Emeltchenko return NULL; 113baa7e1faSGustavo F. Padovan } 1140a708f8fSGustavo F. Padovan 11523691d75SGustavo F. Padovan static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src) 1169e4425ffSGustavo F. Padovan { 11723691d75SGustavo F. Padovan struct l2cap_chan *c; 1189e4425ffSGustavo F. Padovan 11923691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 12023691d75SGustavo F. Padovan if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src)) 12123691d75SGustavo F. Padovan return c; 1229e4425ffSGustavo F. Padovan } 123250938cbSSzymon Janc return NULL; 124250938cbSSzymon Janc } 1259e4425ffSGustavo F. Padovan 1269e4425ffSGustavo F. Padovan int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm) 1279e4425ffSGustavo F. Padovan { 12873b2ec18SGustavo F. Padovan int err; 12973b2ec18SGustavo F. Padovan 130333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1319e4425ffSGustavo F. Padovan 13223691d75SGustavo F. Padovan if (psm && __l2cap_global_chan_by_addr(psm, src)) { 13373b2ec18SGustavo F. Padovan err = -EADDRINUSE; 13473b2ec18SGustavo F. Padovan goto done; 1359e4425ffSGustavo F. Padovan } 1369e4425ffSGustavo F. Padovan 13773b2ec18SGustavo F. Padovan if (psm) { 1389e4425ffSGustavo F. Padovan chan->psm = psm; 1399e4425ffSGustavo F. Padovan chan->sport = psm; 14073b2ec18SGustavo F. Padovan err = 0; 14173b2ec18SGustavo F. Padovan } else { 14273b2ec18SGustavo F. Padovan u16 p; 1439e4425ffSGustavo F. Padovan 14473b2ec18SGustavo F. Padovan err = -EINVAL; 14573b2ec18SGustavo F. Padovan for (p = 0x1001; p < 0x1100; p += 2) 14623691d75SGustavo F. Padovan if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) { 14773b2ec18SGustavo F. Padovan chan->psm = cpu_to_le16(p); 14873b2ec18SGustavo F. Padovan chan->sport = cpu_to_le16(p); 14973b2ec18SGustavo F. Padovan err = 0; 15073b2ec18SGustavo F. Padovan break; 15173b2ec18SGustavo F. Padovan } 15273b2ec18SGustavo F. Padovan } 15373b2ec18SGustavo F. Padovan 15473b2ec18SGustavo F. Padovan done: 155333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 15673b2ec18SGustavo F. Padovan return err; 1579e4425ffSGustavo F. Padovan } 1589e4425ffSGustavo F. Padovan 1599e4425ffSGustavo F. Padovan int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid) 1609e4425ffSGustavo F. Padovan { 161333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1629e4425ffSGustavo F. Padovan 1639e4425ffSGustavo F. Padovan chan->scid = scid; 1649e4425ffSGustavo F. Padovan 165333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 1669e4425ffSGustavo F. Padovan 1679e4425ffSGustavo F. Padovan return 0; 1689e4425ffSGustavo F. Padovan } 1699e4425ffSGustavo F. Padovan 170baa7e1faSGustavo F. Padovan static u16 l2cap_alloc_cid(struct l2cap_conn *conn) 1710a708f8fSGustavo F. Padovan { 1720a708f8fSGustavo F. Padovan u16 cid = L2CAP_CID_DYN_START; 1730a708f8fSGustavo F. Padovan 1740a708f8fSGustavo F. Padovan for (; cid < L2CAP_CID_DYN_END; cid++) { 175baa7e1faSGustavo F. Padovan if (!__l2cap_get_chan_by_scid(conn, cid)) 1760a708f8fSGustavo F. Padovan return cid; 1770a708f8fSGustavo F. Padovan } 1780a708f8fSGustavo F. Padovan 1790a708f8fSGustavo F. Padovan return 0; 1800a708f8fSGustavo F. Padovan } 1810a708f8fSGustavo F. Padovan 1820e587be7SAndrei Emeltchenko static void __l2cap_state_change(struct l2cap_chan *chan, int state) 18389bc500eSGustavo F. Padovan { 18442d2d87cSAndrei Emeltchenko BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state), 185badaaa00SGustavo F. Padovan state_to_string(state)); 186badaaa00SGustavo F. Padovan 18789bc500eSGustavo F. Padovan chan->state = state; 18880b98027SGustavo Padovan chan->ops->state_change(chan, state); 18989bc500eSGustavo F. Padovan } 19089bc500eSGustavo F. Padovan 1910e587be7SAndrei Emeltchenko static void l2cap_state_change(struct l2cap_chan *chan, int state) 1920e587be7SAndrei Emeltchenko { 1930e587be7SAndrei Emeltchenko struct sock *sk = chan->sk; 1940e587be7SAndrei Emeltchenko 1950e587be7SAndrei Emeltchenko lock_sock(sk); 1960e587be7SAndrei Emeltchenko __l2cap_state_change(chan, state); 1970e587be7SAndrei Emeltchenko release_sock(sk); 1980e587be7SAndrei Emeltchenko } 1990e587be7SAndrei Emeltchenko 2002e0052e4SAndrei Emeltchenko static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2012e0052e4SAndrei Emeltchenko { 2022e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2032e0052e4SAndrei Emeltchenko 2042e0052e4SAndrei Emeltchenko sk->sk_err = err; 2052e0052e4SAndrei Emeltchenko } 2062e0052e4SAndrei Emeltchenko 2072e0052e4SAndrei Emeltchenko static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2082e0052e4SAndrei Emeltchenko { 2092e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2102e0052e4SAndrei Emeltchenko 2112e0052e4SAndrei Emeltchenko lock_sock(sk); 2122e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 2132e0052e4SAndrei Emeltchenko release_sock(sk); 2142e0052e4SAndrei Emeltchenko } 2152e0052e4SAndrei Emeltchenko 2164239d16fSMat Martineau static void __set_retrans_timer(struct l2cap_chan *chan) 2174239d16fSMat Martineau { 2184239d16fSMat Martineau if (!delayed_work_pending(&chan->monitor_timer) && 2194239d16fSMat Martineau chan->retrans_timeout) { 2204239d16fSMat Martineau l2cap_set_timer(chan, &chan->retrans_timer, 2214239d16fSMat Martineau msecs_to_jiffies(chan->retrans_timeout)); 2224239d16fSMat Martineau } 2234239d16fSMat Martineau } 2244239d16fSMat Martineau 2254239d16fSMat Martineau static void __set_monitor_timer(struct l2cap_chan *chan) 2264239d16fSMat Martineau { 2274239d16fSMat Martineau __clear_retrans_timer(chan); 2284239d16fSMat Martineau if (chan->monitor_timeout) { 2294239d16fSMat Martineau l2cap_set_timer(chan, &chan->monitor_timer, 2304239d16fSMat Martineau msecs_to_jiffies(chan->monitor_timeout)); 2314239d16fSMat Martineau } 2324239d16fSMat Martineau } 2334239d16fSMat Martineau 234608bcc6dSMat Martineau static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head, 235608bcc6dSMat Martineau u16 seq) 236608bcc6dSMat Martineau { 237608bcc6dSMat Martineau struct sk_buff *skb; 238608bcc6dSMat Martineau 239608bcc6dSMat Martineau skb_queue_walk(head, skb) { 240608bcc6dSMat Martineau if (bt_cb(skb)->control.txseq == seq) 241608bcc6dSMat Martineau return skb; 242608bcc6dSMat Martineau } 243608bcc6dSMat Martineau 244608bcc6dSMat Martineau return NULL; 245608bcc6dSMat Martineau } 246608bcc6dSMat Martineau 2473c588192SMat Martineau /* ---- L2CAP sequence number lists ---- */ 2483c588192SMat Martineau 2493c588192SMat Martineau /* For ERTM, ordered lists of sequence numbers must be tracked for 2503c588192SMat Martineau * SREJ requests that are received and for frames that are to be 2513c588192SMat Martineau * retransmitted. These seq_list functions implement a singly-linked 2523c588192SMat Martineau * list in an array, where membership in the list can also be checked 2533c588192SMat Martineau * in constant time. Items can also be added to the tail of the list 2543c588192SMat Martineau * and removed from the head in constant time, without further memory 2553c588192SMat Martineau * allocs or frees. 2563c588192SMat Martineau */ 2573c588192SMat Martineau 2583c588192SMat Martineau static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) 2593c588192SMat Martineau { 2603c588192SMat Martineau size_t alloc_size, i; 2613c588192SMat Martineau 2623c588192SMat Martineau /* Allocated size is a power of 2 to map sequence numbers 2633c588192SMat Martineau * (which may be up to 14 bits) in to a smaller array that is 2643c588192SMat Martineau * sized for the negotiated ERTM transmit windows. 2653c588192SMat Martineau */ 2663c588192SMat Martineau alloc_size = roundup_pow_of_two(size); 2673c588192SMat Martineau 2683c588192SMat Martineau seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); 2693c588192SMat Martineau if (!seq_list->list) 2703c588192SMat Martineau return -ENOMEM; 2713c588192SMat Martineau 2723c588192SMat Martineau seq_list->mask = alloc_size - 1; 2733c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 2743c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 2753c588192SMat Martineau for (i = 0; i < alloc_size; i++) 2763c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 2773c588192SMat Martineau 2783c588192SMat Martineau return 0; 2793c588192SMat Martineau } 2803c588192SMat Martineau 2813c588192SMat Martineau static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list) 2823c588192SMat Martineau { 2833c588192SMat Martineau kfree(seq_list->list); 2843c588192SMat Martineau } 2853c588192SMat Martineau 2863c588192SMat Martineau static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list, 2873c588192SMat Martineau u16 seq) 2883c588192SMat Martineau { 2893c588192SMat Martineau /* Constant-time check for list membership */ 2903c588192SMat Martineau return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR; 2913c588192SMat Martineau } 2923c588192SMat Martineau 2933c588192SMat Martineau static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq) 2943c588192SMat Martineau { 2953c588192SMat Martineau u16 mask = seq_list->mask; 2963c588192SMat Martineau 2973c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) { 2983c588192SMat Martineau /* In case someone tries to pop the head of an empty list */ 2993c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3003c588192SMat Martineau } else if (seq_list->head == seq) { 3013c588192SMat Martineau /* Head can be removed in constant time */ 3023c588192SMat Martineau seq_list->head = seq_list->list[seq & mask]; 3033c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3043c588192SMat Martineau 3053c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_TAIL) { 3063c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3073c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3083c588192SMat Martineau } 3093c588192SMat Martineau } else { 3103c588192SMat Martineau /* Walk the list to find the sequence number */ 3113c588192SMat Martineau u16 prev = seq_list->head; 3123c588192SMat Martineau while (seq_list->list[prev & mask] != seq) { 3133c588192SMat Martineau prev = seq_list->list[prev & mask]; 3143c588192SMat Martineau if (prev == L2CAP_SEQ_LIST_TAIL) 3153c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3163c588192SMat Martineau } 3173c588192SMat Martineau 3183c588192SMat Martineau /* Unlink the number from the list and clear it */ 3193c588192SMat Martineau seq_list->list[prev & mask] = seq_list->list[seq & mask]; 3203c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3213c588192SMat Martineau if (seq_list->tail == seq) 3223c588192SMat Martineau seq_list->tail = prev; 3233c588192SMat Martineau } 3243c588192SMat Martineau return seq; 3253c588192SMat Martineau } 3263c588192SMat Martineau 3273c588192SMat Martineau static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list) 3283c588192SMat Martineau { 3293c588192SMat Martineau /* Remove the head in constant time */ 3303c588192SMat Martineau return l2cap_seq_list_remove(seq_list, seq_list->head); 3313c588192SMat Martineau } 3323c588192SMat Martineau 3333c588192SMat Martineau static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list) 3343c588192SMat Martineau { 3353c588192SMat Martineau u16 i; 336f522ae36SGustavo Padovan 337f522ae36SGustavo Padovan if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) 338f522ae36SGustavo Padovan return; 339f522ae36SGustavo Padovan 3403c588192SMat Martineau for (i = 0; i <= seq_list->mask; i++) 3413c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3423c588192SMat Martineau 3433c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3443c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3453c588192SMat Martineau } 3463c588192SMat Martineau 3473c588192SMat Martineau static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq) 3483c588192SMat Martineau { 3493c588192SMat Martineau u16 mask = seq_list->mask; 3503c588192SMat Martineau 3513c588192SMat Martineau /* All appends happen in constant time */ 3523c588192SMat Martineau 353f522ae36SGustavo Padovan if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR) 354f522ae36SGustavo Padovan return; 355f522ae36SGustavo Padovan 3563c588192SMat Martineau if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR) 3573c588192SMat Martineau seq_list->head = seq; 3583c588192SMat Martineau else 3593c588192SMat Martineau seq_list->list[seq_list->tail & mask] = seq; 3603c588192SMat Martineau 3613c588192SMat Martineau seq_list->tail = seq; 3623c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL; 3633c588192SMat Martineau } 3643c588192SMat Martineau 365721c4181SGustavo F. Padovan static void l2cap_chan_timeout(struct work_struct *work) 366ab07801dSGustavo F. Padovan { 367721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 368721c4181SGustavo F. Padovan chan_timer.work); 3693df91ea2SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 370ab07801dSGustavo F. Padovan int reason; 371ab07801dSGustavo F. Padovan 372e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s", chan, state_to_string(chan->state)); 373ab07801dSGustavo F. Padovan 3743df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3756be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 376ab07801dSGustavo F. Padovan 37789bc500eSGustavo F. Padovan if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG) 378ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 37989bc500eSGustavo F. Padovan else if (chan->state == BT_CONNECT && 380ab07801dSGustavo F. Padovan chan->sec_level != BT_SECURITY_SDP) 381ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 382ab07801dSGustavo F. Padovan else 383ab07801dSGustavo F. Padovan reason = ETIMEDOUT; 384ab07801dSGustavo F. Padovan 3850f852724SGustavo F. Padovan l2cap_chan_close(chan, reason); 386ab07801dSGustavo F. Padovan 3876be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 388ab07801dSGustavo F. Padovan 38980b98027SGustavo Padovan chan->ops->close(chan); 3903df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 3913df91ea2SAndrei Emeltchenko 392371fd835SUlisses Furquim l2cap_chan_put(chan); 393ab07801dSGustavo F. Padovan } 394ab07801dSGustavo F. Padovan 395eef1d9b6SGustavo Padovan struct l2cap_chan *l2cap_chan_create(void) 3960a708f8fSGustavo F. Padovan { 39748454079SGustavo F. Padovan struct l2cap_chan *chan; 3980a708f8fSGustavo F. Padovan 39948454079SGustavo F. Padovan chan = kzalloc(sizeof(*chan), GFP_ATOMIC); 40048454079SGustavo F. Padovan if (!chan) 40148454079SGustavo F. Padovan return NULL; 4020a708f8fSGustavo F. Padovan 403c03b355eSAndrei Emeltchenko mutex_init(&chan->lock); 404c03b355eSAndrei Emeltchenko 405333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 40623691d75SGustavo F. Padovan list_add(&chan->global_l, &chan_list); 407333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 40823691d75SGustavo F. Padovan 409721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout); 410ab07801dSGustavo F. Padovan 41189bc500eSGustavo F. Padovan chan->state = BT_OPEN; 41289bc500eSGustavo F. Padovan 413144ad330SSyam Sidhardhan kref_init(&chan->kref); 41471ba0e56SGustavo F. Padovan 4152827011fSMat Martineau /* This flag is cleared in l2cap_chan_ready() */ 4162827011fSMat Martineau set_bit(CONF_NOT_COMPLETE, &chan->conf_state); 4172827011fSMat Martineau 418eef1d9b6SGustavo Padovan BT_DBG("chan %p", chan); 419abc545b8SSzymon Janc 42048454079SGustavo F. Padovan return chan; 4210a708f8fSGustavo F. Padovan } 4220a708f8fSGustavo F. Padovan 423144ad330SSyam Sidhardhan static void l2cap_chan_destroy(struct kref *kref) 4246ff5abbfSGustavo F. Padovan { 425144ad330SSyam Sidhardhan struct l2cap_chan *chan = container_of(kref, struct l2cap_chan, kref); 426144ad330SSyam Sidhardhan 4274af66c69SJaganath Kanakkassery BT_DBG("chan %p", chan); 4284af66c69SJaganath Kanakkassery 429333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 43023691d75SGustavo F. Padovan list_del(&chan->global_l); 431333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 43223691d75SGustavo F. Padovan 4334af66c69SJaganath Kanakkassery kfree(chan); 4346ff5abbfSGustavo F. Padovan } 4356ff5abbfSGustavo F. Padovan 43630648372SJaganath Kanakkassery void l2cap_chan_hold(struct l2cap_chan *c) 43730648372SJaganath Kanakkassery { 438144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 43930648372SJaganath Kanakkassery 440144ad330SSyam Sidhardhan kref_get(&c->kref); 44130648372SJaganath Kanakkassery } 44230648372SJaganath Kanakkassery 44330648372SJaganath Kanakkassery void l2cap_chan_put(struct l2cap_chan *c) 44430648372SJaganath Kanakkassery { 445144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 44630648372SJaganath Kanakkassery 447144ad330SSyam Sidhardhan kref_put(&c->kref, l2cap_chan_destroy); 44830648372SJaganath Kanakkassery } 44930648372SJaganath Kanakkassery 450bd4b1653SAndrei Emeltchenko void l2cap_chan_set_defaults(struct l2cap_chan *chan) 451bd4b1653SAndrei Emeltchenko { 452bd4b1653SAndrei Emeltchenko chan->fcs = L2CAP_FCS_CRC16; 453bd4b1653SAndrei Emeltchenko chan->max_tx = L2CAP_DEFAULT_MAX_TX; 454bd4b1653SAndrei Emeltchenko chan->tx_win = L2CAP_DEFAULT_TX_WINDOW; 455bd4b1653SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 456c20f8e35SMat Martineau chan->ack_win = L2CAP_DEFAULT_TX_WINDOW; 457bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 458bd4b1653SAndrei Emeltchenko 459bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 460bd4b1653SAndrei Emeltchenko } 461bd4b1653SAndrei Emeltchenko 46293c3e8f5SAndrei Emeltchenko void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4630a708f8fSGustavo F. Padovan { 4640a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 465097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4660a708f8fSGustavo F. Padovan 4679f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 4680a708f8fSGustavo F. Padovan 4698c1d787bSGustavo F. Padovan chan->conn = conn; 4700a708f8fSGustavo F. Padovan 4715491120eSAndrei Emeltchenko switch (chan->chan_type) { 4725491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 473b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 474b62f328bSVille Tervo /* LE connection */ 4756fcb06a2SAndre Guedes chan->omtu = L2CAP_DEFAULT_MTU; 476fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 477fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 478b62f328bSVille Tervo } else { 4790a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 480fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 4810c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 482b62f328bSVille Tervo } 4835491120eSAndrei Emeltchenko break; 4845491120eSAndrei Emeltchenko 4855491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 4860a708f8fSGustavo F. Padovan /* Connectionless socket */ 487fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 488fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 4890c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4905491120eSAndrei Emeltchenko break; 4915491120eSAndrei Emeltchenko 492416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 493416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 494416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 495416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 496416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 497416fa752SAndrei Emeltchenko break; 498416fa752SAndrei Emeltchenko 4995491120eSAndrei Emeltchenko default: 5000a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 501fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 502fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 5030c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5040a708f8fSGustavo F. Padovan } 5050a708f8fSGustavo F. Padovan 5068f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 5078f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 5088f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 5098f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 5108f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 5118936fa6dSAndrei Emeltchenko chan->local_flush_to = L2CAP_EFS_DEFAULT_FLUSH_TO; 5128f7975b1SAndrei Emeltchenko 513371fd835SUlisses Furquim l2cap_chan_hold(chan); 514baa7e1faSGustavo F. Padovan 5153df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 516643162a8SAndrei Emeltchenko } 517643162a8SAndrei Emeltchenko 518466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 519643162a8SAndrei Emeltchenko { 520643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 521643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 5223df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5230a708f8fSGustavo F. Padovan } 5240a708f8fSGustavo F. Padovan 525466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5260a708f8fSGustavo F. Padovan { 5278c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5280a708f8fSGustavo F. Padovan 529c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5300a708f8fSGustavo F. Padovan 53149208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5320a708f8fSGustavo F. Padovan 5330a708f8fSGustavo F. Padovan if (conn) { 53456f60984SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 535baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5363df91ea2SAndrei Emeltchenko list_del(&chan->list); 5373d57dc68SGustavo F. Padovan 538371fd835SUlisses Furquim l2cap_chan_put(chan); 539baa7e1faSGustavo F. Padovan 5408c1d787bSGustavo F. Padovan chan->conn = NULL; 5413cabbfdaSAndrei Emeltchenko 5423cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 5430a708f8fSGustavo F. Padovan hci_conn_put(conn->hcon); 54456f60984SAndrei Emeltchenko 54556f60984SAndrei Emeltchenko if (mgr && mgr->bredr_chan == chan) 54656f60984SAndrei Emeltchenko mgr->bredr_chan = NULL; 5470a708f8fSGustavo F. Padovan } 5480a708f8fSGustavo F. Padovan 549c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5506be36555SAndrei Emeltchenko 5512827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5526ff5abbfSGustavo F. Padovan return; 5532ead70b8SGustavo F. Padovan 554ee556f66SGustavo Padovan switch(chan->mode) { 555ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 556ee556f66SGustavo Padovan break; 5570a708f8fSGustavo F. Padovan 558ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5591a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5601a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5611a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 5620a708f8fSGustavo F. Padovan 563f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 5640a708f8fSGustavo F. Padovan 5653c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 5663c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 567ee556f66SGustavo Padovan 568ee556f66SGustavo Padovan /* fall through */ 569ee556f66SGustavo Padovan 570ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 571ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 572ee556f66SGustavo Padovan break; 5730a708f8fSGustavo F. Padovan } 574ee556f66SGustavo Padovan 575ee556f66SGustavo Padovan return; 5760a708f8fSGustavo F. Padovan } 5770a708f8fSGustavo F. Padovan 5780f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 5794519de9aSGustavo F. Padovan { 5804519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5814519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 5824519de9aSGustavo F. Padovan 5832d792818SGustavo Padovan BT_DBG("chan %p state %s sk %p", chan, state_to_string(chan->state), 5842d792818SGustavo Padovan sk); 5854519de9aSGustavo F. Padovan 58689bc500eSGustavo F. Padovan switch (chan->state) { 5874519de9aSGustavo F. Padovan case BT_LISTEN: 588c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 5894519de9aSGustavo F. Padovan break; 5904519de9aSGustavo F. Padovan 5914519de9aSGustavo F. Padovan case BT_CONNECTED: 5924519de9aSGustavo F. Padovan case BT_CONFIG: 593715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5944519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 595c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 5964519de9aSGustavo F. Padovan l2cap_send_disconn_req(conn, chan, reason); 5974519de9aSGustavo F. Padovan } else 5984519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5994519de9aSGustavo F. Padovan break; 6004519de9aSGustavo F. Padovan 6014519de9aSGustavo F. Padovan case BT_CONNECT2: 602715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6034519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 6044519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6054519de9aSGustavo F. Padovan __u16 result; 6064519de9aSGustavo F. Padovan 607c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 6084519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 6094519de9aSGustavo F. Padovan else 6104519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 61189bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 6124519de9aSGustavo F. Padovan 6134519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6144519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6154519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 616ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 6174519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6184519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 6194519de9aSGustavo F. Padovan } 6204519de9aSGustavo F. Padovan 6214519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6224519de9aSGustavo F. Padovan break; 6234519de9aSGustavo F. Padovan 6244519de9aSGustavo F. Padovan case BT_CONNECT: 6254519de9aSGustavo F. Padovan case BT_DISCONN: 6264519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6274519de9aSGustavo F. Padovan break; 6284519de9aSGustavo F. Padovan 6294519de9aSGustavo F. Padovan default: 630c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6314519de9aSGustavo F. Padovan break; 6324519de9aSGustavo F. Padovan } 6334519de9aSGustavo F. Padovan } 6344519de9aSGustavo F. Padovan 6354343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6360a708f8fSGustavo F. Padovan { 637715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6384343478fSGustavo F. Padovan switch (chan->sec_level) { 6390a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6400a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6410a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6420a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6430a708f8fSGustavo F. Padovan default: 6440a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6450a708f8fSGustavo F. Padovan } 6462983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6474343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6484343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6490a708f8fSGustavo F. Padovan 6504343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6510a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6520a708f8fSGustavo F. Padovan else 6530a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6540a708f8fSGustavo F. Padovan } else { 6554343478fSGustavo F. Padovan switch (chan->sec_level) { 6560a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6570a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6580a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6590a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6600a708f8fSGustavo F. Padovan default: 6610a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6620a708f8fSGustavo F. Padovan } 6630a708f8fSGustavo F. Padovan } 6640a708f8fSGustavo F. Padovan } 6650a708f8fSGustavo F. Padovan 6660a708f8fSGustavo F. Padovan /* Service level security */ 667d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 6680a708f8fSGustavo F. Padovan { 6698c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6700a708f8fSGustavo F. Padovan __u8 auth_type; 6710a708f8fSGustavo F. Padovan 6724343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 6730a708f8fSGustavo F. Padovan 6744343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 6750a708f8fSGustavo F. Padovan } 6760a708f8fSGustavo F. Padovan 677b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 6780a708f8fSGustavo F. Padovan { 6790a708f8fSGustavo F. Padovan u8 id; 6800a708f8fSGustavo F. Padovan 6810a708f8fSGustavo F. Padovan /* Get next available identificator. 6820a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 6830a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 6840a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 6850a708f8fSGustavo F. Padovan */ 6860a708f8fSGustavo F. Padovan 687333055f2SGustavo F. Padovan spin_lock(&conn->lock); 6880a708f8fSGustavo F. Padovan 6890a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 6900a708f8fSGustavo F. Padovan conn->tx_ident = 1; 6910a708f8fSGustavo F. Padovan 6920a708f8fSGustavo F. Padovan id = conn->tx_ident; 6930a708f8fSGustavo F. Padovan 694333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 6950a708f8fSGustavo F. Padovan 6960a708f8fSGustavo F. Padovan return id; 6970a708f8fSGustavo F. Padovan } 6980a708f8fSGustavo F. Padovan 6992d792818SGustavo Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 7002d792818SGustavo Padovan void *data) 7010a708f8fSGustavo F. Padovan { 7020a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 7030a708f8fSGustavo F. Padovan u8 flags; 7040a708f8fSGustavo F. Padovan 7050a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 7060a708f8fSGustavo F. Padovan 7070a708f8fSGustavo F. Padovan if (!skb) 7080a708f8fSGustavo F. Padovan return; 7090a708f8fSGustavo F. Padovan 7100a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 7110a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 7120a708f8fSGustavo F. Padovan else 7130a708f8fSGustavo F. Padovan flags = ACL_START; 7140a708f8fSGustavo F. Padovan 71514b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 7165e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 71714b12d0bSJaikumar Ganesh 71873d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 7190a708f8fSGustavo F. Padovan } 7200a708f8fSGustavo F. Padovan 72173d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 72273d80debSLuiz Augusto von Dentz { 72373d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 72473d80debSLuiz Augusto von Dentz u16 flags; 72573d80debSLuiz Augusto von Dentz 72673d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 72773d80debSLuiz Augusto von Dentz skb->priority); 72873d80debSLuiz Augusto von Dentz 72973d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 73073d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 73173d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 73273d80debSLuiz Augusto von Dentz else 73373d80debSLuiz Augusto von Dentz flags = ACL_START; 73473d80debSLuiz Augusto von Dentz 73573d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 73673d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7370a708f8fSGustavo F. Padovan } 7380a708f8fSGustavo F. Padovan 739b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 740b5c6aaedSMat Martineau { 741b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 742b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 743b5c6aaedSMat Martineau 744b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 745b5c6aaedSMat Martineau /* S-Frame */ 746b5c6aaedSMat Martineau control->sframe = 1; 747b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 748b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 749b5c6aaedSMat Martineau 750b5c6aaedSMat Martineau control->sar = 0; 751b5c6aaedSMat Martineau control->txseq = 0; 752b5c6aaedSMat Martineau } else { 753b5c6aaedSMat Martineau /* I-Frame */ 754b5c6aaedSMat Martineau control->sframe = 0; 755b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 756b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 757b5c6aaedSMat Martineau 758b5c6aaedSMat Martineau control->poll = 0; 759b5c6aaedSMat Martineau control->super = 0; 760b5c6aaedSMat Martineau } 761b5c6aaedSMat Martineau } 762b5c6aaedSMat Martineau 763b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 764b5c6aaedSMat Martineau { 765b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 766b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 767b5c6aaedSMat Martineau 768b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 769b5c6aaedSMat Martineau /* S-Frame */ 770b5c6aaedSMat Martineau control->sframe = 1; 771b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 772b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 773b5c6aaedSMat Martineau 774b5c6aaedSMat Martineau control->sar = 0; 775b5c6aaedSMat Martineau control->txseq = 0; 776b5c6aaedSMat Martineau } else { 777b5c6aaedSMat Martineau /* I-Frame */ 778b5c6aaedSMat Martineau control->sframe = 0; 779b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 780b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 781b5c6aaedSMat Martineau 782b5c6aaedSMat Martineau control->poll = 0; 783b5c6aaedSMat Martineau control->super = 0; 784b5c6aaedSMat Martineau } 785b5c6aaedSMat Martineau } 786b5c6aaedSMat Martineau 787b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 788b5c6aaedSMat Martineau struct sk_buff *skb) 789b5c6aaedSMat Martineau { 790b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 791b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 792b5c6aaedSMat Martineau &bt_cb(skb)->control); 793cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 794b5c6aaedSMat Martineau } else { 795b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 796b5c6aaedSMat Martineau &bt_cb(skb)->control); 797cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 798b5c6aaedSMat Martineau } 799b5c6aaedSMat Martineau } 800b5c6aaedSMat Martineau 801b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 802b5c6aaedSMat Martineau { 803b5c6aaedSMat Martineau u32 packed; 804b5c6aaedSMat Martineau 805b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 806b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 807b5c6aaedSMat Martineau 808b5c6aaedSMat Martineau if (control->sframe) { 809b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 810b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 811b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 812b5c6aaedSMat Martineau } else { 813b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 814b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 815b5c6aaedSMat Martineau } 816b5c6aaedSMat Martineau 817b5c6aaedSMat Martineau return packed; 818b5c6aaedSMat Martineau } 819b5c6aaedSMat Martineau 820b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 821b5c6aaedSMat Martineau { 822b5c6aaedSMat Martineau u16 packed; 823b5c6aaedSMat Martineau 824b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 825b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 826b5c6aaedSMat Martineau 827b5c6aaedSMat Martineau if (control->sframe) { 828b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 829b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 830b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 831b5c6aaedSMat Martineau } else { 832b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 833b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 834b5c6aaedSMat Martineau } 835b5c6aaedSMat Martineau 836b5c6aaedSMat Martineau return packed; 837b5c6aaedSMat Martineau } 838b5c6aaedSMat Martineau 839b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 840b5c6aaedSMat Martineau struct l2cap_ctrl *control, 841b5c6aaedSMat Martineau struct sk_buff *skb) 842b5c6aaedSMat Martineau { 843b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 844b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 845b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 846b5c6aaedSMat Martineau } else { 847b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 848b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 849b5c6aaedSMat Martineau } 850b5c6aaedSMat Martineau } 851b5c6aaedSMat Martineau 852ba7aa64fSGustavo Padovan static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan) 853ba7aa64fSGustavo Padovan { 854ba7aa64fSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 855ba7aa64fSGustavo Padovan return L2CAP_EXT_HDR_SIZE; 856ba7aa64fSGustavo Padovan else 857ba7aa64fSGustavo Padovan return L2CAP_ENH_HDR_SIZE; 858ba7aa64fSGustavo Padovan } 859ba7aa64fSGustavo Padovan 860a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 861a67d7f6fSMat Martineau u32 control) 8620a708f8fSGustavo F. Padovan { 8630a708f8fSGustavo F. Padovan struct sk_buff *skb; 8640a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 865ba7aa64fSGustavo Padovan int hlen = __ertm_hdr_size(chan); 8660a708f8fSGustavo F. Padovan 8670a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 86803a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 8690a708f8fSGustavo F. Padovan 870a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 8710a708f8fSGustavo F. Padovan 8720a708f8fSGustavo F. Padovan if (!skb) 873a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 8740a708f8fSGustavo F. Padovan 8750a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 8760a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 877fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 87888843ab0SAndrei Emeltchenko 879a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 880a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 881a67d7f6fSMat Martineau else 882a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 8830a708f8fSGustavo F. Padovan 88447d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 885a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 88603a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 8870a708f8fSGustavo F. Padovan } 8880a708f8fSGustavo F. Padovan 88973d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 890a67d7f6fSMat Martineau return skb; 891a67d7f6fSMat Martineau } 892a67d7f6fSMat Martineau 893a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 894a67d7f6fSMat Martineau struct l2cap_ctrl *control) 895a67d7f6fSMat Martineau { 896a67d7f6fSMat Martineau struct sk_buff *skb; 897a67d7f6fSMat Martineau u32 control_field; 898a67d7f6fSMat Martineau 899a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 900a67d7f6fSMat Martineau 901a67d7f6fSMat Martineau if (!control->sframe) 902a67d7f6fSMat Martineau return; 903a67d7f6fSMat Martineau 904a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 905a67d7f6fSMat Martineau !control->poll) 906a67d7f6fSMat Martineau control->final = 1; 907a67d7f6fSMat Martineau 908a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 909a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 910a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 911a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 912a67d7f6fSMat Martineau 913a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 914a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 915a67d7f6fSMat Martineau __clear_ack_timer(chan); 916a67d7f6fSMat Martineau } 917a67d7f6fSMat Martineau 918a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 919a67d7f6fSMat Martineau control->final, control->poll, control->super); 920a67d7f6fSMat Martineau 921a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 922a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 923a67d7f6fSMat Martineau else 924a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 925a67d7f6fSMat Martineau 926a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 927a67d7f6fSMat Martineau if (!IS_ERR(skb)) 92873d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9290a708f8fSGustavo F. Padovan } 9300a708f8fSGustavo F. Padovan 931c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9320a708f8fSGustavo F. Padovan { 933c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9340a708f8fSGustavo F. Padovan 935c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 936c9e3d5e0SMat Martineau 937c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 938c9e3d5e0SMat Martineau control.sframe = 1; 939c9e3d5e0SMat Martineau control.poll = poll; 940c9e3d5e0SMat Martineau 941c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 942c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 943c9e3d5e0SMat Martineau else 944c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 945c9e3d5e0SMat Martineau 946c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 947c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 9480a708f8fSGustavo F. Padovan } 9490a708f8fSGustavo F. Padovan 950b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 9510a708f8fSGustavo F. Padovan { 952c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 9530a708f8fSGustavo F. Padovan } 9540a708f8fSGustavo F. Padovan 95593c3e8f5SAndrei Emeltchenko static bool __amp_capable(struct l2cap_chan *chan) 95693c3e8f5SAndrei Emeltchenko { 95793c3e8f5SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 95893c3e8f5SAndrei Emeltchenko 95993c3e8f5SAndrei Emeltchenko if (enable_hs && 96093c3e8f5SAndrei Emeltchenko chan->chan_policy == BT_CHANNEL_POLICY_AMP_PREFERRED && 96193c3e8f5SAndrei Emeltchenko conn->fixed_chan_mask & L2CAP_FC_A2MP) 96293c3e8f5SAndrei Emeltchenko return true; 96393c3e8f5SAndrei Emeltchenko else 96493c3e8f5SAndrei Emeltchenko return false; 96593c3e8f5SAndrei Emeltchenko } 96693c3e8f5SAndrei Emeltchenko 9672766be48SAndrei Emeltchenko void l2cap_send_conn_req(struct l2cap_chan *chan) 9689b27f350SAndrei Emeltchenko { 9699b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 9709b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 9719b27f350SAndrei Emeltchenko 9729b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 9739b27f350SAndrei Emeltchenko req.psm = chan->psm; 9749b27f350SAndrei Emeltchenko 9759b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 9769b27f350SAndrei Emeltchenko 9779b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 9789b27f350SAndrei Emeltchenko 9799b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 9809b27f350SAndrei Emeltchenko } 9819b27f350SAndrei Emeltchenko 9829f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 9839f0caeb1SVinicius Costa Gomes { 9842827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 9859f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 9869f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 9879f0caeb1SVinicius Costa Gomes 98854a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 9899f0caeb1SVinicius Costa Gomes 99054a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 9919f0caeb1SVinicius Costa Gomes } 9929f0caeb1SVinicius Costa Gomes 99393c3e8f5SAndrei Emeltchenko static void l2cap_start_connection(struct l2cap_chan *chan) 99493c3e8f5SAndrei Emeltchenko { 99593c3e8f5SAndrei Emeltchenko if (__amp_capable(chan)) { 99693c3e8f5SAndrei Emeltchenko BT_DBG("chan %p AMP capable: discover AMPs", chan); 99793c3e8f5SAndrei Emeltchenko a2mp_discover_amp(chan); 99893c3e8f5SAndrei Emeltchenko } else { 99993c3e8f5SAndrei Emeltchenko l2cap_send_conn_req(chan); 100093c3e8f5SAndrei Emeltchenko } 100193c3e8f5SAndrei Emeltchenko } 100293c3e8f5SAndrei Emeltchenko 1003fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 10040a708f8fSGustavo F. Padovan { 10058c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 10060a708f8fSGustavo F. Padovan 10079f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 10089f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 10099f0caeb1SVinicius Costa Gomes return; 10109f0caeb1SVinicius Costa Gomes } 10119f0caeb1SVinicius Costa Gomes 10120a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 10130a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 10140a708f8fSGustavo F. Padovan return; 10150a708f8fSGustavo F. Padovan 1016d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 101793c3e8f5SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) { 101893c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 101993c3e8f5SAndrei Emeltchenko } 10200a708f8fSGustavo F. Padovan } else { 10210a708f8fSGustavo F. Padovan struct l2cap_info_req req; 1022ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 10230a708f8fSGustavo F. Padovan 10240a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 10250a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 10260a708f8fSGustavo F. Padovan 1027ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 10280a708f8fSGustavo F. Padovan 10292d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 10302d792818SGustavo Padovan sizeof(req), &req); 10310a708f8fSGustavo F. Padovan } 10320a708f8fSGustavo F. Padovan } 10330a708f8fSGustavo F. Padovan 10340a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 10350a708f8fSGustavo F. Padovan { 10360a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 10370a708f8fSGustavo F. Padovan if (!disable_ertm) 10380a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 10390a708f8fSGustavo F. Padovan 10400a708f8fSGustavo F. Padovan switch (mode) { 10410a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 10420a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 10430a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 10440a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 10450a708f8fSGustavo F. Padovan default: 10460a708f8fSGustavo F. Padovan return 0x00; 10470a708f8fSGustavo F. Padovan } 10480a708f8fSGustavo F. Padovan } 10490a708f8fSGustavo F. Padovan 10502d792818SGustavo Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 10512d792818SGustavo Padovan struct l2cap_chan *chan, int err) 10520a708f8fSGustavo F. Padovan { 10536be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 10540a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 10550a708f8fSGustavo F. Padovan 10560a708f8fSGustavo F. Padovan if (!conn) 10570a708f8fSGustavo F. Padovan return; 10580a708f8fSGustavo F. Padovan 1059aad3d0e3SAndrei Emeltchenko if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) { 10601a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 10611a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 10621a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 10630a708f8fSGustavo F. Padovan } 10640a708f8fSGustavo F. Padovan 1065416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1066d117773cSGustavo Padovan l2cap_state_change(chan, BT_DISCONN); 1067416fa752SAndrei Emeltchenko return; 1068416fa752SAndrei Emeltchenko } 1069416fa752SAndrei Emeltchenko 1070fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1071fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 10722d792818SGustavo Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_DISCONN_REQ, 10732d792818SGustavo Padovan sizeof(req), &req); 10740a708f8fSGustavo F. Padovan 10756be36555SAndrei Emeltchenko lock_sock(sk); 10760e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 10772e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 10786be36555SAndrei Emeltchenko release_sock(sk); 10790a708f8fSGustavo F. Padovan } 10800a708f8fSGustavo F. Padovan 10810a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 10820a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 10830a708f8fSGustavo F. Padovan { 10843df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 10850a708f8fSGustavo F. Padovan 10860a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 10870a708f8fSGustavo F. Padovan 10883df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 10890a708f8fSGustavo F. Padovan 10903df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 109148454079SGustavo F. Padovan struct sock *sk = chan->sk; 1092baa7e1faSGustavo F. Padovan 10936be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 10940a708f8fSGustavo F. Padovan 1095715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 10966be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10970a708f8fSGustavo F. Padovan continue; 10980a708f8fSGustavo F. Padovan } 10990a708f8fSGustavo F. Padovan 110089bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1101d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1102b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 11036be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11040a708f8fSGustavo F. Padovan continue; 11050a708f8fSGustavo F. Padovan } 11060a708f8fSGustavo F. Padovan 1107c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1108c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1109c1360a1cSGustavo F. Padovan &chan->conf_state)) { 11100f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 11116be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11120a708f8fSGustavo F. Padovan continue; 11130a708f8fSGustavo F. Padovan } 11140a708f8fSGustavo F. Padovan 111593c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 11160a708f8fSGustavo F. Padovan 111789bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 11180a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 11190a708f8fSGustavo F. Padovan char buf[128]; 1120fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1121fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 11220a708f8fSGustavo F. Padovan 1123d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 11246be36555SAndrei Emeltchenko lock_sock(sk); 1125c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1126c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 1127ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1128ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 11292dc4e510SGustavo Padovan chan->ops->defer(chan); 11300a708f8fSGustavo F. Padovan 11310a708f8fSGustavo F. Padovan } else { 11320e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1133ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1134ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 11350a708f8fSGustavo F. Padovan } 11366be36555SAndrei Emeltchenko release_sock(sk); 11370a708f8fSGustavo F. Padovan } else { 1138ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1139ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 11400a708f8fSGustavo F. Padovan } 11410a708f8fSGustavo F. Padovan 1142fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1143fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 11440a708f8fSGustavo F. Padovan 1145c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 11460a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 11476be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11480a708f8fSGustavo F. Padovan continue; 11490a708f8fSGustavo F. Padovan } 11500a708f8fSGustavo F. Padovan 1151c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 11520a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 115373ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 115473ffa904SGustavo F. Padovan chan->num_conf_req++; 11550a708f8fSGustavo F. Padovan } 11560a708f8fSGustavo F. Padovan 11576be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11580a708f8fSGustavo F. Padovan } 11590a708f8fSGustavo F. Padovan 11603df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 11610a708f8fSGustavo F. Padovan } 11620a708f8fSGustavo F. Padovan 1163c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1164b62f328bSVille Tervo * Returns closest match, locked. 1165b62f328bSVille Tervo */ 1166d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1167c2287681SIdo Yariv bdaddr_t *src, 1168c2287681SIdo Yariv bdaddr_t *dst) 1169b62f328bSVille Tervo { 117023691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1171b62f328bSVille Tervo 117223691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1173b62f328bSVille Tervo 117423691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 117523691d75SGustavo F. Padovan struct sock *sk = c->sk; 1176fe4128e0SGustavo F. Padovan 117789bc500eSGustavo F. Padovan if (state && c->state != state) 1178b62f328bSVille Tervo continue; 1179b62f328bSVille Tervo 118023691d75SGustavo F. Padovan if (c->scid == cid) { 1181c2287681SIdo Yariv int src_match, dst_match; 1182c2287681SIdo Yariv int src_any, dst_any; 1183c2287681SIdo Yariv 1184b62f328bSVille Tervo /* Exact match. */ 1185c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1186c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1187c2287681SIdo Yariv if (src_match && dst_match) { 118823691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 118923691d75SGustavo F. Padovan return c; 119023691d75SGustavo F. Padovan } 1191b62f328bSVille Tervo 1192b62f328bSVille Tervo /* Closest match */ 1193c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1194c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1195c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1196c2287681SIdo Yariv (src_any && dst_any)) 119723691d75SGustavo F. Padovan c1 = c; 1198b62f328bSVille Tervo } 1199b62f328bSVille Tervo } 1200280f294fSGustavo F. Padovan 120123691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1202b62f328bSVille Tervo 120323691d75SGustavo F. Padovan return c1; 1204b62f328bSVille Tervo } 1205b62f328bSVille Tervo 1206b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1207b62f328bSVille Tervo { 1208c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 120923691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1210b62f328bSVille Tervo 1211b62f328bSVille Tervo BT_DBG(""); 1212b62f328bSVille Tervo 1213b62f328bSVille Tervo /* Check if we have socket listening on cid */ 121423691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1215c2287681SIdo Yariv conn->src, conn->dst); 121623691d75SGustavo F. Padovan if (!pchan) 1217b62f328bSVille Tervo return; 1218b62f328bSVille Tervo 121923691d75SGustavo F. Padovan parent = pchan->sk; 122023691d75SGustavo F. Padovan 1221aa2ac881SGustavo F. Padovan lock_sock(parent); 122262f3a2cfSGustavo F. Padovan 122380b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 122480808e43SGustavo F. Padovan if (!chan) 1225b62f328bSVille Tervo goto clean; 1226b62f328bSVille Tervo 122780808e43SGustavo F. Padovan sk = chan->sk; 12285d41ce1dSGustavo F. Padovan 1229b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1230a9ea3ed9SSzymon Janc conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT; 1231b62f328bSVille Tervo 1232b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1233b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1234b62f328bSVille Tervo 12353d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 123648454079SGustavo F. Padovan 12376754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1238b62f328bSVille Tervo 1239b62f328bSVille Tervo clean: 1240aa2ac881SGustavo F. Padovan release_sock(parent); 1241b62f328bSVille Tervo } 1242b62f328bSVille Tervo 12430a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 12440a708f8fSGustavo F. Padovan { 124548454079SGustavo F. Padovan struct l2cap_chan *chan; 1246cc110922SVinicius Costa Gomes struct hci_conn *hcon = conn->hcon; 12470a708f8fSGustavo F. Padovan 12480a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12490a708f8fSGustavo F. Padovan 1250cc110922SVinicius Costa Gomes if (!hcon->out && hcon->type == LE_LINK) 1251b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1252b62f328bSVille Tervo 1253cc110922SVinicius Costa Gomes if (hcon->out && hcon->type == LE_LINK) 1254cc110922SVinicius Costa Gomes smp_conn_security(hcon, hcon->pending_sec_level); 1255160dc6acSVinicius Costa Gomes 12563df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12570a708f8fSGustavo F. Padovan 12583df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1259baa7e1faSGustavo F. Padovan 12606be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12610a708f8fSGustavo F. Padovan 1262416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1263416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1264416fa752SAndrei Emeltchenko continue; 1265416fa752SAndrei Emeltchenko } 1266416fa752SAndrei Emeltchenko 1267cc110922SVinicius Costa Gomes if (hcon->type == LE_LINK) { 1268cc110922SVinicius Costa Gomes if (smp_conn_security(hcon, chan->sec_level)) 1269cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1270acd7d370SVille Tervo 127163128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12726be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1273c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 12746be36555SAndrei Emeltchenko lock_sock(sk); 12750e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 12760a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 12776be36555SAndrei Emeltchenko release_sock(sk); 1278b501d6a1SAnderson Briglia 127989bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1280fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 12810a708f8fSGustavo F. Padovan 12826be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12830a708f8fSGustavo F. Padovan } 12840a708f8fSGustavo F. Padovan 12853df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12860a708f8fSGustavo F. Padovan } 12870a708f8fSGustavo F. Padovan 12880a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 12890a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 12900a708f8fSGustavo F. Padovan { 129148454079SGustavo F. Padovan struct l2cap_chan *chan; 12920a708f8fSGustavo F. Padovan 12930a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12940a708f8fSGustavo F. Padovan 12953df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12960a708f8fSGustavo F. Padovan 12973df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1298ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 12991d8b1fd5SGustavo Padovan l2cap_chan_set_err(chan, err); 13000a708f8fSGustavo F. Padovan } 13010a708f8fSGustavo F. Padovan 13023df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 13030a708f8fSGustavo F. Padovan } 13040a708f8fSGustavo F. Padovan 1305f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 13060a708f8fSGustavo F. Padovan { 1307f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1308030013d8SGustavo F. Padovan info_timer.work); 13090a708f8fSGustavo F. Padovan 13100a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 13110a708f8fSGustavo F. Padovan conn->info_ident = 0; 13120a708f8fSGustavo F. Padovan 13130a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 13140a708f8fSGustavo F. Padovan } 13150a708f8fSGustavo F. Padovan 13165d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 13175d3de7dfSVinicius Costa Gomes { 13185d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 13195d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 13205d3de7dfSVinicius Costa Gomes 13215d3de7dfSVinicius Costa Gomes if (!conn) 13225d3de7dfSVinicius Costa Gomes return; 13235d3de7dfSVinicius Costa Gomes 13245d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 13255d3de7dfSVinicius Costa Gomes 13265d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 13275d3de7dfSVinicius Costa Gomes 13283df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 13293df91ea2SAndrei Emeltchenko 13305d3de7dfSVinicius Costa Gomes /* Kill channels */ 13315d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 133261d6ef3eSMat Martineau l2cap_chan_hold(chan); 13336be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 13346be36555SAndrei Emeltchenko 13355d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 13366be36555SAndrei Emeltchenko 13376be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 13386be36555SAndrei Emeltchenko 133980b98027SGustavo Padovan chan->ops->close(chan); 134061d6ef3eSMat Martineau l2cap_chan_put(chan); 13415d3de7dfSVinicius Costa Gomes } 13425d3de7dfSVinicius Costa Gomes 13433df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 13443df91ea2SAndrei Emeltchenko 134573d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 134673d80debSLuiz Augusto von Dentz 13475d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1348127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 13495d3de7dfSVinicius Costa Gomes 135051a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1351127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 13528aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1353d26a2345SVinicius Costa Gomes } 13545d3de7dfSVinicius Costa Gomes 13555d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 13565d3de7dfSVinicius Costa Gomes kfree(conn); 13575d3de7dfSVinicius Costa Gomes } 13585d3de7dfSVinicius Costa Gomes 13596c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 13605d3de7dfSVinicius Costa Gomes { 13616c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 13626c9d42a1SGustavo F. Padovan security_timer.work); 13635d3de7dfSVinicius Costa Gomes 1364d06cc416SJohan Hedberg BT_DBG("conn %p", conn); 1365d06cc416SJohan Hedberg 1366d06cc416SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 1367d06cc416SJohan Hedberg smp_chan_destroy(conn); 13685d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 13695d3de7dfSVinicius Costa Gomes } 1370d06cc416SJohan Hedberg } 13715d3de7dfSVinicius Costa Gomes 13720a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 13730a708f8fSGustavo F. Padovan { 13740a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 137573d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 13760a708f8fSGustavo F. Padovan 13770a708f8fSGustavo F. Padovan if (conn || status) 13780a708f8fSGustavo F. Padovan return conn; 13790a708f8fSGustavo F. Padovan 138073d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 138173d80debSLuiz Augusto von Dentz if (!hchan) 13820a708f8fSGustavo F. Padovan return NULL; 13830a708f8fSGustavo F. Padovan 13848bcde1f2SGustavo Padovan conn = kzalloc(sizeof(struct l2cap_conn), GFP_KERNEL); 138573d80debSLuiz Augusto von Dentz if (!conn) { 138673d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 138773d80debSLuiz Augusto von Dentz return NULL; 138873d80debSLuiz Augusto von Dentz } 138973d80debSLuiz Augusto von Dentz 13900a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 13910a708f8fSGustavo F. Padovan conn->hcon = hcon; 139273d80debSLuiz Augusto von Dentz conn->hchan = hchan; 13930a708f8fSGustavo F. Padovan 139473d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 13950a708f8fSGustavo F. Padovan 1396dcc042d5SAndrei Emeltchenko switch (hcon->type) { 1397dcc042d5SAndrei Emeltchenko case AMP_LINK: 1398dcc042d5SAndrei Emeltchenko conn->mtu = hcon->hdev->block_mtu; 1399dcc042d5SAndrei Emeltchenko break; 1400dcc042d5SAndrei Emeltchenko 1401dcc042d5SAndrei Emeltchenko case LE_LINK: 1402dcc042d5SAndrei Emeltchenko if (hcon->hdev->le_mtu) { 1403acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1404dcc042d5SAndrei Emeltchenko break; 1405dcc042d5SAndrei Emeltchenko } 1406dcc042d5SAndrei Emeltchenko /* fall through */ 1407dcc042d5SAndrei Emeltchenko 1408dcc042d5SAndrei Emeltchenko default: 14090a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1410dcc042d5SAndrei Emeltchenko break; 1411dcc042d5SAndrei Emeltchenko } 1412acd7d370SVille Tervo 14130a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 14140a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 14150a708f8fSGustavo F. Padovan 14160a708f8fSGustavo F. Padovan conn->feat_mask = 0; 14170a708f8fSGustavo F. Padovan 14180a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 14193df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1420baa7e1faSGustavo F. Padovan 1421baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 14220a708f8fSGustavo F. Padovan 14235d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 14246c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 14255d3de7dfSVinicius Costa Gomes else 1426030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 14270a708f8fSGustavo F. Padovan 14289f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 14290a708f8fSGustavo F. Padovan 14300a708f8fSGustavo F. Padovan return conn; 14310a708f8fSGustavo F. Padovan } 14320a708f8fSGustavo F. Padovan 14330a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 14340a708f8fSGustavo F. Padovan 1435c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 14360a708f8fSGustavo F. Padovan * Returns closest match. 14370a708f8fSGustavo F. Padovan */ 1438c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1439c2287681SIdo Yariv bdaddr_t *src, 1440c2287681SIdo Yariv bdaddr_t *dst) 14410a708f8fSGustavo F. Padovan { 144223691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 14430a708f8fSGustavo F. Padovan 144423691d75SGustavo F. Padovan read_lock(&chan_list_lock); 14450a708f8fSGustavo F. Padovan 144623691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 144723691d75SGustavo F. Padovan struct sock *sk = c->sk; 1448fe4128e0SGustavo F. Padovan 144989bc500eSGustavo F. Padovan if (state && c->state != state) 14500a708f8fSGustavo F. Padovan continue; 14510a708f8fSGustavo F. Padovan 145223691d75SGustavo F. Padovan if (c->psm == psm) { 1453c2287681SIdo Yariv int src_match, dst_match; 1454c2287681SIdo Yariv int src_any, dst_any; 1455c2287681SIdo Yariv 14560a708f8fSGustavo F. Padovan /* Exact match. */ 1457c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1458c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1459c2287681SIdo Yariv if (src_match && dst_match) { 1460a7567b20SJohannes Berg read_unlock(&chan_list_lock); 146123691d75SGustavo F. Padovan return c; 146223691d75SGustavo F. Padovan } 14630a708f8fSGustavo F. Padovan 14640a708f8fSGustavo F. Padovan /* Closest match */ 1465c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1466c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1467c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1468c2287681SIdo Yariv (src_any && dst_any)) 146923691d75SGustavo F. Padovan c1 = c; 14700a708f8fSGustavo F. Padovan } 14710a708f8fSGustavo F. Padovan } 14720a708f8fSGustavo F. Padovan 147323691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 14740a708f8fSGustavo F. Padovan 147523691d75SGustavo F. Padovan return c1; 14760a708f8fSGustavo F. Padovan } 14770a708f8fSGustavo F. Padovan 14788e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 14798e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 14800a708f8fSGustavo F. Padovan { 14815d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 14820a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 14830a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 14840a708f8fSGustavo F. Padovan struct hci_conn *hcon; 14850a708f8fSGustavo F. Padovan struct hci_dev *hdev; 14860a708f8fSGustavo F. Padovan __u8 auth_type; 14870a708f8fSGustavo F. Padovan int err; 14880a708f8fSGustavo F. Padovan 14896ed93dc6SAndrei Emeltchenko BT_DBG("%pMR -> %pMR (type %u) psm 0x%2.2x", src, dst, 1490ab19516aSSyam Sidhardhan dst_type, __le16_to_cpu(psm)); 14910a708f8fSGustavo F. Padovan 14920a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 14930a708f8fSGustavo F. Padovan if (!hdev) 14940a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 14950a708f8fSGustavo F. Padovan 149609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14970a708f8fSGustavo F. Padovan 14986be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 149903a00194SGustavo F. Padovan 150003a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 150103a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 150203a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 150303a00194SGustavo F. Padovan err = -EINVAL; 150403a00194SGustavo F. Padovan goto done; 150503a00194SGustavo F. Padovan } 150603a00194SGustavo F. Padovan 150703a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 150803a00194SGustavo F. Padovan err = -EINVAL; 150903a00194SGustavo F. Padovan goto done; 151003a00194SGustavo F. Padovan } 151103a00194SGustavo F. Padovan 151203a00194SGustavo F. Padovan switch (chan->mode) { 151303a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 151403a00194SGustavo F. Padovan break; 151503a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 151603a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 151703a00194SGustavo F. Padovan if (!disable_ertm) 151803a00194SGustavo F. Padovan break; 151903a00194SGustavo F. Padovan /* fall through */ 152003a00194SGustavo F. Padovan default: 152103a00194SGustavo F. Padovan err = -ENOTSUPP; 152203a00194SGustavo F. Padovan goto done; 152303a00194SGustavo F. Padovan } 152403a00194SGustavo F. Padovan 15250797e01dSGustavo Padovan switch (chan->state) { 152603a00194SGustavo F. Padovan case BT_CONNECT: 152703a00194SGustavo F. Padovan case BT_CONNECT2: 152803a00194SGustavo F. Padovan case BT_CONFIG: 152903a00194SGustavo F. Padovan /* Already connecting */ 153003a00194SGustavo F. Padovan err = 0; 153103a00194SGustavo F. Padovan goto done; 153203a00194SGustavo F. Padovan 153303a00194SGustavo F. Padovan case BT_CONNECTED: 153403a00194SGustavo F. Padovan /* Already connected */ 153503a00194SGustavo F. Padovan err = -EISCONN; 153603a00194SGustavo F. Padovan goto done; 153703a00194SGustavo F. Padovan 153803a00194SGustavo F. Padovan case BT_OPEN: 153903a00194SGustavo F. Padovan case BT_BOUND: 154003a00194SGustavo F. Padovan /* Can connect */ 154103a00194SGustavo F. Padovan break; 154203a00194SGustavo F. Padovan 154303a00194SGustavo F. Padovan default: 154403a00194SGustavo F. Padovan err = -EBADFD; 154503a00194SGustavo F. Padovan goto done; 154603a00194SGustavo F. Padovan } 154703a00194SGustavo F. Padovan 154803a00194SGustavo F. Padovan /* Set destination address and psm */ 15490797e01dSGustavo Padovan lock_sock(sk); 15509219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 15516be36555SAndrei Emeltchenko release_sock(sk); 15526be36555SAndrei Emeltchenko 155303a00194SGustavo F. Padovan chan->psm = psm; 155403a00194SGustavo F. Padovan chan->dcid = cid; 15550a708f8fSGustavo F. Padovan 15564343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 15570a708f8fSGustavo F. Padovan 1558fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 15598e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 15604343478fSGustavo F. Padovan chan->sec_level, auth_type); 1561acd7d370SVille Tervo else 15628e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 15634343478fSGustavo F. Padovan chan->sec_level, auth_type); 1564acd7d370SVille Tervo 156530e76272SVille Tervo if (IS_ERR(hcon)) { 156630e76272SVille Tervo err = PTR_ERR(hcon); 15670a708f8fSGustavo F. Padovan goto done; 156830e76272SVille Tervo } 15690a708f8fSGustavo F. Padovan 15700a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 15710a708f8fSGustavo F. Padovan if (!conn) { 15720a708f8fSGustavo F. Padovan hci_conn_put(hcon); 157330e76272SVille Tervo err = -ENOMEM; 15740a708f8fSGustavo F. Padovan goto done; 15750a708f8fSGustavo F. Padovan } 15760a708f8fSGustavo F. Padovan 15779f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 15789f0caeb1SVinicius Costa Gomes err = 0; 15799f0caeb1SVinicius Costa Gomes 15809f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 15819f0caeb1SVinicius Costa Gomes err = -EBUSY; 15829f0caeb1SVinicius Costa Gomes hci_conn_put(hcon); 15839f0caeb1SVinicius Costa Gomes } 15849f0caeb1SVinicius Costa Gomes 15859f0caeb1SVinicius Costa Gomes if (err) 15869f0caeb1SVinicius Costa Gomes goto done; 15879f0caeb1SVinicius Costa Gomes } 15889f0caeb1SVinicius Costa Gomes 15890a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 15900a708f8fSGustavo F. Padovan bacpy(src, conn->src); 15910a708f8fSGustavo F. Padovan 15926be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 159348454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 15946be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 159548454079SGustavo F. Padovan 15966be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1597c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 15980a708f8fSGustavo F. Padovan 15990a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1600715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1601c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1602d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 16036be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 16040a708f8fSGustavo F. Padovan } else 1605fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 16060a708f8fSGustavo F. Padovan } 16070a708f8fSGustavo F. Padovan 160830e76272SVille Tervo err = 0; 160930e76272SVille Tervo 16100a708f8fSGustavo F. Padovan done: 16116be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 161209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16130a708f8fSGustavo F. Padovan hci_dev_put(hdev); 16140a708f8fSGustavo F. Padovan return err; 16150a708f8fSGustavo F. Padovan } 16160a708f8fSGustavo F. Padovan 1617dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 16180a708f8fSGustavo F. Padovan { 16198c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 16200a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 16210a708f8fSGustavo F. Padovan int err = 0; 16220a708f8fSGustavo F. Padovan int timeo = HZ/5; 16230a708f8fSGustavo F. Padovan 16240a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 16250a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1626a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 16270a708f8fSGustavo F. Padovan if (!timeo) 16280a708f8fSGustavo F. Padovan timeo = HZ/5; 16290a708f8fSGustavo F. Padovan 16300a708f8fSGustavo F. Padovan if (signal_pending(current)) { 16310a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 16320a708f8fSGustavo F. Padovan break; 16330a708f8fSGustavo F. Padovan } 16340a708f8fSGustavo F. Padovan 16350a708f8fSGustavo F. Padovan release_sock(sk); 16360a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 16370a708f8fSGustavo F. Padovan lock_sock(sk); 1638a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 16390a708f8fSGustavo F. Padovan 16400a708f8fSGustavo F. Padovan err = sock_error(sk); 16410a708f8fSGustavo F. Padovan if (err) 16420a708f8fSGustavo F. Padovan break; 16430a708f8fSGustavo F. Padovan } 16440a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 16450a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 16460a708f8fSGustavo F. Padovan return err; 16470a708f8fSGustavo F. Padovan } 16480a708f8fSGustavo F. Padovan 1649721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 16500a708f8fSGustavo F. Padovan { 1651721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1652721c4181SGustavo F. Padovan monitor_timer.work); 16530a708f8fSGustavo F. Padovan 1654525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 16550a708f8fSGustavo F. Padovan 16566be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 16576be36555SAndrei Emeltchenko 165880909e04SMat Martineau if (!chan->conn) { 16596be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16608d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16610a708f8fSGustavo F. Padovan return; 16620a708f8fSGustavo F. Padovan } 16630a708f8fSGustavo F. Padovan 1664401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 16650a708f8fSGustavo F. Padovan 16666be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16678d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16680a708f8fSGustavo F. Padovan } 16690a708f8fSGustavo F. Padovan 1670721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 16710a708f8fSGustavo F. Padovan { 1672721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1673721c4181SGustavo F. Padovan retrans_timer.work); 16740a708f8fSGustavo F. Padovan 167549208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 16760a708f8fSGustavo F. Padovan 16776be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 16786be36555SAndrei Emeltchenko 167980909e04SMat Martineau if (!chan->conn) { 168080909e04SMat Martineau l2cap_chan_unlock(chan); 168180909e04SMat Martineau l2cap_chan_put(chan); 168280909e04SMat Martineau return; 168380909e04SMat Martineau } 16840a708f8fSGustavo F. Padovan 1685401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 16866be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16878d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16880a708f8fSGustavo F. Padovan } 16890a708f8fSGustavo F. Padovan 1690d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 16913733937dSMat Martineau struct sk_buff_head *skbs) 16920a708f8fSGustavo F. Padovan { 16930a708f8fSGustavo F. Padovan struct sk_buff *skb; 16943733937dSMat Martineau struct l2cap_ctrl *control; 16950a708f8fSGustavo F. Padovan 16963733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 16973733937dSMat Martineau 16983733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 16993733937dSMat Martineau 17003733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 17013733937dSMat Martineau 17023733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 17033733937dSMat Martineau 17043733937dSMat Martineau bt_cb(skb)->control.retries = 1; 17053733937dSMat Martineau control = &bt_cb(skb)->control; 17063733937dSMat Martineau 17073733937dSMat Martineau control->reqseq = 0; 17083733937dSMat Martineau control->txseq = chan->next_tx_seq; 17093733937dSMat Martineau 17103733937dSMat Martineau __pack_control(chan, control, skb); 17110a708f8fSGustavo F. Padovan 171247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 17133733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 17143733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 17150a708f8fSGustavo F. Padovan } 17160a708f8fSGustavo F. Padovan 17174343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 17180a708f8fSGustavo F. Padovan 1719b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 17203733937dSMat Martineau 1721836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 17223733937dSMat Martineau chan->frames_sent++; 17230a708f8fSGustavo F. Padovan } 17240a708f8fSGustavo F. Padovan } 17250a708f8fSGustavo F. Padovan 172667c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 17270a708f8fSGustavo F. Padovan { 17280a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 172918a48e76SMat Martineau struct l2cap_ctrl *control; 173018a48e76SMat Martineau int sent = 0; 173118a48e76SMat Martineau 173218a48e76SMat Martineau BT_DBG("chan %p", chan); 17330a708f8fSGustavo F. Padovan 173489bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 17350a708f8fSGustavo F. Padovan return -ENOTCONN; 17360a708f8fSGustavo F. Padovan 173794122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 173894122bbeSMat Martineau return 0; 173994122bbeSMat Martineau 174018a48e76SMat Martineau while (chan->tx_send_head && 174118a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 174218a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 17430a708f8fSGustavo F. Padovan 174418a48e76SMat Martineau skb = chan->tx_send_head; 17450a708f8fSGustavo F. Padovan 174618a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 174718a48e76SMat Martineau control = &bt_cb(skb)->control; 17480a708f8fSGustavo F. Padovan 1749e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 175018a48e76SMat Martineau control->final = 1; 1751e2ab4353SGustavo F. Padovan 175218a48e76SMat Martineau control->reqseq = chan->buffer_seq; 175318a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 175418a48e76SMat Martineau control->txseq = chan->next_tx_seq; 17550a708f8fSGustavo F. Padovan 175618a48e76SMat Martineau __pack_control(chan, control, skb); 17570a708f8fSGustavo F. Padovan 175847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 175918a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 176018a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 17610a708f8fSGustavo F. Padovan } 17620a708f8fSGustavo F. Padovan 176318a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 176418a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 176518a48e76SMat Martineau */ 176618a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 176718a48e76SMat Martineau 176818a48e76SMat Martineau if (!tx_skb) 176918a48e76SMat Martineau break; 17700a708f8fSGustavo F. Padovan 17711a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 17720a708f8fSGustavo F. Padovan 1773836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 17746a026610SGustavo F. Padovan chan->unacked_frames++; 17756a026610SGustavo F. Padovan chan->frames_sent++; 177618a48e76SMat Martineau sent++; 17770a708f8fSGustavo F. Padovan 177858d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 177958d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 17800a708f8fSGustavo F. Padovan else 178158d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 178218a48e76SMat Martineau 178318a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 1784b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 17850a708f8fSGustavo F. Padovan } 17860a708f8fSGustavo F. Padovan 1787b4400672SAndrei Emeltchenko BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent, 1788b4400672SAndrei Emeltchenko chan->unacked_frames, skb_queue_len(&chan->tx_q)); 178918a48e76SMat Martineau 179018a48e76SMat Martineau return sent; 17910a708f8fSGustavo F. Padovan } 17920a708f8fSGustavo F. Padovan 1793e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1794e1fbd4c1SMat Martineau { 1795e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1796e1fbd4c1SMat Martineau struct sk_buff *skb; 1797e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1798e1fbd4c1SMat Martineau u16 seq; 1799e1fbd4c1SMat Martineau 1800e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1801e1fbd4c1SMat Martineau 1802e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1803e1fbd4c1SMat Martineau return; 1804e1fbd4c1SMat Martineau 1805e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1806e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1807e1fbd4c1SMat Martineau 1808e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1809e1fbd4c1SMat Martineau if (!skb) { 1810e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1811e1fbd4c1SMat Martineau seq); 1812e1fbd4c1SMat Martineau continue; 1813e1fbd4c1SMat Martineau } 1814e1fbd4c1SMat Martineau 1815e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1816e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1817e1fbd4c1SMat Martineau 1818e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1819e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1820e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 1821e1fbd4c1SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 1822e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1823e1fbd4c1SMat Martineau break; 1824e1fbd4c1SMat Martineau } 1825e1fbd4c1SMat Martineau 1826e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1827e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1828e1fbd4c1SMat Martineau control.final = 1; 1829e1fbd4c1SMat Martineau else 1830e1fbd4c1SMat Martineau control.final = 0; 1831e1fbd4c1SMat Martineau 1832e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1833e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1834e1fbd4c1SMat Martineau * writeable copy 1835e1fbd4c1SMat Martineau */ 18368bcde1f2SGustavo Padovan tx_skb = skb_copy(skb, GFP_KERNEL); 1837e1fbd4c1SMat Martineau } else { 18388bcde1f2SGustavo Padovan tx_skb = skb_clone(skb, GFP_KERNEL); 1839e1fbd4c1SMat Martineau } 1840e1fbd4c1SMat Martineau 1841e1fbd4c1SMat Martineau if (!tx_skb) { 1842e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1843e1fbd4c1SMat Martineau break; 1844e1fbd4c1SMat Martineau } 1845e1fbd4c1SMat Martineau 1846e1fbd4c1SMat Martineau /* Update skb contents */ 1847e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1848e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1849e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1850e1fbd4c1SMat Martineau } else { 1851e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1852e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1853e1fbd4c1SMat Martineau } 1854e1fbd4c1SMat Martineau 1855e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1856e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1857e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1858e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1859e1fbd4c1SMat Martineau } 1860e1fbd4c1SMat Martineau 1861e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1862e1fbd4c1SMat Martineau 1863e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 1864e1fbd4c1SMat Martineau 1865e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 1866e1fbd4c1SMat Martineau } 1867e1fbd4c1SMat Martineau } 1868e1fbd4c1SMat Martineau 1869f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 1870f80842a8SMat Martineau struct l2cap_ctrl *control) 1871f80842a8SMat Martineau { 1872f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1873f80842a8SMat Martineau 1874f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 1875f80842a8SMat Martineau l2cap_ertm_resend(chan); 1876f80842a8SMat Martineau } 1877f80842a8SMat Martineau 1878d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 1879d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 1880d2a7ac5dSMat Martineau { 1881e1fbd4c1SMat Martineau struct sk_buff *skb; 1882e1fbd4c1SMat Martineau 1883e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1884e1fbd4c1SMat Martineau 1885e1fbd4c1SMat Martineau if (control->poll) 1886e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 1887e1fbd4c1SMat Martineau 1888e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1889e1fbd4c1SMat Martineau 1890e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1891e1fbd4c1SMat Martineau return; 1892e1fbd4c1SMat Martineau 1893e1fbd4c1SMat Martineau if (chan->unacked_frames) { 1894e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 1895e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 1896e1fbd4c1SMat Martineau skb == chan->tx_send_head) 1897e1fbd4c1SMat Martineau break; 1898e1fbd4c1SMat Martineau } 1899e1fbd4c1SMat Martineau 1900e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 1901e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 1902e1fbd4c1SMat Martineau break; 1903e1fbd4c1SMat Martineau 1904e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 1905e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 1906e1fbd4c1SMat Martineau } 1907e1fbd4c1SMat Martineau 1908e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 1909e1fbd4c1SMat Martineau } 1910d2a7ac5dSMat Martineau } 1911d2a7ac5dSMat Martineau 1912b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 1913b17e73bbSSzymon Janc { 19140a0aba42SMat Martineau struct l2cap_ctrl control; 19150a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 19160a0aba42SMat Martineau chan->last_acked_seq); 19170a0aba42SMat Martineau int threshold; 19180a0aba42SMat Martineau 19190a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 19200a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 19210a0aba42SMat Martineau 19220a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 19230a0aba42SMat Martineau control.sframe = 1; 19240a0aba42SMat Martineau 19250a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 19260a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 1927b17e73bbSSzymon Janc __clear_ack_timer(chan); 19280a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 19290a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 19300a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 19310a0aba42SMat Martineau } else { 19320a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 19330a0aba42SMat Martineau l2cap_ertm_send(chan); 19340a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 19350a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 19360a0aba42SMat Martineau frames_to_ack = 0; 19370a0aba42SMat Martineau } 19380a0aba42SMat Martineau 1939c20f8e35SMat Martineau /* Ack now if the window is 3/4ths full. 19400a0aba42SMat Martineau * Calculate without mul or div 19410a0aba42SMat Martineau */ 1942c20f8e35SMat Martineau threshold = chan->ack_win; 19430a0aba42SMat Martineau threshold += threshold << 1; 19440a0aba42SMat Martineau threshold >>= 2; 19450a0aba42SMat Martineau 1946b4400672SAndrei Emeltchenko BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack, 19470a0aba42SMat Martineau threshold); 19480a0aba42SMat Martineau 19490a0aba42SMat Martineau if (frames_to_ack >= threshold) { 19500a0aba42SMat Martineau __clear_ack_timer(chan); 19510a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 19520a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 19530a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 19540a0aba42SMat Martineau frames_to_ack = 0; 19550a0aba42SMat Martineau } 19560a0aba42SMat Martineau 19570a0aba42SMat Martineau if (frames_to_ack) 19580a0aba42SMat Martineau __set_ack_timer(chan); 19590a0aba42SMat Martineau } 1960b17e73bbSSzymon Janc } 1961b17e73bbSSzymon Janc 196204124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 196304124681SGustavo F. Padovan struct msghdr *msg, int len, 196404124681SGustavo F. Padovan int count, struct sk_buff *skb) 19650a708f8fSGustavo F. Padovan { 19660952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 19670a708f8fSGustavo F. Padovan struct sk_buff **frag; 196890338947SGustavo Padovan int sent = 0; 19690a708f8fSGustavo F. Padovan 19700a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 19710a708f8fSGustavo F. Padovan return -EFAULT; 19720a708f8fSGustavo F. Padovan 19730a708f8fSGustavo F. Padovan sent += count; 19740a708f8fSGustavo F. Padovan len -= count; 19750a708f8fSGustavo F. Padovan 19760a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 19770a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 19780a708f8fSGustavo F. Padovan while (len) { 1979fbe00700SGustavo Padovan struct sk_buff *tmp; 1980fbe00700SGustavo Padovan 19810a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 19820a708f8fSGustavo F. Padovan 1983fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 198490338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 1985fbe00700SGustavo Padovan if (IS_ERR(tmp)) 1986fbe00700SGustavo Padovan return PTR_ERR(tmp); 19872f7719ceSAndrei Emeltchenko 1988fbe00700SGustavo Padovan *frag = tmp; 1989fbe00700SGustavo Padovan 19900a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 19910a708f8fSGustavo F. Padovan return -EFAULT; 19920a708f8fSGustavo F. Padovan 19935e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 19945e59b791SLuiz Augusto von Dentz 19950a708f8fSGustavo F. Padovan sent += count; 19960a708f8fSGustavo F. Padovan len -= count; 19970a708f8fSGustavo F. Padovan 19982d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 19992d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 20002d0ed3d5SGustavo Padovan 20010a708f8fSGustavo F. Padovan frag = &(*frag)->next; 20020a708f8fSGustavo F. Padovan } 20030a708f8fSGustavo F. Padovan 20040a708f8fSGustavo F. Padovan return sent; 20050a708f8fSGustavo F. Padovan } 20060a708f8fSGustavo F. Padovan 20075e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 20085e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 20095e59b791SLuiz Augusto von Dentz u32 priority) 20100a708f8fSGustavo F. Padovan { 20118c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 20120a708f8fSGustavo F. Padovan struct sk_buff *skb; 201303a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 20140a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 20150a708f8fSGustavo F. Padovan 2016b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu priority %u", chan, len, priority); 20170a708f8fSGustavo F. Padovan 20180a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 20192f7719ceSAndrei Emeltchenko 20202f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 202190338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 202290338947SGustavo Padovan if (IS_ERR(skb)) 202390338947SGustavo Padovan return skb; 20240a708f8fSGustavo F. Padovan 20255e59b791SLuiz Augusto von Dentz skb->priority = priority; 20265e59b791SLuiz Augusto von Dentz 20270a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20280a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2029fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 2030daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 2031daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 20320a708f8fSGustavo F. Padovan 20330952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20340a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20350a708f8fSGustavo F. Padovan kfree_skb(skb); 20360a708f8fSGustavo F. Padovan return ERR_PTR(err); 20370a708f8fSGustavo F. Padovan } 20380a708f8fSGustavo F. Padovan return skb; 20390a708f8fSGustavo F. Padovan } 20400a708f8fSGustavo F. Padovan 20415e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 20425e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 20435e59b791SLuiz Augusto von Dentz u32 priority) 20440a708f8fSGustavo F. Padovan { 20458c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 20460a708f8fSGustavo F. Padovan struct sk_buff *skb; 2047f2ba7faeSGustavo Padovan int err, count; 20480a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 20490a708f8fSGustavo F. Padovan 2050b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 20510a708f8fSGustavo F. Padovan 2052f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 20532f7719ceSAndrei Emeltchenko 2054f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 205590338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 205690338947SGustavo Padovan if (IS_ERR(skb)) 205790338947SGustavo Padovan return skb; 20580a708f8fSGustavo F. Padovan 20595e59b791SLuiz Augusto von Dentz skb->priority = priority; 20605e59b791SLuiz Augusto von Dentz 20610a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20620a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2063fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 20646ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 20650a708f8fSGustavo F. Padovan 20660952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20670a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20680a708f8fSGustavo F. Padovan kfree_skb(skb); 20690a708f8fSGustavo F. Padovan return ERR_PTR(err); 20700a708f8fSGustavo F. Padovan } 20710a708f8fSGustavo F. Padovan return skb; 20720a708f8fSGustavo F. Padovan } 20730a708f8fSGustavo F. Padovan 2074ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2075ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 207694122bbeSMat Martineau u16 sdulen) 20770a708f8fSGustavo F. Padovan { 20788c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 20790a708f8fSGustavo F. Padovan struct sk_buff *skb; 2080e4ca6d98SAndrei Emeltchenko int err, count, hlen; 20810a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 20820a708f8fSGustavo F. Padovan 2083b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 20840a708f8fSGustavo F. Padovan 20850a708f8fSGustavo F. Padovan if (!conn) 20860a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 20870a708f8fSGustavo F. Padovan 2088ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2089e4ca6d98SAndrei Emeltchenko 20900a708f8fSGustavo F. Padovan if (sdulen) 209103a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 20920a708f8fSGustavo F. Padovan 209347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 209403a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 20950a708f8fSGustavo F. Padovan 20960a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 20972f7719ceSAndrei Emeltchenko 20982f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 209990338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 210090338947SGustavo Padovan if (IS_ERR(skb)) 210190338947SGustavo Padovan return skb; 21020a708f8fSGustavo F. Padovan 21030a708f8fSGustavo F. Padovan /* Create L2CAP header */ 21040a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2105fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 21060a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 210788843ab0SAndrei Emeltchenko 210818a48e76SMat Martineau /* Control header is populated later */ 210918a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 211018a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 211118a48e76SMat Martineau else 211218a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 211388843ab0SAndrei Emeltchenko 21140a708f8fSGustavo F. Padovan if (sdulen) 211503a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 21160a708f8fSGustavo F. Padovan 21170952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 21180a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 21190a708f8fSGustavo F. Padovan kfree_skb(skb); 21200a708f8fSGustavo F. Padovan return ERR_PTR(err); 21210a708f8fSGustavo F. Padovan } 21220a708f8fSGustavo F. Padovan 212318a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 21243ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 21250a708f8fSGustavo F. Padovan return skb; 21260a708f8fSGustavo F. Padovan } 21270a708f8fSGustavo F. Padovan 212894122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 212994122bbeSMat Martineau struct sk_buff_head *seg_queue, 213094122bbeSMat Martineau struct msghdr *msg, size_t len) 21310a708f8fSGustavo F. Padovan { 21320a708f8fSGustavo F. Padovan struct sk_buff *skb; 213394122bbeSMat Martineau u16 sdu_len; 213494122bbeSMat Martineau size_t pdu_len; 213594122bbeSMat Martineau u8 sar; 21360a708f8fSGustavo F. Padovan 2137b4400672SAndrei Emeltchenko BT_DBG("chan %p, msg %p, len %zu", chan, msg, len); 21380a708f8fSGustavo F. Padovan 213994122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 214094122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 214194122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 214294122bbeSMat Martineau */ 214394122bbeSMat Martineau 214494122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 214594122bbeSMat Martineau pdu_len = chan->conn->mtu; 214694122bbeSMat Martineau 214794122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 214894122bbeSMat Martineau 214994122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 215035d401dfSGustavo Padovan if (chan->fcs) 215135d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 215235d401dfSGustavo Padovan 2153ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 215494122bbeSMat Martineau 215594122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 215694122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 215794122bbeSMat Martineau 215894122bbeSMat Martineau if (len <= pdu_len) { 215994122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 216094122bbeSMat Martineau sdu_len = 0; 216194122bbeSMat Martineau pdu_len = len; 216294122bbeSMat Martineau } else { 216394122bbeSMat Martineau sar = L2CAP_SAR_START; 216494122bbeSMat Martineau sdu_len = len; 216594122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 216694122bbeSMat Martineau } 21670a708f8fSGustavo F. Padovan 21680a708f8fSGustavo F. Padovan while (len > 0) { 216994122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 21700a708f8fSGustavo F. Padovan 21710a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 217294122bbeSMat Martineau __skb_queue_purge(seg_queue); 21730a708f8fSGustavo F. Padovan return PTR_ERR(skb); 21740a708f8fSGustavo F. Padovan } 21750a708f8fSGustavo F. Padovan 217694122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 217794122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 21780a708f8fSGustavo F. Padovan 217994122bbeSMat Martineau len -= pdu_len; 218094122bbeSMat Martineau if (sdu_len) { 218194122bbeSMat Martineau sdu_len = 0; 218294122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 218394122bbeSMat Martineau } 218494122bbeSMat Martineau 218594122bbeSMat Martineau if (len <= pdu_len) { 218694122bbeSMat Martineau sar = L2CAP_SAR_END; 218794122bbeSMat Martineau pdu_len = len; 218894122bbeSMat Martineau } else { 218994122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 219094122bbeSMat Martineau } 219194122bbeSMat Martineau } 219294122bbeSMat Martineau 2193f0f62799SGustavo Padovan return 0; 21940a708f8fSGustavo F. Padovan } 21950a708f8fSGustavo F. Padovan 21965e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 21975e59b791SLuiz Augusto von Dentz u32 priority) 21989a91a04aSGustavo F. Padovan { 21999a91a04aSGustavo F. Padovan struct sk_buff *skb; 22009a91a04aSGustavo F. Padovan int err; 220194122bbeSMat Martineau struct sk_buff_head seg_queue; 22029a91a04aSGustavo F. Padovan 22039a91a04aSGustavo F. Padovan /* Connectionless channel */ 2204715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 22055e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 22069a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 22079a91a04aSGustavo F. Padovan return PTR_ERR(skb); 22089a91a04aSGustavo F. Padovan 22099a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 22109a91a04aSGustavo F. Padovan return len; 22119a91a04aSGustavo F. Padovan } 22129a91a04aSGustavo F. Padovan 22139a91a04aSGustavo F. Padovan switch (chan->mode) { 22149a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 22159a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 22169a91a04aSGustavo F. Padovan if (len > chan->omtu) 22179a91a04aSGustavo F. Padovan return -EMSGSIZE; 22189a91a04aSGustavo F. Padovan 22199a91a04aSGustavo F. Padovan /* Create a basic PDU */ 22205e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 22219a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 22229a91a04aSGustavo F. Padovan return PTR_ERR(skb); 22239a91a04aSGustavo F. Padovan 22249a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 22259a91a04aSGustavo F. Padovan err = len; 22269a91a04aSGustavo F. Padovan break; 22279a91a04aSGustavo F. Padovan 22289a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 22299a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 223094122bbeSMat Martineau /* Check outgoing MTU */ 223194122bbeSMat Martineau if (len > chan->omtu) { 223294122bbeSMat Martineau err = -EMSGSIZE; 22339a91a04aSGustavo F. Padovan break; 22349a91a04aSGustavo F. Padovan } 22359a91a04aSGustavo F. Padovan 223694122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 223794122bbeSMat Martineau 223894122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 223994122bbeSMat Martineau * since it's possible to block while waiting for memory 224094122bbeSMat Martineau * allocation. 224194122bbeSMat Martineau */ 224294122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 224394122bbeSMat Martineau 224494122bbeSMat Martineau /* The channel could have been closed while segmenting, 224594122bbeSMat Martineau * check that it is still connected. 224694122bbeSMat Martineau */ 224794122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 224894122bbeSMat Martineau __skb_queue_purge(&seg_queue); 224994122bbeSMat Martineau err = -ENOTCONN; 22509a91a04aSGustavo F. Padovan } 22519a91a04aSGustavo F. Padovan 225294122bbeSMat Martineau if (err) 225394122bbeSMat Martineau break; 225494122bbeSMat Martineau 22553733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2256d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 22573733937dSMat Martineau else 2258d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 225994122bbeSMat Martineau 22609a91a04aSGustavo F. Padovan err = len; 22619a91a04aSGustavo F. Padovan 226294122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 226394122bbeSMat Martineau * seg_queue and need to be purged. 226494122bbeSMat Martineau */ 226594122bbeSMat Martineau __skb_queue_purge(&seg_queue); 22669a91a04aSGustavo F. Padovan break; 22679a91a04aSGustavo F. Padovan 22689a91a04aSGustavo F. Padovan default: 22699a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 22709a91a04aSGustavo F. Padovan err = -EBADFD; 22719a91a04aSGustavo F. Padovan } 22729a91a04aSGustavo F. Padovan 22739a91a04aSGustavo F. Padovan return err; 22749a91a04aSGustavo F. Padovan } 22759a91a04aSGustavo F. Padovan 2276d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2277d2a7ac5dSMat Martineau { 2278bed68bdeSMat Martineau struct l2cap_ctrl control; 2279bed68bdeSMat Martineau u16 seq; 2280bed68bdeSMat Martineau 2281b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2282bed68bdeSMat Martineau 2283bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2284bed68bdeSMat Martineau control.sframe = 1; 2285bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2286bed68bdeSMat Martineau 2287bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2288bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2289bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2290bed68bdeSMat Martineau control.reqseq = seq; 2291bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2292bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2293bed68bdeSMat Martineau } 2294bed68bdeSMat Martineau } 2295bed68bdeSMat Martineau 2296bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2297d2a7ac5dSMat Martineau } 2298d2a7ac5dSMat Martineau 2299d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2300d2a7ac5dSMat Martineau { 2301bed68bdeSMat Martineau struct l2cap_ctrl control; 2302bed68bdeSMat Martineau 2303bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2304bed68bdeSMat Martineau 2305bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2306bed68bdeSMat Martineau return; 2307bed68bdeSMat Martineau 2308bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2309bed68bdeSMat Martineau control.sframe = 1; 2310bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2311bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2312bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2313d2a7ac5dSMat Martineau } 2314d2a7ac5dSMat Martineau 2315d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2316d2a7ac5dSMat Martineau { 2317bed68bdeSMat Martineau struct l2cap_ctrl control; 2318bed68bdeSMat Martineau u16 initial_head; 2319bed68bdeSMat Martineau u16 seq; 2320bed68bdeSMat Martineau 2321b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2322bed68bdeSMat Martineau 2323bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2324bed68bdeSMat Martineau control.sframe = 1; 2325bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2326bed68bdeSMat Martineau 2327bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2328bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2329bed68bdeSMat Martineau 2330bed68bdeSMat Martineau do { 2331bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2332bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2333bed68bdeSMat Martineau break; 2334bed68bdeSMat Martineau 2335bed68bdeSMat Martineau control.reqseq = seq; 2336bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2337bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2338bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2339d2a7ac5dSMat Martineau } 2340d2a7ac5dSMat Martineau 2341608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2342608bcc6dSMat Martineau { 2343608bcc6dSMat Martineau struct sk_buff *acked_skb; 2344608bcc6dSMat Martineau u16 ackseq; 2345608bcc6dSMat Martineau 2346b4400672SAndrei Emeltchenko BT_DBG("chan %p, reqseq %u", chan, reqseq); 2347608bcc6dSMat Martineau 2348608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2349608bcc6dSMat Martineau return; 2350608bcc6dSMat Martineau 2351b4400672SAndrei Emeltchenko BT_DBG("expected_ack_seq %u, unacked_frames %u", 2352608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2353608bcc6dSMat Martineau 2354608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2355608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2356608bcc6dSMat Martineau 2357608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2358608bcc6dSMat Martineau if (acked_skb) { 2359608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2360608bcc6dSMat Martineau kfree_skb(acked_skb); 2361608bcc6dSMat Martineau chan->unacked_frames--; 2362608bcc6dSMat Martineau } 2363608bcc6dSMat Martineau } 2364608bcc6dSMat Martineau 2365608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2366608bcc6dSMat Martineau 2367608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2368608bcc6dSMat Martineau __clear_retrans_timer(chan); 2369608bcc6dSMat Martineau 2370b4400672SAndrei Emeltchenko BT_DBG("unacked_frames %u", chan->unacked_frames); 2371608bcc6dSMat Martineau } 2372608bcc6dSMat Martineau 2373608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2374608bcc6dSMat Martineau { 2375608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2376608bcc6dSMat Martineau 2377608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2378608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2379608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2380608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2381608bcc6dSMat Martineau } 2382608bcc6dSMat Martineau 2383d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2384608bcc6dSMat Martineau struct l2cap_ctrl *control, 2385608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2386608bcc6dSMat Martineau { 2387608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2388608bcc6dSMat Martineau event); 2389608bcc6dSMat Martineau 2390608bcc6dSMat Martineau switch (event) { 2391608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2392608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2393608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2394608bcc6dSMat Martineau 2395608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2396608bcc6dSMat Martineau l2cap_ertm_send(chan); 2397608bcc6dSMat Martineau break; 2398608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2399608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2400608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2401608bcc6dSMat Martineau 2402608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2403608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2404608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2405608bcc6dSMat Martineau */ 2406608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2407608bcc6dSMat Martineau } 2408608bcc6dSMat Martineau 2409608bcc6dSMat Martineau l2cap_send_ack(chan); 2410608bcc6dSMat Martineau 2411608bcc6dSMat Martineau break; 2412608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2413608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2414608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2415608bcc6dSMat Martineau 2416608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2417608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2418608bcc6dSMat Martineau 2419608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2420608bcc6dSMat Martineau local_control.sframe = 1; 2421608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2422608bcc6dSMat Martineau local_control.poll = 1; 2423608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2424a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2425608bcc6dSMat Martineau 2426608bcc6dSMat Martineau chan->retry_count = 1; 2427608bcc6dSMat Martineau __set_monitor_timer(chan); 2428608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2429608bcc6dSMat Martineau } 2430608bcc6dSMat Martineau break; 2431608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2432608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2433608bcc6dSMat Martineau break; 2434608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2435608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2436608bcc6dSMat Martineau chan->retry_count = 1; 2437608bcc6dSMat Martineau __set_monitor_timer(chan); 2438608bcc6dSMat Martineau __clear_ack_timer(chan); 2439608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2440608bcc6dSMat Martineau break; 2441608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2442608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2443608bcc6dSMat Martineau chan->retry_count = 1; 2444608bcc6dSMat Martineau __set_monitor_timer(chan); 2445608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2446608bcc6dSMat Martineau break; 2447608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2448608bcc6dSMat Martineau /* Nothing to process */ 2449608bcc6dSMat Martineau break; 2450608bcc6dSMat Martineau default: 2451608bcc6dSMat Martineau break; 2452608bcc6dSMat Martineau } 2453608bcc6dSMat Martineau } 2454608bcc6dSMat Martineau 2455d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2456608bcc6dSMat Martineau struct l2cap_ctrl *control, 2457608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2458608bcc6dSMat Martineau { 2459608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2460608bcc6dSMat Martineau event); 2461608bcc6dSMat Martineau 2462608bcc6dSMat Martineau switch (event) { 2463608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2464608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2465608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2466608bcc6dSMat Martineau /* Queue data, but don't send. */ 2467608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2468608bcc6dSMat Martineau break; 2469608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2470608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2471608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2472608bcc6dSMat Martineau 2473608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2474608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2475608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2476608bcc6dSMat Martineau */ 2477608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2478608bcc6dSMat Martineau } 2479608bcc6dSMat Martineau 2480608bcc6dSMat Martineau l2cap_send_ack(chan); 2481608bcc6dSMat Martineau 2482608bcc6dSMat Martineau break; 2483608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2484608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2485608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2486608bcc6dSMat Martineau 2487608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2488608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2489608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2490608bcc6dSMat Martineau local_control.sframe = 1; 2491608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2492608bcc6dSMat Martineau local_control.poll = 1; 2493608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2494a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2495608bcc6dSMat Martineau 2496608bcc6dSMat Martineau chan->retry_count = 1; 2497608bcc6dSMat Martineau __set_monitor_timer(chan); 2498608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2499608bcc6dSMat Martineau } 2500608bcc6dSMat Martineau break; 2501608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2502608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2503608bcc6dSMat Martineau 2504608bcc6dSMat Martineau /* Fall through */ 2505608bcc6dSMat Martineau 2506608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2507608bcc6dSMat Martineau if (control && control->final) { 2508608bcc6dSMat Martineau __clear_monitor_timer(chan); 2509608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2510608bcc6dSMat Martineau __set_retrans_timer(chan); 2511608bcc6dSMat Martineau chan->retry_count = 0; 2512608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2513608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2514608bcc6dSMat Martineau } 2515608bcc6dSMat Martineau break; 2516608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2517608bcc6dSMat Martineau /* Ignore */ 2518608bcc6dSMat Martineau break; 2519608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2520608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2521608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2522608bcc6dSMat Martineau __set_monitor_timer(chan); 2523608bcc6dSMat Martineau chan->retry_count++; 2524608bcc6dSMat Martineau } else { 2525608bcc6dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED); 2526608bcc6dSMat Martineau } 2527608bcc6dSMat Martineau break; 2528608bcc6dSMat Martineau default: 2529608bcc6dSMat Martineau break; 2530608bcc6dSMat Martineau } 2531608bcc6dSMat Martineau } 2532608bcc6dSMat Martineau 2533d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2534608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2535608bcc6dSMat Martineau { 2536608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2537608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2538608bcc6dSMat Martineau 2539608bcc6dSMat Martineau switch (chan->tx_state) { 2540608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2541d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2542608bcc6dSMat Martineau break; 2543608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2544d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2545608bcc6dSMat Martineau break; 2546608bcc6dSMat Martineau default: 2547608bcc6dSMat Martineau /* Ignore event */ 2548608bcc6dSMat Martineau break; 2549608bcc6dSMat Martineau } 2550608bcc6dSMat Martineau } 2551608bcc6dSMat Martineau 25524b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 25534b51dae9SMat Martineau struct l2cap_ctrl *control) 25544b51dae9SMat Martineau { 25554b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2556401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 25574b51dae9SMat Martineau } 25584b51dae9SMat Martineau 2559f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2560f80842a8SMat Martineau struct l2cap_ctrl *control) 2561f80842a8SMat Martineau { 2562f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2563401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2564f80842a8SMat Martineau } 2565f80842a8SMat Martineau 25660a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 25670a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 25680a708f8fSGustavo F. Padovan { 25690a708f8fSGustavo F. Padovan struct sk_buff *nskb; 257048454079SGustavo F. Padovan struct l2cap_chan *chan; 25710a708f8fSGustavo F. Padovan 25720a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 25730a708f8fSGustavo F. Padovan 25743df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 25753d57dc68SGustavo F. Padovan 25763df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 257748454079SGustavo F. Padovan struct sock *sk = chan->sk; 2578715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 25790a708f8fSGustavo F. Padovan continue; 25800a708f8fSGustavo F. Padovan 25810a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 25820a708f8fSGustavo F. Padovan if (skb->sk == sk) 25830a708f8fSGustavo F. Padovan continue; 25848bcde1f2SGustavo Padovan nskb = skb_clone(skb, GFP_KERNEL); 25850a708f8fSGustavo F. Padovan if (!nskb) 25860a708f8fSGustavo F. Padovan continue; 25870a708f8fSGustavo F. Padovan 258880b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 25890a708f8fSGustavo F. Padovan kfree_skb(nskb); 25900a708f8fSGustavo F. Padovan } 25913d57dc68SGustavo F. Padovan 25923df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 25930a708f8fSGustavo F. Padovan } 25940a708f8fSGustavo F. Padovan 25950a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 2596b4400672SAndrei Emeltchenko static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code, 2597b4400672SAndrei Emeltchenko u8 ident, u16 dlen, void *data) 25980a708f8fSGustavo F. Padovan { 25990a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 26000a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 26010a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 26020a708f8fSGustavo F. Padovan int len, count; 26030a708f8fSGustavo F. Padovan 2604b4400672SAndrei Emeltchenko BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u", 26050a708f8fSGustavo F. Padovan conn, code, ident, dlen); 26060a708f8fSGustavo F. Padovan 26070a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 26080a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 26090a708f8fSGustavo F. Padovan 26108bcde1f2SGustavo Padovan skb = bt_skb_alloc(count, GFP_KERNEL); 26110a708f8fSGustavo F. Padovan if (!skb) 26120a708f8fSGustavo F. Padovan return NULL; 26130a708f8fSGustavo F. Padovan 26140a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 26150a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 26163300d9a9SClaudio Takahasi 26173300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2618ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 26193300d9a9SClaudio Takahasi else 2620ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 26210a708f8fSGustavo F. Padovan 26220a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 26230a708f8fSGustavo F. Padovan cmd->code = code; 26240a708f8fSGustavo F. Padovan cmd->ident = ident; 26250a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 26260a708f8fSGustavo F. Padovan 26270a708f8fSGustavo F. Padovan if (dlen) { 26280a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 26290a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 26300a708f8fSGustavo F. Padovan data += count; 26310a708f8fSGustavo F. Padovan } 26320a708f8fSGustavo F. Padovan 26330a708f8fSGustavo F. Padovan len -= skb->len; 26340a708f8fSGustavo F. Padovan 26350a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 26360a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 26370a708f8fSGustavo F. Padovan while (len) { 26380a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 26390a708f8fSGustavo F. Padovan 26408bcde1f2SGustavo Padovan *frag = bt_skb_alloc(count, GFP_KERNEL); 26410a708f8fSGustavo F. Padovan if (!*frag) 26420a708f8fSGustavo F. Padovan goto fail; 26430a708f8fSGustavo F. Padovan 26440a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 26450a708f8fSGustavo F. Padovan 26460a708f8fSGustavo F. Padovan len -= count; 26470a708f8fSGustavo F. Padovan data += count; 26480a708f8fSGustavo F. Padovan 26490a708f8fSGustavo F. Padovan frag = &(*frag)->next; 26500a708f8fSGustavo F. Padovan } 26510a708f8fSGustavo F. Padovan 26520a708f8fSGustavo F. Padovan return skb; 26530a708f8fSGustavo F. Padovan 26540a708f8fSGustavo F. Padovan fail: 26550a708f8fSGustavo F. Padovan kfree_skb(skb); 26560a708f8fSGustavo F. Padovan return NULL; 26570a708f8fSGustavo F. Padovan } 26580a708f8fSGustavo F. Padovan 26592d792818SGustavo Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, 26602d792818SGustavo Padovan unsigned long *val) 26610a708f8fSGustavo F. Padovan { 26620a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26630a708f8fSGustavo F. Padovan int len; 26640a708f8fSGustavo F. Padovan 26650a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 26660a708f8fSGustavo F. Padovan *ptr += len; 26670a708f8fSGustavo F. Padovan 26680a708f8fSGustavo F. Padovan *type = opt->type; 26690a708f8fSGustavo F. Padovan *olen = opt->len; 26700a708f8fSGustavo F. Padovan 26710a708f8fSGustavo F. Padovan switch (opt->len) { 26720a708f8fSGustavo F. Padovan case 1: 26730a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 26740a708f8fSGustavo F. Padovan break; 26750a708f8fSGustavo F. Padovan 26760a708f8fSGustavo F. Padovan case 2: 26770a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 26780a708f8fSGustavo F. Padovan break; 26790a708f8fSGustavo F. Padovan 26800a708f8fSGustavo F. Padovan case 4: 26810a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 26820a708f8fSGustavo F. Padovan break; 26830a708f8fSGustavo F. Padovan 26840a708f8fSGustavo F. Padovan default: 26850a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 26860a708f8fSGustavo F. Padovan break; 26870a708f8fSGustavo F. Padovan } 26880a708f8fSGustavo F. Padovan 2689b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val); 26900a708f8fSGustavo F. Padovan return len; 26910a708f8fSGustavo F. Padovan } 26920a708f8fSGustavo F. Padovan 26930a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 26940a708f8fSGustavo F. Padovan { 26950a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26960a708f8fSGustavo F. Padovan 2697b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val); 26980a708f8fSGustavo F. Padovan 26990a708f8fSGustavo F. Padovan opt->type = type; 27000a708f8fSGustavo F. Padovan opt->len = len; 27010a708f8fSGustavo F. Padovan 27020a708f8fSGustavo F. Padovan switch (len) { 27030a708f8fSGustavo F. Padovan case 1: 27040a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 27050a708f8fSGustavo F. Padovan break; 27060a708f8fSGustavo F. Padovan 27070a708f8fSGustavo F. Padovan case 2: 27080a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 27090a708f8fSGustavo F. Padovan break; 27100a708f8fSGustavo F. Padovan 27110a708f8fSGustavo F. Padovan case 4: 27120a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 27130a708f8fSGustavo F. Padovan break; 27140a708f8fSGustavo F. Padovan 27150a708f8fSGustavo F. Padovan default: 27160a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 27170a708f8fSGustavo F. Padovan break; 27180a708f8fSGustavo F. Padovan } 27190a708f8fSGustavo F. Padovan 27200a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 27210a708f8fSGustavo F. Padovan } 27220a708f8fSGustavo F. Padovan 2723f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2724f89cef09SAndrei Emeltchenko { 2725f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2726f89cef09SAndrei Emeltchenko 2727f89cef09SAndrei Emeltchenko switch (chan->mode) { 2728f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2729f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2730f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2731f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2732f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2733ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 27348936fa6dSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_EFS_DEFAULT_FLUSH_TO); 2735f89cef09SAndrei Emeltchenko break; 2736f89cef09SAndrei Emeltchenko 2737f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2738f89cef09SAndrei Emeltchenko efs.id = 1; 2739f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2740f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2741f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2742f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2743f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2744f89cef09SAndrei Emeltchenko break; 2745f89cef09SAndrei Emeltchenko 2746f89cef09SAndrei Emeltchenko default: 2747f89cef09SAndrei Emeltchenko return; 2748f89cef09SAndrei Emeltchenko } 2749f89cef09SAndrei Emeltchenko 2750f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2751f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2752f89cef09SAndrei Emeltchenko } 2753f89cef09SAndrei Emeltchenko 2754721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 27550a708f8fSGustavo F. Padovan { 2756721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2757721c4181SGustavo F. Padovan ack_timer.work); 27580362520bSMat Martineau u16 frames_to_ack; 27590a708f8fSGustavo F. Padovan 27602fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 27612fb9b3d4SGustavo F. Padovan 27626be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 27636be36555SAndrei Emeltchenko 27640362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 27650362520bSMat Martineau chan->last_acked_seq); 27660362520bSMat Martineau 27670362520bSMat Martineau if (frames_to_ack) 27680362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 27696be36555SAndrei Emeltchenko 27706be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 277109bfb2eeSSzymon Janc l2cap_chan_put(chan); 27720a708f8fSGustavo F. Padovan } 27730a708f8fSGustavo F. Padovan 2774466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 27750a708f8fSGustavo F. Padovan { 27763c588192SMat Martineau int err; 27773c588192SMat Martineau 2778105bdf9eSMat Martineau chan->next_tx_seq = 0; 2779105bdf9eSMat Martineau chan->expected_tx_seq = 0; 278042e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 27816a026610SGustavo F. Padovan chan->unacked_frames = 0; 278242e5c802SGustavo F. Padovan chan->buffer_seq = 0; 27836a026610SGustavo F. Padovan chan->frames_sent = 0; 2784105bdf9eSMat Martineau chan->last_acked_seq = 0; 2785105bdf9eSMat Martineau chan->sdu = NULL; 2786105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2787105bdf9eSMat Martineau chan->sdu_len = 0; 2788105bdf9eSMat Martineau 2789d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2790d34c34fbSMat Martineau 279108333283SMat Martineau chan->local_amp_id = 0; 279208333283SMat Martineau chan->move_id = 0; 279308333283SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 279408333283SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 279508333283SMat Martineau 2796105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2797105bdf9eSMat Martineau return 0; 2798105bdf9eSMat Martineau 2799105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2800105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 28010a708f8fSGustavo F. Padovan 2802721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2803721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2804721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 28050a708f8fSGustavo F. Padovan 2806f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 28070a708f8fSGustavo F. Padovan 28083c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 28093c588192SMat Martineau if (err < 0) 28103c588192SMat Martineau return err; 28113c588192SMat Martineau 28129dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 28139dc9affcSMat Martineau if (err < 0) 28149dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 28159dc9affcSMat Martineau 28169dc9affcSMat Martineau return err; 28170a708f8fSGustavo F. Padovan } 28180a708f8fSGustavo F. Padovan 28190a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 28200a708f8fSGustavo F. Padovan { 28210a708f8fSGustavo F. Padovan switch (mode) { 28220a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 28230a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 28240a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 28250a708f8fSGustavo F. Padovan return mode; 28260a708f8fSGustavo F. Padovan /* fall through */ 28270a708f8fSGustavo F. Padovan default: 28280a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 28290a708f8fSGustavo F. Padovan } 28300a708f8fSGustavo F. Padovan } 28310a708f8fSGustavo F. Padovan 28326327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 28336327eb98SAndrei Emeltchenko { 28346327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 28356327eb98SAndrei Emeltchenko } 28366327eb98SAndrei Emeltchenko 2837f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2838f89cef09SAndrei Emeltchenko { 2839f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2840f89cef09SAndrei Emeltchenko } 2841f89cef09SAndrei Emeltchenko 28426327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 28436327eb98SAndrei Emeltchenko { 28446327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 2845836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 28466327eb98SAndrei Emeltchenko /* use extended control field */ 28476327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 2848836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 2849836be934SAndrei Emeltchenko } else { 28506327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 28516327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 2852836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 2853836be934SAndrei Emeltchenko } 2854c20f8e35SMat Martineau chan->ack_win = chan->tx_win; 28556327eb98SAndrei Emeltchenko } 28566327eb98SAndrei Emeltchenko 2857710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 28580a708f8fSGustavo F. Padovan { 28590a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 28600c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 28610a708f8fSGustavo F. Padovan void *ptr = req->data; 2862c8f79162SAndrei Emeltchenko u16 size; 28630a708f8fSGustavo F. Padovan 286449208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 28650a708f8fSGustavo F. Padovan 286673ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 28670a708f8fSGustavo F. Padovan goto done; 28680a708f8fSGustavo F. Padovan 28690c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28700a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 28710a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2872c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 28730a708f8fSGustavo F. Padovan break; 28740a708f8fSGustavo F. Padovan 2875f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 2876f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 2877f89cef09SAndrei Emeltchenko 28780a708f8fSGustavo F. Padovan /* fall through */ 28790a708f8fSGustavo F. Padovan default: 28808c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 28810a708f8fSGustavo F. Padovan break; 28820a708f8fSGustavo F. Padovan } 28830a708f8fSGustavo F. Padovan 28840a708f8fSGustavo F. Padovan done: 28850c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 28860c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 28870a708f8fSGustavo F. Padovan 28880c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28890a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 28908c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 28918c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 28920a708f8fSGustavo F. Padovan break; 28930a708f8fSGustavo F. Padovan 28940a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 28950a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28960a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28970a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28980a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 28990a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 29000a708f8fSGustavo F. Padovan 29010a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 29020a708f8fSGustavo F. Padovan (unsigned long) &rfc); 29030a708f8fSGustavo F. Padovan break; 29040a708f8fSGustavo F. Padovan 29050a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 29060a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 290747d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 29080a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 29090a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2910c8f79162SAndrei Emeltchenko 2911c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 29122d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 2913c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2914c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 29150a708f8fSGustavo F. Padovan 29166327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 29176327eb98SAndrei Emeltchenko 29186327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 29196327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 29200a708f8fSGustavo F. Padovan 29210a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 29220a708f8fSGustavo F. Padovan (unsigned long) &rfc); 29230a708f8fSGustavo F. Padovan 2924f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2925f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2926f89cef09SAndrei Emeltchenko 29278c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 29280a708f8fSGustavo F. Padovan break; 29290a708f8fSGustavo F. Padovan 293047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2931c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 293247d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 293347d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 29340a708f8fSGustavo F. Padovan } 29356327eb98SAndrei Emeltchenko 29366327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 29376327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 29386327eb98SAndrei Emeltchenko chan->tx_win); 29390a708f8fSGustavo F. Padovan break; 29400a708f8fSGustavo F. Padovan 29410a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 2942273759e2SMat Martineau l2cap_txwin_setup(chan); 29430a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 29440a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 29450a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 29460a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 29470a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2948c8f79162SAndrei Emeltchenko 2949c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 29502d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 2951c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2952c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 29530a708f8fSGustavo F. Padovan 29540a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 29550a708f8fSGustavo F. Padovan (unsigned long) &rfc); 29560a708f8fSGustavo F. Padovan 2957f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2958f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2959f89cef09SAndrei Emeltchenko 29608c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 29610a708f8fSGustavo F. Padovan break; 29620a708f8fSGustavo F. Padovan 296347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2964c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 296547d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 296647d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 29670a708f8fSGustavo F. Padovan } 29680a708f8fSGustavo F. Padovan break; 29690a708f8fSGustavo F. Padovan } 29700a708f8fSGustavo F. Padovan 2971fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 297259e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 29730a708f8fSGustavo F. Padovan 29740a708f8fSGustavo F. Padovan return ptr - data; 29750a708f8fSGustavo F. Padovan } 29760a708f8fSGustavo F. Padovan 297773ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 29780a708f8fSGustavo F. Padovan { 29790a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 29800a708f8fSGustavo F. Padovan void *ptr = rsp->data; 298173ffa904SGustavo F. Padovan void *req = chan->conf_req; 298273ffa904SGustavo F. Padovan int len = chan->conf_len; 29830a708f8fSGustavo F. Padovan int type, hint, olen; 29840a708f8fSGustavo F. Padovan unsigned long val; 29850a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 298642dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 298742dceae2SAndrei Emeltchenko u8 remote_efs = 0; 29880a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 29890a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 2990c8f79162SAndrei Emeltchenko u16 size; 29910a708f8fSGustavo F. Padovan 299273ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 29930a708f8fSGustavo F. Padovan 29940a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 29950a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 29960a708f8fSGustavo F. Padovan 29970a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 29980a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 29990a708f8fSGustavo F. Padovan 30000a708f8fSGustavo F. Padovan switch (type) { 30010a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 30020a708f8fSGustavo F. Padovan mtu = val; 30030a708f8fSGustavo F. Padovan break; 30040a708f8fSGustavo F. Padovan 30050a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 30060c1bc5c6SGustavo F. Padovan chan->flush_to = val; 30070a708f8fSGustavo F. Padovan break; 30080a708f8fSGustavo F. Padovan 30090a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 30100a708f8fSGustavo F. Padovan break; 30110a708f8fSGustavo F. Padovan 30120a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 30130a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 30140a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 30150a708f8fSGustavo F. Padovan break; 30160a708f8fSGustavo F. Padovan 30170a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 30180a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 3019c1360a1cSGustavo F. Padovan set_bit(CONF_NO_FCS_RECV, &chan->conf_state); 302042dceae2SAndrei Emeltchenko break; 30210a708f8fSGustavo F. Padovan 302242dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 302342dceae2SAndrei Emeltchenko remote_efs = 1; 302442dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 302542dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 30260a708f8fSGustavo F. Padovan break; 30270a708f8fSGustavo F. Padovan 30286327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 30296327eb98SAndrei Emeltchenko if (!enable_hs) 30306327eb98SAndrei Emeltchenko return -ECONNREFUSED; 30316327eb98SAndrei Emeltchenko 30326327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 30336327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 3034836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 30356327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 30360a708f8fSGustavo F. Padovan break; 30370a708f8fSGustavo F. Padovan 30380a708f8fSGustavo F. Padovan default: 30390a708f8fSGustavo F. Padovan if (hint) 30400a708f8fSGustavo F. Padovan break; 30410a708f8fSGustavo F. Padovan 30420a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 30430a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 30440a708f8fSGustavo F. Padovan break; 30450a708f8fSGustavo F. Padovan } 30460a708f8fSGustavo F. Padovan } 30470a708f8fSGustavo F. Padovan 304873ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 30490a708f8fSGustavo F. Padovan goto done; 30500a708f8fSGustavo F. Padovan 30510c1bc5c6SGustavo F. Padovan switch (chan->mode) { 30520a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 30530a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3054c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 30550c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 30568c1d787bSGustavo F. Padovan chan->conn->feat_mask); 30570a708f8fSGustavo F. Padovan break; 30580a708f8fSGustavo F. Padovan } 30590a708f8fSGustavo F. Padovan 306042dceae2SAndrei Emeltchenko if (remote_efs) { 306142dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 306242dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 306342dceae2SAndrei Emeltchenko else 306442dceae2SAndrei Emeltchenko return -ECONNREFUSED; 306542dceae2SAndrei Emeltchenko } 306642dceae2SAndrei Emeltchenko 30670c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 30680a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30690a708f8fSGustavo F. Padovan 30700a708f8fSGustavo F. Padovan break; 30710a708f8fSGustavo F. Padovan } 30720a708f8fSGustavo F. Padovan 30730a708f8fSGustavo F. Padovan done: 30740c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 30750a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30760c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 30770a708f8fSGustavo F. Padovan 307873ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 30790a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30800a708f8fSGustavo F. Padovan 30812d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 30822d792818SGustavo Padovan (unsigned long) &rfc); 30830a708f8fSGustavo F. Padovan } 30840a708f8fSGustavo F. Padovan 30850a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 30860a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 30870a708f8fSGustavo F. Padovan * which ones we don't like. */ 30880a708f8fSGustavo F. Padovan 30890a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 30900a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30910a708f8fSGustavo F. Padovan else { 30920c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3093c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 30940a708f8fSGustavo F. Padovan } 30950c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 30960a708f8fSGustavo F. Padovan 309742dceae2SAndrei Emeltchenko if (remote_efs) { 309842dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 309942dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 310042dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 310142dceae2SAndrei Emeltchenko 310242dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 310342dceae2SAndrei Emeltchenko 310442dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 310542dceae2SAndrei Emeltchenko return -ECONNREFUSED; 310642dceae2SAndrei Emeltchenko 310742dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 310842dceae2SAndrei Emeltchenko sizeof(efs), 310942dceae2SAndrei Emeltchenko (unsigned long) &efs); 31100e8b207eSAndrei Emeltchenko } else { 31113e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 31120e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 31130e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 311442dceae2SAndrei Emeltchenko } 311542dceae2SAndrei Emeltchenko } 311642dceae2SAndrei Emeltchenko 31170a708f8fSGustavo F. Padovan switch (rfc.mode) { 31180a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 311947d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3120c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 31210a708f8fSGustavo F. Padovan break; 31220a708f8fSGustavo F. Padovan 31230a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 31246327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 31252c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 31266327eb98SAndrei Emeltchenko else 31276327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 31286327eb98SAndrei Emeltchenko 31292c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 31300a708f8fSGustavo F. Padovan 3131c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 31322d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 31332d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3134c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3135c8f79162SAndrei Emeltchenko chan->remote_mps = size; 31360a708f8fSGustavo F. Padovan 31370a708f8fSGustavo F. Padovan rfc.retrans_timeout = 31384fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 31390a708f8fSGustavo F. Padovan rfc.monitor_timeout = 31404fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 31410a708f8fSGustavo F. Padovan 3142c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 31430a708f8fSGustavo F. Padovan 31440a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31450a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31460a708f8fSGustavo F. Padovan 314742dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 314842dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 314942dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 315042dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 315142dceae2SAndrei Emeltchenko chan->remote_flush_to = 315242dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 315342dceae2SAndrei Emeltchenko chan->remote_acc_lat = 315442dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 315542dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 315642dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 315742dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 31582d792818SGustavo Padovan sizeof(efs), 31592d792818SGustavo Padovan (unsigned long) &efs); 316042dceae2SAndrei Emeltchenko } 31610a708f8fSGustavo F. Padovan break; 31620a708f8fSGustavo F. Padovan 31630a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3164c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 31652d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 31662d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3167c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3168c8f79162SAndrei Emeltchenko chan->remote_mps = size; 31690a708f8fSGustavo F. Padovan 3170c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 31710a708f8fSGustavo F. Padovan 31722d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 31732d792818SGustavo Padovan (unsigned long) &rfc); 31740a708f8fSGustavo F. Padovan 31750a708f8fSGustavo F. Padovan break; 31760a708f8fSGustavo F. Padovan 31770a708f8fSGustavo F. Padovan default: 31780a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 31790a708f8fSGustavo F. Padovan 31800a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 31810c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 31820a708f8fSGustavo F. Padovan } 31830a708f8fSGustavo F. Padovan 31840a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3185c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 31860a708f8fSGustavo F. Padovan } 3187fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 31880a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 318959e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 31900a708f8fSGustavo F. Padovan 31910a708f8fSGustavo F. Padovan return ptr - data; 31920a708f8fSGustavo F. Padovan } 31930a708f8fSGustavo F. Padovan 31942d792818SGustavo Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, 31952d792818SGustavo Padovan void *data, u16 *result) 31960a708f8fSGustavo F. Padovan { 31970a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 31980a708f8fSGustavo F. Padovan void *ptr = req->data; 31990a708f8fSGustavo F. Padovan int type, olen; 32000a708f8fSGustavo F. Padovan unsigned long val; 320136e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 320266af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 32030a708f8fSGustavo F. Padovan 3204fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 32050a708f8fSGustavo F. Padovan 32060a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32070a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 32080a708f8fSGustavo F. Padovan 32090a708f8fSGustavo F. Padovan switch (type) { 32100a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 32110a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 32120a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 32130c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 32140a708f8fSGustavo F. Padovan } else 32150c1bc5c6SGustavo F. Padovan chan->imtu = val; 32160c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 32170a708f8fSGustavo F. Padovan break; 32180a708f8fSGustavo F. Padovan 32190a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 32200c1bc5c6SGustavo F. Padovan chan->flush_to = val; 32210a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 32220c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 32230a708f8fSGustavo F. Padovan break; 32240a708f8fSGustavo F. Padovan 32250a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 32260a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 32270a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 32280a708f8fSGustavo F. Padovan 3229c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 32300c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 32310a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32320a708f8fSGustavo F. Padovan 323347d1ec61SGustavo F. Padovan chan->fcs = 0; 32340a708f8fSGustavo F. Padovan 32350a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 32360a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 32370a708f8fSGustavo F. Padovan break; 32386327eb98SAndrei Emeltchenko 32396327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 3240c20f8e35SMat Martineau chan->ack_win = min_t(u16, val, chan->ack_win); 32413e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 32423e6b3b95SGustavo F. Padovan chan->tx_win); 32436327eb98SAndrei Emeltchenko break; 324466af7aafSAndrei Emeltchenko 324566af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 324666af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 324766af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 324866af7aafSAndrei Emeltchenko 324966af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 325066af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 325166af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 325266af7aafSAndrei Emeltchenko return -ECONNREFUSED; 325366af7aafSAndrei Emeltchenko 32542d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, sizeof(efs), 32552d792818SGustavo Padovan (unsigned long) &efs); 325666af7aafSAndrei Emeltchenko break; 32570a708f8fSGustavo F. Padovan } 32580a708f8fSGustavo F. Padovan } 32590a708f8fSGustavo F. Padovan 32600c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 32610a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32620a708f8fSGustavo F. Padovan 32630c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 32640a708f8fSGustavo F. Padovan 32650e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 32660a708f8fSGustavo F. Padovan switch (rfc.mode) { 32670a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 326847d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 326947d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 327047d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3271c20f8e35SMat Martineau if (!test_bit(FLAG_EXT_CTRL, &chan->flags)) 3272c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3273c20f8e35SMat Martineau rfc.txwin_size); 327466af7aafSAndrei Emeltchenko 327566af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 327666af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 327766af7aafSAndrei Emeltchenko chan->local_sdu_itime = 327866af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 327966af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 328066af7aafSAndrei Emeltchenko chan->local_flush_to = 328166af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 328266af7aafSAndrei Emeltchenko } 32830a708f8fSGustavo F. Padovan break; 328466af7aafSAndrei Emeltchenko 32850a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 328647d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 32870a708f8fSGustavo F. Padovan } 32880a708f8fSGustavo F. Padovan } 32890a708f8fSGustavo F. Padovan 3290fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 329159e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 32920a708f8fSGustavo F. Padovan 32930a708f8fSGustavo F. Padovan return ptr - data; 32940a708f8fSGustavo F. Padovan } 32950a708f8fSGustavo F. Padovan 32962d792818SGustavo Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, 32972d792818SGustavo Padovan u16 result, u16 flags) 32980a708f8fSGustavo F. Padovan { 32990a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 33000a708f8fSGustavo F. Padovan void *ptr = rsp->data; 33010a708f8fSGustavo F. Padovan 3302fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 33030a708f8fSGustavo F. Padovan 3304fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 33050a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 33060a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 33070a708f8fSGustavo F. Padovan 33080a708f8fSGustavo F. Padovan return ptr - data; 33090a708f8fSGustavo F. Padovan } 33100a708f8fSGustavo F. Padovan 33118c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3312710f9b0aSGustavo F. Padovan { 3313710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 33148c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3315710f9b0aSGustavo F. Padovan u8 buf[128]; 3316710f9b0aSGustavo F. Padovan 3317fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3318fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3319ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3320ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 33212d792818SGustavo Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp); 3322710f9b0aSGustavo F. Padovan 3323c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3324710f9b0aSGustavo F. Padovan return; 3325710f9b0aSGustavo F. Padovan 3326710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3327710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3328710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3329710f9b0aSGustavo F. Padovan } 3330710f9b0aSGustavo F. Padovan 333147d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 33320a708f8fSGustavo F. Padovan { 33330a708f8fSGustavo F. Padovan int type, olen; 33340a708f8fSGustavo F. Padovan unsigned long val; 3335c20f8e35SMat Martineau /* Use sane default values in case a misbehaving remote device 3336c20f8e35SMat Martineau * did not send an RFC or extended window size option. 3337c20f8e35SMat Martineau */ 3338c20f8e35SMat Martineau u16 txwin_ext = chan->ack_win; 3339c20f8e35SMat Martineau struct l2cap_conf_rfc rfc = { 3340c20f8e35SMat Martineau .mode = chan->mode, 3341c20f8e35SMat Martineau .retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO), 3342c20f8e35SMat Martineau .monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO), 3343c20f8e35SMat Martineau .max_pdu_size = cpu_to_le16(chan->imtu), 3344c20f8e35SMat Martineau .txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW), 3345c20f8e35SMat Martineau }; 33460a708f8fSGustavo F. Padovan 334747d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 33480a708f8fSGustavo F. Padovan 33490c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 33500a708f8fSGustavo F. Padovan return; 33510a708f8fSGustavo F. Padovan 33520a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 33530a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 33540a708f8fSGustavo F. Padovan 3355c20f8e35SMat Martineau switch (type) { 3356c20f8e35SMat Martineau case L2CAP_CONF_RFC: 3357c20f8e35SMat Martineau if (olen == sizeof(rfc)) 33580a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 3359c20f8e35SMat Martineau break; 3360c20f8e35SMat Martineau case L2CAP_CONF_EWS: 3361c20f8e35SMat Martineau txwin_ext = val; 3362c20f8e35SMat Martineau break; 3363c20f8e35SMat Martineau } 33640a708f8fSGustavo F. Padovan } 33650a708f8fSGustavo F. Padovan 33660a708f8fSGustavo F. Padovan switch (rfc.mode) { 33670a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 336847d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 336947d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 337047d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3371c20f8e35SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 3372c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, txwin_ext); 3373c20f8e35SMat Martineau else 3374c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3375c20f8e35SMat Martineau rfc.txwin_size); 33760a708f8fSGustavo F. Padovan break; 33770a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 337847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 33790a708f8fSGustavo F. Padovan } 33800a708f8fSGustavo F. Padovan } 33810a708f8fSGustavo F. Padovan 33822d792818SGustavo Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, 33832d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 33840a708f8fSGustavo F. Padovan { 3385e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 33860a708f8fSGustavo F. Padovan 3387e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 33880a708f8fSGustavo F. Padovan return 0; 33890a708f8fSGustavo F. Padovan 33900a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 33910a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 339217cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 33930a708f8fSGustavo F. Padovan 33940a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 33950a708f8fSGustavo F. Padovan conn->info_ident = 0; 33960a708f8fSGustavo F. Padovan 33970a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 33980a708f8fSGustavo F. Padovan } 33990a708f8fSGustavo F. Padovan 34000a708f8fSGustavo F. Padovan return 0; 34010a708f8fSGustavo F. Padovan } 34020a708f8fSGustavo F. Padovan 34031700915fSMat Martineau static struct l2cap_chan *l2cap_connect(struct l2cap_conn *conn, 34041700915fSMat Martineau struct l2cap_cmd_hdr *cmd, 34054c89b6aaSMat Martineau u8 *data, u8 rsp_code, u8 amp_id) 34060a708f8fSGustavo F. Padovan { 34070a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 34080a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 340923691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 34100a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 34110a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 34120a708f8fSGustavo F. Padovan 34130a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 34140a708f8fSGustavo F. Padovan __le16 psm = req->psm; 34150a708f8fSGustavo F. Padovan 3416097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 34170a708f8fSGustavo F. Padovan 34180a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3419c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 342023691d75SGustavo F. Padovan if (!pchan) { 34210a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 34220a708f8fSGustavo F. Padovan goto sendresp; 34230a708f8fSGustavo F. Padovan } 34240a708f8fSGustavo F. Padovan 342523691d75SGustavo F. Padovan parent = pchan->sk; 342623691d75SGustavo F. Padovan 34273df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3428aa2ac881SGustavo F. Padovan lock_sock(parent); 34290a708f8fSGustavo F. Padovan 34300a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 34312983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 34320a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 34339f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 34340a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 34350a708f8fSGustavo F. Padovan goto response; 34360a708f8fSGustavo F. Padovan } 34370a708f8fSGustavo F. Padovan 34380a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 34390a708f8fSGustavo F. Padovan 34402dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 34412dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 34422dfa1003SGustavo Padovan goto response; 34432dfa1003SGustavo Padovan 344480b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 344580808e43SGustavo F. Padovan if (!chan) 34460a708f8fSGustavo F. Padovan goto response; 34470a708f8fSGustavo F. Padovan 344880808e43SGustavo F. Padovan sk = chan->sk; 344980808e43SGustavo F. Padovan 34500a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 34510a708f8fSGustavo F. Padovan 34520a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 34530a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3454fe4128e0SGustavo F. Padovan chan->psm = psm; 3455fe4128e0SGustavo F. Padovan chan->dcid = scid; 34561700915fSMat Martineau chan->local_amp_id = amp_id; 34570a708f8fSGustavo F. Padovan 34586be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 345948454079SGustavo F. Padovan 3460fe4128e0SGustavo F. Padovan dcid = chan->scid; 34610a708f8fSGustavo F. Padovan 3462c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 34630a708f8fSGustavo F. Padovan 3464fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 34650a708f8fSGustavo F. Padovan 34660a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3467d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3468c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 34690e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34700a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34710a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 34722dc4e510SGustavo Padovan chan->ops->defer(chan); 34730a708f8fSGustavo F. Padovan } else { 34741700915fSMat Martineau /* Force pending result for AMP controllers. 34751700915fSMat Martineau * The connection will succeed after the 34761700915fSMat Martineau * physical link is up. 34771700915fSMat Martineau */ 34781700915fSMat Martineau if (amp_id) { 34791700915fSMat Martineau __l2cap_state_change(chan, BT_CONNECT2); 34801700915fSMat Martineau result = L2CAP_CR_PEND; 34811700915fSMat Martineau } else { 34820e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 34830a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 34841700915fSMat Martineau } 34850a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 34860a708f8fSGustavo F. Padovan } 34870a708f8fSGustavo F. Padovan } else { 34880e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34890a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34900a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 34910a708f8fSGustavo F. Padovan } 34920a708f8fSGustavo F. Padovan } else { 34930e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34940a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34950a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 34960a708f8fSGustavo F. Padovan } 34970a708f8fSGustavo F. Padovan 34980a708f8fSGustavo F. Padovan response: 3499aa2ac881SGustavo F. Padovan release_sock(parent); 35003df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 35010a708f8fSGustavo F. Padovan 35020a708f8fSGustavo F. Padovan sendresp: 35030a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 35040a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 35050a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 35060a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 35074c89b6aaSMat Martineau l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp); 35080a708f8fSGustavo F. Padovan 35090a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 35100a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3511ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 35120a708f8fSGustavo F. Padovan 35130a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 35140a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 35150a708f8fSGustavo F. Padovan 3516ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 35170a708f8fSGustavo F. Padovan 35182d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 35192d792818SGustavo Padovan sizeof(info), &info); 35200a708f8fSGustavo F. Padovan } 35210a708f8fSGustavo F. Padovan 3522c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 35230a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 35240a708f8fSGustavo F. Padovan u8 buf[128]; 3525c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 35260a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 352773ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 352873ffa904SGustavo F. Padovan chan->num_conf_req++; 35290a708f8fSGustavo F. Padovan } 35301700915fSMat Martineau 35311700915fSMat Martineau return chan; 35324c89b6aaSMat Martineau } 35330a708f8fSGustavo F. Padovan 35344c89b6aaSMat Martineau static int l2cap_connect_req(struct l2cap_conn *conn, 35354c89b6aaSMat Martineau struct l2cap_cmd_hdr *cmd, u8 *data) 35364c89b6aaSMat Martineau { 3537300229f9SGustavo Padovan l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP, 0); 35380a708f8fSGustavo F. Padovan return 0; 35390a708f8fSGustavo F. Padovan } 35400a708f8fSGustavo F. Padovan 35415909cf30SMat Martineau static int l2cap_connect_create_rsp(struct l2cap_conn *conn, 35422d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 35430a708f8fSGustavo F. Padovan { 35440a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 35450a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 354648454079SGustavo F. Padovan struct l2cap_chan *chan; 35470a708f8fSGustavo F. Padovan u8 req[128]; 35483df91ea2SAndrei Emeltchenko int err; 35490a708f8fSGustavo F. Padovan 35500a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 35510a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 35520a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 35530a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 35540a708f8fSGustavo F. Padovan 35551b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 35561b009c98SAndrei Emeltchenko dcid, scid, result, status); 35570a708f8fSGustavo F. Padovan 35583df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 35593df91ea2SAndrei Emeltchenko 35600a708f8fSGustavo F. Padovan if (scid) { 35613df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 35623df91ea2SAndrei Emeltchenko if (!chan) { 35633df91ea2SAndrei Emeltchenko err = -EFAULT; 35643df91ea2SAndrei Emeltchenko goto unlock; 35653df91ea2SAndrei Emeltchenko } 35660a708f8fSGustavo F. Padovan } else { 35673df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 35683df91ea2SAndrei Emeltchenko if (!chan) { 35693df91ea2SAndrei Emeltchenko err = -EFAULT; 35703df91ea2SAndrei Emeltchenko goto unlock; 35713df91ea2SAndrei Emeltchenko } 35720a708f8fSGustavo F. Padovan } 35730a708f8fSGustavo F. Padovan 35743df91ea2SAndrei Emeltchenko err = 0; 35753df91ea2SAndrei Emeltchenko 35766be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 357748454079SGustavo F. Padovan 35780a708f8fSGustavo F. Padovan switch (result) { 35790a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 358089bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3581fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3582fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3583c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 35840a708f8fSGustavo F. Padovan 3585c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 35860a708f8fSGustavo F. Padovan break; 35870a708f8fSGustavo F. Padovan 35880a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 358973ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 359073ffa904SGustavo F. Padovan chan->num_conf_req++; 35910a708f8fSGustavo F. Padovan break; 35920a708f8fSGustavo F. Padovan 35930a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3594c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 35950a708f8fSGustavo F. Padovan break; 35960a708f8fSGustavo F. Padovan 35970a708f8fSGustavo F. Padovan default: 359848454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 35990a708f8fSGustavo F. Padovan break; 36000a708f8fSGustavo F. Padovan } 36010a708f8fSGustavo F. Padovan 36026be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 36033df91ea2SAndrei Emeltchenko 36043df91ea2SAndrei Emeltchenko unlock: 36053df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 36063df91ea2SAndrei Emeltchenko 36073df91ea2SAndrei Emeltchenko return err; 36080a708f8fSGustavo F. Padovan } 36090a708f8fSGustavo F. Padovan 361047d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 36110a708f8fSGustavo F. Padovan { 36120a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 36130a708f8fSGustavo F. Padovan * sides request it. 36140a708f8fSGustavo F. Padovan */ 36150c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 361647d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3617c1360a1cSGustavo F. Padovan else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) 361847d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 36190a708f8fSGustavo F. Padovan } 36200a708f8fSGustavo F. Padovan 362129d8a590SAndrei Emeltchenko static void l2cap_send_efs_conf_rsp(struct l2cap_chan *chan, void *data, 362229d8a590SAndrei Emeltchenko u8 ident, u16 flags) 362329d8a590SAndrei Emeltchenko { 362429d8a590SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 362529d8a590SAndrei Emeltchenko 362629d8a590SAndrei Emeltchenko BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident, 362729d8a590SAndrei Emeltchenko flags); 362829d8a590SAndrei Emeltchenko 362929d8a590SAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 363029d8a590SAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 363129d8a590SAndrei Emeltchenko 363229d8a590SAndrei Emeltchenko l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP, 363329d8a590SAndrei Emeltchenko l2cap_build_conf_rsp(chan, data, 363429d8a590SAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), data); 363529d8a590SAndrei Emeltchenko } 363629d8a590SAndrei Emeltchenko 36372d792818SGustavo Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, 36382d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 36392d792818SGustavo Padovan u8 *data) 36400a708f8fSGustavo F. Padovan { 36410a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 36420a708f8fSGustavo F. Padovan u16 dcid, flags; 36430a708f8fSGustavo F. Padovan u8 rsp[64]; 364448454079SGustavo F. Padovan struct l2cap_chan *chan; 36453c588192SMat Martineau int len, err = 0; 36460a708f8fSGustavo F. Padovan 36470a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 36480a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 36490a708f8fSGustavo F. Padovan 36500a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 36510a708f8fSGustavo F. Padovan 3652baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 365348454079SGustavo F. Padovan if (!chan) 36540a708f8fSGustavo F. Padovan return -ENOENT; 36550a708f8fSGustavo F. Padovan 3656033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3657e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 36580a708f8fSGustavo F. Padovan 3659ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3660e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3661e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3662e2fd318eSIlia Kolomisnky 36630a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 36640a708f8fSGustavo F. Padovan sizeof(rej), &rej); 36650a708f8fSGustavo F. Padovan goto unlock; 36660a708f8fSGustavo F. Padovan } 36670a708f8fSGustavo F. Padovan 36680a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 36690a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 36707ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 36710a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3672fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 36730a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 36740a708f8fSGustavo F. Padovan goto unlock; 36750a708f8fSGustavo F. Padovan } 36760a708f8fSGustavo F. Padovan 36770a708f8fSGustavo F. Padovan /* Store config. */ 367873ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 367973ffa904SGustavo F. Padovan chan->conf_len += len; 36800a708f8fSGustavo F. Padovan 368159e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 36820a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 36830a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3684fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 36855325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 36860a708f8fSGustavo F. Padovan goto unlock; 36870a708f8fSGustavo F. Padovan } 36880a708f8fSGustavo F. Padovan 36890a708f8fSGustavo F. Padovan /* Complete config. */ 369073ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 36910a708f8fSGustavo F. Padovan if (len < 0) { 3692e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 36930a708f8fSGustavo F. Padovan goto unlock; 36940a708f8fSGustavo F. Padovan } 36950a708f8fSGustavo F. Padovan 36960a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 369773ffa904SGustavo F. Padovan chan->num_conf_rsp++; 36980a708f8fSGustavo F. Padovan 36990a708f8fSGustavo F. Padovan /* Reset config buffer. */ 370073ffa904SGustavo F. Padovan chan->conf_len = 0; 37010a708f8fSGustavo F. Padovan 3702c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 37030a708f8fSGustavo F. Padovan goto unlock; 37040a708f8fSGustavo F. Padovan 3705c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 370647d1ec61SGustavo F. Padovan set_default_fcs(chan); 37070a708f8fSGustavo F. Padovan 3708105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3709105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 37103c588192SMat Martineau err = l2cap_ertm_init(chan); 37110a708f8fSGustavo F. Padovan 37123c588192SMat Martineau if (err < 0) 37133c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 37143c588192SMat Martineau else 3715cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 37163c588192SMat Martineau 37170a708f8fSGustavo F. Padovan goto unlock; 37180a708f8fSGustavo F. Padovan } 37190a708f8fSGustavo F. Padovan 3720c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 37210a708f8fSGustavo F. Padovan u8 buf[64]; 37220a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 372373ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 372473ffa904SGustavo F. Padovan chan->num_conf_req++; 37250a708f8fSGustavo F. Padovan } 37260a708f8fSGustavo F. Padovan 37270e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 37280e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 37290e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 37300e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 37310e8b207eSAndrei Emeltchenko 37320e8b207eSAndrei Emeltchenko /* check compatibility */ 37330e8b207eSAndrei Emeltchenko 373479de886dSAndrei Emeltchenko /* Send rsp for BR/EDR channel */ 373579de886dSAndrei Emeltchenko if (!chan->ctrl_id) 373629d8a590SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, rsp, cmd->ident, flags); 373779de886dSAndrei Emeltchenko else 373879de886dSAndrei Emeltchenko chan->ident = cmd->ident; 37390e8b207eSAndrei Emeltchenko } 37400e8b207eSAndrei Emeltchenko 37410a708f8fSGustavo F. Padovan unlock: 37426be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37433c588192SMat Martineau return err; 37440a708f8fSGustavo F. Padovan } 37450a708f8fSGustavo F. Padovan 37462d792818SGustavo Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, 37472d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 37480a708f8fSGustavo F. Padovan { 37490a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 37500a708f8fSGustavo F. Padovan u16 scid, flags, result; 375148454079SGustavo F. Padovan struct l2cap_chan *chan; 375261386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 37533c588192SMat Martineau int err = 0; 37540a708f8fSGustavo F. Padovan 37550a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 37560a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 37570a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 37580a708f8fSGustavo F. Padovan 375961386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 376061386cbaSAndrei Emeltchenko result, len); 37610a708f8fSGustavo F. Padovan 3762baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 376348454079SGustavo F. Padovan if (!chan) 37640a708f8fSGustavo F. Padovan return 0; 37650a708f8fSGustavo F. Padovan 37660a708f8fSGustavo F. Padovan switch (result) { 37670a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 376847d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 37690e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 37700a708f8fSGustavo F. Padovan break; 37710a708f8fSGustavo F. Padovan 37720e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 37730e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 37740e8b207eSAndrei Emeltchenko 37750e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 37760e8b207eSAndrei Emeltchenko char buf[64]; 37770e8b207eSAndrei Emeltchenko 37780e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 37790e8b207eSAndrei Emeltchenko buf, &result); 37800e8b207eSAndrei Emeltchenko if (len < 0) { 37810e8b207eSAndrei Emeltchenko l2cap_send_disconn_req(conn, chan, ECONNRESET); 37820e8b207eSAndrei Emeltchenko goto done; 37830e8b207eSAndrei Emeltchenko } 37840e8b207eSAndrei Emeltchenko 37850e8b207eSAndrei Emeltchenko /* check compatibility */ 37860e8b207eSAndrei Emeltchenko 378779de886dSAndrei Emeltchenko if (!chan->ctrl_id) 378879de886dSAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, buf, cmd->ident, 378979de886dSAndrei Emeltchenko 0); 379079de886dSAndrei Emeltchenko else 379179de886dSAndrei Emeltchenko chan->ident = cmd->ident; 37920e8b207eSAndrei Emeltchenko } 37930e8b207eSAndrei Emeltchenko goto done; 37940e8b207eSAndrei Emeltchenko 37950a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 379673ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 37970a708f8fSGustavo F. Padovan char req[64]; 37980a708f8fSGustavo F. Padovan 37990a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 3800e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 38010a708f8fSGustavo F. Padovan goto done; 38020a708f8fSGustavo F. Padovan } 38030a708f8fSGustavo F. Padovan 38040a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 38050a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 3806b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 3807b4450035SGustavo F. Padovan req, &result); 38080a708f8fSGustavo F. Padovan if (len < 0) { 3809e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 38100a708f8fSGustavo F. Padovan goto done; 38110a708f8fSGustavo F. Padovan } 38120a708f8fSGustavo F. Padovan 38130a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 38140a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 381573ffa904SGustavo F. Padovan chan->num_conf_req++; 38160a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 38170a708f8fSGustavo F. Padovan goto done; 38180a708f8fSGustavo F. Padovan break; 38190a708f8fSGustavo F. Padovan } 38200a708f8fSGustavo F. Padovan 38210a708f8fSGustavo F. Padovan default: 38226be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 38232e0052e4SAndrei Emeltchenko 3824ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 3825e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 38260a708f8fSGustavo F. Padovan goto done; 38270a708f8fSGustavo F. Padovan } 38280a708f8fSGustavo F. Padovan 382959e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 38300a708f8fSGustavo F. Padovan goto done; 38310a708f8fSGustavo F. Padovan 3832c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 38330a708f8fSGustavo F. Padovan 3834c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 383547d1ec61SGustavo F. Padovan set_default_fcs(chan); 38360a708f8fSGustavo F. Padovan 3837105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3838105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 38393c588192SMat Martineau err = l2cap_ertm_init(chan); 38400a708f8fSGustavo F. Padovan 38413c588192SMat Martineau if (err < 0) 38423c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 38433c588192SMat Martineau else 3844cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 38450a708f8fSGustavo F. Padovan } 38460a708f8fSGustavo F. Padovan 38470a708f8fSGustavo F. Padovan done: 38486be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 38493c588192SMat Martineau return err; 38500a708f8fSGustavo F. Padovan } 38510a708f8fSGustavo F. Padovan 38522d792818SGustavo Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, 38532d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 38540a708f8fSGustavo F. Padovan { 38550a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 38560a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 38570a708f8fSGustavo F. Padovan u16 dcid, scid; 385848454079SGustavo F. Padovan struct l2cap_chan *chan; 38590a708f8fSGustavo F. Padovan struct sock *sk; 38600a708f8fSGustavo F. Padovan 38610a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 38620a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 38630a708f8fSGustavo F. Padovan 38640a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 38650a708f8fSGustavo F. Padovan 38663df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 38673df91ea2SAndrei Emeltchenko 38683df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 38693df91ea2SAndrei Emeltchenko if (!chan) { 38703df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38710a708f8fSGustavo F. Padovan return 0; 38723df91ea2SAndrei Emeltchenko } 38730a708f8fSGustavo F. Padovan 38746be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 38756be36555SAndrei Emeltchenko 387648454079SGustavo F. Padovan sk = chan->sk; 387748454079SGustavo F. Padovan 3878fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3879fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 38800a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 38810a708f8fSGustavo F. Padovan 38826be36555SAndrei Emeltchenko lock_sock(sk); 38830a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 38846be36555SAndrei Emeltchenko release_sock(sk); 38850a708f8fSGustavo F. Padovan 388661d6ef3eSMat Martineau l2cap_chan_hold(chan); 388748454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 38886be36555SAndrei Emeltchenko 38896be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 38900a708f8fSGustavo F. Padovan 389180b98027SGustavo Padovan chan->ops->close(chan); 389261d6ef3eSMat Martineau l2cap_chan_put(chan); 38933df91ea2SAndrei Emeltchenko 38943df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38953df91ea2SAndrei Emeltchenko 38960a708f8fSGustavo F. Padovan return 0; 38970a708f8fSGustavo F. Padovan } 38980a708f8fSGustavo F. Padovan 38992d792818SGustavo Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, 39002d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39010a708f8fSGustavo F. Padovan { 39020a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 39030a708f8fSGustavo F. Padovan u16 dcid, scid; 390448454079SGustavo F. Padovan struct l2cap_chan *chan; 39050a708f8fSGustavo F. Padovan 39060a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 39070a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 39080a708f8fSGustavo F. Padovan 39090a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 39100a708f8fSGustavo F. Padovan 39113df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 39123df91ea2SAndrei Emeltchenko 39133df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 39143df91ea2SAndrei Emeltchenko if (!chan) { 39153df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39160a708f8fSGustavo F. Padovan return 0; 39173df91ea2SAndrei Emeltchenko } 39180a708f8fSGustavo F. Padovan 39196be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 392048454079SGustavo F. Padovan 392161d6ef3eSMat Martineau l2cap_chan_hold(chan); 392248454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 39236be36555SAndrei Emeltchenko 39246be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39250a708f8fSGustavo F. Padovan 392680b98027SGustavo Padovan chan->ops->close(chan); 392761d6ef3eSMat Martineau l2cap_chan_put(chan); 39283df91ea2SAndrei Emeltchenko 39293df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39303df91ea2SAndrei Emeltchenko 39310a708f8fSGustavo F. Padovan return 0; 39320a708f8fSGustavo F. Padovan } 39330a708f8fSGustavo F. Padovan 39342d792818SGustavo Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, 39352d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39360a708f8fSGustavo F. Padovan { 39370a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 39380a708f8fSGustavo F. Padovan u16 type; 39390a708f8fSGustavo F. Padovan 39400a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 39410a708f8fSGustavo F. Padovan 39420a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 39430a708f8fSGustavo F. Padovan 39440a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 39450a708f8fSGustavo F. Padovan u8 buf[8]; 39460a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 39470a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 3948ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 3949ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 39500a708f8fSGustavo F. Padovan if (!disable_ertm) 39510a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 39520a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 3953a5fd6f30SAndrei Emeltchenko if (enable_hs) 39546327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 39556327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 3956a5fd6f30SAndrei Emeltchenko 39570a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 39582d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 39592d792818SGustavo Padovan buf); 39600a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 39610a708f8fSGustavo F. Padovan u8 buf[12]; 39620a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 396350a147cdSMat Martineau 396450a147cdSMat Martineau if (enable_hs) 396550a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 396650a147cdSMat Martineau else 396750a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 396850a147cdSMat Martineau 3969ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 3970ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 3971c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 39722d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 39732d792818SGustavo Padovan buf); 39740a708f8fSGustavo F. Padovan } else { 39750a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 39760a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 3977ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 39782d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), 39792d792818SGustavo Padovan &rsp); 39800a708f8fSGustavo F. Padovan } 39810a708f8fSGustavo F. Padovan 39820a708f8fSGustavo F. Padovan return 0; 39830a708f8fSGustavo F. Padovan } 39840a708f8fSGustavo F. Padovan 39852d792818SGustavo Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, 39862d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39870a708f8fSGustavo F. Padovan { 39880a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 39890a708f8fSGustavo F. Padovan u16 type, result; 39900a708f8fSGustavo F. Padovan 39910a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 39920a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 39930a708f8fSGustavo F. Padovan 39940a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 39950a708f8fSGustavo F. Padovan 3996e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 3997e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 3998e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 3999e90165beSAndrei Emeltchenko return 0; 4000e90165beSAndrei Emeltchenko 400117cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 40020a708f8fSGustavo F. Padovan 40030a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 40040a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 40050a708f8fSGustavo F. Padovan conn->info_ident = 0; 40060a708f8fSGustavo F. Padovan 40070a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 40080a708f8fSGustavo F. Padovan 40090a708f8fSGustavo F. Padovan return 0; 40100a708f8fSGustavo F. Padovan } 40110a708f8fSGustavo F. Padovan 4012978c93b9SAndrei Emeltchenko switch (type) { 4013978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 40140a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 40150a708f8fSGustavo F. Padovan 40160a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 40170a708f8fSGustavo F. Padovan struct l2cap_info_req req; 4018ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 40190a708f8fSGustavo F. Padovan 40200a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 40210a708f8fSGustavo F. Padovan 40220a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 40230a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 40240a708f8fSGustavo F. Padovan } else { 40250a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 40260a708f8fSGustavo F. Padovan conn->info_ident = 0; 40270a708f8fSGustavo F. Padovan 40280a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 40290a708f8fSGustavo F. Padovan } 4030978c93b9SAndrei Emeltchenko break; 4031978c93b9SAndrei Emeltchenko 4032978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 4033978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 40340a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 40350a708f8fSGustavo F. Padovan conn->info_ident = 0; 40360a708f8fSGustavo F. Padovan 40370a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 4038978c93b9SAndrei Emeltchenko break; 40390a708f8fSGustavo F. Padovan } 40400a708f8fSGustavo F. Padovan 40410a708f8fSGustavo F. Padovan return 0; 40420a708f8fSGustavo F. Padovan } 40430a708f8fSGustavo F. Padovan 40441700915fSMat Martineau static int l2cap_create_channel_req(struct l2cap_conn *conn, 40452d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 40462d792818SGustavo Padovan u16 cmd_len, void *data) 4047f94ff6ffSMat Martineau { 4048f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 40491700915fSMat Martineau struct l2cap_chan *chan; 4050f94ff6ffSMat Martineau u16 psm, scid; 4051f94ff6ffSMat Martineau 4052f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 4053f94ff6ffSMat Martineau return -EPROTO; 4054f94ff6ffSMat Martineau 4055f94ff6ffSMat Martineau if (!enable_hs) 4056f94ff6ffSMat Martineau return -EINVAL; 4057f94ff6ffSMat Martineau 4058f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 4059f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 4060f94ff6ffSMat Martineau 4061ad0ac6caSAndrei Emeltchenko BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id); 4062f94ff6ffSMat Martineau 40631700915fSMat Martineau if (req->amp_id) { 40641700915fSMat Martineau struct hci_dev *hdev; 40651700915fSMat Martineau 40661700915fSMat Martineau /* Validate AMP controller id */ 40671700915fSMat Martineau hdev = hci_dev_get(req->amp_id); 40681700915fSMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 40691700915fSMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 40701700915fSMat Martineau struct l2cap_create_chan_rsp rsp; 40711700915fSMat Martineau 4072f94ff6ffSMat Martineau rsp.dcid = 0; 4073f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 40741700915fSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_CR_BAD_AMP); 40758ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 4076f94ff6ffSMat Martineau 4077f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 4078f94ff6ffSMat Martineau sizeof(rsp), &rsp); 4079f94ff6ffSMat Martineau 40801700915fSMat Martineau if (hdev) 40811700915fSMat Martineau hci_dev_put(hdev); 40821700915fSMat Martineau 40831700915fSMat Martineau return 0; 40841700915fSMat Martineau } 40851700915fSMat Martineau 40861700915fSMat Martineau hci_dev_put(hdev); 40871700915fSMat Martineau } 40881700915fSMat Martineau 40891700915fSMat Martineau chan = l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 40901700915fSMat Martineau req->amp_id); 40911700915fSMat Martineau 4092f94ff6ffSMat Martineau return 0; 4093f94ff6ffSMat Martineau } 4094f94ff6ffSMat Martineau 40958d5a04a1SMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_conn *conn, u8 ident, 40968d5a04a1SMat Martineau u16 icid, u16 result) 40978d5a04a1SMat Martineau { 40988d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 40998d5a04a1SMat Martineau 4100ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 41018d5a04a1SMat Martineau 41028d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 41038d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 41048d5a04a1SMat Martineau 41058d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_RSP, sizeof(rsp), &rsp); 41068d5a04a1SMat Martineau } 41078d5a04a1SMat Martineau 41088d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_conn *conn, 4109ad0ac6caSAndrei Emeltchenko struct l2cap_chan *chan, 4110ad0ac6caSAndrei Emeltchenko u16 icid, u16 result) 41118d5a04a1SMat Martineau { 41128d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 41138d5a04a1SMat Martineau u8 ident; 41148d5a04a1SMat Martineau 4115ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 41168d5a04a1SMat Martineau 41178d5a04a1SMat Martineau ident = l2cap_get_ident(conn); 41188d5a04a1SMat Martineau if (chan) 41198d5a04a1SMat Martineau chan->ident = ident; 41208d5a04a1SMat Martineau 41218d5a04a1SMat Martineau cfm.icid = cpu_to_le16(icid); 41228d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 41238d5a04a1SMat Martineau 41248d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM, sizeof(cfm), &cfm); 41258d5a04a1SMat Martineau } 41268d5a04a1SMat Martineau 41278d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 41288d5a04a1SMat Martineau u16 icid) 41298d5a04a1SMat Martineau { 41308d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 41318d5a04a1SMat Martineau 4132ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 41338d5a04a1SMat Martineau 41348d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 41358d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 41368d5a04a1SMat Martineau } 41378d5a04a1SMat Martineau 41388d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 4139ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4140ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 41418d5a04a1SMat Martineau { 41428d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 41438d5a04a1SMat Martineau u16 icid = 0; 41448d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 41458d5a04a1SMat Martineau 41468d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 41478d5a04a1SMat Martineau return -EPROTO; 41488d5a04a1SMat Martineau 41498d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 41508d5a04a1SMat Martineau 4151ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id); 41528d5a04a1SMat Martineau 41538d5a04a1SMat Martineau if (!enable_hs) 41548d5a04a1SMat Martineau return -EINVAL; 41558d5a04a1SMat Martineau 41568d5a04a1SMat Martineau /* Placeholder: Always refuse */ 41578d5a04a1SMat Martineau l2cap_send_move_chan_rsp(conn, cmd->ident, icid, result); 41588d5a04a1SMat Martineau 41598d5a04a1SMat Martineau return 0; 41608d5a04a1SMat Martineau } 41618d5a04a1SMat Martineau 41628d5a04a1SMat Martineau static inline int l2cap_move_channel_rsp(struct l2cap_conn *conn, 4163ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4164ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 41658d5a04a1SMat Martineau { 41668d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 41678d5a04a1SMat Martineau u16 icid, result; 41688d5a04a1SMat Martineau 41698d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 41708d5a04a1SMat Martineau return -EPROTO; 41718d5a04a1SMat Martineau 41728d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 41738d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 41748d5a04a1SMat Martineau 4175ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 41768d5a04a1SMat Martineau 41778d5a04a1SMat Martineau /* Placeholder: Always unconfirmed */ 41788d5a04a1SMat Martineau l2cap_send_move_chan_cfm(conn, NULL, icid, L2CAP_MC_UNCONFIRMED); 41798d5a04a1SMat Martineau 41808d5a04a1SMat Martineau return 0; 41818d5a04a1SMat Martineau } 41828d5a04a1SMat Martineau 41838d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm(struct l2cap_conn *conn, 4184ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4185ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 41868d5a04a1SMat Martineau { 41878d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 41888d5a04a1SMat Martineau u16 icid, result; 41898d5a04a1SMat Martineau 41908d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 41918d5a04a1SMat Martineau return -EPROTO; 41928d5a04a1SMat Martineau 41938d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 41948d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 41958d5a04a1SMat Martineau 4196ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 41978d5a04a1SMat Martineau 41988d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 41998d5a04a1SMat Martineau 42008d5a04a1SMat Martineau return 0; 42018d5a04a1SMat Martineau } 42028d5a04a1SMat Martineau 42038d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 4204ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4205ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 42068d5a04a1SMat Martineau { 42078d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 42088d5a04a1SMat Martineau u16 icid; 42098d5a04a1SMat Martineau 42108d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 42118d5a04a1SMat Martineau return -EPROTO; 42128d5a04a1SMat Martineau 42138d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 42148d5a04a1SMat Martineau 4215ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 42168d5a04a1SMat Martineau 42178d5a04a1SMat Martineau return 0; 42188d5a04a1SMat Martineau } 42198d5a04a1SMat Martineau 4220e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4221de73115aSClaudio Takahasi u16 to_multiplier) 4222de73115aSClaudio Takahasi { 4223de73115aSClaudio Takahasi u16 max_latency; 4224de73115aSClaudio Takahasi 4225de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4226de73115aSClaudio Takahasi return -EINVAL; 4227de73115aSClaudio Takahasi 4228de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4229de73115aSClaudio Takahasi return -EINVAL; 4230de73115aSClaudio Takahasi 4231de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4232de73115aSClaudio Takahasi return -EINVAL; 4233de73115aSClaudio Takahasi 4234de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 4235de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 4236de73115aSClaudio Takahasi return -EINVAL; 4237de73115aSClaudio Takahasi 4238de73115aSClaudio Takahasi return 0; 4239de73115aSClaudio Takahasi } 4240de73115aSClaudio Takahasi 4241de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 42422d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 42432d792818SGustavo Padovan u8 *data) 4244de73115aSClaudio Takahasi { 4245de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 4246de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 4247de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 4248de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 42492ce603ebSClaudio Takahasi int err; 4250de73115aSClaudio Takahasi 4251de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 4252de73115aSClaudio Takahasi return -EINVAL; 4253de73115aSClaudio Takahasi 4254de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 4255de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 4256de73115aSClaudio Takahasi return -EPROTO; 4257de73115aSClaudio Takahasi 4258de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 4259de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 4260de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 4261de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 4262de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 4263de73115aSClaudio Takahasi 4264de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 4265de73115aSClaudio Takahasi min, max, latency, to_multiplier); 4266de73115aSClaudio Takahasi 4267de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 42682ce603ebSClaudio Takahasi 42692ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 42702ce603ebSClaudio Takahasi if (err) 4271ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 4272de73115aSClaudio Takahasi else 4273ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 4274de73115aSClaudio Takahasi 4275de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 4276de73115aSClaudio Takahasi sizeof(rsp), &rsp); 4277de73115aSClaudio Takahasi 42782ce603ebSClaudio Takahasi if (!err) 42792ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 42802ce603ebSClaudio Takahasi 4281de73115aSClaudio Takahasi return 0; 4282de73115aSClaudio Takahasi } 4283de73115aSClaudio Takahasi 42843300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 42852d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 42862d792818SGustavo Padovan u8 *data) 42873300d9a9SClaudio Takahasi { 42883300d9a9SClaudio Takahasi int err = 0; 42893300d9a9SClaudio Takahasi 42903300d9a9SClaudio Takahasi switch (cmd->code) { 42913300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 42923300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 42933300d9a9SClaudio Takahasi break; 42943300d9a9SClaudio Takahasi 42953300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 42963300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 42973300d9a9SClaudio Takahasi break; 42983300d9a9SClaudio Takahasi 42993300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 4300f5a2598dSMat Martineau case L2CAP_CREATE_CHAN_RSP: 43015909cf30SMat Martineau err = l2cap_connect_create_rsp(conn, cmd, data); 43023300d9a9SClaudio Takahasi break; 43033300d9a9SClaudio Takahasi 43043300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 43053300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 43063300d9a9SClaudio Takahasi break; 43073300d9a9SClaudio Takahasi 43083300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 43093300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 43103300d9a9SClaudio Takahasi break; 43113300d9a9SClaudio Takahasi 43123300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 43133300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 43143300d9a9SClaudio Takahasi break; 43153300d9a9SClaudio Takahasi 43163300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 43173300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 43183300d9a9SClaudio Takahasi break; 43193300d9a9SClaudio Takahasi 43203300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 43213300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 43223300d9a9SClaudio Takahasi break; 43233300d9a9SClaudio Takahasi 43243300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 43253300d9a9SClaudio Takahasi break; 43263300d9a9SClaudio Takahasi 43273300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 43283300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 43293300d9a9SClaudio Takahasi break; 43303300d9a9SClaudio Takahasi 43313300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 43323300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 43333300d9a9SClaudio Takahasi break; 43343300d9a9SClaudio Takahasi 4335f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 4336f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 4337f94ff6ffSMat Martineau break; 4338f94ff6ffSMat Martineau 43398d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 43408d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 43418d5a04a1SMat Martineau break; 43428d5a04a1SMat Martineau 43438d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 43448d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 43458d5a04a1SMat Martineau break; 43468d5a04a1SMat Martineau 43478d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 43488d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 43498d5a04a1SMat Martineau break; 43508d5a04a1SMat Martineau 43518d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 43528d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 43538d5a04a1SMat Martineau break; 43548d5a04a1SMat Martineau 43553300d9a9SClaudio Takahasi default: 43563300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 43573300d9a9SClaudio Takahasi err = -EINVAL; 43583300d9a9SClaudio Takahasi break; 43593300d9a9SClaudio Takahasi } 43603300d9a9SClaudio Takahasi 43613300d9a9SClaudio Takahasi return err; 43623300d9a9SClaudio Takahasi } 43633300d9a9SClaudio Takahasi 43643300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 43653300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 43663300d9a9SClaudio Takahasi { 43673300d9a9SClaudio Takahasi switch (cmd->code) { 43683300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 43693300d9a9SClaudio Takahasi return 0; 43703300d9a9SClaudio Takahasi 43713300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 4372de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 43733300d9a9SClaudio Takahasi 43743300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 43753300d9a9SClaudio Takahasi return 0; 43763300d9a9SClaudio Takahasi 43773300d9a9SClaudio Takahasi default: 43783300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 43793300d9a9SClaudio Takahasi return -EINVAL; 43803300d9a9SClaudio Takahasi } 43813300d9a9SClaudio Takahasi } 43823300d9a9SClaudio Takahasi 43833300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 43843300d9a9SClaudio Takahasi struct sk_buff *skb) 43850a708f8fSGustavo F. Padovan { 43860a708f8fSGustavo F. Padovan u8 *data = skb->data; 43870a708f8fSGustavo F. Padovan int len = skb->len; 43880a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 43893300d9a9SClaudio Takahasi int err; 43900a708f8fSGustavo F. Padovan 43910a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 43920a708f8fSGustavo F. Padovan 43930a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 43940a708f8fSGustavo F. Padovan u16 cmd_len; 43950a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 43960a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 43970a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 43980a708f8fSGustavo F. Padovan 43990a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 44000a708f8fSGustavo F. Padovan 44012d792818SGustavo Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 44022d792818SGustavo Padovan cmd.ident); 44030a708f8fSGustavo F. Padovan 44040a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 44050a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 44060a708f8fSGustavo F. Padovan break; 44070a708f8fSGustavo F. Padovan } 44080a708f8fSGustavo F. Padovan 44093300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 44103300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 44113300d9a9SClaudio Takahasi else 44123300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 44130a708f8fSGustavo F. Padovan 44140a708f8fSGustavo F. Padovan if (err) { 4415e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 44162c6d1a2eSGustavo F. Padovan 44172c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 44180a708f8fSGustavo F. Padovan 44190a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 4420ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 44212d792818SGustavo Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 44222d792818SGustavo Padovan sizeof(rej), &rej); 44230a708f8fSGustavo F. Padovan } 44240a708f8fSGustavo F. Padovan 44250a708f8fSGustavo F. Padovan data += cmd_len; 44260a708f8fSGustavo F. Padovan len -= cmd_len; 44270a708f8fSGustavo F. Padovan } 44280a708f8fSGustavo F. Padovan 44290a708f8fSGustavo F. Padovan kfree_skb(skb); 44300a708f8fSGustavo F. Padovan } 44310a708f8fSGustavo F. Padovan 443247d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 44330a708f8fSGustavo F. Padovan { 44340a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 4435e4ca6d98SAndrei Emeltchenko int hdr_size; 4436e4ca6d98SAndrei Emeltchenko 4437e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 4438e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 4439e4ca6d98SAndrei Emeltchenko else 4440e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 44410a708f8fSGustavo F. Padovan 444247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 444303a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 44440a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 44450a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 44460a708f8fSGustavo F. Padovan 44470a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 44480a708f8fSGustavo F. Padovan return -EBADMSG; 44490a708f8fSGustavo F. Padovan } 44500a708f8fSGustavo F. Padovan return 0; 44510a708f8fSGustavo F. Padovan } 44520a708f8fSGustavo F. Padovan 44536ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 44540a708f8fSGustavo F. Padovan { 4455e31f7633SMat Martineau struct l2cap_ctrl control; 44560a708f8fSGustavo F. Padovan 4457e31f7633SMat Martineau BT_DBG("chan %p", chan); 44580a708f8fSGustavo F. Padovan 4459e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 4460e31f7633SMat Martineau control.sframe = 1; 4461e31f7633SMat Martineau control.final = 1; 4462e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 4463e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 44640a708f8fSGustavo F. Padovan 4465e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4466e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 4467e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 44680a708f8fSGustavo F. Padovan } 44690a708f8fSGustavo F. Padovan 4470e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 4471e31f7633SMat Martineau chan->unacked_frames > 0) 4472e31f7633SMat Martineau __set_retrans_timer(chan); 44730a708f8fSGustavo F. Padovan 4474e31f7633SMat Martineau /* Send pending iframes */ 4475525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 44760a708f8fSGustavo F. Padovan 4477e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 4478e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 4479e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 4480e31f7633SMat Martineau * send it now. 4481e31f7633SMat Martineau */ 4482e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 4483e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 44840a708f8fSGustavo F. Padovan } 44850a708f8fSGustavo F. Padovan } 44860a708f8fSGustavo F. Padovan 44872d792818SGustavo Padovan static void append_skb_frag(struct sk_buff *skb, struct sk_buff *new_frag, 44882d792818SGustavo Padovan struct sk_buff **last_frag) 44890a708f8fSGustavo F. Padovan { 449084084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 449184084a31SMat Martineau * skb->data_len reflects only data in fragments 449284084a31SMat Martineau */ 449384084a31SMat Martineau if (!skb_has_frag_list(skb)) 449484084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 449584084a31SMat Martineau 449684084a31SMat Martineau new_frag->next = NULL; 449784084a31SMat Martineau 449884084a31SMat Martineau (*last_frag)->next = new_frag; 449984084a31SMat Martineau *last_frag = new_frag; 450084084a31SMat Martineau 450184084a31SMat Martineau skb->len += new_frag->len; 450284084a31SMat Martineau skb->data_len += new_frag->len; 450384084a31SMat Martineau skb->truesize += new_frag->truesize; 450484084a31SMat Martineau } 450584084a31SMat Martineau 45064b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 45074b51dae9SMat Martineau struct l2cap_ctrl *control) 450884084a31SMat Martineau { 450984084a31SMat Martineau int err = -EINVAL; 45100a708f8fSGustavo F. Padovan 45114b51dae9SMat Martineau switch (control->sar) { 45127e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 451384084a31SMat Martineau if (chan->sdu) 451484084a31SMat Martineau break; 45150a708f8fSGustavo F. Padovan 451680b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 451784084a31SMat Martineau break; 45180a708f8fSGustavo F. Padovan 45197e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 452084084a31SMat Martineau if (chan->sdu) 452184084a31SMat Martineau break; 45220a708f8fSGustavo F. Padovan 45236f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 452403a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 45250a708f8fSGustavo F. Padovan 452684084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 452784084a31SMat Martineau err = -EMSGSIZE; 452884084a31SMat Martineau break; 452984084a31SMat Martineau } 45300a708f8fSGustavo F. Padovan 453184084a31SMat Martineau if (skb->len >= chan->sdu_len) 453284084a31SMat Martineau break; 453384084a31SMat Martineau 453484084a31SMat Martineau chan->sdu = skb; 453584084a31SMat Martineau chan->sdu_last_frag = skb; 453684084a31SMat Martineau 453784084a31SMat Martineau skb = NULL; 453884084a31SMat Martineau err = 0; 45390a708f8fSGustavo F. Padovan break; 45400a708f8fSGustavo F. Padovan 45417e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 45426f61fd47SGustavo F. Padovan if (!chan->sdu) 454384084a31SMat Martineau break; 45440a708f8fSGustavo F. Padovan 454584084a31SMat Martineau append_skb_frag(chan->sdu, skb, 454684084a31SMat Martineau &chan->sdu_last_frag); 454784084a31SMat Martineau skb = NULL; 45480a708f8fSGustavo F. Padovan 454984084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 455084084a31SMat Martineau break; 45510a708f8fSGustavo F. Padovan 455284084a31SMat Martineau err = 0; 45530a708f8fSGustavo F. Padovan break; 45540a708f8fSGustavo F. Padovan 45557e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 45566f61fd47SGustavo F. Padovan if (!chan->sdu) 455784084a31SMat Martineau break; 45580a708f8fSGustavo F. Padovan 455984084a31SMat Martineau append_skb_frag(chan->sdu, skb, 456084084a31SMat Martineau &chan->sdu_last_frag); 456184084a31SMat Martineau skb = NULL; 45620a708f8fSGustavo F. Padovan 456384084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 456484084a31SMat Martineau break; 45650a708f8fSGustavo F. Padovan 456680b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 45670a708f8fSGustavo F. Padovan 456884084a31SMat Martineau if (!err) { 456984084a31SMat Martineau /* Reassembly complete */ 457084084a31SMat Martineau chan->sdu = NULL; 457184084a31SMat Martineau chan->sdu_last_frag = NULL; 457284084a31SMat Martineau chan->sdu_len = 0; 45730a708f8fSGustavo F. Padovan } 45740a708f8fSGustavo F. Padovan break; 45750a708f8fSGustavo F. Padovan } 45760a708f8fSGustavo F. Padovan 457784084a31SMat Martineau if (err) { 45780a708f8fSGustavo F. Padovan kfree_skb(skb); 45796f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 45806f61fd47SGustavo F. Padovan chan->sdu = NULL; 458184084a31SMat Martineau chan->sdu_last_frag = NULL; 458284084a31SMat Martineau chan->sdu_len = 0; 458384084a31SMat Martineau } 45840a708f8fSGustavo F. Padovan 458584084a31SMat Martineau return err; 45860a708f8fSGustavo F. Padovan } 45870a708f8fSGustavo F. Padovan 4588e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 45890a708f8fSGustavo F. Padovan { 459061aa4f5bSMat Martineau u8 event; 459161aa4f5bSMat Martineau 459261aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 459361aa4f5bSMat Martineau return; 459461aa4f5bSMat Martineau 459561aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 4596401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 45970a708f8fSGustavo F. Padovan } 45980a708f8fSGustavo F. Padovan 4599d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 4600d2a7ac5dSMat Martineau { 460163838725SMat Martineau int err = 0; 460263838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 460363838725SMat Martineau * until a gap is encountered. 460463838725SMat Martineau */ 460563838725SMat Martineau 460663838725SMat Martineau BT_DBG("chan %p", chan); 460763838725SMat Martineau 460863838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 460963838725SMat Martineau struct sk_buff *skb; 461063838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 461163838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 461263838725SMat Martineau 461363838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 461463838725SMat Martineau 461563838725SMat Martineau if (!skb) 461663838725SMat Martineau break; 461763838725SMat Martineau 461863838725SMat Martineau skb_unlink(skb, &chan->srej_q); 461963838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 462063838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 462163838725SMat Martineau if (err) 462263838725SMat Martineau break; 462363838725SMat Martineau } 462463838725SMat Martineau 462563838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 462663838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 462763838725SMat Martineau l2cap_send_ack(chan); 462863838725SMat Martineau } 462963838725SMat Martineau 463063838725SMat Martineau return err; 4631d2a7ac5dSMat Martineau } 4632d2a7ac5dSMat Martineau 4633d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 4634d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4635d2a7ac5dSMat Martineau { 4636f80842a8SMat Martineau struct sk_buff *skb; 4637f80842a8SMat Martineau 4638f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 4639f80842a8SMat Martineau 4640f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 4641f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4642f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4643f80842a8SMat Martineau return; 4644f80842a8SMat Martineau } 4645f80842a8SMat Martineau 4646f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4647f80842a8SMat Martineau 4648f80842a8SMat Martineau if (skb == NULL) { 4649f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 4650f80842a8SMat Martineau control->reqseq); 4651f80842a8SMat Martineau return; 4652f80842a8SMat Martineau } 4653f80842a8SMat Martineau 4654f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 4655f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4656f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4657f80842a8SMat Martineau return; 4658f80842a8SMat Martineau } 4659f80842a8SMat Martineau 4660f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4661f80842a8SMat Martineau 4662f80842a8SMat Martineau if (control->poll) { 4663f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 4664f80842a8SMat Martineau 4665f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4666f80842a8SMat Martineau l2cap_retransmit(chan, control); 4667f80842a8SMat Martineau l2cap_ertm_send(chan); 4668f80842a8SMat Martineau 4669f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4670f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4671f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4672f80842a8SMat Martineau } 4673f80842a8SMat Martineau } else { 4674f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 4675f80842a8SMat Martineau 4676f80842a8SMat Martineau if (control->final) { 4677f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 4678f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 4679f80842a8SMat Martineau &chan->conn_state)) 4680f80842a8SMat Martineau l2cap_retransmit(chan, control); 4681f80842a8SMat Martineau } else { 4682f80842a8SMat Martineau l2cap_retransmit(chan, control); 4683f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4684f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4685f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4686f80842a8SMat Martineau } 4687f80842a8SMat Martineau } 4688f80842a8SMat Martineau } 4689d2a7ac5dSMat Martineau } 4690d2a7ac5dSMat Martineau 4691d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 4692d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4693d2a7ac5dSMat Martineau { 4694fcd289dfSMat Martineau struct sk_buff *skb; 4695fcd289dfSMat Martineau 4696fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 4697fcd289dfSMat Martineau 4698fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 4699fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4700fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4701fcd289dfSMat Martineau return; 4702fcd289dfSMat Martineau } 4703fcd289dfSMat Martineau 4704fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4705fcd289dfSMat Martineau 4706fcd289dfSMat Martineau if (chan->max_tx && skb && 4707fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 4708fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4709fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4710fcd289dfSMat Martineau return; 4711fcd289dfSMat Martineau } 4712fcd289dfSMat Martineau 4713fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4714fcd289dfSMat Martineau 4715fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 4716fcd289dfSMat Martineau 4717fcd289dfSMat Martineau if (control->final) { 4718fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 4719fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4720fcd289dfSMat Martineau } else { 4721fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4722fcd289dfSMat Martineau l2cap_ertm_send(chan); 4723fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 4724fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 4725fcd289dfSMat Martineau } 4726d2a7ac5dSMat Martineau } 4727d2a7ac5dSMat Martineau 47284b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 47294b51dae9SMat Martineau { 47304b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 47314b51dae9SMat Martineau 47324b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 47334b51dae9SMat Martineau chan->expected_tx_seq); 47344b51dae9SMat Martineau 47354b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 47364b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 47374b51dae9SMat Martineau chan->tx_win) { 47384b51dae9SMat Martineau /* See notes below regarding "double poll" and 47394b51dae9SMat Martineau * invalid packets. 47404b51dae9SMat Martineau */ 47414b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 47424b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 47434b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 47444b51dae9SMat Martineau } else { 47454b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 47464b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 47474b51dae9SMat Martineau } 47484b51dae9SMat Martineau } 47494b51dae9SMat Martineau 47504b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 47514b51dae9SMat Martineau BT_DBG("Expected SREJ"); 47524b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 47534b51dae9SMat Martineau } 47544b51dae9SMat Martineau 47554b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 47564b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 47574b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 47584b51dae9SMat Martineau } 47594b51dae9SMat Martineau 47604b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 47614b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 47624b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 47634b51dae9SMat Martineau } 47644b51dae9SMat Martineau } 47654b51dae9SMat Martineau 47664b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 47674b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 47684b51dae9SMat Martineau chan->tx_win) { 47694b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 47704b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 47714b51dae9SMat Martineau } else { 47724b51dae9SMat Martineau BT_DBG("Expected"); 47734b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 47744b51dae9SMat Martineau } 47754b51dae9SMat Martineau } 47764b51dae9SMat Martineau 47774b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 47782d792818SGustavo Padovan __seq_offset(chan, chan->expected_tx_seq, chan->last_acked_seq)) { 47794b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 47804b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 47814b51dae9SMat Martineau } 47824b51dae9SMat Martineau 47834b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 47844b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 47854b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 47864b51dae9SMat Martineau * the remote stack receives and processes both polls, 47874b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 47884b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 47894b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 47904b51dae9SMat Martineau * request. 47914b51dae9SMat Martineau * 47924b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 47934b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 47944b51dae9SMat Martineau * invalid frames to be safely ignored. 47954b51dae9SMat Martineau * 47964b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 47974b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 47984b51dae9SMat Martineau * causes a disconnect. 47994b51dae9SMat Martineau */ 48004b51dae9SMat Martineau 48014b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 48024b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 48034b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 48044b51dae9SMat Martineau } else { 48054b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 48064b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 48074b51dae9SMat Martineau } 48084b51dae9SMat Martineau } else { 48094b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 48104b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 48114b51dae9SMat Martineau } 48124b51dae9SMat Martineau } 48134b51dae9SMat Martineau 4814d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 4815d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4816d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4817d2a7ac5dSMat Martineau { 4818d2a7ac5dSMat Martineau int err = 0; 4819d2a7ac5dSMat Martineau bool skb_in_use = 0; 4820d2a7ac5dSMat Martineau 4821d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4822d2a7ac5dSMat Martineau event); 4823d2a7ac5dSMat Martineau 4824d2a7ac5dSMat Martineau switch (event) { 4825d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4826d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 4827d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4828d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4829d2a7ac5dSMat Martineau 4830d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4831d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 4832d2a7ac5dSMat Martineau control->txseq); 4833d2a7ac5dSMat Martineau break; 4834d2a7ac5dSMat Martineau } 4835d2a7ac5dSMat Martineau 4836d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 4837d2a7ac5dSMat Martineau control->txseq); 4838d2a7ac5dSMat Martineau 4839d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 4840d2a7ac5dSMat Martineau skb_in_use = 1; 4841d2a7ac5dSMat Martineau 4842d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 4843d2a7ac5dSMat Martineau if (err) 4844d2a7ac5dSMat Martineau break; 4845d2a7ac5dSMat Martineau 4846d2a7ac5dSMat Martineau if (control->final) { 4847d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4848d2a7ac5dSMat Martineau &chan->conn_state)) { 4849d2a7ac5dSMat Martineau control->final = 0; 4850d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4851d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4852d2a7ac5dSMat Martineau } 4853d2a7ac5dSMat Martineau } 4854d2a7ac5dSMat Martineau 4855d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 4856d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4857d2a7ac5dSMat Martineau break; 4858d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4859d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4860d2a7ac5dSMat Martineau 4861d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 4862d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 4863d2a7ac5dSMat Martineau * when local busy is exited. 4864d2a7ac5dSMat Martineau */ 4865d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4866d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 4867d2a7ac5dSMat Martineau control->txseq); 4868d2a7ac5dSMat Martineau break; 4869d2a7ac5dSMat Martineau } 4870d2a7ac5dSMat Martineau 4871d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 4872d2a7ac5dSMat Martineau * must be sent for each missing frame. The 4873d2a7ac5dSMat Martineau * current frame is stored for later use. 4874d2a7ac5dSMat Martineau */ 4875d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4876d2a7ac5dSMat Martineau skb_in_use = 1; 4877d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4878d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4879d2a7ac5dSMat Martineau 4880d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 4881d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 4882d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4883d2a7ac5dSMat Martineau 4884d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 4885d2a7ac5dSMat Martineau break; 4886d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4887d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4888d2a7ac5dSMat Martineau break; 4889d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4890d2a7ac5dSMat Martineau break; 4891d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4892d2a7ac5dSMat Martineau default: 4893d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4894d2a7ac5dSMat Martineau ECONNRESET); 4895d2a7ac5dSMat Martineau break; 4896d2a7ac5dSMat Martineau } 4897d2a7ac5dSMat Martineau break; 4898d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4899d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4900d2a7ac5dSMat Martineau if (control->final) { 4901d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4902d2a7ac5dSMat Martineau 4903d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4904d2a7ac5dSMat Martineau &chan->conn_state)) { 4905d2a7ac5dSMat Martineau control->final = 0; 4906d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4907d2a7ac5dSMat Martineau } 4908d2a7ac5dSMat Martineau 4909d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4910d2a7ac5dSMat Martineau } else if (control->poll) { 4911d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 4912d2a7ac5dSMat Martineau } else { 4913d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4914d2a7ac5dSMat Martineau &chan->conn_state) && 4915d2a7ac5dSMat Martineau chan->unacked_frames) 4916d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4917d2a7ac5dSMat Martineau 4918d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4919d2a7ac5dSMat Martineau } 4920d2a7ac5dSMat Martineau break; 4921d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4922d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4923d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4924d2a7ac5dSMat Martineau if (control && control->poll) { 4925d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4926d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 4927d2a7ac5dSMat Martineau } 4928d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 4929d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 4930d2a7ac5dSMat Martineau break; 4931d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4932d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4933d2a7ac5dSMat Martineau break; 4934d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4935d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4936d2a7ac5dSMat Martineau break; 4937d2a7ac5dSMat Martineau default: 4938d2a7ac5dSMat Martineau break; 4939d2a7ac5dSMat Martineau } 4940d2a7ac5dSMat Martineau 4941d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4942d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4943d2a7ac5dSMat Martineau kfree_skb(skb); 4944d2a7ac5dSMat Martineau } 4945d2a7ac5dSMat Martineau 4946d2a7ac5dSMat Martineau return err; 4947d2a7ac5dSMat Martineau } 4948d2a7ac5dSMat Martineau 4949d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 4950d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4951d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4952d2a7ac5dSMat Martineau { 4953d2a7ac5dSMat Martineau int err = 0; 4954d2a7ac5dSMat Martineau u16 txseq = control->txseq; 4955d2a7ac5dSMat Martineau bool skb_in_use = 0; 4956d2a7ac5dSMat Martineau 4957d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4958d2a7ac5dSMat Martineau event); 4959d2a7ac5dSMat Martineau 4960d2a7ac5dSMat Martineau switch (event) { 4961d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4962d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 4963d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4964d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 4965d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4966d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4967d2a7ac5dSMat Martineau skb_in_use = 1; 4968d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4969d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4970d2a7ac5dSMat Martineau 4971d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 4972d2a7ac5dSMat Martineau break; 4973d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 4974d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 4975d2a7ac5dSMat Martineau 4976d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4977d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4978d2a7ac5dSMat Martineau skb_in_use = 1; 4979d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4980d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4981d2a7ac5dSMat Martineau 4982d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 4983d2a7ac5dSMat Martineau if (err) 4984d2a7ac5dSMat Martineau break; 4985d2a7ac5dSMat Martineau 4986d2a7ac5dSMat Martineau break; 4987d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4988d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 4989d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 4990d2a7ac5dSMat Martineau * the missing frames. 4991d2a7ac5dSMat Martineau */ 4992d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4993d2a7ac5dSMat Martineau skb_in_use = 1; 4994d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4995d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4996d2a7ac5dSMat Martineau 4997d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4998d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4999d2a7ac5dSMat Martineau break; 5000d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 5001d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 5002d2a7ac5dSMat Martineau * some expected retransmitted frames are 5003d2a7ac5dSMat Martineau * missing. Request retransmission of missing 5004d2a7ac5dSMat Martineau * SREJ'd frames. 5005d2a7ac5dSMat Martineau */ 5006d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5007d2a7ac5dSMat Martineau skb_in_use = 1; 5008d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5009d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5010d2a7ac5dSMat Martineau 5011d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5012d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 5013d2a7ac5dSMat Martineau break; 5014d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 5015d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 5016d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5017d2a7ac5dSMat Martineau break; 5018d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5019d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 5020d2a7ac5dSMat Martineau * was already received. Ignore it completely. 5021d2a7ac5dSMat Martineau */ 5022d2a7ac5dSMat Martineau break; 5023d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5024d2a7ac5dSMat Martineau break; 5025d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5026d2a7ac5dSMat Martineau default: 5027d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5028d2a7ac5dSMat Martineau ECONNRESET); 5029d2a7ac5dSMat Martineau break; 5030d2a7ac5dSMat Martineau } 5031d2a7ac5dSMat Martineau break; 5032d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5033d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5034d2a7ac5dSMat Martineau if (control->final) { 5035d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5036d2a7ac5dSMat Martineau 5037d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5038d2a7ac5dSMat Martineau &chan->conn_state)) { 5039d2a7ac5dSMat Martineau control->final = 0; 5040d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5041d2a7ac5dSMat Martineau } 5042d2a7ac5dSMat Martineau 5043d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5044d2a7ac5dSMat Martineau } else if (control->poll) { 5045d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5046d2a7ac5dSMat Martineau &chan->conn_state) && 5047d2a7ac5dSMat Martineau chan->unacked_frames) { 5048d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5049d2a7ac5dSMat Martineau } 5050d2a7ac5dSMat Martineau 5051d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5052d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5053d2a7ac5dSMat Martineau } else { 5054d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5055d2a7ac5dSMat Martineau &chan->conn_state) && 5056d2a7ac5dSMat Martineau chan->unacked_frames) 5057d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5058d2a7ac5dSMat Martineau 5059d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5060d2a7ac5dSMat Martineau } 5061d2a7ac5dSMat Martineau break; 5062d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5063d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5064d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5065d2a7ac5dSMat Martineau if (control->poll) { 5066d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5067d2a7ac5dSMat Martineau } else { 5068d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 5069d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 5070d2a7ac5dSMat Martineau rr_control.sframe = 1; 5071d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 5072d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 5073d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 5074d2a7ac5dSMat Martineau } 5075d2a7ac5dSMat Martineau 5076d2a7ac5dSMat Martineau break; 5077d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5078d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5079d2a7ac5dSMat Martineau break; 5080d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5081d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5082d2a7ac5dSMat Martineau break; 5083d2a7ac5dSMat Martineau } 5084d2a7ac5dSMat Martineau 5085d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5086d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5087d2a7ac5dSMat Martineau kfree_skb(skb); 5088d2a7ac5dSMat Martineau } 5089d2a7ac5dSMat Martineau 5090d2a7ac5dSMat Martineau return err; 5091d2a7ac5dSMat Martineau } 5092d2a7ac5dSMat Martineau 5093d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 5094d2a7ac5dSMat Martineau { 5095d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 5096d2a7ac5dSMat Martineau u16 unacked; 5097d2a7ac5dSMat Martineau 5098d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 5099d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 5100d2a7ac5dSMat Martineau } 5101d2a7ac5dSMat Martineau 5102cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5103cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 51040a708f8fSGustavo F. Padovan { 5105d2a7ac5dSMat Martineau int err = 0; 5106d2a7ac5dSMat Martineau 5107d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 5108d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 5109d2a7ac5dSMat Martineau 5110d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 5111d2a7ac5dSMat Martineau switch (chan->rx_state) { 5112d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 5113d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 5114d2a7ac5dSMat Martineau break; 5115d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 5116d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 5117d2a7ac5dSMat Martineau event); 5118d2a7ac5dSMat Martineau break; 5119d2a7ac5dSMat Martineau default: 5120d2a7ac5dSMat Martineau /* shut it down */ 5121d2a7ac5dSMat Martineau break; 5122d2a7ac5dSMat Martineau } 5123d2a7ac5dSMat Martineau } else { 5124d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 5125d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 5126d2a7ac5dSMat Martineau chan->expected_ack_seq); 5127d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5128d2a7ac5dSMat Martineau } 5129d2a7ac5dSMat Martineau 5130d2a7ac5dSMat Martineau return err; 5131cec8ab6eSMat Martineau } 5132cec8ab6eSMat Martineau 5133cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5134cec8ab6eSMat Martineau struct sk_buff *skb) 5135cec8ab6eSMat Martineau { 51364b51dae9SMat Martineau int err = 0; 51374b51dae9SMat Martineau 51384b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 51394b51dae9SMat Martineau chan->rx_state); 51404b51dae9SMat Martineau 51414b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 51424b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 51434b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 51444b51dae9SMat Martineau 51454b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 51464b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 51474b51dae9SMat Martineau 51484b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 51494b51dae9SMat Martineau 51504b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 51514b51dae9SMat Martineau } else { 51524b51dae9SMat Martineau if (chan->sdu) { 51534b51dae9SMat Martineau kfree_skb(chan->sdu); 51544b51dae9SMat Martineau chan->sdu = NULL; 51554b51dae9SMat Martineau } 51564b51dae9SMat Martineau chan->sdu_last_frag = NULL; 51574b51dae9SMat Martineau chan->sdu_len = 0; 51584b51dae9SMat Martineau 51594b51dae9SMat Martineau if (skb) { 51604b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 51614b51dae9SMat Martineau kfree_skb(skb); 51624b51dae9SMat Martineau } 51634b51dae9SMat Martineau } 51644b51dae9SMat Martineau 51654b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 51664b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 51674b51dae9SMat Martineau 51684b51dae9SMat Martineau return err; 5169cec8ab6eSMat Martineau } 5170cec8ab6eSMat Martineau 5171cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 5172cec8ab6eSMat Martineau { 5173cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 5174cec8ab6eSMat Martineau u16 len; 5175cec8ab6eSMat Martineau u8 event; 51760a708f8fSGustavo F. Padovan 5177b76bbd66SMat Martineau __unpack_control(chan, skb); 5178b76bbd66SMat Martineau 51790a708f8fSGustavo F. Padovan len = skb->len; 51800a708f8fSGustavo F. Padovan 51810a708f8fSGustavo F. Padovan /* 51820a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 51830a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 5184cec8ab6eSMat Martineau * procedures and ask for retransmission. 51850a708f8fSGustavo F. Padovan */ 518647d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 51870a708f8fSGustavo F. Padovan goto drop; 51880a708f8fSGustavo F. Padovan 5189cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 519003a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 51910a708f8fSGustavo F. Padovan 519247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 519303a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 51940a708f8fSGustavo F. Padovan 519547d1ec61SGustavo F. Padovan if (len > chan->mps) { 51968c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51970a708f8fSGustavo F. Padovan goto drop; 51980a708f8fSGustavo F. Padovan } 51990a708f8fSGustavo F. Padovan 5200cec8ab6eSMat Martineau if (!control->sframe) { 5201cec8ab6eSMat Martineau int err; 52020a708f8fSGustavo F. Padovan 5203cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 5204cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 5205cec8ab6eSMat Martineau control->txseq); 5206836be934SAndrei Emeltchenko 5207cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 5208cec8ab6eSMat Martineau * valid in TX WAIT_F 5209cec8ab6eSMat Martineau */ 5210cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 52110a708f8fSGustavo F. Padovan goto drop; 52120a708f8fSGustavo F. Padovan 5213cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 5214cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 5215cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 52160a708f8fSGustavo F. Padovan } else { 5217cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 5218cec8ab6eSMat Martineau } 5219cec8ab6eSMat Martineau 5220cec8ab6eSMat Martineau if (err) 5221cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5222cec8ab6eSMat Martineau ECONNRESET); 5223cec8ab6eSMat Martineau } else { 5224cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 5225cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 5226cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 5227cec8ab6eSMat Martineau }; 5228cec8ab6eSMat Martineau 5229cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 5230cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 5231cec8ab6eSMat Martineau goto drop; 5232cec8ab6eSMat Martineau 5233cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 5234cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 5235cec8ab6eSMat Martineau control->super); 5236cec8ab6eSMat Martineau 52370a708f8fSGustavo F. Padovan if (len != 0) { 52380a708f8fSGustavo F. Padovan BT_ERR("%d", len); 52398c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 52400a708f8fSGustavo F. Padovan goto drop; 52410a708f8fSGustavo F. Padovan } 52420a708f8fSGustavo F. Padovan 5243cec8ab6eSMat Martineau /* Validate F and P bits */ 5244cec8ab6eSMat Martineau if (control->final && (control->poll || 5245cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 5246cec8ab6eSMat Martineau goto drop; 5247cec8ab6eSMat Martineau 5248cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 5249cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 5250cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 52510a708f8fSGustavo F. Padovan } 52520a708f8fSGustavo F. Padovan 52530a708f8fSGustavo F. Padovan return 0; 52540a708f8fSGustavo F. Padovan 52550a708f8fSGustavo F. Padovan drop: 52560a708f8fSGustavo F. Padovan kfree_skb(skb); 52570a708f8fSGustavo F. Padovan return 0; 52580a708f8fSGustavo F. Padovan } 52590a708f8fSGustavo F. Padovan 526013ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 526113ca56e0SAndrei Emeltchenko struct sk_buff *skb) 52620a708f8fSGustavo F. Padovan { 526348454079SGustavo F. Padovan struct l2cap_chan *chan; 52640a708f8fSGustavo F. Padovan 5265baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 526648454079SGustavo F. Padovan if (!chan) { 526797e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 526897e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 526997e8e89dSAndrei Emeltchenko if (!chan) { 527097e8e89dSAndrei Emeltchenko kfree_skb(skb); 527113ca56e0SAndrei Emeltchenko return; 527297e8e89dSAndrei Emeltchenko } 527397e8e89dSAndrei Emeltchenko 527497e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 527597e8e89dSAndrei Emeltchenko } else { 52760a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 52776be36555SAndrei Emeltchenko /* Drop packet and return */ 52783379013bSDan Carpenter kfree_skb(skb); 527913ca56e0SAndrei Emeltchenko return; 52800a708f8fSGustavo F. Padovan } 528197e8e89dSAndrei Emeltchenko } 52820a708f8fSGustavo F. Padovan 528349208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 52840a708f8fSGustavo F. Padovan 528589bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 52860a708f8fSGustavo F. Padovan goto drop; 52870a708f8fSGustavo F. Padovan 52880c1bc5c6SGustavo F. Padovan switch (chan->mode) { 52890a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 52900a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 52910a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 52920a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 52930a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 52940a708f8fSGustavo F. Padovan 52950c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 52960a708f8fSGustavo F. Padovan goto drop; 52970a708f8fSGustavo F. Padovan 529880b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 52990a708f8fSGustavo F. Padovan goto done; 53000a708f8fSGustavo F. Padovan break; 53010a708f8fSGustavo F. Padovan 53020a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 53030a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 5304cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 53050a708f8fSGustavo F. Padovan goto done; 53060a708f8fSGustavo F. Padovan 53070a708f8fSGustavo F. Padovan default: 53080c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 53090a708f8fSGustavo F. Padovan break; 53100a708f8fSGustavo F. Padovan } 53110a708f8fSGustavo F. Padovan 53120a708f8fSGustavo F. Padovan drop: 53130a708f8fSGustavo F. Padovan kfree_skb(skb); 53140a708f8fSGustavo F. Padovan 53150a708f8fSGustavo F. Padovan done: 53166be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 53170a708f8fSGustavo F. Padovan } 53180a708f8fSGustavo F. Padovan 531984104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 532084104b24SAndrei Emeltchenko struct sk_buff *skb) 53210a708f8fSGustavo F. Padovan { 532223691d75SGustavo F. Padovan struct l2cap_chan *chan; 53230a708f8fSGustavo F. Padovan 5324c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 532523691d75SGustavo F. Padovan if (!chan) 53260a708f8fSGustavo F. Padovan goto drop; 53270a708f8fSGustavo F. Padovan 53285b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 53290a708f8fSGustavo F. Padovan 533089bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 53310a708f8fSGustavo F. Padovan goto drop; 53320a708f8fSGustavo F. Padovan 5333e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 53340a708f8fSGustavo F. Padovan goto drop; 53350a708f8fSGustavo F. Padovan 533680b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 533784104b24SAndrei Emeltchenko return; 53380a708f8fSGustavo F. Padovan 53390a708f8fSGustavo F. Padovan drop: 53400a708f8fSGustavo F. Padovan kfree_skb(skb); 53410a708f8fSGustavo F. Padovan } 53420a708f8fSGustavo F. Padovan 53436810fca7SAndrei Emeltchenko static void l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 5344d9b88702SAndrei Emeltchenko struct sk_buff *skb) 53459f69bda6SGustavo F. Padovan { 534623691d75SGustavo F. Padovan struct l2cap_chan *chan; 53479f69bda6SGustavo F. Padovan 5348c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 534923691d75SGustavo F. Padovan if (!chan) 53509f69bda6SGustavo F. Padovan goto drop; 53519f69bda6SGustavo F. Padovan 53525b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 53539f69bda6SGustavo F. Padovan 535489bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 53559f69bda6SGustavo F. Padovan goto drop; 53569f69bda6SGustavo F. Padovan 5357e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 53589f69bda6SGustavo F. Padovan goto drop; 53599f69bda6SGustavo F. Padovan 536080b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 53616810fca7SAndrei Emeltchenko return; 53629f69bda6SGustavo F. Padovan 53639f69bda6SGustavo F. Padovan drop: 53649f69bda6SGustavo F. Padovan kfree_skb(skb); 53659f69bda6SGustavo F. Padovan } 53669f69bda6SGustavo F. Padovan 53670a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 53680a708f8fSGustavo F. Padovan { 53690a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 53700a708f8fSGustavo F. Padovan u16 cid, len; 53710a708f8fSGustavo F. Padovan __le16 psm; 53720a708f8fSGustavo F. Padovan 53730a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 53740a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 53750a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 53760a708f8fSGustavo F. Padovan 53770a708f8fSGustavo F. Padovan if (len != skb->len) { 53780a708f8fSGustavo F. Padovan kfree_skb(skb); 53790a708f8fSGustavo F. Padovan return; 53800a708f8fSGustavo F. Padovan } 53810a708f8fSGustavo F. Padovan 53820a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 53830a708f8fSGustavo F. Padovan 53840a708f8fSGustavo F. Padovan switch (cid) { 53853300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 53860a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 53870a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 53880a708f8fSGustavo F. Padovan break; 53890a708f8fSGustavo F. Padovan 53900a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 5391097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 53920181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 53930a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 53940a708f8fSGustavo F. Padovan break; 53950a708f8fSGustavo F. Padovan 53969f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 53979f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 53989f69bda6SGustavo F. Padovan break; 53999f69bda6SGustavo F. Padovan 5400b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 5401b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 5402b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 5403b501d6a1SAnderson Briglia break; 5404b501d6a1SAnderson Briglia 54050a708f8fSGustavo F. Padovan default: 54060a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 54070a708f8fSGustavo F. Padovan break; 54080a708f8fSGustavo F. Padovan } 54090a708f8fSGustavo F. Padovan } 54100a708f8fSGustavo F. Padovan 54110a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 54120a708f8fSGustavo F. Padovan 5413686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 54140a708f8fSGustavo F. Padovan { 54150a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 541623691d75SGustavo F. Padovan struct l2cap_chan *c; 54170a708f8fSGustavo F. Padovan 54186ed93dc6SAndrei Emeltchenko BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 54190a708f8fSGustavo F. Padovan 54200a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 542123691d75SGustavo F. Padovan read_lock(&chan_list_lock); 542223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 542323691d75SGustavo F. Padovan struct sock *sk = c->sk; 54244343478fSGustavo F. Padovan 542589bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 54260a708f8fSGustavo F. Padovan continue; 54270a708f8fSGustavo F. Padovan 54280a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 54290a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 543043bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 54310a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 54320a708f8fSGustavo F. Padovan exact++; 54330a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 54340a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 543543bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 54360a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 54370a708f8fSGustavo F. Padovan } 54380a708f8fSGustavo F. Padovan } 543923691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 54400a708f8fSGustavo F. Padovan 54410a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 54420a708f8fSGustavo F. Padovan } 54430a708f8fSGustavo F. Padovan 54449e664631SAndrei Emeltchenko void l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 54450a708f8fSGustavo F. Padovan { 54460a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 54470a708f8fSGustavo F. Padovan 54486ed93dc6SAndrei Emeltchenko BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status); 54490a708f8fSGustavo F. Padovan 54500a708f8fSGustavo F. Padovan if (!status) { 54510a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 54520a708f8fSGustavo F. Padovan if (conn) 54530a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 54540a708f8fSGustavo F. Padovan } else 5455e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 54560a708f8fSGustavo F. Padovan 54570a708f8fSGustavo F. Padovan } 54580a708f8fSGustavo F. Padovan 5459686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 54600a708f8fSGustavo F. Padovan { 54610a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 54620a708f8fSGustavo F. Padovan 54630a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 54640a708f8fSGustavo F. Padovan 5465686ebf28SUlisses Furquim if (!conn) 54669f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 54670a708f8fSGustavo F. Padovan return conn->disc_reason; 54680a708f8fSGustavo F. Padovan } 54690a708f8fSGustavo F. Padovan 54709e664631SAndrei Emeltchenko void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 54710a708f8fSGustavo F. Padovan { 54720a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 54730a708f8fSGustavo F. Padovan 5474e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 54750a708f8fSGustavo F. Padovan } 54760a708f8fSGustavo F. Padovan 54774343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 54780a708f8fSGustavo F. Padovan { 5479715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 54800a708f8fSGustavo F. Padovan return; 54810a708f8fSGustavo F. Padovan 54820a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 54834343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 5484ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 54854343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 54860f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 54870a708f8fSGustavo F. Padovan } else { 54884343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 5489c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 54900a708f8fSGustavo F. Padovan } 54910a708f8fSGustavo F. Padovan } 54920a708f8fSGustavo F. Padovan 5493686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 54940a708f8fSGustavo F. Padovan { 54950a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 549648454079SGustavo F. Padovan struct l2cap_chan *chan; 54970a708f8fSGustavo F. Padovan 54980a708f8fSGustavo F. Padovan if (!conn) 54990a708f8fSGustavo F. Padovan return 0; 55000a708f8fSGustavo F. Padovan 550189d8b407SAndrei Emeltchenko BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt); 55020a708f8fSGustavo F. Padovan 5503160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 550435d4adccSHemant Gupta if (!status && encrypt) 5505160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 550617cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 5507160dc6acSVinicius Costa Gomes } 5508160dc6acSVinicius Costa Gomes 55093df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 55100a708f8fSGustavo F. Padovan 55113df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 55126be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 55130a708f8fSGustavo F. Padovan 551489d8b407SAndrei Emeltchenko BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid, 551589d8b407SAndrei Emeltchenko state_to_string(chan->state)); 5516f1cb9af5SVinicius Costa Gomes 551778eb2f98SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 551878eb2f98SAndrei Emeltchenko l2cap_chan_unlock(chan); 551978eb2f98SAndrei Emeltchenko continue; 552078eb2f98SAndrei Emeltchenko } 552178eb2f98SAndrei Emeltchenko 5522f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 5523f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 5524f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 5525cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 5526f1cb9af5SVinicius Costa Gomes } 5527f1cb9af5SVinicius Costa Gomes 55286be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 5529f1cb9af5SVinicius Costa Gomes continue; 5530f1cb9af5SVinicius Costa Gomes } 5531f1cb9af5SVinicius Costa Gomes 5532c1360a1cSGustavo F. Padovan if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 55336be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 55340a708f8fSGustavo F. Padovan continue; 55350a708f8fSGustavo F. Padovan } 55360a708f8fSGustavo F. Padovan 553789bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 553889bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 5539a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 5540a7d7723aSGustavo Padovan 5541c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 5542a7d7723aSGustavo Padovan sk->sk_state_change(sk); 5543a7d7723aSGustavo Padovan 55444343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 55456be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 55460a708f8fSGustavo F. Padovan continue; 55470a708f8fSGustavo F. Padovan } 55480a708f8fSGustavo F. Padovan 554989bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 55500a708f8fSGustavo F. Padovan if (!status) { 555193c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 55520a708f8fSGustavo F. Padovan } else { 5553ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 55540a708f8fSGustavo F. Padovan } 555589bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 55566be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 55570a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5558df3c3931SJohan Hedberg __u16 res, stat; 55590a708f8fSGustavo F. Padovan 55606be36555SAndrei Emeltchenko lock_sock(sk); 55616be36555SAndrei Emeltchenko 55620a708f8fSGustavo F. Padovan if (!status) { 5563c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 5564c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 5565df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 5566df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 55672dc4e510SGustavo Padovan chan->ops->defer(chan); 5568df3c3931SJohan Hedberg } else { 55690e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 5570df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 5571df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 5572df3c3931SJohan Hedberg } 55730a708f8fSGustavo F. Padovan } else { 55740e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 5575ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 5576df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 5577df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 55780a708f8fSGustavo F. Padovan } 55790a708f8fSGustavo F. Padovan 55806be36555SAndrei Emeltchenko release_sock(sk); 55816be36555SAndrei Emeltchenko 5582fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5583fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5584df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 5585df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 5586fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5587fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 55882d369359SMat Martineau 55892d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 55902d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 55912d369359SMat Martineau char buf[128]; 55922d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 55932d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 55942d369359SMat Martineau L2CAP_CONF_REQ, 55952d369359SMat Martineau l2cap_build_conf_req(chan, buf), 55962d369359SMat Martineau buf); 55972d369359SMat Martineau chan->num_conf_req++; 55982d369359SMat Martineau } 55990a708f8fSGustavo F. Padovan } 56000a708f8fSGustavo F. Padovan 56016be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 56020a708f8fSGustavo F. Padovan } 56030a708f8fSGustavo F. Padovan 56043df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 56050a708f8fSGustavo F. Padovan 56060a708f8fSGustavo F. Padovan return 0; 56070a708f8fSGustavo F. Padovan } 56080a708f8fSGustavo F. Padovan 5609686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 56100a708f8fSGustavo F. Padovan { 56110a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 5612d73a0988SAndrei Emeltchenko struct l2cap_hdr *hdr; 5613d73a0988SAndrei Emeltchenko int len; 56140a708f8fSGustavo F. Padovan 56151d13a254SAndrei Emeltchenko /* For AMP controller do not create l2cap conn */ 56161d13a254SAndrei Emeltchenko if (!conn && hcon->hdev->dev_type != HCI_BREDR) 56171d13a254SAndrei Emeltchenko goto drop; 56180a708f8fSGustavo F. Padovan 56190a708f8fSGustavo F. Padovan if (!conn) 56200a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 56210a708f8fSGustavo F. Padovan 56220a708f8fSGustavo F. Padovan if (!conn) 56230a708f8fSGustavo F. Padovan goto drop; 56240a708f8fSGustavo F. Padovan 56250a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 56260a708f8fSGustavo F. Padovan 5627d73a0988SAndrei Emeltchenko switch (flags) { 5628d73a0988SAndrei Emeltchenko case ACL_START: 5629d73a0988SAndrei Emeltchenko case ACL_START_NO_FLUSH: 5630d73a0988SAndrei Emeltchenko case ACL_COMPLETE: 56310a708f8fSGustavo F. Padovan if (conn->rx_len) { 56320a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 56330a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 56340a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 56350a708f8fSGustavo F. Padovan conn->rx_len = 0; 56360a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 56370a708f8fSGustavo F. Padovan } 56380a708f8fSGustavo F. Padovan 56390a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 56400a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 56410a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 56420a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 56430a708f8fSGustavo F. Padovan goto drop; 56440a708f8fSGustavo F. Padovan } 56450a708f8fSGustavo F. Padovan 56460a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 56470a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 56480a708f8fSGustavo F. Padovan 56490a708f8fSGustavo F. Padovan if (len == skb->len) { 56500a708f8fSGustavo F. Padovan /* Complete frame received */ 56510a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 56520a708f8fSGustavo F. Padovan return 0; 56530a708f8fSGustavo F. Padovan } 56540a708f8fSGustavo F. Padovan 56550a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 56560a708f8fSGustavo F. Padovan 56570a708f8fSGustavo F. Padovan if (skb->len > len) { 56580a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 56590a708f8fSGustavo F. Padovan skb->len, len); 56600a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 56610a708f8fSGustavo F. Padovan goto drop; 56620a708f8fSGustavo F. Padovan } 56630a708f8fSGustavo F. Padovan 56640a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 56658bcde1f2SGustavo Padovan conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL); 56660a708f8fSGustavo F. Padovan if (!conn->rx_skb) 56670a708f8fSGustavo F. Padovan goto drop; 56680a708f8fSGustavo F. Padovan 56690a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 56700a708f8fSGustavo F. Padovan skb->len); 56710a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 5672d73a0988SAndrei Emeltchenko break; 5673d73a0988SAndrei Emeltchenko 5674d73a0988SAndrei Emeltchenko case ACL_CONT: 56750a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 56760a708f8fSGustavo F. Padovan 56770a708f8fSGustavo F. Padovan if (!conn->rx_len) { 56780a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 56790a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 56800a708f8fSGustavo F. Padovan goto drop; 56810a708f8fSGustavo F. Padovan } 56820a708f8fSGustavo F. Padovan 56830a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 56840a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 56850a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 56860a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 56870a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 56880a708f8fSGustavo F. Padovan conn->rx_len = 0; 56890a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 56900a708f8fSGustavo F. Padovan goto drop; 56910a708f8fSGustavo F. Padovan } 56920a708f8fSGustavo F. Padovan 56930a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 56940a708f8fSGustavo F. Padovan skb->len); 56950a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 56960a708f8fSGustavo F. Padovan 56970a708f8fSGustavo F. Padovan if (!conn->rx_len) { 56980a708f8fSGustavo F. Padovan /* Complete frame received */ 56990a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 57000a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 57010a708f8fSGustavo F. Padovan } 5702d73a0988SAndrei Emeltchenko break; 57030a708f8fSGustavo F. Padovan } 57040a708f8fSGustavo F. Padovan 57050a708f8fSGustavo F. Padovan drop: 57060a708f8fSGustavo F. Padovan kfree_skb(skb); 57070a708f8fSGustavo F. Padovan return 0; 57080a708f8fSGustavo F. Padovan } 57090a708f8fSGustavo F. Padovan 57100a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 57110a708f8fSGustavo F. Padovan { 571223691d75SGustavo F. Padovan struct l2cap_chan *c; 57130a708f8fSGustavo F. Padovan 5714333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 57150a708f8fSGustavo F. Padovan 571623691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 571723691d75SGustavo F. Padovan struct sock *sk = c->sk; 57180a708f8fSGustavo F. Padovan 5719fcb73338SAndrei Emeltchenko seq_printf(f, "%pMR %pMR %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 5720fcb73338SAndrei Emeltchenko &bt_sk(sk)->src, &bt_sk(sk)->dst, 572189bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 572223691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 572323691d75SGustavo F. Padovan c->sec_level, c->mode); 57240a708f8fSGustavo F. Padovan } 57250a708f8fSGustavo F. Padovan 5726333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 57270a708f8fSGustavo F. Padovan 57280a708f8fSGustavo F. Padovan return 0; 57290a708f8fSGustavo F. Padovan } 57300a708f8fSGustavo F. Padovan 57310a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 57320a708f8fSGustavo F. Padovan { 57330a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 57340a708f8fSGustavo F. Padovan } 57350a708f8fSGustavo F. Padovan 57360a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 57370a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 57380a708f8fSGustavo F. Padovan .read = seq_read, 57390a708f8fSGustavo F. Padovan .llseek = seq_lseek, 57400a708f8fSGustavo F. Padovan .release = single_release, 57410a708f8fSGustavo F. Padovan }; 57420a708f8fSGustavo F. Padovan 57430a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 57440a708f8fSGustavo F. Padovan 574564274518SGustavo F. Padovan int __init l2cap_init(void) 57460a708f8fSGustavo F. Padovan { 57470a708f8fSGustavo F. Padovan int err; 57480a708f8fSGustavo F. Padovan 5749bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 57500a708f8fSGustavo F. Padovan if (err < 0) 57510a708f8fSGustavo F. Padovan return err; 57520a708f8fSGustavo F. Padovan 57530a708f8fSGustavo F. Padovan if (bt_debugfs) { 57542d792818SGustavo Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, bt_debugfs, 57552d792818SGustavo Padovan NULL, &l2cap_debugfs_fops); 57560a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 57570a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 57580a708f8fSGustavo F. Padovan } 57590a708f8fSGustavo F. Padovan 57600a708f8fSGustavo F. Padovan return 0; 57610a708f8fSGustavo F. Padovan } 57620a708f8fSGustavo F. Padovan 576364274518SGustavo F. Padovan void l2cap_exit(void) 57640a708f8fSGustavo F. Padovan { 57650a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 5766bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 57670a708f8fSGustavo F. Padovan } 57680a708f8fSGustavo F. Padovan 57690a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 57700a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 5771