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 103b1a130b7SMat Martineau /* Find channel with given DCID. 104b1a130b7SMat Martineau * Returns locked channel. 105b1a130b7SMat Martineau */ 106b1a130b7SMat Martineau static struct l2cap_chan *l2cap_get_chan_by_dcid(struct l2cap_conn *conn, 107b1a130b7SMat Martineau u16 cid) 108b1a130b7SMat Martineau { 109b1a130b7SMat Martineau struct l2cap_chan *c; 110b1a130b7SMat Martineau 111b1a130b7SMat Martineau mutex_lock(&conn->chan_lock); 112b1a130b7SMat Martineau c = __l2cap_get_chan_by_dcid(conn, cid); 113b1a130b7SMat Martineau if (c) 114b1a130b7SMat Martineau l2cap_chan_lock(c); 115b1a130b7SMat Martineau mutex_unlock(&conn->chan_lock); 116b1a130b7SMat Martineau 117b1a130b7SMat Martineau return c; 118b1a130b7SMat Martineau } 119b1a130b7SMat Martineau 1202d792818SGustavo Padovan static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, 1212d792818SGustavo Padovan u8 ident) 1220a708f8fSGustavo F. Padovan { 1233df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 124baa7e1faSGustavo F. Padovan 1253df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 1263df91ea2SAndrei Emeltchenko if (c->ident == ident) 1273df91ea2SAndrei Emeltchenko return c; 1280a708f8fSGustavo F. Padovan } 1293df91ea2SAndrei Emeltchenko return NULL; 130baa7e1faSGustavo F. Padovan } 1310a708f8fSGustavo F. Padovan 13223691d75SGustavo F. Padovan static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src) 1339e4425ffSGustavo F. Padovan { 13423691d75SGustavo F. Padovan struct l2cap_chan *c; 1359e4425ffSGustavo F. Padovan 13623691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 13723691d75SGustavo F. Padovan if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src)) 13823691d75SGustavo F. Padovan return c; 1399e4425ffSGustavo F. Padovan } 140250938cbSSzymon Janc return NULL; 141250938cbSSzymon Janc } 1429e4425ffSGustavo F. Padovan 1439e4425ffSGustavo F. Padovan int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm) 1449e4425ffSGustavo F. Padovan { 14573b2ec18SGustavo F. Padovan int err; 14673b2ec18SGustavo F. Padovan 147333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1489e4425ffSGustavo F. Padovan 14923691d75SGustavo F. Padovan if (psm && __l2cap_global_chan_by_addr(psm, src)) { 15073b2ec18SGustavo F. Padovan err = -EADDRINUSE; 15173b2ec18SGustavo F. Padovan goto done; 1529e4425ffSGustavo F. Padovan } 1539e4425ffSGustavo F. Padovan 15473b2ec18SGustavo F. Padovan if (psm) { 1559e4425ffSGustavo F. Padovan chan->psm = psm; 1569e4425ffSGustavo F. Padovan chan->sport = psm; 15773b2ec18SGustavo F. Padovan err = 0; 15873b2ec18SGustavo F. Padovan } else { 15973b2ec18SGustavo F. Padovan u16 p; 1609e4425ffSGustavo F. Padovan 16173b2ec18SGustavo F. Padovan err = -EINVAL; 16273b2ec18SGustavo F. Padovan for (p = 0x1001; p < 0x1100; p += 2) 16323691d75SGustavo F. Padovan if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) { 16473b2ec18SGustavo F. Padovan chan->psm = cpu_to_le16(p); 16573b2ec18SGustavo F. Padovan chan->sport = cpu_to_le16(p); 16673b2ec18SGustavo F. Padovan err = 0; 16773b2ec18SGustavo F. Padovan break; 16873b2ec18SGustavo F. Padovan } 16973b2ec18SGustavo F. Padovan } 17073b2ec18SGustavo F. Padovan 17173b2ec18SGustavo F. Padovan done: 172333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 17373b2ec18SGustavo F. Padovan return err; 1749e4425ffSGustavo F. Padovan } 1759e4425ffSGustavo F. Padovan 1769e4425ffSGustavo F. Padovan int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid) 1779e4425ffSGustavo F. Padovan { 178333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1799e4425ffSGustavo F. Padovan 1809e4425ffSGustavo F. Padovan chan->scid = scid; 1819e4425ffSGustavo F. Padovan 182333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 1839e4425ffSGustavo F. Padovan 1849e4425ffSGustavo F. Padovan return 0; 1859e4425ffSGustavo F. Padovan } 1869e4425ffSGustavo F. Padovan 187baa7e1faSGustavo F. Padovan static u16 l2cap_alloc_cid(struct l2cap_conn *conn) 1880a708f8fSGustavo F. Padovan { 1890a708f8fSGustavo F. Padovan u16 cid = L2CAP_CID_DYN_START; 1900a708f8fSGustavo F. Padovan 1910a708f8fSGustavo F. Padovan for (; cid < L2CAP_CID_DYN_END; cid++) { 192baa7e1faSGustavo F. Padovan if (!__l2cap_get_chan_by_scid(conn, cid)) 1930a708f8fSGustavo F. Padovan return cid; 1940a708f8fSGustavo F. Padovan } 1950a708f8fSGustavo F. Padovan 1960a708f8fSGustavo F. Padovan return 0; 1970a708f8fSGustavo F. Padovan } 1980a708f8fSGustavo F. Padovan 1990e587be7SAndrei Emeltchenko static void __l2cap_state_change(struct l2cap_chan *chan, int state) 20089bc500eSGustavo F. Padovan { 20142d2d87cSAndrei Emeltchenko BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state), 202badaaa00SGustavo F. Padovan state_to_string(state)); 203badaaa00SGustavo F. Padovan 20489bc500eSGustavo F. Padovan chan->state = state; 20580b98027SGustavo Padovan chan->ops->state_change(chan, state); 20689bc500eSGustavo F. Padovan } 20789bc500eSGustavo F. Padovan 2080e587be7SAndrei Emeltchenko static void l2cap_state_change(struct l2cap_chan *chan, int state) 2090e587be7SAndrei Emeltchenko { 2100e587be7SAndrei Emeltchenko struct sock *sk = chan->sk; 2110e587be7SAndrei Emeltchenko 2120e587be7SAndrei Emeltchenko lock_sock(sk); 2130e587be7SAndrei Emeltchenko __l2cap_state_change(chan, state); 2140e587be7SAndrei Emeltchenko release_sock(sk); 2150e587be7SAndrei Emeltchenko } 2160e587be7SAndrei Emeltchenko 2172e0052e4SAndrei Emeltchenko static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2182e0052e4SAndrei Emeltchenko { 2192e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2202e0052e4SAndrei Emeltchenko 2212e0052e4SAndrei Emeltchenko sk->sk_err = err; 2222e0052e4SAndrei Emeltchenko } 2232e0052e4SAndrei Emeltchenko 2242e0052e4SAndrei Emeltchenko static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2252e0052e4SAndrei Emeltchenko { 2262e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2272e0052e4SAndrei Emeltchenko 2282e0052e4SAndrei Emeltchenko lock_sock(sk); 2292e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 2302e0052e4SAndrei Emeltchenko release_sock(sk); 2312e0052e4SAndrei Emeltchenko } 2322e0052e4SAndrei Emeltchenko 2334239d16fSMat Martineau static void __set_retrans_timer(struct l2cap_chan *chan) 2344239d16fSMat Martineau { 2354239d16fSMat Martineau if (!delayed_work_pending(&chan->monitor_timer) && 2364239d16fSMat Martineau chan->retrans_timeout) { 2374239d16fSMat Martineau l2cap_set_timer(chan, &chan->retrans_timer, 2384239d16fSMat Martineau msecs_to_jiffies(chan->retrans_timeout)); 2394239d16fSMat Martineau } 2404239d16fSMat Martineau } 2414239d16fSMat Martineau 2424239d16fSMat Martineau static void __set_monitor_timer(struct l2cap_chan *chan) 2434239d16fSMat Martineau { 2444239d16fSMat Martineau __clear_retrans_timer(chan); 2454239d16fSMat Martineau if (chan->monitor_timeout) { 2464239d16fSMat Martineau l2cap_set_timer(chan, &chan->monitor_timer, 2474239d16fSMat Martineau msecs_to_jiffies(chan->monitor_timeout)); 2484239d16fSMat Martineau } 2494239d16fSMat Martineau } 2504239d16fSMat Martineau 251608bcc6dSMat Martineau static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head, 252608bcc6dSMat Martineau u16 seq) 253608bcc6dSMat Martineau { 254608bcc6dSMat Martineau struct sk_buff *skb; 255608bcc6dSMat Martineau 256608bcc6dSMat Martineau skb_queue_walk(head, skb) { 257608bcc6dSMat Martineau if (bt_cb(skb)->control.txseq == seq) 258608bcc6dSMat Martineau return skb; 259608bcc6dSMat Martineau } 260608bcc6dSMat Martineau 261608bcc6dSMat Martineau return NULL; 262608bcc6dSMat Martineau } 263608bcc6dSMat Martineau 2643c588192SMat Martineau /* ---- L2CAP sequence number lists ---- */ 2653c588192SMat Martineau 2663c588192SMat Martineau /* For ERTM, ordered lists of sequence numbers must be tracked for 2673c588192SMat Martineau * SREJ requests that are received and for frames that are to be 2683c588192SMat Martineau * retransmitted. These seq_list functions implement a singly-linked 2693c588192SMat Martineau * list in an array, where membership in the list can also be checked 2703c588192SMat Martineau * in constant time. Items can also be added to the tail of the list 2713c588192SMat Martineau * and removed from the head in constant time, without further memory 2723c588192SMat Martineau * allocs or frees. 2733c588192SMat Martineau */ 2743c588192SMat Martineau 2753c588192SMat Martineau static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) 2763c588192SMat Martineau { 2773c588192SMat Martineau size_t alloc_size, i; 2783c588192SMat Martineau 2793c588192SMat Martineau /* Allocated size is a power of 2 to map sequence numbers 2803c588192SMat Martineau * (which may be up to 14 bits) in to a smaller array that is 2813c588192SMat Martineau * sized for the negotiated ERTM transmit windows. 2823c588192SMat Martineau */ 2833c588192SMat Martineau alloc_size = roundup_pow_of_two(size); 2843c588192SMat Martineau 2853c588192SMat Martineau seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); 2863c588192SMat Martineau if (!seq_list->list) 2873c588192SMat Martineau return -ENOMEM; 2883c588192SMat Martineau 2893c588192SMat Martineau seq_list->mask = alloc_size - 1; 2903c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 2913c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 2923c588192SMat Martineau for (i = 0; i < alloc_size; i++) 2933c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 2943c588192SMat Martineau 2953c588192SMat Martineau return 0; 2963c588192SMat Martineau } 2973c588192SMat Martineau 2983c588192SMat Martineau static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list) 2993c588192SMat Martineau { 3003c588192SMat Martineau kfree(seq_list->list); 3013c588192SMat Martineau } 3023c588192SMat Martineau 3033c588192SMat Martineau static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list, 3043c588192SMat Martineau u16 seq) 3053c588192SMat Martineau { 3063c588192SMat Martineau /* Constant-time check for list membership */ 3073c588192SMat Martineau return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR; 3083c588192SMat Martineau } 3093c588192SMat Martineau 3103c588192SMat Martineau static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq) 3113c588192SMat Martineau { 3123c588192SMat Martineau u16 mask = seq_list->mask; 3133c588192SMat Martineau 3143c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) { 3153c588192SMat Martineau /* In case someone tries to pop the head of an empty list */ 3163c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3173c588192SMat Martineau } else if (seq_list->head == seq) { 3183c588192SMat Martineau /* Head can be removed in constant time */ 3193c588192SMat Martineau seq_list->head = seq_list->list[seq & mask]; 3203c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3213c588192SMat Martineau 3223c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_TAIL) { 3233c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3243c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3253c588192SMat Martineau } 3263c588192SMat Martineau } else { 3273c588192SMat Martineau /* Walk the list to find the sequence number */ 3283c588192SMat Martineau u16 prev = seq_list->head; 3293c588192SMat Martineau while (seq_list->list[prev & mask] != seq) { 3303c588192SMat Martineau prev = seq_list->list[prev & mask]; 3313c588192SMat Martineau if (prev == L2CAP_SEQ_LIST_TAIL) 3323c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3333c588192SMat Martineau } 3343c588192SMat Martineau 3353c588192SMat Martineau /* Unlink the number from the list and clear it */ 3363c588192SMat Martineau seq_list->list[prev & mask] = seq_list->list[seq & mask]; 3373c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3383c588192SMat Martineau if (seq_list->tail == seq) 3393c588192SMat Martineau seq_list->tail = prev; 3403c588192SMat Martineau } 3413c588192SMat Martineau return seq; 3423c588192SMat Martineau } 3433c588192SMat Martineau 3443c588192SMat Martineau static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list) 3453c588192SMat Martineau { 3463c588192SMat Martineau /* Remove the head in constant time */ 3473c588192SMat Martineau return l2cap_seq_list_remove(seq_list, seq_list->head); 3483c588192SMat Martineau } 3493c588192SMat Martineau 3503c588192SMat Martineau static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list) 3513c588192SMat Martineau { 3523c588192SMat Martineau u16 i; 353f522ae36SGustavo Padovan 354f522ae36SGustavo Padovan if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) 355f522ae36SGustavo Padovan return; 356f522ae36SGustavo Padovan 3573c588192SMat Martineau for (i = 0; i <= seq_list->mask; i++) 3583c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3593c588192SMat Martineau 3603c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3613c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3623c588192SMat Martineau } 3633c588192SMat Martineau 3643c588192SMat Martineau static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq) 3653c588192SMat Martineau { 3663c588192SMat Martineau u16 mask = seq_list->mask; 3673c588192SMat Martineau 3683c588192SMat Martineau /* All appends happen in constant time */ 3693c588192SMat Martineau 370f522ae36SGustavo Padovan if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR) 371f522ae36SGustavo Padovan return; 372f522ae36SGustavo Padovan 3733c588192SMat Martineau if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR) 3743c588192SMat Martineau seq_list->head = seq; 3753c588192SMat Martineau else 3763c588192SMat Martineau seq_list->list[seq_list->tail & mask] = seq; 3773c588192SMat Martineau 3783c588192SMat Martineau seq_list->tail = seq; 3793c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL; 3803c588192SMat Martineau } 3813c588192SMat Martineau 382721c4181SGustavo F. Padovan static void l2cap_chan_timeout(struct work_struct *work) 383ab07801dSGustavo F. Padovan { 384721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 385721c4181SGustavo F. Padovan chan_timer.work); 3863df91ea2SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 387ab07801dSGustavo F. Padovan int reason; 388ab07801dSGustavo F. Padovan 389e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s", chan, state_to_string(chan->state)); 390ab07801dSGustavo F. Padovan 3913df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3926be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 393ab07801dSGustavo F. Padovan 39489bc500eSGustavo F. Padovan if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG) 395ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 39689bc500eSGustavo F. Padovan else if (chan->state == BT_CONNECT && 397ab07801dSGustavo F. Padovan chan->sec_level != BT_SECURITY_SDP) 398ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 399ab07801dSGustavo F. Padovan else 400ab07801dSGustavo F. Padovan reason = ETIMEDOUT; 401ab07801dSGustavo F. Padovan 4020f852724SGustavo F. Padovan l2cap_chan_close(chan, reason); 403ab07801dSGustavo F. Padovan 4046be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 405ab07801dSGustavo F. Padovan 40680b98027SGustavo Padovan chan->ops->close(chan); 4073df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 4083df91ea2SAndrei Emeltchenko 409371fd835SUlisses Furquim l2cap_chan_put(chan); 410ab07801dSGustavo F. Padovan } 411ab07801dSGustavo F. Padovan 412eef1d9b6SGustavo Padovan struct l2cap_chan *l2cap_chan_create(void) 4130a708f8fSGustavo F. Padovan { 41448454079SGustavo F. Padovan struct l2cap_chan *chan; 4150a708f8fSGustavo F. Padovan 41648454079SGustavo F. Padovan chan = kzalloc(sizeof(*chan), GFP_ATOMIC); 41748454079SGustavo F. Padovan if (!chan) 41848454079SGustavo F. Padovan return NULL; 4190a708f8fSGustavo F. Padovan 420c03b355eSAndrei Emeltchenko mutex_init(&chan->lock); 421c03b355eSAndrei Emeltchenko 422333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 42323691d75SGustavo F. Padovan list_add(&chan->global_l, &chan_list); 424333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 42523691d75SGustavo F. Padovan 426721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout); 427ab07801dSGustavo F. Padovan 42889bc500eSGustavo F. Padovan chan->state = BT_OPEN; 42989bc500eSGustavo F. Padovan 430144ad330SSyam Sidhardhan kref_init(&chan->kref); 43171ba0e56SGustavo F. Padovan 4322827011fSMat Martineau /* This flag is cleared in l2cap_chan_ready() */ 4332827011fSMat Martineau set_bit(CONF_NOT_COMPLETE, &chan->conf_state); 4342827011fSMat Martineau 435eef1d9b6SGustavo Padovan BT_DBG("chan %p", chan); 436abc545b8SSzymon Janc 43748454079SGustavo F. Padovan return chan; 4380a708f8fSGustavo F. Padovan } 4390a708f8fSGustavo F. Padovan 440144ad330SSyam Sidhardhan static void l2cap_chan_destroy(struct kref *kref) 4416ff5abbfSGustavo F. Padovan { 442144ad330SSyam Sidhardhan struct l2cap_chan *chan = container_of(kref, struct l2cap_chan, kref); 443144ad330SSyam Sidhardhan 4444af66c69SJaganath Kanakkassery BT_DBG("chan %p", chan); 4454af66c69SJaganath Kanakkassery 446333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 44723691d75SGustavo F. Padovan list_del(&chan->global_l); 448333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 44923691d75SGustavo F. Padovan 4504af66c69SJaganath Kanakkassery kfree(chan); 4516ff5abbfSGustavo F. Padovan } 4526ff5abbfSGustavo F. Padovan 45330648372SJaganath Kanakkassery void l2cap_chan_hold(struct l2cap_chan *c) 45430648372SJaganath Kanakkassery { 455144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 45630648372SJaganath Kanakkassery 457144ad330SSyam Sidhardhan kref_get(&c->kref); 45830648372SJaganath Kanakkassery } 45930648372SJaganath Kanakkassery 46030648372SJaganath Kanakkassery void l2cap_chan_put(struct l2cap_chan *c) 46130648372SJaganath Kanakkassery { 462144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 46330648372SJaganath Kanakkassery 464144ad330SSyam Sidhardhan kref_put(&c->kref, l2cap_chan_destroy); 46530648372SJaganath Kanakkassery } 46630648372SJaganath Kanakkassery 467bd4b1653SAndrei Emeltchenko void l2cap_chan_set_defaults(struct l2cap_chan *chan) 468bd4b1653SAndrei Emeltchenko { 469bd4b1653SAndrei Emeltchenko chan->fcs = L2CAP_FCS_CRC16; 470bd4b1653SAndrei Emeltchenko chan->max_tx = L2CAP_DEFAULT_MAX_TX; 471bd4b1653SAndrei Emeltchenko chan->tx_win = L2CAP_DEFAULT_TX_WINDOW; 472bd4b1653SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 473c20f8e35SMat Martineau chan->ack_win = L2CAP_DEFAULT_TX_WINDOW; 474bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 475bd4b1653SAndrei Emeltchenko 476bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 477bd4b1653SAndrei Emeltchenko } 478bd4b1653SAndrei Emeltchenko 47993c3e8f5SAndrei Emeltchenko void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4800a708f8fSGustavo F. Padovan { 4810a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 482097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4830a708f8fSGustavo F. Padovan 4849f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 4850a708f8fSGustavo F. Padovan 4868c1d787bSGustavo F. Padovan chan->conn = conn; 4870a708f8fSGustavo F. Padovan 4885491120eSAndrei Emeltchenko switch (chan->chan_type) { 4895491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 490b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 491b62f328bSVille Tervo /* LE connection */ 4926fcb06a2SAndre Guedes chan->omtu = L2CAP_DEFAULT_MTU; 493fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 494fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 495b62f328bSVille Tervo } else { 4960a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 497fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 4980c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 499b62f328bSVille Tervo } 5005491120eSAndrei Emeltchenko break; 5015491120eSAndrei Emeltchenko 5025491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 5030a708f8fSGustavo F. Padovan /* Connectionless socket */ 504fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 505fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 5060c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5075491120eSAndrei Emeltchenko break; 5085491120eSAndrei Emeltchenko 509416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 510416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 511416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 512416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 513416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 514416fa752SAndrei Emeltchenko break; 515416fa752SAndrei Emeltchenko 5165491120eSAndrei Emeltchenko default: 5170a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 518fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 519fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 5200c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5210a708f8fSGustavo F. Padovan } 5220a708f8fSGustavo F. Padovan 5238f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 5248f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 5258f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 5268f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 5278f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 5288936fa6dSAndrei Emeltchenko chan->local_flush_to = L2CAP_EFS_DEFAULT_FLUSH_TO; 5298f7975b1SAndrei Emeltchenko 530371fd835SUlisses Furquim l2cap_chan_hold(chan); 531baa7e1faSGustavo F. Padovan 5323df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 533643162a8SAndrei Emeltchenko } 534643162a8SAndrei Emeltchenko 535466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 536643162a8SAndrei Emeltchenko { 537643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 538643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 5393df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5400a708f8fSGustavo F. Padovan } 5410a708f8fSGustavo F. Padovan 542466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5430a708f8fSGustavo F. Padovan { 5448c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5450a708f8fSGustavo F. Padovan 546c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5470a708f8fSGustavo F. Padovan 54849208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5490a708f8fSGustavo F. Padovan 5500a708f8fSGustavo F. Padovan if (conn) { 55156f60984SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 552baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5533df91ea2SAndrei Emeltchenko list_del(&chan->list); 5543d57dc68SGustavo F. Padovan 555371fd835SUlisses Furquim l2cap_chan_put(chan); 556baa7e1faSGustavo F. Padovan 5578c1d787bSGustavo F. Padovan chan->conn = NULL; 5583cabbfdaSAndrei Emeltchenko 5593cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 5600a708f8fSGustavo F. Padovan hci_conn_put(conn->hcon); 56156f60984SAndrei Emeltchenko 56256f60984SAndrei Emeltchenko if (mgr && mgr->bredr_chan == chan) 56356f60984SAndrei Emeltchenko mgr->bredr_chan = NULL; 5640a708f8fSGustavo F. Padovan } 5650a708f8fSGustavo F. Padovan 566c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5676be36555SAndrei Emeltchenko 5682827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5696ff5abbfSGustavo F. Padovan return; 5702ead70b8SGustavo F. Padovan 571ee556f66SGustavo Padovan switch(chan->mode) { 572ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 573ee556f66SGustavo Padovan break; 5740a708f8fSGustavo F. Padovan 575ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5761a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5771a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5781a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 5790a708f8fSGustavo F. Padovan 580f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 5810a708f8fSGustavo F. Padovan 5823c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 5833c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 584ee556f66SGustavo Padovan 585ee556f66SGustavo Padovan /* fall through */ 586ee556f66SGustavo Padovan 587ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 588ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 589ee556f66SGustavo Padovan break; 5900a708f8fSGustavo F. Padovan } 591ee556f66SGustavo Padovan 592ee556f66SGustavo Padovan return; 5930a708f8fSGustavo F. Padovan } 5940a708f8fSGustavo F. Padovan 5950f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 5964519de9aSGustavo F. Padovan { 5974519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5984519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 5994519de9aSGustavo F. Padovan 6002d792818SGustavo Padovan BT_DBG("chan %p state %s sk %p", chan, state_to_string(chan->state), 6012d792818SGustavo Padovan sk); 6024519de9aSGustavo F. Padovan 60389bc500eSGustavo F. Padovan switch (chan->state) { 6044519de9aSGustavo F. Padovan case BT_LISTEN: 605c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6064519de9aSGustavo F. Padovan break; 6074519de9aSGustavo F. Padovan 6084519de9aSGustavo F. Padovan case BT_CONNECTED: 6094519de9aSGustavo F. Padovan case BT_CONFIG: 610715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6114519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 612c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 6134519de9aSGustavo F. Padovan l2cap_send_disconn_req(conn, chan, reason); 6144519de9aSGustavo F. Padovan } else 6154519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6164519de9aSGustavo F. Padovan break; 6174519de9aSGustavo F. Padovan 6184519de9aSGustavo F. Padovan case BT_CONNECT2: 619715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6204519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 6214519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6224519de9aSGustavo F. Padovan __u16 result; 6234519de9aSGustavo F. Padovan 624c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 6254519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 6264519de9aSGustavo F. Padovan else 6274519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 62889bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 6294519de9aSGustavo F. Padovan 6304519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6314519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6324519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 633ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 6344519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6354519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 6364519de9aSGustavo F. Padovan } 6374519de9aSGustavo F. Padovan 6384519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6394519de9aSGustavo F. Padovan break; 6404519de9aSGustavo F. Padovan 6414519de9aSGustavo F. Padovan case BT_CONNECT: 6424519de9aSGustavo F. Padovan case BT_DISCONN: 6434519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6444519de9aSGustavo F. Padovan break; 6454519de9aSGustavo F. Padovan 6464519de9aSGustavo F. Padovan default: 647c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6484519de9aSGustavo F. Padovan break; 6494519de9aSGustavo F. Padovan } 6504519de9aSGustavo F. Padovan } 6514519de9aSGustavo F. Padovan 6524343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6530a708f8fSGustavo F. Padovan { 654715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6554343478fSGustavo F. Padovan switch (chan->sec_level) { 6560a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6570a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6580a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6590a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6600a708f8fSGustavo F. Padovan default: 6610a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6620a708f8fSGustavo F. Padovan } 6632983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6644343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6654343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6660a708f8fSGustavo F. Padovan 6674343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6680a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6690a708f8fSGustavo F. Padovan else 6700a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6710a708f8fSGustavo F. Padovan } else { 6724343478fSGustavo F. Padovan switch (chan->sec_level) { 6730a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6740a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6750a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6760a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6770a708f8fSGustavo F. Padovan default: 6780a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6790a708f8fSGustavo F. Padovan } 6800a708f8fSGustavo F. Padovan } 6810a708f8fSGustavo F. Padovan } 6820a708f8fSGustavo F. Padovan 6830a708f8fSGustavo F. Padovan /* Service level security */ 684d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 6850a708f8fSGustavo F. Padovan { 6868c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6870a708f8fSGustavo F. Padovan __u8 auth_type; 6880a708f8fSGustavo F. Padovan 6894343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 6900a708f8fSGustavo F. Padovan 6914343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 6920a708f8fSGustavo F. Padovan } 6930a708f8fSGustavo F. Padovan 694b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 6950a708f8fSGustavo F. Padovan { 6960a708f8fSGustavo F. Padovan u8 id; 6970a708f8fSGustavo F. Padovan 6980a708f8fSGustavo F. Padovan /* Get next available identificator. 6990a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 7000a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 7010a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 7020a708f8fSGustavo F. Padovan */ 7030a708f8fSGustavo F. Padovan 704333055f2SGustavo F. Padovan spin_lock(&conn->lock); 7050a708f8fSGustavo F. Padovan 7060a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 7070a708f8fSGustavo F. Padovan conn->tx_ident = 1; 7080a708f8fSGustavo F. Padovan 7090a708f8fSGustavo F. Padovan id = conn->tx_ident; 7100a708f8fSGustavo F. Padovan 711333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 7120a708f8fSGustavo F. Padovan 7130a708f8fSGustavo F. Padovan return id; 7140a708f8fSGustavo F. Padovan } 7150a708f8fSGustavo F. Padovan 7162d792818SGustavo Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 7172d792818SGustavo Padovan void *data) 7180a708f8fSGustavo F. Padovan { 7190a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 7200a708f8fSGustavo F. Padovan u8 flags; 7210a708f8fSGustavo F. Padovan 7220a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 7230a708f8fSGustavo F. Padovan 7240a708f8fSGustavo F. Padovan if (!skb) 7250a708f8fSGustavo F. Padovan return; 7260a708f8fSGustavo F. Padovan 7270a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 7280a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 7290a708f8fSGustavo F. Padovan else 7300a708f8fSGustavo F. Padovan flags = ACL_START; 7310a708f8fSGustavo F. Padovan 73214b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 7335e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 73414b12d0bSJaikumar Ganesh 73573d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 7360a708f8fSGustavo F. Padovan } 7370a708f8fSGustavo F. Padovan 73802b0fbb9SMat Martineau static bool __chan_is_moving(struct l2cap_chan *chan) 73902b0fbb9SMat Martineau { 74002b0fbb9SMat Martineau return chan->move_state != L2CAP_MOVE_STABLE && 74102b0fbb9SMat Martineau chan->move_state != L2CAP_MOVE_WAIT_PREPARE; 74202b0fbb9SMat Martineau } 74302b0fbb9SMat Martineau 74473d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 74573d80debSLuiz Augusto von Dentz { 74673d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 74773d80debSLuiz Augusto von Dentz u16 flags; 74873d80debSLuiz Augusto von Dentz 74973d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 75073d80debSLuiz Augusto von Dentz skb->priority); 75173d80debSLuiz Augusto von Dentz 75273d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 75373d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 75473d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 75573d80debSLuiz Augusto von Dentz else 75673d80debSLuiz Augusto von Dentz flags = ACL_START; 75773d80debSLuiz Augusto von Dentz 75873d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 75973d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7600a708f8fSGustavo F. Padovan } 7610a708f8fSGustavo F. Padovan 762b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 763b5c6aaedSMat Martineau { 764b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 765b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 766b5c6aaedSMat Martineau 767b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 768b5c6aaedSMat Martineau /* S-Frame */ 769b5c6aaedSMat Martineau control->sframe = 1; 770b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 771b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 772b5c6aaedSMat Martineau 773b5c6aaedSMat Martineau control->sar = 0; 774b5c6aaedSMat Martineau control->txseq = 0; 775b5c6aaedSMat Martineau } else { 776b5c6aaedSMat Martineau /* I-Frame */ 777b5c6aaedSMat Martineau control->sframe = 0; 778b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 779b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 780b5c6aaedSMat Martineau 781b5c6aaedSMat Martineau control->poll = 0; 782b5c6aaedSMat Martineau control->super = 0; 783b5c6aaedSMat Martineau } 784b5c6aaedSMat Martineau } 785b5c6aaedSMat Martineau 786b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 787b5c6aaedSMat Martineau { 788b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 789b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 790b5c6aaedSMat Martineau 791b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 792b5c6aaedSMat Martineau /* S-Frame */ 793b5c6aaedSMat Martineau control->sframe = 1; 794b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 795b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 796b5c6aaedSMat Martineau 797b5c6aaedSMat Martineau control->sar = 0; 798b5c6aaedSMat Martineau control->txseq = 0; 799b5c6aaedSMat Martineau } else { 800b5c6aaedSMat Martineau /* I-Frame */ 801b5c6aaedSMat Martineau control->sframe = 0; 802b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 803b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 804b5c6aaedSMat Martineau 805b5c6aaedSMat Martineau control->poll = 0; 806b5c6aaedSMat Martineau control->super = 0; 807b5c6aaedSMat Martineau } 808b5c6aaedSMat Martineau } 809b5c6aaedSMat Martineau 810b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 811b5c6aaedSMat Martineau struct sk_buff *skb) 812b5c6aaedSMat Martineau { 813b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 814b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 815b5c6aaedSMat Martineau &bt_cb(skb)->control); 816cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 817b5c6aaedSMat Martineau } else { 818b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 819b5c6aaedSMat Martineau &bt_cb(skb)->control); 820cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 821b5c6aaedSMat Martineau } 822b5c6aaedSMat Martineau } 823b5c6aaedSMat Martineau 824b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 825b5c6aaedSMat Martineau { 826b5c6aaedSMat Martineau u32 packed; 827b5c6aaedSMat Martineau 828b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 829b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 830b5c6aaedSMat Martineau 831b5c6aaedSMat Martineau if (control->sframe) { 832b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 833b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 834b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 835b5c6aaedSMat Martineau } else { 836b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 837b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 838b5c6aaedSMat Martineau } 839b5c6aaedSMat Martineau 840b5c6aaedSMat Martineau return packed; 841b5c6aaedSMat Martineau } 842b5c6aaedSMat Martineau 843b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 844b5c6aaedSMat Martineau { 845b5c6aaedSMat Martineau u16 packed; 846b5c6aaedSMat Martineau 847b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 848b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 849b5c6aaedSMat Martineau 850b5c6aaedSMat Martineau if (control->sframe) { 851b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 852b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 853b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 854b5c6aaedSMat Martineau } else { 855b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 856b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 857b5c6aaedSMat Martineau } 858b5c6aaedSMat Martineau 859b5c6aaedSMat Martineau return packed; 860b5c6aaedSMat Martineau } 861b5c6aaedSMat Martineau 862b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 863b5c6aaedSMat Martineau struct l2cap_ctrl *control, 864b5c6aaedSMat Martineau struct sk_buff *skb) 865b5c6aaedSMat Martineau { 866b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 867b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 868b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 869b5c6aaedSMat Martineau } else { 870b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 871b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 872b5c6aaedSMat Martineau } 873b5c6aaedSMat Martineau } 874b5c6aaedSMat Martineau 875ba7aa64fSGustavo Padovan static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan) 876ba7aa64fSGustavo Padovan { 877ba7aa64fSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 878ba7aa64fSGustavo Padovan return L2CAP_EXT_HDR_SIZE; 879ba7aa64fSGustavo Padovan else 880ba7aa64fSGustavo Padovan return L2CAP_ENH_HDR_SIZE; 881ba7aa64fSGustavo Padovan } 882ba7aa64fSGustavo Padovan 883a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 884a67d7f6fSMat Martineau u32 control) 8850a708f8fSGustavo F. Padovan { 8860a708f8fSGustavo F. Padovan struct sk_buff *skb; 8870a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 888ba7aa64fSGustavo Padovan int hlen = __ertm_hdr_size(chan); 8890a708f8fSGustavo F. Padovan 8900a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 89103a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 8920a708f8fSGustavo F. Padovan 893a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 8940a708f8fSGustavo F. Padovan 8950a708f8fSGustavo F. Padovan if (!skb) 896a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 8970a708f8fSGustavo F. Padovan 8980a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 8990a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 900fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 90188843ab0SAndrei Emeltchenko 902a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 903a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 904a67d7f6fSMat Martineau else 905a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 9060a708f8fSGustavo F. Padovan 90747d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 908a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 90903a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 9100a708f8fSGustavo F. Padovan } 9110a708f8fSGustavo F. Padovan 91273d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 913a67d7f6fSMat Martineau return skb; 914a67d7f6fSMat Martineau } 915a67d7f6fSMat Martineau 916a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 917a67d7f6fSMat Martineau struct l2cap_ctrl *control) 918a67d7f6fSMat Martineau { 919a67d7f6fSMat Martineau struct sk_buff *skb; 920a67d7f6fSMat Martineau u32 control_field; 921a67d7f6fSMat Martineau 922a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 923a67d7f6fSMat Martineau 924a67d7f6fSMat Martineau if (!control->sframe) 925a67d7f6fSMat Martineau return; 926a67d7f6fSMat Martineau 927a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 928a67d7f6fSMat Martineau !control->poll) 929a67d7f6fSMat Martineau control->final = 1; 930a67d7f6fSMat Martineau 931a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 932a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 933a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 934a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 935a67d7f6fSMat Martineau 936a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 937a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 938a67d7f6fSMat Martineau __clear_ack_timer(chan); 939a67d7f6fSMat Martineau } 940a67d7f6fSMat Martineau 941a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 942a67d7f6fSMat Martineau control->final, control->poll, control->super); 943a67d7f6fSMat Martineau 944a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 945a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 946a67d7f6fSMat Martineau else 947a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 948a67d7f6fSMat Martineau 949a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 950a67d7f6fSMat Martineau if (!IS_ERR(skb)) 95173d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9520a708f8fSGustavo F. Padovan } 9530a708f8fSGustavo F. Padovan 954c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9550a708f8fSGustavo F. Padovan { 956c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9570a708f8fSGustavo F. Padovan 958c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 959c9e3d5e0SMat Martineau 960c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 961c9e3d5e0SMat Martineau control.sframe = 1; 962c9e3d5e0SMat Martineau control.poll = poll; 963c9e3d5e0SMat Martineau 964c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 965c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 966c9e3d5e0SMat Martineau else 967c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 968c9e3d5e0SMat Martineau 969c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 970c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 9710a708f8fSGustavo F. Padovan } 9720a708f8fSGustavo F. Padovan 973b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 9740a708f8fSGustavo F. Padovan { 975c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 9760a708f8fSGustavo F. Padovan } 9770a708f8fSGustavo F. Padovan 97893c3e8f5SAndrei Emeltchenko static bool __amp_capable(struct l2cap_chan *chan) 97993c3e8f5SAndrei Emeltchenko { 98093c3e8f5SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 98193c3e8f5SAndrei Emeltchenko 98293c3e8f5SAndrei Emeltchenko if (enable_hs && 98393c3e8f5SAndrei Emeltchenko chan->chan_policy == BT_CHANNEL_POLICY_AMP_PREFERRED && 98493c3e8f5SAndrei Emeltchenko conn->fixed_chan_mask & L2CAP_FC_A2MP) 98593c3e8f5SAndrei Emeltchenko return true; 98693c3e8f5SAndrei Emeltchenko else 98793c3e8f5SAndrei Emeltchenko return false; 98893c3e8f5SAndrei Emeltchenko } 98993c3e8f5SAndrei Emeltchenko 9902766be48SAndrei Emeltchenko void l2cap_send_conn_req(struct l2cap_chan *chan) 9919b27f350SAndrei Emeltchenko { 9929b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 9939b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 9949b27f350SAndrei Emeltchenko 9959b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 9969b27f350SAndrei Emeltchenko req.psm = chan->psm; 9979b27f350SAndrei Emeltchenko 9989b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 9999b27f350SAndrei Emeltchenko 10009b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 10019b27f350SAndrei Emeltchenko 10029b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 10039b27f350SAndrei Emeltchenko } 10049b27f350SAndrei Emeltchenko 100502b0fbb9SMat Martineau static void l2cap_move_setup(struct l2cap_chan *chan) 100602b0fbb9SMat Martineau { 100702b0fbb9SMat Martineau struct sk_buff *skb; 100802b0fbb9SMat Martineau 100902b0fbb9SMat Martineau BT_DBG("chan %p", chan); 101002b0fbb9SMat Martineau 101102b0fbb9SMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 101202b0fbb9SMat Martineau return; 101302b0fbb9SMat Martineau 101402b0fbb9SMat Martineau __clear_retrans_timer(chan); 101502b0fbb9SMat Martineau __clear_monitor_timer(chan); 101602b0fbb9SMat Martineau __clear_ack_timer(chan); 101702b0fbb9SMat Martineau 101802b0fbb9SMat Martineau chan->retry_count = 0; 101902b0fbb9SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 102002b0fbb9SMat Martineau if (bt_cb(skb)->control.retries) 102102b0fbb9SMat Martineau bt_cb(skb)->control.retries = 1; 102202b0fbb9SMat Martineau else 102302b0fbb9SMat Martineau break; 102402b0fbb9SMat Martineau } 102502b0fbb9SMat Martineau 102602b0fbb9SMat Martineau chan->expected_tx_seq = chan->buffer_seq; 102702b0fbb9SMat Martineau 102802b0fbb9SMat Martineau clear_bit(CONN_REJ_ACT, &chan->conn_state); 102902b0fbb9SMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 103002b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 103102b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->srej_list); 103202b0fbb9SMat Martineau skb_queue_purge(&chan->srej_q); 103302b0fbb9SMat Martineau 103402b0fbb9SMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 103502b0fbb9SMat Martineau chan->rx_state = L2CAP_RX_STATE_MOVE; 103602b0fbb9SMat Martineau 103702b0fbb9SMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 103802b0fbb9SMat Martineau } 103902b0fbb9SMat Martineau 10409f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 10419f0caeb1SVinicius Costa Gomes { 10422827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 10439f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 10449f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 10459f0caeb1SVinicius Costa Gomes 104654a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 10479f0caeb1SVinicius Costa Gomes 104854a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 10499f0caeb1SVinicius Costa Gomes } 10509f0caeb1SVinicius Costa Gomes 105193c3e8f5SAndrei Emeltchenko static void l2cap_start_connection(struct l2cap_chan *chan) 105293c3e8f5SAndrei Emeltchenko { 105393c3e8f5SAndrei Emeltchenko if (__amp_capable(chan)) { 105493c3e8f5SAndrei Emeltchenko BT_DBG("chan %p AMP capable: discover AMPs", chan); 105593c3e8f5SAndrei Emeltchenko a2mp_discover_amp(chan); 105693c3e8f5SAndrei Emeltchenko } else { 105793c3e8f5SAndrei Emeltchenko l2cap_send_conn_req(chan); 105893c3e8f5SAndrei Emeltchenko } 105993c3e8f5SAndrei Emeltchenko } 106093c3e8f5SAndrei Emeltchenko 1061fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 10620a708f8fSGustavo F. Padovan { 10638c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 10640a708f8fSGustavo F. Padovan 10659f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 10669f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 10679f0caeb1SVinicius Costa Gomes return; 10689f0caeb1SVinicius Costa Gomes } 10699f0caeb1SVinicius Costa Gomes 10700a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 10710a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 10720a708f8fSGustavo F. Padovan return; 10730a708f8fSGustavo F. Padovan 1074d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 107593c3e8f5SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) { 107693c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 107793c3e8f5SAndrei Emeltchenko } 10780a708f8fSGustavo F. Padovan } else { 10790a708f8fSGustavo F. Padovan struct l2cap_info_req req; 1080ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 10810a708f8fSGustavo F. Padovan 10820a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 10830a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 10840a708f8fSGustavo F. Padovan 1085ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 10860a708f8fSGustavo F. Padovan 10872d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 10882d792818SGustavo Padovan sizeof(req), &req); 10890a708f8fSGustavo F. Padovan } 10900a708f8fSGustavo F. Padovan } 10910a708f8fSGustavo F. Padovan 10920a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 10930a708f8fSGustavo F. Padovan { 10940a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 10950a708f8fSGustavo F. Padovan if (!disable_ertm) 10960a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 10970a708f8fSGustavo F. Padovan 10980a708f8fSGustavo F. Padovan switch (mode) { 10990a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 11000a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 11010a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 11020a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 11030a708f8fSGustavo F. Padovan default: 11040a708f8fSGustavo F. Padovan return 0x00; 11050a708f8fSGustavo F. Padovan } 11060a708f8fSGustavo F. Padovan } 11070a708f8fSGustavo F. Padovan 11082d792818SGustavo Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 11092d792818SGustavo Padovan struct l2cap_chan *chan, int err) 11100a708f8fSGustavo F. Padovan { 11116be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 11120a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 11130a708f8fSGustavo F. Padovan 11140a708f8fSGustavo F. Padovan if (!conn) 11150a708f8fSGustavo F. Padovan return; 11160a708f8fSGustavo F. Padovan 1117aad3d0e3SAndrei Emeltchenko if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) { 11181a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 11191a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 11201a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 11210a708f8fSGustavo F. Padovan } 11220a708f8fSGustavo F. Padovan 1123416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1124d117773cSGustavo Padovan l2cap_state_change(chan, BT_DISCONN); 1125416fa752SAndrei Emeltchenko return; 1126416fa752SAndrei Emeltchenko } 1127416fa752SAndrei Emeltchenko 1128fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1129fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 11302d792818SGustavo Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_DISCONN_REQ, 11312d792818SGustavo Padovan sizeof(req), &req); 11320a708f8fSGustavo F. Padovan 11336be36555SAndrei Emeltchenko lock_sock(sk); 11340e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 11352e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 11366be36555SAndrei Emeltchenko release_sock(sk); 11370a708f8fSGustavo F. Padovan } 11380a708f8fSGustavo F. Padovan 11390a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 11400a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 11410a708f8fSGustavo F. Padovan { 11423df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 11430a708f8fSGustavo F. Padovan 11440a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 11450a708f8fSGustavo F. Padovan 11463df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 11470a708f8fSGustavo F. Padovan 11483df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 114948454079SGustavo F. Padovan struct sock *sk = chan->sk; 1150baa7e1faSGustavo F. Padovan 11516be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 11520a708f8fSGustavo F. Padovan 1153715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 11546be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11550a708f8fSGustavo F. Padovan continue; 11560a708f8fSGustavo F. Padovan } 11570a708f8fSGustavo F. Padovan 115889bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1159d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1160b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 11616be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11620a708f8fSGustavo F. Padovan continue; 11630a708f8fSGustavo F. Padovan } 11640a708f8fSGustavo F. Padovan 1165c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1166c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1167c1360a1cSGustavo F. Padovan &chan->conf_state)) { 11680f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 11696be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11700a708f8fSGustavo F. Padovan continue; 11710a708f8fSGustavo F. Padovan } 11720a708f8fSGustavo F. Padovan 117393c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 11740a708f8fSGustavo F. Padovan 117589bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 11760a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 11770a708f8fSGustavo F. Padovan char buf[128]; 1178fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1179fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 11800a708f8fSGustavo F. Padovan 1181d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 11826be36555SAndrei Emeltchenko lock_sock(sk); 1183c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1184c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 1185ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1186ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 11872dc4e510SGustavo Padovan chan->ops->defer(chan); 11880a708f8fSGustavo F. Padovan 11890a708f8fSGustavo F. Padovan } else { 11900e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1191ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1192ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 11930a708f8fSGustavo F. Padovan } 11946be36555SAndrei Emeltchenko release_sock(sk); 11950a708f8fSGustavo F. Padovan } else { 1196ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1197ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 11980a708f8fSGustavo F. Padovan } 11990a708f8fSGustavo F. Padovan 1200fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1201fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 12020a708f8fSGustavo F. Padovan 1203c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 12040a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 12056be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12060a708f8fSGustavo F. Padovan continue; 12070a708f8fSGustavo F. Padovan } 12080a708f8fSGustavo F. Padovan 1209c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 12100a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 121173ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 121273ffa904SGustavo F. Padovan chan->num_conf_req++; 12130a708f8fSGustavo F. Padovan } 12140a708f8fSGustavo F. Padovan 12156be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12160a708f8fSGustavo F. Padovan } 12170a708f8fSGustavo F. Padovan 12183df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12190a708f8fSGustavo F. Padovan } 12200a708f8fSGustavo F. Padovan 1221c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1222b62f328bSVille Tervo * Returns closest match, locked. 1223b62f328bSVille Tervo */ 1224d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1225c2287681SIdo Yariv bdaddr_t *src, 1226c2287681SIdo Yariv bdaddr_t *dst) 1227b62f328bSVille Tervo { 122823691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1229b62f328bSVille Tervo 123023691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1231b62f328bSVille Tervo 123223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 123323691d75SGustavo F. Padovan struct sock *sk = c->sk; 1234fe4128e0SGustavo F. Padovan 123589bc500eSGustavo F. Padovan if (state && c->state != state) 1236b62f328bSVille Tervo continue; 1237b62f328bSVille Tervo 123823691d75SGustavo F. Padovan if (c->scid == cid) { 1239c2287681SIdo Yariv int src_match, dst_match; 1240c2287681SIdo Yariv int src_any, dst_any; 1241c2287681SIdo Yariv 1242b62f328bSVille Tervo /* Exact match. */ 1243c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1244c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1245c2287681SIdo Yariv if (src_match && dst_match) { 124623691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 124723691d75SGustavo F. Padovan return c; 124823691d75SGustavo F. Padovan } 1249b62f328bSVille Tervo 1250b62f328bSVille Tervo /* Closest match */ 1251c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1252c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1253c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1254c2287681SIdo Yariv (src_any && dst_any)) 125523691d75SGustavo F. Padovan c1 = c; 1256b62f328bSVille Tervo } 1257b62f328bSVille Tervo } 1258280f294fSGustavo F. Padovan 125923691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1260b62f328bSVille Tervo 126123691d75SGustavo F. Padovan return c1; 1262b62f328bSVille Tervo } 1263b62f328bSVille Tervo 1264b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1265b62f328bSVille Tervo { 1266c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 126723691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1268b62f328bSVille Tervo 1269b62f328bSVille Tervo BT_DBG(""); 1270b62f328bSVille Tervo 1271b62f328bSVille Tervo /* Check if we have socket listening on cid */ 127223691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1273c2287681SIdo Yariv conn->src, conn->dst); 127423691d75SGustavo F. Padovan if (!pchan) 1275b62f328bSVille Tervo return; 1276b62f328bSVille Tervo 127723691d75SGustavo F. Padovan parent = pchan->sk; 127823691d75SGustavo F. Padovan 1279aa2ac881SGustavo F. Padovan lock_sock(parent); 128062f3a2cfSGustavo F. Padovan 128180b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 128280808e43SGustavo F. Padovan if (!chan) 1283b62f328bSVille Tervo goto clean; 1284b62f328bSVille Tervo 128580808e43SGustavo F. Padovan sk = chan->sk; 12865d41ce1dSGustavo F. Padovan 1287b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1288a9ea3ed9SSzymon Janc conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT; 1289b62f328bSVille Tervo 1290b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1291b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1292b62f328bSVille Tervo 12933d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 129448454079SGustavo F. Padovan 12956754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1296b62f328bSVille Tervo 1297b62f328bSVille Tervo clean: 1298aa2ac881SGustavo F. Padovan release_sock(parent); 1299b62f328bSVille Tervo } 1300b62f328bSVille Tervo 13010a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 13020a708f8fSGustavo F. Padovan { 130348454079SGustavo F. Padovan struct l2cap_chan *chan; 1304cc110922SVinicius Costa Gomes struct hci_conn *hcon = conn->hcon; 13050a708f8fSGustavo F. Padovan 13060a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 13070a708f8fSGustavo F. Padovan 1308cc110922SVinicius Costa Gomes if (!hcon->out && hcon->type == LE_LINK) 1309b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1310b62f328bSVille Tervo 1311cc110922SVinicius Costa Gomes if (hcon->out && hcon->type == LE_LINK) 1312cc110922SVinicius Costa Gomes smp_conn_security(hcon, hcon->pending_sec_level); 1313160dc6acSVinicius Costa Gomes 13143df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 13150a708f8fSGustavo F. Padovan 13163df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1317baa7e1faSGustavo F. Padovan 13186be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 13190a708f8fSGustavo F. Padovan 1320416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1321416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1322416fa752SAndrei Emeltchenko continue; 1323416fa752SAndrei Emeltchenko } 1324416fa752SAndrei Emeltchenko 1325cc110922SVinicius Costa Gomes if (hcon->type == LE_LINK) { 1326cc110922SVinicius Costa Gomes if (smp_conn_security(hcon, chan->sec_level)) 1327cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1328acd7d370SVille Tervo 132963128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 13306be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1331c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 13326be36555SAndrei Emeltchenko lock_sock(sk); 13330e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 13340a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 13356be36555SAndrei Emeltchenko release_sock(sk); 1336b501d6a1SAnderson Briglia 133789bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1338fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 13390a708f8fSGustavo F. Padovan 13406be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 13410a708f8fSGustavo F. Padovan } 13420a708f8fSGustavo F. Padovan 13433df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 13440a708f8fSGustavo F. Padovan } 13450a708f8fSGustavo F. Padovan 13460a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 13470a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 13480a708f8fSGustavo F. Padovan { 134948454079SGustavo F. Padovan struct l2cap_chan *chan; 13500a708f8fSGustavo F. Padovan 13510a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 13520a708f8fSGustavo F. Padovan 13533df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 13540a708f8fSGustavo F. Padovan 13553df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1356ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 13571d8b1fd5SGustavo Padovan l2cap_chan_set_err(chan, err); 13580a708f8fSGustavo F. Padovan } 13590a708f8fSGustavo F. Padovan 13603df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 13610a708f8fSGustavo F. Padovan } 13620a708f8fSGustavo F. Padovan 1363f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 13640a708f8fSGustavo F. Padovan { 1365f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1366030013d8SGustavo F. Padovan info_timer.work); 13670a708f8fSGustavo F. Padovan 13680a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 13690a708f8fSGustavo F. Padovan conn->info_ident = 0; 13700a708f8fSGustavo F. Padovan 13710a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 13720a708f8fSGustavo F. Padovan } 13730a708f8fSGustavo F. Padovan 13745d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 13755d3de7dfSVinicius Costa Gomes { 13765d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 13775d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 13785d3de7dfSVinicius Costa Gomes 13795d3de7dfSVinicius Costa Gomes if (!conn) 13805d3de7dfSVinicius Costa Gomes return; 13815d3de7dfSVinicius Costa Gomes 13825d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 13835d3de7dfSVinicius Costa Gomes 13845d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 13855d3de7dfSVinicius Costa Gomes 13863df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 13873df91ea2SAndrei Emeltchenko 13885d3de7dfSVinicius Costa Gomes /* Kill channels */ 13895d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 139061d6ef3eSMat Martineau l2cap_chan_hold(chan); 13916be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 13926be36555SAndrei Emeltchenko 13935d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 13946be36555SAndrei Emeltchenko 13956be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 13966be36555SAndrei Emeltchenko 139780b98027SGustavo Padovan chan->ops->close(chan); 139861d6ef3eSMat Martineau l2cap_chan_put(chan); 13995d3de7dfSVinicius Costa Gomes } 14005d3de7dfSVinicius Costa Gomes 14013df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14023df91ea2SAndrei Emeltchenko 140373d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 140473d80debSLuiz Augusto von Dentz 14055d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1406127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 14075d3de7dfSVinicius Costa Gomes 140851a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1409127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 14108aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1411d26a2345SVinicius Costa Gomes } 14125d3de7dfSVinicius Costa Gomes 14135d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 14145d3de7dfSVinicius Costa Gomes kfree(conn); 14155d3de7dfSVinicius Costa Gomes } 14165d3de7dfSVinicius Costa Gomes 14176c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 14185d3de7dfSVinicius Costa Gomes { 14196c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 14206c9d42a1SGustavo F. Padovan security_timer.work); 14215d3de7dfSVinicius Costa Gomes 1422d06cc416SJohan Hedberg BT_DBG("conn %p", conn); 1423d06cc416SJohan Hedberg 1424d06cc416SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 1425d06cc416SJohan Hedberg smp_chan_destroy(conn); 14265d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 14275d3de7dfSVinicius Costa Gomes } 1428d06cc416SJohan Hedberg } 14295d3de7dfSVinicius Costa Gomes 14300a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 14310a708f8fSGustavo F. Padovan { 14320a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 143373d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 14340a708f8fSGustavo F. Padovan 14350a708f8fSGustavo F. Padovan if (conn || status) 14360a708f8fSGustavo F. Padovan return conn; 14370a708f8fSGustavo F. Padovan 143873d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 143973d80debSLuiz Augusto von Dentz if (!hchan) 14400a708f8fSGustavo F. Padovan return NULL; 14410a708f8fSGustavo F. Padovan 14428bcde1f2SGustavo Padovan conn = kzalloc(sizeof(struct l2cap_conn), GFP_KERNEL); 144373d80debSLuiz Augusto von Dentz if (!conn) { 144473d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 144573d80debSLuiz Augusto von Dentz return NULL; 144673d80debSLuiz Augusto von Dentz } 144773d80debSLuiz Augusto von Dentz 14480a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 14490a708f8fSGustavo F. Padovan conn->hcon = hcon; 145073d80debSLuiz Augusto von Dentz conn->hchan = hchan; 14510a708f8fSGustavo F. Padovan 145273d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 14530a708f8fSGustavo F. Padovan 1454dcc042d5SAndrei Emeltchenko switch (hcon->type) { 1455dcc042d5SAndrei Emeltchenko case AMP_LINK: 1456dcc042d5SAndrei Emeltchenko conn->mtu = hcon->hdev->block_mtu; 1457dcc042d5SAndrei Emeltchenko break; 1458dcc042d5SAndrei Emeltchenko 1459dcc042d5SAndrei Emeltchenko case LE_LINK: 1460dcc042d5SAndrei Emeltchenko if (hcon->hdev->le_mtu) { 1461acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1462dcc042d5SAndrei Emeltchenko break; 1463dcc042d5SAndrei Emeltchenko } 1464dcc042d5SAndrei Emeltchenko /* fall through */ 1465dcc042d5SAndrei Emeltchenko 1466dcc042d5SAndrei Emeltchenko default: 14670a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1468dcc042d5SAndrei Emeltchenko break; 1469dcc042d5SAndrei Emeltchenko } 1470acd7d370SVille Tervo 14710a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 14720a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 14730a708f8fSGustavo F. Padovan 14740a708f8fSGustavo F. Padovan conn->feat_mask = 0; 14750a708f8fSGustavo F. Padovan 14760a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 14773df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1478baa7e1faSGustavo F. Padovan 1479baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 14800a708f8fSGustavo F. Padovan 14815d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 14826c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 14835d3de7dfSVinicius Costa Gomes else 1484030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 14850a708f8fSGustavo F. Padovan 14869f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 14870a708f8fSGustavo F. Padovan 14880a708f8fSGustavo F. Padovan return conn; 14890a708f8fSGustavo F. Padovan } 14900a708f8fSGustavo F. Padovan 14910a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 14920a708f8fSGustavo F. Padovan 1493c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 14940a708f8fSGustavo F. Padovan * Returns closest match. 14950a708f8fSGustavo F. Padovan */ 1496c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1497c2287681SIdo Yariv bdaddr_t *src, 1498c2287681SIdo Yariv bdaddr_t *dst) 14990a708f8fSGustavo F. Padovan { 150023691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 15010a708f8fSGustavo F. Padovan 150223691d75SGustavo F. Padovan read_lock(&chan_list_lock); 15030a708f8fSGustavo F. Padovan 150423691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 150523691d75SGustavo F. Padovan struct sock *sk = c->sk; 1506fe4128e0SGustavo F. Padovan 150789bc500eSGustavo F. Padovan if (state && c->state != state) 15080a708f8fSGustavo F. Padovan continue; 15090a708f8fSGustavo F. Padovan 151023691d75SGustavo F. Padovan if (c->psm == psm) { 1511c2287681SIdo Yariv int src_match, dst_match; 1512c2287681SIdo Yariv int src_any, dst_any; 1513c2287681SIdo Yariv 15140a708f8fSGustavo F. Padovan /* Exact match. */ 1515c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1516c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1517c2287681SIdo Yariv if (src_match && dst_match) { 1518a7567b20SJohannes Berg read_unlock(&chan_list_lock); 151923691d75SGustavo F. Padovan return c; 152023691d75SGustavo F. Padovan } 15210a708f8fSGustavo F. Padovan 15220a708f8fSGustavo F. Padovan /* Closest match */ 1523c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1524c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1525c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1526c2287681SIdo Yariv (src_any && dst_any)) 152723691d75SGustavo F. Padovan c1 = c; 15280a708f8fSGustavo F. Padovan } 15290a708f8fSGustavo F. Padovan } 15300a708f8fSGustavo F. Padovan 153123691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 15320a708f8fSGustavo F. Padovan 153323691d75SGustavo F. Padovan return c1; 15340a708f8fSGustavo F. Padovan } 15350a708f8fSGustavo F. Padovan 15368e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 15378e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 15380a708f8fSGustavo F. Padovan { 15395d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 15400a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 15410a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 15420a708f8fSGustavo F. Padovan struct hci_conn *hcon; 15430a708f8fSGustavo F. Padovan struct hci_dev *hdev; 15440a708f8fSGustavo F. Padovan __u8 auth_type; 15450a708f8fSGustavo F. Padovan int err; 15460a708f8fSGustavo F. Padovan 15476ed93dc6SAndrei Emeltchenko BT_DBG("%pMR -> %pMR (type %u) psm 0x%2.2x", src, dst, 1548ab19516aSSyam Sidhardhan dst_type, __le16_to_cpu(psm)); 15490a708f8fSGustavo F. Padovan 15500a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 15510a708f8fSGustavo F. Padovan if (!hdev) 15520a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 15530a708f8fSGustavo F. Padovan 155409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 15550a708f8fSGustavo F. Padovan 15566be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 155703a00194SGustavo F. Padovan 155803a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 155903a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 156003a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 156103a00194SGustavo F. Padovan err = -EINVAL; 156203a00194SGustavo F. Padovan goto done; 156303a00194SGustavo F. Padovan } 156403a00194SGustavo F. Padovan 156503a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 156603a00194SGustavo F. Padovan err = -EINVAL; 156703a00194SGustavo F. Padovan goto done; 156803a00194SGustavo F. Padovan } 156903a00194SGustavo F. Padovan 157003a00194SGustavo F. Padovan switch (chan->mode) { 157103a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 157203a00194SGustavo F. Padovan break; 157303a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 157403a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 157503a00194SGustavo F. Padovan if (!disable_ertm) 157603a00194SGustavo F. Padovan break; 157703a00194SGustavo F. Padovan /* fall through */ 157803a00194SGustavo F. Padovan default: 157903a00194SGustavo F. Padovan err = -ENOTSUPP; 158003a00194SGustavo F. Padovan goto done; 158103a00194SGustavo F. Padovan } 158203a00194SGustavo F. Padovan 15830797e01dSGustavo Padovan switch (chan->state) { 158403a00194SGustavo F. Padovan case BT_CONNECT: 158503a00194SGustavo F. Padovan case BT_CONNECT2: 158603a00194SGustavo F. Padovan case BT_CONFIG: 158703a00194SGustavo F. Padovan /* Already connecting */ 158803a00194SGustavo F. Padovan err = 0; 158903a00194SGustavo F. Padovan goto done; 159003a00194SGustavo F. Padovan 159103a00194SGustavo F. Padovan case BT_CONNECTED: 159203a00194SGustavo F. Padovan /* Already connected */ 159303a00194SGustavo F. Padovan err = -EISCONN; 159403a00194SGustavo F. Padovan goto done; 159503a00194SGustavo F. Padovan 159603a00194SGustavo F. Padovan case BT_OPEN: 159703a00194SGustavo F. Padovan case BT_BOUND: 159803a00194SGustavo F. Padovan /* Can connect */ 159903a00194SGustavo F. Padovan break; 160003a00194SGustavo F. Padovan 160103a00194SGustavo F. Padovan default: 160203a00194SGustavo F. Padovan err = -EBADFD; 160303a00194SGustavo F. Padovan goto done; 160403a00194SGustavo F. Padovan } 160503a00194SGustavo F. Padovan 160603a00194SGustavo F. Padovan /* Set destination address and psm */ 16070797e01dSGustavo Padovan lock_sock(sk); 16089219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 16096be36555SAndrei Emeltchenko release_sock(sk); 16106be36555SAndrei Emeltchenko 161103a00194SGustavo F. Padovan chan->psm = psm; 161203a00194SGustavo F. Padovan chan->dcid = cid; 16130a708f8fSGustavo F. Padovan 16144343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 16150a708f8fSGustavo F. Padovan 1616fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 16178e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 16184343478fSGustavo F. Padovan chan->sec_level, auth_type); 1619acd7d370SVille Tervo else 16208e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 16214343478fSGustavo F. Padovan chan->sec_level, auth_type); 1622acd7d370SVille Tervo 162330e76272SVille Tervo if (IS_ERR(hcon)) { 162430e76272SVille Tervo err = PTR_ERR(hcon); 16250a708f8fSGustavo F. Padovan goto done; 162630e76272SVille Tervo } 16270a708f8fSGustavo F. Padovan 16280a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 16290a708f8fSGustavo F. Padovan if (!conn) { 16300a708f8fSGustavo F. Padovan hci_conn_put(hcon); 163130e76272SVille Tervo err = -ENOMEM; 16320a708f8fSGustavo F. Padovan goto done; 16330a708f8fSGustavo F. Padovan } 16340a708f8fSGustavo F. Padovan 16359f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 16369f0caeb1SVinicius Costa Gomes err = 0; 16379f0caeb1SVinicius Costa Gomes 16389f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 16399f0caeb1SVinicius Costa Gomes err = -EBUSY; 16409f0caeb1SVinicius Costa Gomes hci_conn_put(hcon); 16419f0caeb1SVinicius Costa Gomes } 16429f0caeb1SVinicius Costa Gomes 16439f0caeb1SVinicius Costa Gomes if (err) 16449f0caeb1SVinicius Costa Gomes goto done; 16459f0caeb1SVinicius Costa Gomes } 16469f0caeb1SVinicius Costa Gomes 16470a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 16480a708f8fSGustavo F. Padovan bacpy(src, conn->src); 16490a708f8fSGustavo F. Padovan 16506be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 165148454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 16526be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 165348454079SGustavo F. Padovan 16546be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1655c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 16560a708f8fSGustavo F. Padovan 16570a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1658715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1659c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1660d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 16616be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 16620a708f8fSGustavo F. Padovan } else 1663fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 16640a708f8fSGustavo F. Padovan } 16650a708f8fSGustavo F. Padovan 166630e76272SVille Tervo err = 0; 166730e76272SVille Tervo 16680a708f8fSGustavo F. Padovan done: 16696be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 167009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16710a708f8fSGustavo F. Padovan hci_dev_put(hdev); 16720a708f8fSGustavo F. Padovan return err; 16730a708f8fSGustavo F. Padovan } 16740a708f8fSGustavo F. Padovan 1675dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 16760a708f8fSGustavo F. Padovan { 16778c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 16780a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 16790a708f8fSGustavo F. Padovan int err = 0; 16800a708f8fSGustavo F. Padovan int timeo = HZ/5; 16810a708f8fSGustavo F. Padovan 16820a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 16830a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1684a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 16850a708f8fSGustavo F. Padovan if (!timeo) 16860a708f8fSGustavo F. Padovan timeo = HZ/5; 16870a708f8fSGustavo F. Padovan 16880a708f8fSGustavo F. Padovan if (signal_pending(current)) { 16890a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 16900a708f8fSGustavo F. Padovan break; 16910a708f8fSGustavo F. Padovan } 16920a708f8fSGustavo F. Padovan 16930a708f8fSGustavo F. Padovan release_sock(sk); 16940a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 16950a708f8fSGustavo F. Padovan lock_sock(sk); 1696a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 16970a708f8fSGustavo F. Padovan 16980a708f8fSGustavo F. Padovan err = sock_error(sk); 16990a708f8fSGustavo F. Padovan if (err) 17000a708f8fSGustavo F. Padovan break; 17010a708f8fSGustavo F. Padovan } 17020a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 17030a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 17040a708f8fSGustavo F. Padovan return err; 17050a708f8fSGustavo F. Padovan } 17060a708f8fSGustavo F. Padovan 1707721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 17080a708f8fSGustavo F. Padovan { 1709721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1710721c4181SGustavo F. Padovan monitor_timer.work); 17110a708f8fSGustavo F. Padovan 1712525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 17130a708f8fSGustavo F. Padovan 17146be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 17156be36555SAndrei Emeltchenko 171680909e04SMat Martineau if (!chan->conn) { 17176be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 17188d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 17190a708f8fSGustavo F. Padovan return; 17200a708f8fSGustavo F. Padovan } 17210a708f8fSGustavo F. Padovan 1722401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 17230a708f8fSGustavo F. Padovan 17246be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 17258d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 17260a708f8fSGustavo F. Padovan } 17270a708f8fSGustavo F. Padovan 1728721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 17290a708f8fSGustavo F. Padovan { 1730721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1731721c4181SGustavo F. Padovan retrans_timer.work); 17320a708f8fSGustavo F. Padovan 173349208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 17340a708f8fSGustavo F. Padovan 17356be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 17366be36555SAndrei Emeltchenko 173780909e04SMat Martineau if (!chan->conn) { 173880909e04SMat Martineau l2cap_chan_unlock(chan); 173980909e04SMat Martineau l2cap_chan_put(chan); 174080909e04SMat Martineau return; 174180909e04SMat Martineau } 17420a708f8fSGustavo F. Padovan 1743401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 17446be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 17458d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 17460a708f8fSGustavo F. Padovan } 17470a708f8fSGustavo F. Padovan 1748d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 17493733937dSMat Martineau struct sk_buff_head *skbs) 17500a708f8fSGustavo F. Padovan { 17510a708f8fSGustavo F. Padovan struct sk_buff *skb; 17523733937dSMat Martineau struct l2cap_ctrl *control; 17530a708f8fSGustavo F. Padovan 17543733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 17553733937dSMat Martineau 17563733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 17573733937dSMat Martineau 17583733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 17593733937dSMat Martineau 17603733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 17613733937dSMat Martineau 17623733937dSMat Martineau bt_cb(skb)->control.retries = 1; 17633733937dSMat Martineau control = &bt_cb(skb)->control; 17643733937dSMat Martineau 17653733937dSMat Martineau control->reqseq = 0; 17663733937dSMat Martineau control->txseq = chan->next_tx_seq; 17673733937dSMat Martineau 17683733937dSMat Martineau __pack_control(chan, control, skb); 17690a708f8fSGustavo F. Padovan 177047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 17713733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 17723733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 17730a708f8fSGustavo F. Padovan } 17740a708f8fSGustavo F. Padovan 17754343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 17760a708f8fSGustavo F. Padovan 1777b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 17783733937dSMat Martineau 1779836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 17803733937dSMat Martineau chan->frames_sent++; 17810a708f8fSGustavo F. Padovan } 17820a708f8fSGustavo F. Padovan } 17830a708f8fSGustavo F. Padovan 178467c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 17850a708f8fSGustavo F. Padovan { 17860a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 178718a48e76SMat Martineau struct l2cap_ctrl *control; 178818a48e76SMat Martineau int sent = 0; 178918a48e76SMat Martineau 179018a48e76SMat Martineau BT_DBG("chan %p", chan); 17910a708f8fSGustavo F. Padovan 179289bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 17930a708f8fSGustavo F. Padovan return -ENOTCONN; 17940a708f8fSGustavo F. Padovan 179594122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 179694122bbeSMat Martineau return 0; 179794122bbeSMat Martineau 179818a48e76SMat Martineau while (chan->tx_send_head && 179918a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 180018a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 18010a708f8fSGustavo F. Padovan 180218a48e76SMat Martineau skb = chan->tx_send_head; 18030a708f8fSGustavo F. Padovan 180418a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 180518a48e76SMat Martineau control = &bt_cb(skb)->control; 18060a708f8fSGustavo F. Padovan 1807e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 180818a48e76SMat Martineau control->final = 1; 1809e2ab4353SGustavo F. Padovan 181018a48e76SMat Martineau control->reqseq = chan->buffer_seq; 181118a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 181218a48e76SMat Martineau control->txseq = chan->next_tx_seq; 18130a708f8fSGustavo F. Padovan 181418a48e76SMat Martineau __pack_control(chan, control, skb); 18150a708f8fSGustavo F. Padovan 181647d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 181718a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 181818a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 18190a708f8fSGustavo F. Padovan } 18200a708f8fSGustavo F. Padovan 182118a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 182218a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 182318a48e76SMat Martineau */ 182418a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 182518a48e76SMat Martineau 182618a48e76SMat Martineau if (!tx_skb) 182718a48e76SMat Martineau break; 18280a708f8fSGustavo F. Padovan 18291a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 18300a708f8fSGustavo F. Padovan 1831836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 18326a026610SGustavo F. Padovan chan->unacked_frames++; 18336a026610SGustavo F. Padovan chan->frames_sent++; 183418a48e76SMat Martineau sent++; 18350a708f8fSGustavo F. Padovan 183658d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 183758d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 18380a708f8fSGustavo F. Padovan else 183958d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 184018a48e76SMat Martineau 184118a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 1842b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 18430a708f8fSGustavo F. Padovan } 18440a708f8fSGustavo F. Padovan 1845b4400672SAndrei Emeltchenko BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent, 1846b4400672SAndrei Emeltchenko chan->unacked_frames, skb_queue_len(&chan->tx_q)); 184718a48e76SMat Martineau 184818a48e76SMat Martineau return sent; 18490a708f8fSGustavo F. Padovan } 18500a708f8fSGustavo F. Padovan 1851e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1852e1fbd4c1SMat Martineau { 1853e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1854e1fbd4c1SMat Martineau struct sk_buff *skb; 1855e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1856e1fbd4c1SMat Martineau u16 seq; 1857e1fbd4c1SMat Martineau 1858e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1859e1fbd4c1SMat Martineau 1860e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1861e1fbd4c1SMat Martineau return; 1862e1fbd4c1SMat Martineau 1863e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1864e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1865e1fbd4c1SMat Martineau 1866e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1867e1fbd4c1SMat Martineau if (!skb) { 1868e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1869e1fbd4c1SMat Martineau seq); 1870e1fbd4c1SMat Martineau continue; 1871e1fbd4c1SMat Martineau } 1872e1fbd4c1SMat Martineau 1873e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1874e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1875e1fbd4c1SMat Martineau 1876e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1877e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1878e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 1879e1fbd4c1SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 1880e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1881e1fbd4c1SMat Martineau break; 1882e1fbd4c1SMat Martineau } 1883e1fbd4c1SMat Martineau 1884e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1885e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1886e1fbd4c1SMat Martineau control.final = 1; 1887e1fbd4c1SMat Martineau else 1888e1fbd4c1SMat Martineau control.final = 0; 1889e1fbd4c1SMat Martineau 1890e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1891e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1892e1fbd4c1SMat Martineau * writeable copy 1893e1fbd4c1SMat Martineau */ 18948bcde1f2SGustavo Padovan tx_skb = skb_copy(skb, GFP_KERNEL); 1895e1fbd4c1SMat Martineau } else { 18968bcde1f2SGustavo Padovan tx_skb = skb_clone(skb, GFP_KERNEL); 1897e1fbd4c1SMat Martineau } 1898e1fbd4c1SMat Martineau 1899e1fbd4c1SMat Martineau if (!tx_skb) { 1900e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1901e1fbd4c1SMat Martineau break; 1902e1fbd4c1SMat Martineau } 1903e1fbd4c1SMat Martineau 1904e1fbd4c1SMat Martineau /* Update skb contents */ 1905e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1906e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1907e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1908e1fbd4c1SMat Martineau } else { 1909e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1910e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1911e1fbd4c1SMat Martineau } 1912e1fbd4c1SMat Martineau 1913e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1914e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1915e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1916e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1917e1fbd4c1SMat Martineau } 1918e1fbd4c1SMat Martineau 1919e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1920e1fbd4c1SMat Martineau 1921e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 1922e1fbd4c1SMat Martineau 1923e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 1924e1fbd4c1SMat Martineau } 1925e1fbd4c1SMat Martineau } 1926e1fbd4c1SMat Martineau 1927f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 1928f80842a8SMat Martineau struct l2cap_ctrl *control) 1929f80842a8SMat Martineau { 1930f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1931f80842a8SMat Martineau 1932f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 1933f80842a8SMat Martineau l2cap_ertm_resend(chan); 1934f80842a8SMat Martineau } 1935f80842a8SMat Martineau 1936d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 1937d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 1938d2a7ac5dSMat Martineau { 1939e1fbd4c1SMat Martineau struct sk_buff *skb; 1940e1fbd4c1SMat Martineau 1941e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1942e1fbd4c1SMat Martineau 1943e1fbd4c1SMat Martineau if (control->poll) 1944e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 1945e1fbd4c1SMat Martineau 1946e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1947e1fbd4c1SMat Martineau 1948e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1949e1fbd4c1SMat Martineau return; 1950e1fbd4c1SMat Martineau 1951e1fbd4c1SMat Martineau if (chan->unacked_frames) { 1952e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 1953e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 1954e1fbd4c1SMat Martineau skb == chan->tx_send_head) 1955e1fbd4c1SMat Martineau break; 1956e1fbd4c1SMat Martineau } 1957e1fbd4c1SMat Martineau 1958e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 1959e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 1960e1fbd4c1SMat Martineau break; 1961e1fbd4c1SMat Martineau 1962e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 1963e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 1964e1fbd4c1SMat Martineau } 1965e1fbd4c1SMat Martineau 1966e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 1967e1fbd4c1SMat Martineau } 1968d2a7ac5dSMat Martineau } 1969d2a7ac5dSMat Martineau 1970b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 1971b17e73bbSSzymon Janc { 19720a0aba42SMat Martineau struct l2cap_ctrl control; 19730a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 19740a0aba42SMat Martineau chan->last_acked_seq); 19750a0aba42SMat Martineau int threshold; 19760a0aba42SMat Martineau 19770a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 19780a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 19790a0aba42SMat Martineau 19800a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 19810a0aba42SMat Martineau control.sframe = 1; 19820a0aba42SMat Martineau 19830a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 19840a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 1985b17e73bbSSzymon Janc __clear_ack_timer(chan); 19860a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 19870a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 19880a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 19890a0aba42SMat Martineau } else { 19900a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 19910a0aba42SMat Martineau l2cap_ertm_send(chan); 19920a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 19930a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 19940a0aba42SMat Martineau frames_to_ack = 0; 19950a0aba42SMat Martineau } 19960a0aba42SMat Martineau 1997c20f8e35SMat Martineau /* Ack now if the window is 3/4ths full. 19980a0aba42SMat Martineau * Calculate without mul or div 19990a0aba42SMat Martineau */ 2000c20f8e35SMat Martineau threshold = chan->ack_win; 20010a0aba42SMat Martineau threshold += threshold << 1; 20020a0aba42SMat Martineau threshold >>= 2; 20030a0aba42SMat Martineau 2004b4400672SAndrei Emeltchenko BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack, 20050a0aba42SMat Martineau threshold); 20060a0aba42SMat Martineau 20070a0aba42SMat Martineau if (frames_to_ack >= threshold) { 20080a0aba42SMat Martineau __clear_ack_timer(chan); 20090a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 20100a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 20110a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 20120a0aba42SMat Martineau frames_to_ack = 0; 20130a0aba42SMat Martineau } 20140a0aba42SMat Martineau 20150a0aba42SMat Martineau if (frames_to_ack) 20160a0aba42SMat Martineau __set_ack_timer(chan); 20170a0aba42SMat Martineau } 2018b17e73bbSSzymon Janc } 2019b17e73bbSSzymon Janc 202004124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 202104124681SGustavo F. Padovan struct msghdr *msg, int len, 202204124681SGustavo F. Padovan int count, struct sk_buff *skb) 20230a708f8fSGustavo F. Padovan { 20240952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 20250a708f8fSGustavo F. Padovan struct sk_buff **frag; 202690338947SGustavo Padovan int sent = 0; 20270a708f8fSGustavo F. Padovan 20280a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 20290a708f8fSGustavo F. Padovan return -EFAULT; 20300a708f8fSGustavo F. Padovan 20310a708f8fSGustavo F. Padovan sent += count; 20320a708f8fSGustavo F. Padovan len -= count; 20330a708f8fSGustavo F. Padovan 20340a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 20350a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 20360a708f8fSGustavo F. Padovan while (len) { 2037fbe00700SGustavo Padovan struct sk_buff *tmp; 2038fbe00700SGustavo Padovan 20390a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 20400a708f8fSGustavo F. Padovan 2041fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 204290338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 2043fbe00700SGustavo Padovan if (IS_ERR(tmp)) 2044fbe00700SGustavo Padovan return PTR_ERR(tmp); 20452f7719ceSAndrei Emeltchenko 2046fbe00700SGustavo Padovan *frag = tmp; 2047fbe00700SGustavo Padovan 20480a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 20490a708f8fSGustavo F. Padovan return -EFAULT; 20500a708f8fSGustavo F. Padovan 20515e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 20525e59b791SLuiz Augusto von Dentz 20530a708f8fSGustavo F. Padovan sent += count; 20540a708f8fSGustavo F. Padovan len -= count; 20550a708f8fSGustavo F. Padovan 20562d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 20572d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 20582d0ed3d5SGustavo Padovan 20590a708f8fSGustavo F. Padovan frag = &(*frag)->next; 20600a708f8fSGustavo F. Padovan } 20610a708f8fSGustavo F. Padovan 20620a708f8fSGustavo F. Padovan return sent; 20630a708f8fSGustavo F. Padovan } 20640a708f8fSGustavo F. Padovan 20655e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 20665e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 20675e59b791SLuiz Augusto von Dentz u32 priority) 20680a708f8fSGustavo F. Padovan { 20698c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 20700a708f8fSGustavo F. Padovan struct sk_buff *skb; 207103a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 20720a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 20730a708f8fSGustavo F. Padovan 2074b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu priority %u", chan, len, priority); 20750a708f8fSGustavo F. Padovan 20760a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 20772f7719ceSAndrei Emeltchenko 20782f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 207990338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 208090338947SGustavo Padovan if (IS_ERR(skb)) 208190338947SGustavo Padovan return skb; 20820a708f8fSGustavo F. Padovan 20835e59b791SLuiz Augusto von Dentz skb->priority = priority; 20845e59b791SLuiz Augusto von Dentz 20850a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20860a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2087fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 2088daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 2089daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 20900a708f8fSGustavo F. Padovan 20910952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20920a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20930a708f8fSGustavo F. Padovan kfree_skb(skb); 20940a708f8fSGustavo F. Padovan return ERR_PTR(err); 20950a708f8fSGustavo F. Padovan } 20960a708f8fSGustavo F. Padovan return skb; 20970a708f8fSGustavo F. Padovan } 20980a708f8fSGustavo F. Padovan 20995e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 21005e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 21015e59b791SLuiz Augusto von Dentz u32 priority) 21020a708f8fSGustavo F. Padovan { 21038c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 21040a708f8fSGustavo F. Padovan struct sk_buff *skb; 2105f2ba7faeSGustavo Padovan int err, count; 21060a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 21070a708f8fSGustavo F. Padovan 2108b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 21090a708f8fSGustavo F. Padovan 2110f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 21112f7719ceSAndrei Emeltchenko 2112f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 211390338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 211490338947SGustavo Padovan if (IS_ERR(skb)) 211590338947SGustavo Padovan return skb; 21160a708f8fSGustavo F. Padovan 21175e59b791SLuiz Augusto von Dentz skb->priority = priority; 21185e59b791SLuiz Augusto von Dentz 21190a708f8fSGustavo F. Padovan /* Create L2CAP header */ 21200a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2121fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 21226ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 21230a708f8fSGustavo F. Padovan 21240952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 21250a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 21260a708f8fSGustavo F. Padovan kfree_skb(skb); 21270a708f8fSGustavo F. Padovan return ERR_PTR(err); 21280a708f8fSGustavo F. Padovan } 21290a708f8fSGustavo F. Padovan return skb; 21300a708f8fSGustavo F. Padovan } 21310a708f8fSGustavo F. Padovan 2132ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2133ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 213494122bbeSMat Martineau u16 sdulen) 21350a708f8fSGustavo F. Padovan { 21368c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 21370a708f8fSGustavo F. Padovan struct sk_buff *skb; 2138e4ca6d98SAndrei Emeltchenko int err, count, hlen; 21390a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 21400a708f8fSGustavo F. Padovan 2141b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 21420a708f8fSGustavo F. Padovan 21430a708f8fSGustavo F. Padovan if (!conn) 21440a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 21450a708f8fSGustavo F. Padovan 2146ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2147e4ca6d98SAndrei Emeltchenko 21480a708f8fSGustavo F. Padovan if (sdulen) 214903a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 21500a708f8fSGustavo F. Padovan 215147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 215203a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 21530a708f8fSGustavo F. Padovan 21540a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 21552f7719ceSAndrei Emeltchenko 21562f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 215790338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 215890338947SGustavo Padovan if (IS_ERR(skb)) 215990338947SGustavo Padovan return skb; 21600a708f8fSGustavo F. Padovan 21610a708f8fSGustavo F. Padovan /* Create L2CAP header */ 21620a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2163fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 21640a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 216588843ab0SAndrei Emeltchenko 216618a48e76SMat Martineau /* Control header is populated later */ 216718a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 216818a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 216918a48e76SMat Martineau else 217018a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 217188843ab0SAndrei Emeltchenko 21720a708f8fSGustavo F. Padovan if (sdulen) 217303a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 21740a708f8fSGustavo F. Padovan 21750952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 21760a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 21770a708f8fSGustavo F. Padovan kfree_skb(skb); 21780a708f8fSGustavo F. Padovan return ERR_PTR(err); 21790a708f8fSGustavo F. Padovan } 21800a708f8fSGustavo F. Padovan 218118a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 21823ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 21830a708f8fSGustavo F. Padovan return skb; 21840a708f8fSGustavo F. Padovan } 21850a708f8fSGustavo F. Padovan 218694122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 218794122bbeSMat Martineau struct sk_buff_head *seg_queue, 218894122bbeSMat Martineau struct msghdr *msg, size_t len) 21890a708f8fSGustavo F. Padovan { 21900a708f8fSGustavo F. Padovan struct sk_buff *skb; 219194122bbeSMat Martineau u16 sdu_len; 219294122bbeSMat Martineau size_t pdu_len; 219394122bbeSMat Martineau u8 sar; 21940a708f8fSGustavo F. Padovan 2195b4400672SAndrei Emeltchenko BT_DBG("chan %p, msg %p, len %zu", chan, msg, len); 21960a708f8fSGustavo F. Padovan 219794122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 219894122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 219994122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 220094122bbeSMat Martineau */ 220194122bbeSMat Martineau 220294122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 220394122bbeSMat Martineau pdu_len = chan->conn->mtu; 220494122bbeSMat Martineau 220594122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 220694122bbeSMat Martineau 220794122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 220835d401dfSGustavo Padovan if (chan->fcs) 220935d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 221035d401dfSGustavo Padovan 2211ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 221294122bbeSMat Martineau 221394122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 221494122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 221594122bbeSMat Martineau 221694122bbeSMat Martineau if (len <= pdu_len) { 221794122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 221894122bbeSMat Martineau sdu_len = 0; 221994122bbeSMat Martineau pdu_len = len; 222094122bbeSMat Martineau } else { 222194122bbeSMat Martineau sar = L2CAP_SAR_START; 222294122bbeSMat Martineau sdu_len = len; 222394122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 222494122bbeSMat Martineau } 22250a708f8fSGustavo F. Padovan 22260a708f8fSGustavo F. Padovan while (len > 0) { 222794122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 22280a708f8fSGustavo F. Padovan 22290a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 223094122bbeSMat Martineau __skb_queue_purge(seg_queue); 22310a708f8fSGustavo F. Padovan return PTR_ERR(skb); 22320a708f8fSGustavo F. Padovan } 22330a708f8fSGustavo F. Padovan 223494122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 223594122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 22360a708f8fSGustavo F. Padovan 223794122bbeSMat Martineau len -= pdu_len; 223894122bbeSMat Martineau if (sdu_len) { 223994122bbeSMat Martineau sdu_len = 0; 224094122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 224194122bbeSMat Martineau } 224294122bbeSMat Martineau 224394122bbeSMat Martineau if (len <= pdu_len) { 224494122bbeSMat Martineau sar = L2CAP_SAR_END; 224594122bbeSMat Martineau pdu_len = len; 224694122bbeSMat Martineau } else { 224794122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 224894122bbeSMat Martineau } 224994122bbeSMat Martineau } 225094122bbeSMat Martineau 2251f0f62799SGustavo Padovan return 0; 22520a708f8fSGustavo F. Padovan } 22530a708f8fSGustavo F. Padovan 22545e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 22555e59b791SLuiz Augusto von Dentz u32 priority) 22569a91a04aSGustavo F. Padovan { 22579a91a04aSGustavo F. Padovan struct sk_buff *skb; 22589a91a04aSGustavo F. Padovan int err; 225994122bbeSMat Martineau struct sk_buff_head seg_queue; 22609a91a04aSGustavo F. Padovan 22619a91a04aSGustavo F. Padovan /* Connectionless channel */ 2262715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 22635e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 22649a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 22659a91a04aSGustavo F. Padovan return PTR_ERR(skb); 22669a91a04aSGustavo F. Padovan 22679a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 22689a91a04aSGustavo F. Padovan return len; 22699a91a04aSGustavo F. Padovan } 22709a91a04aSGustavo F. Padovan 22719a91a04aSGustavo F. Padovan switch (chan->mode) { 22729a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 22739a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 22749a91a04aSGustavo F. Padovan if (len > chan->omtu) 22759a91a04aSGustavo F. Padovan return -EMSGSIZE; 22769a91a04aSGustavo F. Padovan 22779a91a04aSGustavo F. Padovan /* Create a basic PDU */ 22785e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 22799a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 22809a91a04aSGustavo F. Padovan return PTR_ERR(skb); 22819a91a04aSGustavo F. Padovan 22829a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 22839a91a04aSGustavo F. Padovan err = len; 22849a91a04aSGustavo F. Padovan break; 22859a91a04aSGustavo F. Padovan 22869a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 22879a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 228894122bbeSMat Martineau /* Check outgoing MTU */ 228994122bbeSMat Martineau if (len > chan->omtu) { 229094122bbeSMat Martineau err = -EMSGSIZE; 22919a91a04aSGustavo F. Padovan break; 22929a91a04aSGustavo F. Padovan } 22939a91a04aSGustavo F. Padovan 229494122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 229594122bbeSMat Martineau 229694122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 229794122bbeSMat Martineau * since it's possible to block while waiting for memory 229894122bbeSMat Martineau * allocation. 229994122bbeSMat Martineau */ 230094122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 230194122bbeSMat Martineau 230294122bbeSMat Martineau /* The channel could have been closed while segmenting, 230394122bbeSMat Martineau * check that it is still connected. 230494122bbeSMat Martineau */ 230594122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 230694122bbeSMat Martineau __skb_queue_purge(&seg_queue); 230794122bbeSMat Martineau err = -ENOTCONN; 23089a91a04aSGustavo F. Padovan } 23099a91a04aSGustavo F. Padovan 231094122bbeSMat Martineau if (err) 231194122bbeSMat Martineau break; 231294122bbeSMat Martineau 23133733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2314d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 23153733937dSMat Martineau else 2316d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 231794122bbeSMat Martineau 23189a91a04aSGustavo F. Padovan err = len; 23199a91a04aSGustavo F. Padovan 232094122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 232194122bbeSMat Martineau * seg_queue and need to be purged. 232294122bbeSMat Martineau */ 232394122bbeSMat Martineau __skb_queue_purge(&seg_queue); 23249a91a04aSGustavo F. Padovan break; 23259a91a04aSGustavo F. Padovan 23269a91a04aSGustavo F. Padovan default: 23279a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 23289a91a04aSGustavo F. Padovan err = -EBADFD; 23299a91a04aSGustavo F. Padovan } 23309a91a04aSGustavo F. Padovan 23319a91a04aSGustavo F. Padovan return err; 23329a91a04aSGustavo F. Padovan } 23339a91a04aSGustavo F. Padovan 2334d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2335d2a7ac5dSMat Martineau { 2336bed68bdeSMat Martineau struct l2cap_ctrl control; 2337bed68bdeSMat Martineau u16 seq; 2338bed68bdeSMat Martineau 2339b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2340bed68bdeSMat Martineau 2341bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2342bed68bdeSMat Martineau control.sframe = 1; 2343bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2344bed68bdeSMat Martineau 2345bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2346bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2347bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2348bed68bdeSMat Martineau control.reqseq = seq; 2349bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2350bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2351bed68bdeSMat Martineau } 2352bed68bdeSMat Martineau } 2353bed68bdeSMat Martineau 2354bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2355d2a7ac5dSMat Martineau } 2356d2a7ac5dSMat Martineau 2357d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2358d2a7ac5dSMat Martineau { 2359bed68bdeSMat Martineau struct l2cap_ctrl control; 2360bed68bdeSMat Martineau 2361bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2362bed68bdeSMat Martineau 2363bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2364bed68bdeSMat Martineau return; 2365bed68bdeSMat Martineau 2366bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2367bed68bdeSMat Martineau control.sframe = 1; 2368bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2369bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2370bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2371d2a7ac5dSMat Martineau } 2372d2a7ac5dSMat Martineau 2373d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2374d2a7ac5dSMat Martineau { 2375bed68bdeSMat Martineau struct l2cap_ctrl control; 2376bed68bdeSMat Martineau u16 initial_head; 2377bed68bdeSMat Martineau u16 seq; 2378bed68bdeSMat Martineau 2379b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2380bed68bdeSMat Martineau 2381bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2382bed68bdeSMat Martineau control.sframe = 1; 2383bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2384bed68bdeSMat Martineau 2385bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2386bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2387bed68bdeSMat Martineau 2388bed68bdeSMat Martineau do { 2389bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2390bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2391bed68bdeSMat Martineau break; 2392bed68bdeSMat Martineau 2393bed68bdeSMat Martineau control.reqseq = seq; 2394bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2395bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2396bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2397d2a7ac5dSMat Martineau } 2398d2a7ac5dSMat Martineau 2399608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2400608bcc6dSMat Martineau { 2401608bcc6dSMat Martineau struct sk_buff *acked_skb; 2402608bcc6dSMat Martineau u16 ackseq; 2403608bcc6dSMat Martineau 2404b4400672SAndrei Emeltchenko BT_DBG("chan %p, reqseq %u", chan, reqseq); 2405608bcc6dSMat Martineau 2406608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2407608bcc6dSMat Martineau return; 2408608bcc6dSMat Martineau 2409b4400672SAndrei Emeltchenko BT_DBG("expected_ack_seq %u, unacked_frames %u", 2410608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2411608bcc6dSMat Martineau 2412608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2413608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2414608bcc6dSMat Martineau 2415608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2416608bcc6dSMat Martineau if (acked_skb) { 2417608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2418608bcc6dSMat Martineau kfree_skb(acked_skb); 2419608bcc6dSMat Martineau chan->unacked_frames--; 2420608bcc6dSMat Martineau } 2421608bcc6dSMat Martineau } 2422608bcc6dSMat Martineau 2423608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2424608bcc6dSMat Martineau 2425608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2426608bcc6dSMat Martineau __clear_retrans_timer(chan); 2427608bcc6dSMat Martineau 2428b4400672SAndrei Emeltchenko BT_DBG("unacked_frames %u", chan->unacked_frames); 2429608bcc6dSMat Martineau } 2430608bcc6dSMat Martineau 2431608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2432608bcc6dSMat Martineau { 2433608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2434608bcc6dSMat Martineau 2435608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2436608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2437608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2438608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2439608bcc6dSMat Martineau } 2440608bcc6dSMat Martineau 2441d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2442608bcc6dSMat Martineau struct l2cap_ctrl *control, 2443608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2444608bcc6dSMat Martineau { 2445608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2446608bcc6dSMat Martineau event); 2447608bcc6dSMat Martineau 2448608bcc6dSMat Martineau switch (event) { 2449608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2450608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2451608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2452608bcc6dSMat Martineau 2453608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2454608bcc6dSMat Martineau l2cap_ertm_send(chan); 2455608bcc6dSMat Martineau break; 2456608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2457608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2458608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2459608bcc6dSMat Martineau 2460608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2461608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2462608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2463608bcc6dSMat Martineau */ 2464608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2465608bcc6dSMat Martineau } 2466608bcc6dSMat Martineau 2467608bcc6dSMat Martineau l2cap_send_ack(chan); 2468608bcc6dSMat Martineau 2469608bcc6dSMat Martineau break; 2470608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2471608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2472608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2473608bcc6dSMat Martineau 2474608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2475608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2476608bcc6dSMat Martineau 2477608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2478608bcc6dSMat Martineau local_control.sframe = 1; 2479608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2480608bcc6dSMat Martineau local_control.poll = 1; 2481608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2482a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2483608bcc6dSMat Martineau 2484608bcc6dSMat Martineau chan->retry_count = 1; 2485608bcc6dSMat Martineau __set_monitor_timer(chan); 2486608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2487608bcc6dSMat Martineau } 2488608bcc6dSMat Martineau break; 2489608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2490608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2491608bcc6dSMat Martineau break; 2492608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2493608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2494608bcc6dSMat Martineau chan->retry_count = 1; 2495608bcc6dSMat Martineau __set_monitor_timer(chan); 2496608bcc6dSMat Martineau __clear_ack_timer(chan); 2497608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2498608bcc6dSMat Martineau break; 2499608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2500608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2501608bcc6dSMat Martineau chan->retry_count = 1; 2502608bcc6dSMat Martineau __set_monitor_timer(chan); 2503608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2504608bcc6dSMat Martineau break; 2505608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2506608bcc6dSMat Martineau /* Nothing to process */ 2507608bcc6dSMat Martineau break; 2508608bcc6dSMat Martineau default: 2509608bcc6dSMat Martineau break; 2510608bcc6dSMat Martineau } 2511608bcc6dSMat Martineau } 2512608bcc6dSMat Martineau 2513d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2514608bcc6dSMat Martineau struct l2cap_ctrl *control, 2515608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2516608bcc6dSMat Martineau { 2517608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2518608bcc6dSMat Martineau event); 2519608bcc6dSMat Martineau 2520608bcc6dSMat Martineau switch (event) { 2521608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2522608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2523608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2524608bcc6dSMat Martineau /* Queue data, but don't send. */ 2525608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2526608bcc6dSMat Martineau break; 2527608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2528608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2529608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2530608bcc6dSMat Martineau 2531608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2532608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2533608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2534608bcc6dSMat Martineau */ 2535608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2536608bcc6dSMat Martineau } 2537608bcc6dSMat Martineau 2538608bcc6dSMat Martineau l2cap_send_ack(chan); 2539608bcc6dSMat Martineau 2540608bcc6dSMat Martineau break; 2541608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2542608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2543608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2544608bcc6dSMat Martineau 2545608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2546608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2547608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2548608bcc6dSMat Martineau local_control.sframe = 1; 2549608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2550608bcc6dSMat Martineau local_control.poll = 1; 2551608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2552a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2553608bcc6dSMat Martineau 2554608bcc6dSMat Martineau chan->retry_count = 1; 2555608bcc6dSMat Martineau __set_monitor_timer(chan); 2556608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2557608bcc6dSMat Martineau } 2558608bcc6dSMat Martineau break; 2559608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2560608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2561608bcc6dSMat Martineau 2562608bcc6dSMat Martineau /* Fall through */ 2563608bcc6dSMat Martineau 2564608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2565608bcc6dSMat Martineau if (control && control->final) { 2566608bcc6dSMat Martineau __clear_monitor_timer(chan); 2567608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2568608bcc6dSMat Martineau __set_retrans_timer(chan); 2569608bcc6dSMat Martineau chan->retry_count = 0; 2570608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2571608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2572608bcc6dSMat Martineau } 2573608bcc6dSMat Martineau break; 2574608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2575608bcc6dSMat Martineau /* Ignore */ 2576608bcc6dSMat Martineau break; 2577608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2578608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2579608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2580608bcc6dSMat Martineau __set_monitor_timer(chan); 2581608bcc6dSMat Martineau chan->retry_count++; 2582608bcc6dSMat Martineau } else { 2583608bcc6dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED); 2584608bcc6dSMat Martineau } 2585608bcc6dSMat Martineau break; 2586608bcc6dSMat Martineau default: 2587608bcc6dSMat Martineau break; 2588608bcc6dSMat Martineau } 2589608bcc6dSMat Martineau } 2590608bcc6dSMat Martineau 2591d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2592608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2593608bcc6dSMat Martineau { 2594608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2595608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2596608bcc6dSMat Martineau 2597608bcc6dSMat Martineau switch (chan->tx_state) { 2598608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2599d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2600608bcc6dSMat Martineau break; 2601608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2602d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2603608bcc6dSMat Martineau break; 2604608bcc6dSMat Martineau default: 2605608bcc6dSMat Martineau /* Ignore event */ 2606608bcc6dSMat Martineau break; 2607608bcc6dSMat Martineau } 2608608bcc6dSMat Martineau } 2609608bcc6dSMat Martineau 26104b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 26114b51dae9SMat Martineau struct l2cap_ctrl *control) 26124b51dae9SMat Martineau { 26134b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2614401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 26154b51dae9SMat Martineau } 26164b51dae9SMat Martineau 2617f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2618f80842a8SMat Martineau struct l2cap_ctrl *control) 2619f80842a8SMat Martineau { 2620f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2621401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2622f80842a8SMat Martineau } 2623f80842a8SMat Martineau 26240a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 26250a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 26260a708f8fSGustavo F. Padovan { 26270a708f8fSGustavo F. Padovan struct sk_buff *nskb; 262848454079SGustavo F. Padovan struct l2cap_chan *chan; 26290a708f8fSGustavo F. Padovan 26300a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 26310a708f8fSGustavo F. Padovan 26323df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 26333d57dc68SGustavo F. Padovan 26343df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 263548454079SGustavo F. Padovan struct sock *sk = chan->sk; 2636715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 26370a708f8fSGustavo F. Padovan continue; 26380a708f8fSGustavo F. Padovan 26390a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 26400a708f8fSGustavo F. Padovan if (skb->sk == sk) 26410a708f8fSGustavo F. Padovan continue; 26428bcde1f2SGustavo Padovan nskb = skb_clone(skb, GFP_KERNEL); 26430a708f8fSGustavo F. Padovan if (!nskb) 26440a708f8fSGustavo F. Padovan continue; 26450a708f8fSGustavo F. Padovan 264680b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 26470a708f8fSGustavo F. Padovan kfree_skb(nskb); 26480a708f8fSGustavo F. Padovan } 26493d57dc68SGustavo F. Padovan 26503df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 26510a708f8fSGustavo F. Padovan } 26520a708f8fSGustavo F. Padovan 26530a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 2654b4400672SAndrei Emeltchenko static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code, 2655b4400672SAndrei Emeltchenko u8 ident, u16 dlen, void *data) 26560a708f8fSGustavo F. Padovan { 26570a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 26580a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 26590a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 26600a708f8fSGustavo F. Padovan int len, count; 26610a708f8fSGustavo F. Padovan 2662b4400672SAndrei Emeltchenko BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u", 26630a708f8fSGustavo F. Padovan conn, code, ident, dlen); 26640a708f8fSGustavo F. Padovan 26650a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 26660a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 26670a708f8fSGustavo F. Padovan 26688bcde1f2SGustavo Padovan skb = bt_skb_alloc(count, GFP_KERNEL); 26690a708f8fSGustavo F. Padovan if (!skb) 26700a708f8fSGustavo F. Padovan return NULL; 26710a708f8fSGustavo F. Padovan 26720a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 26730a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 26743300d9a9SClaudio Takahasi 26753300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2676ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 26773300d9a9SClaudio Takahasi else 2678ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 26790a708f8fSGustavo F. Padovan 26800a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 26810a708f8fSGustavo F. Padovan cmd->code = code; 26820a708f8fSGustavo F. Padovan cmd->ident = ident; 26830a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 26840a708f8fSGustavo F. Padovan 26850a708f8fSGustavo F. Padovan if (dlen) { 26860a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 26870a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 26880a708f8fSGustavo F. Padovan data += count; 26890a708f8fSGustavo F. Padovan } 26900a708f8fSGustavo F. Padovan 26910a708f8fSGustavo F. Padovan len -= skb->len; 26920a708f8fSGustavo F. Padovan 26930a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 26940a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 26950a708f8fSGustavo F. Padovan while (len) { 26960a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 26970a708f8fSGustavo F. Padovan 26988bcde1f2SGustavo Padovan *frag = bt_skb_alloc(count, GFP_KERNEL); 26990a708f8fSGustavo F. Padovan if (!*frag) 27000a708f8fSGustavo F. Padovan goto fail; 27010a708f8fSGustavo F. Padovan 27020a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 27030a708f8fSGustavo F. Padovan 27040a708f8fSGustavo F. Padovan len -= count; 27050a708f8fSGustavo F. Padovan data += count; 27060a708f8fSGustavo F. Padovan 27070a708f8fSGustavo F. Padovan frag = &(*frag)->next; 27080a708f8fSGustavo F. Padovan } 27090a708f8fSGustavo F. Padovan 27100a708f8fSGustavo F. Padovan return skb; 27110a708f8fSGustavo F. Padovan 27120a708f8fSGustavo F. Padovan fail: 27130a708f8fSGustavo F. Padovan kfree_skb(skb); 27140a708f8fSGustavo F. Padovan return NULL; 27150a708f8fSGustavo F. Padovan } 27160a708f8fSGustavo F. Padovan 27172d792818SGustavo Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, 27182d792818SGustavo Padovan unsigned long *val) 27190a708f8fSGustavo F. Padovan { 27200a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 27210a708f8fSGustavo F. Padovan int len; 27220a708f8fSGustavo F. Padovan 27230a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 27240a708f8fSGustavo F. Padovan *ptr += len; 27250a708f8fSGustavo F. Padovan 27260a708f8fSGustavo F. Padovan *type = opt->type; 27270a708f8fSGustavo F. Padovan *olen = opt->len; 27280a708f8fSGustavo F. Padovan 27290a708f8fSGustavo F. Padovan switch (opt->len) { 27300a708f8fSGustavo F. Padovan case 1: 27310a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 27320a708f8fSGustavo F. Padovan break; 27330a708f8fSGustavo F. Padovan 27340a708f8fSGustavo F. Padovan case 2: 27350a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 27360a708f8fSGustavo F. Padovan break; 27370a708f8fSGustavo F. Padovan 27380a708f8fSGustavo F. Padovan case 4: 27390a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 27400a708f8fSGustavo F. Padovan break; 27410a708f8fSGustavo F. Padovan 27420a708f8fSGustavo F. Padovan default: 27430a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 27440a708f8fSGustavo F. Padovan break; 27450a708f8fSGustavo F. Padovan } 27460a708f8fSGustavo F. Padovan 2747b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val); 27480a708f8fSGustavo F. Padovan return len; 27490a708f8fSGustavo F. Padovan } 27500a708f8fSGustavo F. Padovan 27510a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 27520a708f8fSGustavo F. Padovan { 27530a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 27540a708f8fSGustavo F. Padovan 2755b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val); 27560a708f8fSGustavo F. Padovan 27570a708f8fSGustavo F. Padovan opt->type = type; 27580a708f8fSGustavo F. Padovan opt->len = len; 27590a708f8fSGustavo F. Padovan 27600a708f8fSGustavo F. Padovan switch (len) { 27610a708f8fSGustavo F. Padovan case 1: 27620a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 27630a708f8fSGustavo F. Padovan break; 27640a708f8fSGustavo F. Padovan 27650a708f8fSGustavo F. Padovan case 2: 27660a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 27670a708f8fSGustavo F. Padovan break; 27680a708f8fSGustavo F. Padovan 27690a708f8fSGustavo F. Padovan case 4: 27700a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 27710a708f8fSGustavo F. Padovan break; 27720a708f8fSGustavo F. Padovan 27730a708f8fSGustavo F. Padovan default: 27740a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 27750a708f8fSGustavo F. Padovan break; 27760a708f8fSGustavo F. Padovan } 27770a708f8fSGustavo F. Padovan 27780a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 27790a708f8fSGustavo F. Padovan } 27800a708f8fSGustavo F. Padovan 2781f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2782f89cef09SAndrei Emeltchenko { 2783f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2784f89cef09SAndrei Emeltchenko 2785f89cef09SAndrei Emeltchenko switch (chan->mode) { 2786f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2787f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2788f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2789f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2790f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2791ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 27928936fa6dSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_EFS_DEFAULT_FLUSH_TO); 2793f89cef09SAndrei Emeltchenko break; 2794f89cef09SAndrei Emeltchenko 2795f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2796f89cef09SAndrei Emeltchenko efs.id = 1; 2797f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2798f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2799f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2800f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2801f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2802f89cef09SAndrei Emeltchenko break; 2803f89cef09SAndrei Emeltchenko 2804f89cef09SAndrei Emeltchenko default: 2805f89cef09SAndrei Emeltchenko return; 2806f89cef09SAndrei Emeltchenko } 2807f89cef09SAndrei Emeltchenko 2808f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2809f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2810f89cef09SAndrei Emeltchenko } 2811f89cef09SAndrei Emeltchenko 2812721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 28130a708f8fSGustavo F. Padovan { 2814721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2815721c4181SGustavo F. Padovan ack_timer.work); 28160362520bSMat Martineau u16 frames_to_ack; 28170a708f8fSGustavo F. Padovan 28182fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 28192fb9b3d4SGustavo F. Padovan 28206be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 28216be36555SAndrei Emeltchenko 28220362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 28230362520bSMat Martineau chan->last_acked_seq); 28240362520bSMat Martineau 28250362520bSMat Martineau if (frames_to_ack) 28260362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 28276be36555SAndrei Emeltchenko 28286be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 282909bfb2eeSSzymon Janc l2cap_chan_put(chan); 28300a708f8fSGustavo F. Padovan } 28310a708f8fSGustavo F. Padovan 2832466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 28330a708f8fSGustavo F. Padovan { 28343c588192SMat Martineau int err; 28353c588192SMat Martineau 2836105bdf9eSMat Martineau chan->next_tx_seq = 0; 2837105bdf9eSMat Martineau chan->expected_tx_seq = 0; 283842e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 28396a026610SGustavo F. Padovan chan->unacked_frames = 0; 284042e5c802SGustavo F. Padovan chan->buffer_seq = 0; 28416a026610SGustavo F. Padovan chan->frames_sent = 0; 2842105bdf9eSMat Martineau chan->last_acked_seq = 0; 2843105bdf9eSMat Martineau chan->sdu = NULL; 2844105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2845105bdf9eSMat Martineau chan->sdu_len = 0; 2846105bdf9eSMat Martineau 2847d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2848d34c34fbSMat Martineau 284908333283SMat Martineau chan->local_amp_id = 0; 285008333283SMat Martineau chan->move_id = 0; 285108333283SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 285208333283SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 285308333283SMat Martineau 2854105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2855105bdf9eSMat Martineau return 0; 2856105bdf9eSMat Martineau 2857105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2858105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 28590a708f8fSGustavo F. Padovan 2860721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2861721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2862721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 28630a708f8fSGustavo F. Padovan 2864f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 28650a708f8fSGustavo F. Padovan 28663c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 28673c588192SMat Martineau if (err < 0) 28683c588192SMat Martineau return err; 28693c588192SMat Martineau 28709dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 28719dc9affcSMat Martineau if (err < 0) 28729dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 28739dc9affcSMat Martineau 28749dc9affcSMat Martineau return err; 28750a708f8fSGustavo F. Padovan } 28760a708f8fSGustavo F. Padovan 28770a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 28780a708f8fSGustavo F. Padovan { 28790a708f8fSGustavo F. Padovan switch (mode) { 28800a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 28810a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 28820a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 28830a708f8fSGustavo F. Padovan return mode; 28840a708f8fSGustavo F. Padovan /* fall through */ 28850a708f8fSGustavo F. Padovan default: 28860a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 28870a708f8fSGustavo F. Padovan } 28880a708f8fSGustavo F. Padovan } 28890a708f8fSGustavo F. Padovan 28906327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 28916327eb98SAndrei Emeltchenko { 28926327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 28936327eb98SAndrei Emeltchenko } 28946327eb98SAndrei Emeltchenko 2895f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2896f89cef09SAndrei Emeltchenko { 2897f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2898f89cef09SAndrei Emeltchenko } 2899f89cef09SAndrei Emeltchenko 29006327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 29016327eb98SAndrei Emeltchenko { 29026327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 2903836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 29046327eb98SAndrei Emeltchenko /* use extended control field */ 29056327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 2906836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 2907836be934SAndrei Emeltchenko } else { 29086327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 29096327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 2910836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 2911836be934SAndrei Emeltchenko } 2912c20f8e35SMat Martineau chan->ack_win = chan->tx_win; 29136327eb98SAndrei Emeltchenko } 29146327eb98SAndrei Emeltchenko 2915710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 29160a708f8fSGustavo F. Padovan { 29170a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 29180c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 29190a708f8fSGustavo F. Padovan void *ptr = req->data; 2920c8f79162SAndrei Emeltchenko u16 size; 29210a708f8fSGustavo F. Padovan 292249208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 29230a708f8fSGustavo F. Padovan 292473ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 29250a708f8fSGustavo F. Padovan goto done; 29260a708f8fSGustavo F. Padovan 29270c1bc5c6SGustavo F. Padovan switch (chan->mode) { 29280a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 29290a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2930c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 29310a708f8fSGustavo F. Padovan break; 29320a708f8fSGustavo F. Padovan 2933f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 2934f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 2935f89cef09SAndrei Emeltchenko 29360a708f8fSGustavo F. Padovan /* fall through */ 29370a708f8fSGustavo F. Padovan default: 29388c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 29390a708f8fSGustavo F. Padovan break; 29400a708f8fSGustavo F. Padovan } 29410a708f8fSGustavo F. Padovan 29420a708f8fSGustavo F. Padovan done: 29430c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 29440c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 29450a708f8fSGustavo F. Padovan 29460c1bc5c6SGustavo F. Padovan switch (chan->mode) { 29470a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 29488c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 29498c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 29500a708f8fSGustavo F. Padovan break; 29510a708f8fSGustavo F. Padovan 29520a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 29530a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 29540a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 29550a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 29560a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 29570a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 29580a708f8fSGustavo F. Padovan 29590a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 29600a708f8fSGustavo F. Padovan (unsigned long) &rfc); 29610a708f8fSGustavo F. Padovan break; 29620a708f8fSGustavo F. Padovan 29630a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 29640a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 296547d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 29660a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 29670a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2968c8f79162SAndrei Emeltchenko 2969c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 29702d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 2971c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2972c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 29730a708f8fSGustavo F. Padovan 29746327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 29756327eb98SAndrei Emeltchenko 29766327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 29776327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 29780a708f8fSGustavo F. Padovan 29790a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 29800a708f8fSGustavo F. Padovan (unsigned long) &rfc); 29810a708f8fSGustavo F. Padovan 2982f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2983f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2984f89cef09SAndrei Emeltchenko 29858c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 29860a708f8fSGustavo F. Padovan break; 29870a708f8fSGustavo F. Padovan 298847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2989c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 299047d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 299147d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 29920a708f8fSGustavo F. Padovan } 29936327eb98SAndrei Emeltchenko 29946327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 29956327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 29966327eb98SAndrei Emeltchenko chan->tx_win); 29970a708f8fSGustavo F. Padovan break; 29980a708f8fSGustavo F. Padovan 29990a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3000273759e2SMat Martineau l2cap_txwin_setup(chan); 30010a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 30020a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 30030a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 30040a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 30050a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 3006c8f79162SAndrei Emeltchenko 3007c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 30082d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3009c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3010c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 30110a708f8fSGustavo F. Padovan 30120a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 30130a708f8fSGustavo F. Padovan (unsigned long) &rfc); 30140a708f8fSGustavo F. Padovan 3015f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3016f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3017f89cef09SAndrei Emeltchenko 30188c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 30190a708f8fSGustavo F. Padovan break; 30200a708f8fSGustavo F. Padovan 302147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 3022c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 302347d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 302447d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 30250a708f8fSGustavo F. Padovan } 30260a708f8fSGustavo F. Padovan break; 30270a708f8fSGustavo F. Padovan } 30280a708f8fSGustavo F. Padovan 3029fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 303059e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 30310a708f8fSGustavo F. Padovan 30320a708f8fSGustavo F. Padovan return ptr - data; 30330a708f8fSGustavo F. Padovan } 30340a708f8fSGustavo F. Padovan 303573ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 30360a708f8fSGustavo F. Padovan { 30370a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 30380a708f8fSGustavo F. Padovan void *ptr = rsp->data; 303973ffa904SGustavo F. Padovan void *req = chan->conf_req; 304073ffa904SGustavo F. Padovan int len = chan->conf_len; 30410a708f8fSGustavo F. Padovan int type, hint, olen; 30420a708f8fSGustavo F. Padovan unsigned long val; 30430a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 304442dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 304542dceae2SAndrei Emeltchenko u8 remote_efs = 0; 30460a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 30470a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 3048c8f79162SAndrei Emeltchenko u16 size; 30490a708f8fSGustavo F. Padovan 305073ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 30510a708f8fSGustavo F. Padovan 30520a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 30530a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 30540a708f8fSGustavo F. Padovan 30550a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 30560a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 30570a708f8fSGustavo F. Padovan 30580a708f8fSGustavo F. Padovan switch (type) { 30590a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 30600a708f8fSGustavo F. Padovan mtu = val; 30610a708f8fSGustavo F. Padovan break; 30620a708f8fSGustavo F. Padovan 30630a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 30640c1bc5c6SGustavo F. Padovan chan->flush_to = val; 30650a708f8fSGustavo F. Padovan break; 30660a708f8fSGustavo F. Padovan 30670a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 30680a708f8fSGustavo F. Padovan break; 30690a708f8fSGustavo F. Padovan 30700a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 30710a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 30720a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 30730a708f8fSGustavo F. Padovan break; 30740a708f8fSGustavo F. Padovan 30750a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 30760a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 3077c1360a1cSGustavo F. Padovan set_bit(CONF_NO_FCS_RECV, &chan->conf_state); 307842dceae2SAndrei Emeltchenko break; 30790a708f8fSGustavo F. Padovan 308042dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 308142dceae2SAndrei Emeltchenko remote_efs = 1; 308242dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 308342dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 30840a708f8fSGustavo F. Padovan break; 30850a708f8fSGustavo F. Padovan 30866327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 30876327eb98SAndrei Emeltchenko if (!enable_hs) 30886327eb98SAndrei Emeltchenko return -ECONNREFUSED; 30896327eb98SAndrei Emeltchenko 30906327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 30916327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 3092836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 30936327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 30940a708f8fSGustavo F. Padovan break; 30950a708f8fSGustavo F. Padovan 30960a708f8fSGustavo F. Padovan default: 30970a708f8fSGustavo F. Padovan if (hint) 30980a708f8fSGustavo F. Padovan break; 30990a708f8fSGustavo F. Padovan 31000a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 31010a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 31020a708f8fSGustavo F. Padovan break; 31030a708f8fSGustavo F. Padovan } 31040a708f8fSGustavo F. Padovan } 31050a708f8fSGustavo F. Padovan 310673ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 31070a708f8fSGustavo F. Padovan goto done; 31080a708f8fSGustavo F. Padovan 31090c1bc5c6SGustavo F. Padovan switch (chan->mode) { 31100a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 31110a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3112c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 31130c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 31148c1d787bSGustavo F. Padovan chan->conn->feat_mask); 31150a708f8fSGustavo F. Padovan break; 31160a708f8fSGustavo F. Padovan } 31170a708f8fSGustavo F. Padovan 311842dceae2SAndrei Emeltchenko if (remote_efs) { 311942dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 312042dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 312142dceae2SAndrei Emeltchenko else 312242dceae2SAndrei Emeltchenko return -ECONNREFUSED; 312342dceae2SAndrei Emeltchenko } 312442dceae2SAndrei Emeltchenko 31250c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 31260a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31270a708f8fSGustavo F. Padovan 31280a708f8fSGustavo F. Padovan break; 31290a708f8fSGustavo F. Padovan } 31300a708f8fSGustavo F. Padovan 31310a708f8fSGustavo F. Padovan done: 31320c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 31330a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 31340c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 31350a708f8fSGustavo F. Padovan 313673ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 31370a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31380a708f8fSGustavo F. Padovan 31392d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 31402d792818SGustavo Padovan (unsigned long) &rfc); 31410a708f8fSGustavo F. Padovan } 31420a708f8fSGustavo F. Padovan 31430a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 31440a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 31450a708f8fSGustavo F. Padovan * which ones we don't like. */ 31460a708f8fSGustavo F. Padovan 31470a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 31480a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 31490a708f8fSGustavo F. Padovan else { 31500c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3151c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 31520a708f8fSGustavo F. Padovan } 31530c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 31540a708f8fSGustavo F. Padovan 315542dceae2SAndrei Emeltchenko if (remote_efs) { 315642dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 315742dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 315842dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 315942dceae2SAndrei Emeltchenko 316042dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 316142dceae2SAndrei Emeltchenko 316242dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 316342dceae2SAndrei Emeltchenko return -ECONNREFUSED; 316442dceae2SAndrei Emeltchenko 316542dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 316642dceae2SAndrei Emeltchenko sizeof(efs), 316742dceae2SAndrei Emeltchenko (unsigned long) &efs); 31680e8b207eSAndrei Emeltchenko } else { 31693e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 31700e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 31710e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 317242dceae2SAndrei Emeltchenko } 317342dceae2SAndrei Emeltchenko } 317442dceae2SAndrei Emeltchenko 31750a708f8fSGustavo F. Padovan switch (rfc.mode) { 31760a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 317747d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3178c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 31790a708f8fSGustavo F. Padovan break; 31800a708f8fSGustavo F. Padovan 31810a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 31826327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 31832c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 31846327eb98SAndrei Emeltchenko else 31856327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 31866327eb98SAndrei Emeltchenko 31872c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 31880a708f8fSGustavo F. Padovan 3189c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 31902d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 31912d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3192c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3193c8f79162SAndrei Emeltchenko chan->remote_mps = size; 31940a708f8fSGustavo F. Padovan 31950a708f8fSGustavo F. Padovan rfc.retrans_timeout = 31964fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 31970a708f8fSGustavo F. Padovan rfc.monitor_timeout = 31984fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 31990a708f8fSGustavo F. Padovan 3200c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 32010a708f8fSGustavo F. Padovan 32020a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 32030a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 32040a708f8fSGustavo F. Padovan 320542dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 320642dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 320742dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 320842dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 320942dceae2SAndrei Emeltchenko chan->remote_flush_to = 321042dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 321142dceae2SAndrei Emeltchenko chan->remote_acc_lat = 321242dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 321342dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 321442dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 321542dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 32162d792818SGustavo Padovan sizeof(efs), 32172d792818SGustavo Padovan (unsigned long) &efs); 321842dceae2SAndrei Emeltchenko } 32190a708f8fSGustavo F. Padovan break; 32200a708f8fSGustavo F. Padovan 32210a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3222c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 32232d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 32242d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3225c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3226c8f79162SAndrei Emeltchenko chan->remote_mps = size; 32270a708f8fSGustavo F. Padovan 3228c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 32290a708f8fSGustavo F. Padovan 32302d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 32312d792818SGustavo Padovan (unsigned long) &rfc); 32320a708f8fSGustavo F. Padovan 32330a708f8fSGustavo F. Padovan break; 32340a708f8fSGustavo F. Padovan 32350a708f8fSGustavo F. Padovan default: 32360a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 32370a708f8fSGustavo F. Padovan 32380a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 32390c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 32400a708f8fSGustavo F. Padovan } 32410a708f8fSGustavo F. Padovan 32420a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3243c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 32440a708f8fSGustavo F. Padovan } 3245fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 32460a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 324759e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 32480a708f8fSGustavo F. Padovan 32490a708f8fSGustavo F. Padovan return ptr - data; 32500a708f8fSGustavo F. Padovan } 32510a708f8fSGustavo F. Padovan 32522d792818SGustavo Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, 32532d792818SGustavo Padovan void *data, u16 *result) 32540a708f8fSGustavo F. Padovan { 32550a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 32560a708f8fSGustavo F. Padovan void *ptr = req->data; 32570a708f8fSGustavo F. Padovan int type, olen; 32580a708f8fSGustavo F. Padovan unsigned long val; 325936e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 326066af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 32610a708f8fSGustavo F. Padovan 3262fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 32630a708f8fSGustavo F. Padovan 32640a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32650a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 32660a708f8fSGustavo F. Padovan 32670a708f8fSGustavo F. Padovan switch (type) { 32680a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 32690a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 32700a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 32710c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 32720a708f8fSGustavo F. Padovan } else 32730c1bc5c6SGustavo F. Padovan chan->imtu = val; 32740c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 32750a708f8fSGustavo F. Padovan break; 32760a708f8fSGustavo F. Padovan 32770a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 32780c1bc5c6SGustavo F. Padovan chan->flush_to = val; 32790a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 32800c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 32810a708f8fSGustavo F. Padovan break; 32820a708f8fSGustavo F. Padovan 32830a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 32840a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 32850a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 32860a708f8fSGustavo F. Padovan 3287c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 32880c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 32890a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32900a708f8fSGustavo F. Padovan 329147d1ec61SGustavo F. Padovan chan->fcs = 0; 32920a708f8fSGustavo F. Padovan 32930a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 32940a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 32950a708f8fSGustavo F. Padovan break; 32966327eb98SAndrei Emeltchenko 32976327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 3298c20f8e35SMat Martineau chan->ack_win = min_t(u16, val, chan->ack_win); 32993e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 33003e6b3b95SGustavo F. Padovan chan->tx_win); 33016327eb98SAndrei Emeltchenko break; 330266af7aafSAndrei Emeltchenko 330366af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 330466af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 330566af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 330666af7aafSAndrei Emeltchenko 330766af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 330866af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 330966af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 331066af7aafSAndrei Emeltchenko return -ECONNREFUSED; 331166af7aafSAndrei Emeltchenko 33122d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, sizeof(efs), 33132d792818SGustavo Padovan (unsigned long) &efs); 331466af7aafSAndrei Emeltchenko break; 33150a708f8fSGustavo F. Padovan } 33160a708f8fSGustavo F. Padovan } 33170a708f8fSGustavo F. Padovan 33180c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 33190a708f8fSGustavo F. Padovan return -ECONNREFUSED; 33200a708f8fSGustavo F. Padovan 33210c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 33220a708f8fSGustavo F. Padovan 33230e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 33240a708f8fSGustavo F. Padovan switch (rfc.mode) { 33250a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 332647d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 332747d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 332847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3329c20f8e35SMat Martineau if (!test_bit(FLAG_EXT_CTRL, &chan->flags)) 3330c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3331c20f8e35SMat Martineau rfc.txwin_size); 333266af7aafSAndrei Emeltchenko 333366af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 333466af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 333566af7aafSAndrei Emeltchenko chan->local_sdu_itime = 333666af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 333766af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 333866af7aafSAndrei Emeltchenko chan->local_flush_to = 333966af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 334066af7aafSAndrei Emeltchenko } 33410a708f8fSGustavo F. Padovan break; 334266af7aafSAndrei Emeltchenko 33430a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 334447d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 33450a708f8fSGustavo F. Padovan } 33460a708f8fSGustavo F. Padovan } 33470a708f8fSGustavo F. Padovan 3348fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 334959e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 33500a708f8fSGustavo F. Padovan 33510a708f8fSGustavo F. Padovan return ptr - data; 33520a708f8fSGustavo F. Padovan } 33530a708f8fSGustavo F. Padovan 33542d792818SGustavo Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, 33552d792818SGustavo Padovan u16 result, u16 flags) 33560a708f8fSGustavo F. Padovan { 33570a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 33580a708f8fSGustavo F. Padovan void *ptr = rsp->data; 33590a708f8fSGustavo F. Padovan 3360fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 33610a708f8fSGustavo F. Padovan 3362fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 33630a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 33640a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 33650a708f8fSGustavo F. Padovan 33660a708f8fSGustavo F. Padovan return ptr - data; 33670a708f8fSGustavo F. Padovan } 33680a708f8fSGustavo F. Padovan 33698c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3370710f9b0aSGustavo F. Padovan { 3371710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 33728c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3373710f9b0aSGustavo F. Padovan u8 buf[128]; 3374710f9b0aSGustavo F. Padovan 3375fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3376fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3377ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3378ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 33792d792818SGustavo Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp); 3380710f9b0aSGustavo F. Padovan 3381c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3382710f9b0aSGustavo F. Padovan return; 3383710f9b0aSGustavo F. Padovan 3384710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3385710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3386710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3387710f9b0aSGustavo F. Padovan } 3388710f9b0aSGustavo F. Padovan 338947d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 33900a708f8fSGustavo F. Padovan { 33910a708f8fSGustavo F. Padovan int type, olen; 33920a708f8fSGustavo F. Padovan unsigned long val; 3393c20f8e35SMat Martineau /* Use sane default values in case a misbehaving remote device 3394c20f8e35SMat Martineau * did not send an RFC or extended window size option. 3395c20f8e35SMat Martineau */ 3396c20f8e35SMat Martineau u16 txwin_ext = chan->ack_win; 3397c20f8e35SMat Martineau struct l2cap_conf_rfc rfc = { 3398c20f8e35SMat Martineau .mode = chan->mode, 3399c20f8e35SMat Martineau .retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO), 3400c20f8e35SMat Martineau .monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO), 3401c20f8e35SMat Martineau .max_pdu_size = cpu_to_le16(chan->imtu), 3402c20f8e35SMat Martineau .txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW), 3403c20f8e35SMat Martineau }; 34040a708f8fSGustavo F. Padovan 340547d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 34060a708f8fSGustavo F. Padovan 34070c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 34080a708f8fSGustavo F. Padovan return; 34090a708f8fSGustavo F. Padovan 34100a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 34110a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 34120a708f8fSGustavo F. Padovan 3413c20f8e35SMat Martineau switch (type) { 3414c20f8e35SMat Martineau case L2CAP_CONF_RFC: 3415c20f8e35SMat Martineau if (olen == sizeof(rfc)) 34160a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 3417c20f8e35SMat Martineau break; 3418c20f8e35SMat Martineau case L2CAP_CONF_EWS: 3419c20f8e35SMat Martineau txwin_ext = val; 3420c20f8e35SMat Martineau break; 3421c20f8e35SMat Martineau } 34220a708f8fSGustavo F. Padovan } 34230a708f8fSGustavo F. Padovan 34240a708f8fSGustavo F. Padovan switch (rfc.mode) { 34250a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 342647d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 342747d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 342847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3429c20f8e35SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 3430c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, txwin_ext); 3431c20f8e35SMat Martineau else 3432c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3433c20f8e35SMat Martineau rfc.txwin_size); 34340a708f8fSGustavo F. Padovan break; 34350a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 343647d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 34370a708f8fSGustavo F. Padovan } 34380a708f8fSGustavo F. Padovan } 34390a708f8fSGustavo F. Padovan 34402d792818SGustavo Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, 34412d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 34420a708f8fSGustavo F. Padovan { 3443e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 34440a708f8fSGustavo F. Padovan 3445e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 34460a708f8fSGustavo F. Padovan return 0; 34470a708f8fSGustavo F. Padovan 34480a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 34490a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 345017cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 34510a708f8fSGustavo F. Padovan 34520a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 34530a708f8fSGustavo F. Padovan conn->info_ident = 0; 34540a708f8fSGustavo F. Padovan 34550a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 34560a708f8fSGustavo F. Padovan } 34570a708f8fSGustavo F. Padovan 34580a708f8fSGustavo F. Padovan return 0; 34590a708f8fSGustavo F. Padovan } 34600a708f8fSGustavo F. Padovan 34611700915fSMat Martineau static struct l2cap_chan *l2cap_connect(struct l2cap_conn *conn, 34621700915fSMat Martineau struct l2cap_cmd_hdr *cmd, 34634c89b6aaSMat Martineau u8 *data, u8 rsp_code, u8 amp_id) 34640a708f8fSGustavo F. Padovan { 34650a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 34660a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 346723691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 34680a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 34690a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 34700a708f8fSGustavo F. Padovan 34710a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 34720a708f8fSGustavo F. Padovan __le16 psm = req->psm; 34730a708f8fSGustavo F. Padovan 3474097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 34750a708f8fSGustavo F. Padovan 34760a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3477c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 347823691d75SGustavo F. Padovan if (!pchan) { 34790a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 34800a708f8fSGustavo F. Padovan goto sendresp; 34810a708f8fSGustavo F. Padovan } 34820a708f8fSGustavo F. Padovan 348323691d75SGustavo F. Padovan parent = pchan->sk; 348423691d75SGustavo F. Padovan 34853df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3486aa2ac881SGustavo F. Padovan lock_sock(parent); 34870a708f8fSGustavo F. Padovan 34880a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 34892983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 34900a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 34919f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 34920a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 34930a708f8fSGustavo F. Padovan goto response; 34940a708f8fSGustavo F. Padovan } 34950a708f8fSGustavo F. Padovan 34960a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 34970a708f8fSGustavo F. Padovan 34982dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 34992dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 35002dfa1003SGustavo Padovan goto response; 35012dfa1003SGustavo Padovan 350280b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 350380808e43SGustavo F. Padovan if (!chan) 35040a708f8fSGustavo F. Padovan goto response; 35050a708f8fSGustavo F. Padovan 350680808e43SGustavo F. Padovan sk = chan->sk; 350780808e43SGustavo F. Padovan 35080a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 35090a708f8fSGustavo F. Padovan 35100a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 35110a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3512fe4128e0SGustavo F. Padovan chan->psm = psm; 3513fe4128e0SGustavo F. Padovan chan->dcid = scid; 35141700915fSMat Martineau chan->local_amp_id = amp_id; 35150a708f8fSGustavo F. Padovan 35166be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 351748454079SGustavo F. Padovan 3518fe4128e0SGustavo F. Padovan dcid = chan->scid; 35190a708f8fSGustavo F. Padovan 3520c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 35210a708f8fSGustavo F. Padovan 3522fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 35230a708f8fSGustavo F. Padovan 35240a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3525d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3526c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 35270e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 35280a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 35290a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 35302dc4e510SGustavo Padovan chan->ops->defer(chan); 35310a708f8fSGustavo F. Padovan } else { 35321700915fSMat Martineau /* Force pending result for AMP controllers. 35331700915fSMat Martineau * The connection will succeed after the 35341700915fSMat Martineau * physical link is up. 35351700915fSMat Martineau */ 35361700915fSMat Martineau if (amp_id) { 35371700915fSMat Martineau __l2cap_state_change(chan, BT_CONNECT2); 35381700915fSMat Martineau result = L2CAP_CR_PEND; 35391700915fSMat Martineau } else { 35400e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 35410a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 35421700915fSMat Martineau } 35430a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 35440a708f8fSGustavo F. Padovan } 35450a708f8fSGustavo F. Padovan } else { 35460e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 35470a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 35480a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 35490a708f8fSGustavo F. Padovan } 35500a708f8fSGustavo F. Padovan } else { 35510e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 35520a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 35530a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 35540a708f8fSGustavo F. Padovan } 35550a708f8fSGustavo F. Padovan 35560a708f8fSGustavo F. Padovan response: 3557aa2ac881SGustavo F. Padovan release_sock(parent); 35583df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 35590a708f8fSGustavo F. Padovan 35600a708f8fSGustavo F. Padovan sendresp: 35610a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 35620a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 35630a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 35640a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 35654c89b6aaSMat Martineau l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp); 35660a708f8fSGustavo F. Padovan 35670a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 35680a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3569ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 35700a708f8fSGustavo F. Padovan 35710a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 35720a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 35730a708f8fSGustavo F. Padovan 3574ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 35750a708f8fSGustavo F. Padovan 35762d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 35772d792818SGustavo Padovan sizeof(info), &info); 35780a708f8fSGustavo F. Padovan } 35790a708f8fSGustavo F. Padovan 3580c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 35810a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 35820a708f8fSGustavo F. Padovan u8 buf[128]; 3583c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 35840a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 358573ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 358673ffa904SGustavo F. Padovan chan->num_conf_req++; 35870a708f8fSGustavo F. Padovan } 35881700915fSMat Martineau 35891700915fSMat Martineau return chan; 35904c89b6aaSMat Martineau } 35910a708f8fSGustavo F. Padovan 35924c89b6aaSMat Martineau static int l2cap_connect_req(struct l2cap_conn *conn, 35934c89b6aaSMat Martineau struct l2cap_cmd_hdr *cmd, u8 *data) 35944c89b6aaSMat Martineau { 3595300229f9SGustavo Padovan l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP, 0); 35960a708f8fSGustavo F. Padovan return 0; 35970a708f8fSGustavo F. Padovan } 35980a708f8fSGustavo F. Padovan 35995909cf30SMat Martineau static int l2cap_connect_create_rsp(struct l2cap_conn *conn, 36002d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 36010a708f8fSGustavo F. Padovan { 36020a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 36030a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 360448454079SGustavo F. Padovan struct l2cap_chan *chan; 36050a708f8fSGustavo F. Padovan u8 req[128]; 36063df91ea2SAndrei Emeltchenko int err; 36070a708f8fSGustavo F. Padovan 36080a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 36090a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 36100a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 36110a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 36120a708f8fSGustavo F. Padovan 36131b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 36141b009c98SAndrei Emeltchenko dcid, scid, result, status); 36150a708f8fSGustavo F. Padovan 36163df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 36173df91ea2SAndrei Emeltchenko 36180a708f8fSGustavo F. Padovan if (scid) { 36193df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 36203df91ea2SAndrei Emeltchenko if (!chan) { 36213df91ea2SAndrei Emeltchenko err = -EFAULT; 36223df91ea2SAndrei Emeltchenko goto unlock; 36233df91ea2SAndrei Emeltchenko } 36240a708f8fSGustavo F. Padovan } else { 36253df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 36263df91ea2SAndrei Emeltchenko if (!chan) { 36273df91ea2SAndrei Emeltchenko err = -EFAULT; 36283df91ea2SAndrei Emeltchenko goto unlock; 36293df91ea2SAndrei Emeltchenko } 36300a708f8fSGustavo F. Padovan } 36310a708f8fSGustavo F. Padovan 36323df91ea2SAndrei Emeltchenko err = 0; 36333df91ea2SAndrei Emeltchenko 36346be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 363548454079SGustavo F. Padovan 36360a708f8fSGustavo F. Padovan switch (result) { 36370a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 363889bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3639fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3640fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3641c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 36420a708f8fSGustavo F. Padovan 3643c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 36440a708f8fSGustavo F. Padovan break; 36450a708f8fSGustavo F. Padovan 36460a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 364773ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 364873ffa904SGustavo F. Padovan chan->num_conf_req++; 36490a708f8fSGustavo F. Padovan break; 36500a708f8fSGustavo F. Padovan 36510a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3652c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 36530a708f8fSGustavo F. Padovan break; 36540a708f8fSGustavo F. Padovan 36550a708f8fSGustavo F. Padovan default: 365648454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 36570a708f8fSGustavo F. Padovan break; 36580a708f8fSGustavo F. Padovan } 36590a708f8fSGustavo F. Padovan 36606be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 36613df91ea2SAndrei Emeltchenko 36623df91ea2SAndrei Emeltchenko unlock: 36633df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 36643df91ea2SAndrei Emeltchenko 36653df91ea2SAndrei Emeltchenko return err; 36660a708f8fSGustavo F. Padovan } 36670a708f8fSGustavo F. Padovan 366847d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 36690a708f8fSGustavo F. Padovan { 36700a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 36710a708f8fSGustavo F. Padovan * sides request it. 36720a708f8fSGustavo F. Padovan */ 36730c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 367447d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3675c1360a1cSGustavo F. Padovan else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) 367647d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 36770a708f8fSGustavo F. Padovan } 36780a708f8fSGustavo F. Padovan 367929d8a590SAndrei Emeltchenko static void l2cap_send_efs_conf_rsp(struct l2cap_chan *chan, void *data, 368029d8a590SAndrei Emeltchenko u8 ident, u16 flags) 368129d8a590SAndrei Emeltchenko { 368229d8a590SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 368329d8a590SAndrei Emeltchenko 368429d8a590SAndrei Emeltchenko BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident, 368529d8a590SAndrei Emeltchenko flags); 368629d8a590SAndrei Emeltchenko 368729d8a590SAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 368829d8a590SAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 368929d8a590SAndrei Emeltchenko 369029d8a590SAndrei Emeltchenko l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP, 369129d8a590SAndrei Emeltchenko l2cap_build_conf_rsp(chan, data, 369229d8a590SAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), data); 369329d8a590SAndrei Emeltchenko } 369429d8a590SAndrei Emeltchenko 36952d792818SGustavo Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, 36962d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 36972d792818SGustavo Padovan u8 *data) 36980a708f8fSGustavo F. Padovan { 36990a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 37000a708f8fSGustavo F. Padovan u16 dcid, flags; 37010a708f8fSGustavo F. Padovan u8 rsp[64]; 370248454079SGustavo F. Padovan struct l2cap_chan *chan; 37033c588192SMat Martineau int len, err = 0; 37040a708f8fSGustavo F. Padovan 37050a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 37060a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 37070a708f8fSGustavo F. Padovan 37080a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 37090a708f8fSGustavo F. Padovan 3710baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 371148454079SGustavo F. Padovan if (!chan) 37120a708f8fSGustavo F. Padovan return -ENOENT; 37130a708f8fSGustavo F. Padovan 3714033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3715e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 37160a708f8fSGustavo F. Padovan 3717ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3718e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3719e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3720e2fd318eSIlia Kolomisnky 37210a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 37220a708f8fSGustavo F. Padovan sizeof(rej), &rej); 37230a708f8fSGustavo F. Padovan goto unlock; 37240a708f8fSGustavo F. Padovan } 37250a708f8fSGustavo F. Padovan 37260a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 37270a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 37287ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 37290a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3730fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 37310a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 37320a708f8fSGustavo F. Padovan goto unlock; 37330a708f8fSGustavo F. Padovan } 37340a708f8fSGustavo F. Padovan 37350a708f8fSGustavo F. Padovan /* Store config. */ 373673ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 373773ffa904SGustavo F. Padovan chan->conf_len += len; 37380a708f8fSGustavo F. Padovan 373959e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 37400a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 37410a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3742fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 37435325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 37440a708f8fSGustavo F. Padovan goto unlock; 37450a708f8fSGustavo F. Padovan } 37460a708f8fSGustavo F. Padovan 37470a708f8fSGustavo F. Padovan /* Complete config. */ 374873ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 37490a708f8fSGustavo F. Padovan if (len < 0) { 3750e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 37510a708f8fSGustavo F. Padovan goto unlock; 37520a708f8fSGustavo F. Padovan } 37530a708f8fSGustavo F. Padovan 37540a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 375573ffa904SGustavo F. Padovan chan->num_conf_rsp++; 37560a708f8fSGustavo F. Padovan 37570a708f8fSGustavo F. Padovan /* Reset config buffer. */ 375873ffa904SGustavo F. Padovan chan->conf_len = 0; 37590a708f8fSGustavo F. Padovan 3760c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 37610a708f8fSGustavo F. Padovan goto unlock; 37620a708f8fSGustavo F. Padovan 3763c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 376447d1ec61SGustavo F. Padovan set_default_fcs(chan); 37650a708f8fSGustavo F. Padovan 3766105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3767105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 37683c588192SMat Martineau err = l2cap_ertm_init(chan); 37690a708f8fSGustavo F. Padovan 37703c588192SMat Martineau if (err < 0) 37713c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 37723c588192SMat Martineau else 3773cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 37743c588192SMat Martineau 37750a708f8fSGustavo F. Padovan goto unlock; 37760a708f8fSGustavo F. Padovan } 37770a708f8fSGustavo F. Padovan 3778c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 37790a708f8fSGustavo F. Padovan u8 buf[64]; 37800a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 378173ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 378273ffa904SGustavo F. Padovan chan->num_conf_req++; 37830a708f8fSGustavo F. Padovan } 37840a708f8fSGustavo F. Padovan 37850e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 37860e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 37870e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 37880e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 37890e8b207eSAndrei Emeltchenko 37900e8b207eSAndrei Emeltchenko /* check compatibility */ 37910e8b207eSAndrei Emeltchenko 379279de886dSAndrei Emeltchenko /* Send rsp for BR/EDR channel */ 379379de886dSAndrei Emeltchenko if (!chan->ctrl_id) 379429d8a590SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, rsp, cmd->ident, flags); 379579de886dSAndrei Emeltchenko else 379679de886dSAndrei Emeltchenko chan->ident = cmd->ident; 37970e8b207eSAndrei Emeltchenko } 37980e8b207eSAndrei Emeltchenko 37990a708f8fSGustavo F. Padovan unlock: 38006be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 38013c588192SMat Martineau return err; 38020a708f8fSGustavo F. Padovan } 38030a708f8fSGustavo F. Padovan 38042d792818SGustavo Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, 38052d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 38060a708f8fSGustavo F. Padovan { 38070a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 38080a708f8fSGustavo F. Padovan u16 scid, flags, result; 380948454079SGustavo F. Padovan struct l2cap_chan *chan; 381061386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 38113c588192SMat Martineau int err = 0; 38120a708f8fSGustavo F. Padovan 38130a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 38140a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 38150a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 38160a708f8fSGustavo F. Padovan 381761386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 381861386cbaSAndrei Emeltchenko result, len); 38190a708f8fSGustavo F. Padovan 3820baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 382148454079SGustavo F. Padovan if (!chan) 38220a708f8fSGustavo F. Padovan return 0; 38230a708f8fSGustavo F. Padovan 38240a708f8fSGustavo F. Padovan switch (result) { 38250a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 382647d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 38270e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 38280a708f8fSGustavo F. Padovan break; 38290a708f8fSGustavo F. Padovan 38300e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 38310e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 38320e8b207eSAndrei Emeltchenko 38330e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 38340e8b207eSAndrei Emeltchenko char buf[64]; 38350e8b207eSAndrei Emeltchenko 38360e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 38370e8b207eSAndrei Emeltchenko buf, &result); 38380e8b207eSAndrei Emeltchenko if (len < 0) { 38390e8b207eSAndrei Emeltchenko l2cap_send_disconn_req(conn, chan, ECONNRESET); 38400e8b207eSAndrei Emeltchenko goto done; 38410e8b207eSAndrei Emeltchenko } 38420e8b207eSAndrei Emeltchenko 38430e8b207eSAndrei Emeltchenko /* check compatibility */ 38440e8b207eSAndrei Emeltchenko 384579de886dSAndrei Emeltchenko if (!chan->ctrl_id) 384679de886dSAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, buf, cmd->ident, 384779de886dSAndrei Emeltchenko 0); 384879de886dSAndrei Emeltchenko else 384979de886dSAndrei Emeltchenko chan->ident = cmd->ident; 38500e8b207eSAndrei Emeltchenko } 38510e8b207eSAndrei Emeltchenko goto done; 38520e8b207eSAndrei Emeltchenko 38530a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 385473ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 38550a708f8fSGustavo F. Padovan char req[64]; 38560a708f8fSGustavo F. Padovan 38570a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 3858e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 38590a708f8fSGustavo F. Padovan goto done; 38600a708f8fSGustavo F. Padovan } 38610a708f8fSGustavo F. Padovan 38620a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 38630a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 3864b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 3865b4450035SGustavo F. Padovan req, &result); 38660a708f8fSGustavo F. Padovan if (len < 0) { 3867e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 38680a708f8fSGustavo F. Padovan goto done; 38690a708f8fSGustavo F. Padovan } 38700a708f8fSGustavo F. Padovan 38710a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 38720a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 387373ffa904SGustavo F. Padovan chan->num_conf_req++; 38740a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 38750a708f8fSGustavo F. Padovan goto done; 38760a708f8fSGustavo F. Padovan break; 38770a708f8fSGustavo F. Padovan } 38780a708f8fSGustavo F. Padovan 38790a708f8fSGustavo F. Padovan default: 38806be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 38812e0052e4SAndrei Emeltchenko 3882ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 3883e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 38840a708f8fSGustavo F. Padovan goto done; 38850a708f8fSGustavo F. Padovan } 38860a708f8fSGustavo F. Padovan 388759e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 38880a708f8fSGustavo F. Padovan goto done; 38890a708f8fSGustavo F. Padovan 3890c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 38910a708f8fSGustavo F. Padovan 3892c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 389347d1ec61SGustavo F. Padovan set_default_fcs(chan); 38940a708f8fSGustavo F. Padovan 3895105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3896105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 38973c588192SMat Martineau err = l2cap_ertm_init(chan); 38980a708f8fSGustavo F. Padovan 38993c588192SMat Martineau if (err < 0) 39003c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 39013c588192SMat Martineau else 3902cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 39030a708f8fSGustavo F. Padovan } 39040a708f8fSGustavo F. Padovan 39050a708f8fSGustavo F. Padovan done: 39066be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39073c588192SMat Martineau return err; 39080a708f8fSGustavo F. Padovan } 39090a708f8fSGustavo F. Padovan 39102d792818SGustavo Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, 39112d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39120a708f8fSGustavo F. Padovan { 39130a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 39140a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 39150a708f8fSGustavo F. Padovan u16 dcid, scid; 391648454079SGustavo F. Padovan struct l2cap_chan *chan; 39170a708f8fSGustavo F. Padovan struct sock *sk; 39180a708f8fSGustavo F. Padovan 39190a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 39200a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 39210a708f8fSGustavo F. Padovan 39220a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 39230a708f8fSGustavo F. Padovan 39243df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 39253df91ea2SAndrei Emeltchenko 39263df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 39273df91ea2SAndrei Emeltchenko if (!chan) { 39283df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39290a708f8fSGustavo F. Padovan return 0; 39303df91ea2SAndrei Emeltchenko } 39310a708f8fSGustavo F. Padovan 39326be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 39336be36555SAndrei Emeltchenko 393448454079SGustavo F. Padovan sk = chan->sk; 393548454079SGustavo F. Padovan 3936fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3937fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 39380a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 39390a708f8fSGustavo F. Padovan 39406be36555SAndrei Emeltchenko lock_sock(sk); 39410a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 39426be36555SAndrei Emeltchenko release_sock(sk); 39430a708f8fSGustavo F. Padovan 394461d6ef3eSMat Martineau l2cap_chan_hold(chan); 394548454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 39466be36555SAndrei Emeltchenko 39476be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39480a708f8fSGustavo F. Padovan 394980b98027SGustavo Padovan chan->ops->close(chan); 395061d6ef3eSMat Martineau l2cap_chan_put(chan); 39513df91ea2SAndrei Emeltchenko 39523df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39533df91ea2SAndrei Emeltchenko 39540a708f8fSGustavo F. Padovan return 0; 39550a708f8fSGustavo F. Padovan } 39560a708f8fSGustavo F. Padovan 39572d792818SGustavo Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, 39582d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39590a708f8fSGustavo F. Padovan { 39600a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 39610a708f8fSGustavo F. Padovan u16 dcid, scid; 396248454079SGustavo F. Padovan struct l2cap_chan *chan; 39630a708f8fSGustavo F. Padovan 39640a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 39650a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 39660a708f8fSGustavo F. Padovan 39670a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 39680a708f8fSGustavo F. Padovan 39693df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 39703df91ea2SAndrei Emeltchenko 39713df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 39723df91ea2SAndrei Emeltchenko if (!chan) { 39733df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39740a708f8fSGustavo F. Padovan return 0; 39753df91ea2SAndrei Emeltchenko } 39760a708f8fSGustavo F. Padovan 39776be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 397848454079SGustavo F. Padovan 397961d6ef3eSMat Martineau l2cap_chan_hold(chan); 398048454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 39816be36555SAndrei Emeltchenko 39826be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39830a708f8fSGustavo F. Padovan 398480b98027SGustavo Padovan chan->ops->close(chan); 398561d6ef3eSMat Martineau l2cap_chan_put(chan); 39863df91ea2SAndrei Emeltchenko 39873df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39883df91ea2SAndrei Emeltchenko 39890a708f8fSGustavo F. Padovan return 0; 39900a708f8fSGustavo F. Padovan } 39910a708f8fSGustavo F. Padovan 39922d792818SGustavo Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, 39932d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39940a708f8fSGustavo F. Padovan { 39950a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 39960a708f8fSGustavo F. Padovan u16 type; 39970a708f8fSGustavo F. Padovan 39980a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 39990a708f8fSGustavo F. Padovan 40000a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 40010a708f8fSGustavo F. Padovan 40020a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 40030a708f8fSGustavo F. Padovan u8 buf[8]; 40040a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 40050a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 4006ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 4007ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 40080a708f8fSGustavo F. Padovan if (!disable_ertm) 40090a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 40100a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 4011a5fd6f30SAndrei Emeltchenko if (enable_hs) 40126327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 40136327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 4014a5fd6f30SAndrei Emeltchenko 40150a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 40162d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 40172d792818SGustavo Padovan buf); 40180a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 40190a708f8fSGustavo F. Padovan u8 buf[12]; 40200a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 402150a147cdSMat Martineau 402250a147cdSMat Martineau if (enable_hs) 402350a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 402450a147cdSMat Martineau else 402550a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 402650a147cdSMat Martineau 4027ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 4028ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 4029c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 40302d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 40312d792818SGustavo Padovan buf); 40320a708f8fSGustavo F. Padovan } else { 40330a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 40340a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 4035ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 40362d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), 40372d792818SGustavo Padovan &rsp); 40380a708f8fSGustavo F. Padovan } 40390a708f8fSGustavo F. Padovan 40400a708f8fSGustavo F. Padovan return 0; 40410a708f8fSGustavo F. Padovan } 40420a708f8fSGustavo F. Padovan 40432d792818SGustavo Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, 40442d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 40450a708f8fSGustavo F. Padovan { 40460a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 40470a708f8fSGustavo F. Padovan u16 type, result; 40480a708f8fSGustavo F. Padovan 40490a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 40500a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 40510a708f8fSGustavo F. Padovan 40520a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 40530a708f8fSGustavo F. Padovan 4054e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 4055e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 4056e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 4057e90165beSAndrei Emeltchenko return 0; 4058e90165beSAndrei Emeltchenko 405917cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 40600a708f8fSGustavo F. Padovan 40610a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 40620a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 40630a708f8fSGustavo F. Padovan conn->info_ident = 0; 40640a708f8fSGustavo F. Padovan 40650a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 40660a708f8fSGustavo F. Padovan 40670a708f8fSGustavo F. Padovan return 0; 40680a708f8fSGustavo F. Padovan } 40690a708f8fSGustavo F. Padovan 4070978c93b9SAndrei Emeltchenko switch (type) { 4071978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 40720a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 40730a708f8fSGustavo F. Padovan 40740a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 40750a708f8fSGustavo F. Padovan struct l2cap_info_req req; 4076ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 40770a708f8fSGustavo F. Padovan 40780a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 40790a708f8fSGustavo F. Padovan 40800a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 40810a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 40820a708f8fSGustavo F. Padovan } else { 40830a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 40840a708f8fSGustavo F. Padovan conn->info_ident = 0; 40850a708f8fSGustavo F. Padovan 40860a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 40870a708f8fSGustavo F. Padovan } 4088978c93b9SAndrei Emeltchenko break; 4089978c93b9SAndrei Emeltchenko 4090978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 4091978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 40920a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 40930a708f8fSGustavo F. Padovan conn->info_ident = 0; 40940a708f8fSGustavo F. Padovan 40950a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 4096978c93b9SAndrei Emeltchenko break; 40970a708f8fSGustavo F. Padovan } 40980a708f8fSGustavo F. Padovan 40990a708f8fSGustavo F. Padovan return 0; 41000a708f8fSGustavo F. Padovan } 41010a708f8fSGustavo F. Padovan 41021700915fSMat Martineau static int l2cap_create_channel_req(struct l2cap_conn *conn, 41032d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 41042d792818SGustavo Padovan u16 cmd_len, void *data) 4105f94ff6ffSMat Martineau { 4106f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 41071700915fSMat Martineau struct l2cap_chan *chan; 4108f94ff6ffSMat Martineau u16 psm, scid; 4109f94ff6ffSMat Martineau 4110f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 4111f94ff6ffSMat Martineau return -EPROTO; 4112f94ff6ffSMat Martineau 4113f94ff6ffSMat Martineau if (!enable_hs) 4114f94ff6ffSMat Martineau return -EINVAL; 4115f94ff6ffSMat Martineau 4116f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 4117f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 4118f94ff6ffSMat Martineau 4119ad0ac6caSAndrei Emeltchenko BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id); 4120f94ff6ffSMat Martineau 41211700915fSMat Martineau if (req->amp_id) { 41221700915fSMat Martineau struct hci_dev *hdev; 41231700915fSMat Martineau 41241700915fSMat Martineau /* Validate AMP controller id */ 41251700915fSMat Martineau hdev = hci_dev_get(req->amp_id); 41261700915fSMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 41271700915fSMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 41281700915fSMat Martineau struct l2cap_create_chan_rsp rsp; 41291700915fSMat Martineau 4130f94ff6ffSMat Martineau rsp.dcid = 0; 4131f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 41321700915fSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_CR_BAD_AMP); 41338ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 4134f94ff6ffSMat Martineau 4135f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 4136f94ff6ffSMat Martineau sizeof(rsp), &rsp); 4137f94ff6ffSMat Martineau 41381700915fSMat Martineau if (hdev) 41391700915fSMat Martineau hci_dev_put(hdev); 41401700915fSMat Martineau 41411700915fSMat Martineau return 0; 41421700915fSMat Martineau } 41431700915fSMat Martineau 41441700915fSMat Martineau hci_dev_put(hdev); 41451700915fSMat Martineau } 41461700915fSMat Martineau 41471700915fSMat Martineau chan = l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 41481700915fSMat Martineau req->amp_id); 41491700915fSMat Martineau 4150f94ff6ffSMat Martineau return 0; 4151f94ff6ffSMat Martineau } 4152f94ff6ffSMat Martineau 41538d5a04a1SMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_conn *conn, u8 ident, 41548d5a04a1SMat Martineau u16 icid, u16 result) 41558d5a04a1SMat Martineau { 41568d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 41578d5a04a1SMat Martineau 4158ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 41598d5a04a1SMat Martineau 41608d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 41618d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 41628d5a04a1SMat Martineau 41638d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_RSP, sizeof(rsp), &rsp); 41648d5a04a1SMat Martineau } 41658d5a04a1SMat Martineau 41668d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_conn *conn, 4167ad0ac6caSAndrei Emeltchenko struct l2cap_chan *chan, 4168ad0ac6caSAndrei Emeltchenko u16 icid, u16 result) 41698d5a04a1SMat Martineau { 41708d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 41718d5a04a1SMat Martineau u8 ident; 41728d5a04a1SMat Martineau 4173ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 41748d5a04a1SMat Martineau 41758d5a04a1SMat Martineau ident = l2cap_get_ident(conn); 41768d5a04a1SMat Martineau if (chan) 41778d5a04a1SMat Martineau chan->ident = ident; 41788d5a04a1SMat Martineau 41798d5a04a1SMat Martineau cfm.icid = cpu_to_le16(icid); 41808d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 41818d5a04a1SMat Martineau 41828d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM, sizeof(cfm), &cfm); 41838d5a04a1SMat Martineau } 41848d5a04a1SMat Martineau 41858d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 41868d5a04a1SMat Martineau u16 icid) 41878d5a04a1SMat Martineau { 41888d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 41898d5a04a1SMat Martineau 4190ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 41918d5a04a1SMat Martineau 41928d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 41938d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 41948d5a04a1SMat Martineau } 41958d5a04a1SMat Martineau 41968d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 4197ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4198ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 41998d5a04a1SMat Martineau { 42008d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 420102b0fbb9SMat Martineau struct l2cap_chan *chan; 42028d5a04a1SMat Martineau u16 icid = 0; 42038d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 42048d5a04a1SMat Martineau 42058d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 42068d5a04a1SMat Martineau return -EPROTO; 42078d5a04a1SMat Martineau 42088d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 42098d5a04a1SMat Martineau 4210ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id); 42118d5a04a1SMat Martineau 42128d5a04a1SMat Martineau if (!enable_hs) 42138d5a04a1SMat Martineau return -EINVAL; 42148d5a04a1SMat Martineau 421502b0fbb9SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 421602b0fbb9SMat Martineau if (!chan) { 421702b0fbb9SMat Martineau l2cap_send_move_chan_rsp(conn, cmd->ident, icid, 421802b0fbb9SMat Martineau L2CAP_MR_NOT_ALLOWED); 421902b0fbb9SMat Martineau return 0; 422002b0fbb9SMat Martineau } 422102b0fbb9SMat Martineau 422202b0fbb9SMat Martineau if (chan->scid < L2CAP_CID_DYN_START || 422302b0fbb9SMat Martineau chan->chan_policy == BT_CHANNEL_POLICY_BREDR_ONLY || 422402b0fbb9SMat Martineau (chan->mode != L2CAP_MODE_ERTM && 422502b0fbb9SMat Martineau chan->mode != L2CAP_MODE_STREAMING)) { 422602b0fbb9SMat Martineau result = L2CAP_MR_NOT_ALLOWED; 422702b0fbb9SMat Martineau goto send_move_response; 422802b0fbb9SMat Martineau } 422902b0fbb9SMat Martineau 423002b0fbb9SMat Martineau if (chan->local_amp_id == req->dest_amp_id) { 423102b0fbb9SMat Martineau result = L2CAP_MR_SAME_ID; 423202b0fbb9SMat Martineau goto send_move_response; 423302b0fbb9SMat Martineau } 423402b0fbb9SMat Martineau 423502b0fbb9SMat Martineau if (req->dest_amp_id) { 423602b0fbb9SMat Martineau struct hci_dev *hdev; 423702b0fbb9SMat Martineau hdev = hci_dev_get(req->dest_amp_id); 423802b0fbb9SMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 423902b0fbb9SMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 424002b0fbb9SMat Martineau if (hdev) 424102b0fbb9SMat Martineau hci_dev_put(hdev); 424202b0fbb9SMat Martineau 424302b0fbb9SMat Martineau result = L2CAP_MR_BAD_ID; 424402b0fbb9SMat Martineau goto send_move_response; 424502b0fbb9SMat Martineau } 424602b0fbb9SMat Martineau hci_dev_put(hdev); 424702b0fbb9SMat Martineau } 424802b0fbb9SMat Martineau 424902b0fbb9SMat Martineau /* Detect a move collision. Only send a collision response 425002b0fbb9SMat Martineau * if this side has "lost", otherwise proceed with the move. 425102b0fbb9SMat Martineau * The winner has the larger bd_addr. 425202b0fbb9SMat Martineau */ 425302b0fbb9SMat Martineau if ((__chan_is_moving(chan) || 425402b0fbb9SMat Martineau chan->move_role != L2CAP_MOVE_ROLE_NONE) && 425502b0fbb9SMat Martineau bacmp(conn->src, conn->dst) > 0) { 425602b0fbb9SMat Martineau result = L2CAP_MR_COLLISION; 425702b0fbb9SMat Martineau goto send_move_response; 425802b0fbb9SMat Martineau } 425902b0fbb9SMat Martineau 426002b0fbb9SMat Martineau chan->ident = cmd->ident; 426102b0fbb9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 426202b0fbb9SMat Martineau l2cap_move_setup(chan); 426302b0fbb9SMat Martineau chan->move_id = req->dest_amp_id; 426402b0fbb9SMat Martineau icid = chan->dcid; 426502b0fbb9SMat Martineau 426602b0fbb9SMat Martineau if (!req->dest_amp_id) { 426702b0fbb9SMat Martineau /* Moving to BR/EDR */ 426802b0fbb9SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 426902b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 427002b0fbb9SMat Martineau result = L2CAP_MR_PEND; 427102b0fbb9SMat Martineau } else { 427202b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 427302b0fbb9SMat Martineau result = L2CAP_MR_SUCCESS; 427402b0fbb9SMat Martineau } 427502b0fbb9SMat Martineau } else { 427602b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 427702b0fbb9SMat Martineau /* Placeholder - uncomment when amp functions are available */ 427802b0fbb9SMat Martineau /*amp_accept_physical(chan, req->dest_amp_id);*/ 427902b0fbb9SMat Martineau result = L2CAP_MR_PEND; 428002b0fbb9SMat Martineau } 428102b0fbb9SMat Martineau 428202b0fbb9SMat Martineau send_move_response: 42838d5a04a1SMat Martineau l2cap_send_move_chan_rsp(conn, cmd->ident, icid, result); 42848d5a04a1SMat Martineau 428502b0fbb9SMat Martineau l2cap_chan_unlock(chan); 428602b0fbb9SMat Martineau 42878d5a04a1SMat Martineau return 0; 42888d5a04a1SMat Martineau } 42898d5a04a1SMat Martineau 42908d5a04a1SMat Martineau static inline int l2cap_move_channel_rsp(struct l2cap_conn *conn, 4291ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4292ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 42938d5a04a1SMat Martineau { 42948d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 42958d5a04a1SMat Martineau u16 icid, result; 42968d5a04a1SMat Martineau 42978d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 42988d5a04a1SMat Martineau return -EPROTO; 42998d5a04a1SMat Martineau 43008d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 43018d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 43028d5a04a1SMat Martineau 4303ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 43048d5a04a1SMat Martineau 43058d5a04a1SMat Martineau /* Placeholder: Always unconfirmed */ 43068d5a04a1SMat Martineau l2cap_send_move_chan_cfm(conn, NULL, icid, L2CAP_MC_UNCONFIRMED); 43078d5a04a1SMat Martineau 43088d5a04a1SMat Martineau return 0; 43098d5a04a1SMat Martineau } 43108d5a04a1SMat Martineau 43118d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm(struct l2cap_conn *conn, 4312ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4313ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 43148d5a04a1SMat Martineau { 43158d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 43168d5a04a1SMat Martineau u16 icid, result; 43178d5a04a1SMat Martineau 43188d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 43198d5a04a1SMat Martineau return -EPROTO; 43208d5a04a1SMat Martineau 43218d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 43228d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 43238d5a04a1SMat Martineau 4324ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 43258d5a04a1SMat Martineau 43268d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 43278d5a04a1SMat Martineau 43288d5a04a1SMat Martineau return 0; 43298d5a04a1SMat Martineau } 43308d5a04a1SMat Martineau 43318d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 4332ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4333ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 43348d5a04a1SMat Martineau { 43358d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 43368d5a04a1SMat Martineau u16 icid; 43378d5a04a1SMat Martineau 43388d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 43398d5a04a1SMat Martineau return -EPROTO; 43408d5a04a1SMat Martineau 43418d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 43428d5a04a1SMat Martineau 4343ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 43448d5a04a1SMat Martineau 43458d5a04a1SMat Martineau return 0; 43468d5a04a1SMat Martineau } 43478d5a04a1SMat Martineau 4348e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4349de73115aSClaudio Takahasi u16 to_multiplier) 4350de73115aSClaudio Takahasi { 4351de73115aSClaudio Takahasi u16 max_latency; 4352de73115aSClaudio Takahasi 4353de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4354de73115aSClaudio Takahasi return -EINVAL; 4355de73115aSClaudio Takahasi 4356de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4357de73115aSClaudio Takahasi return -EINVAL; 4358de73115aSClaudio Takahasi 4359de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4360de73115aSClaudio Takahasi return -EINVAL; 4361de73115aSClaudio Takahasi 4362de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 4363de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 4364de73115aSClaudio Takahasi return -EINVAL; 4365de73115aSClaudio Takahasi 4366de73115aSClaudio Takahasi return 0; 4367de73115aSClaudio Takahasi } 4368de73115aSClaudio Takahasi 4369de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 43702d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 43712d792818SGustavo Padovan u8 *data) 4372de73115aSClaudio Takahasi { 4373de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 4374de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 4375de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 4376de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 43772ce603ebSClaudio Takahasi int err; 4378de73115aSClaudio Takahasi 4379de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 4380de73115aSClaudio Takahasi return -EINVAL; 4381de73115aSClaudio Takahasi 4382de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 4383de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 4384de73115aSClaudio Takahasi return -EPROTO; 4385de73115aSClaudio Takahasi 4386de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 4387de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 4388de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 4389de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 4390de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 4391de73115aSClaudio Takahasi 4392de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 4393de73115aSClaudio Takahasi min, max, latency, to_multiplier); 4394de73115aSClaudio Takahasi 4395de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 43962ce603ebSClaudio Takahasi 43972ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 43982ce603ebSClaudio Takahasi if (err) 4399ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 4400de73115aSClaudio Takahasi else 4401ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 4402de73115aSClaudio Takahasi 4403de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 4404de73115aSClaudio Takahasi sizeof(rsp), &rsp); 4405de73115aSClaudio Takahasi 44062ce603ebSClaudio Takahasi if (!err) 44072ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 44082ce603ebSClaudio Takahasi 4409de73115aSClaudio Takahasi return 0; 4410de73115aSClaudio Takahasi } 4411de73115aSClaudio Takahasi 44123300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 44132d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 44142d792818SGustavo Padovan u8 *data) 44153300d9a9SClaudio Takahasi { 44163300d9a9SClaudio Takahasi int err = 0; 44173300d9a9SClaudio Takahasi 44183300d9a9SClaudio Takahasi switch (cmd->code) { 44193300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 44203300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 44213300d9a9SClaudio Takahasi break; 44223300d9a9SClaudio Takahasi 44233300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 44243300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 44253300d9a9SClaudio Takahasi break; 44263300d9a9SClaudio Takahasi 44273300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 4428f5a2598dSMat Martineau case L2CAP_CREATE_CHAN_RSP: 44295909cf30SMat Martineau err = l2cap_connect_create_rsp(conn, cmd, data); 44303300d9a9SClaudio Takahasi break; 44313300d9a9SClaudio Takahasi 44323300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 44333300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 44343300d9a9SClaudio Takahasi break; 44353300d9a9SClaudio Takahasi 44363300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 44373300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 44383300d9a9SClaudio Takahasi break; 44393300d9a9SClaudio Takahasi 44403300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 44413300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 44423300d9a9SClaudio Takahasi break; 44433300d9a9SClaudio Takahasi 44443300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 44453300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 44463300d9a9SClaudio Takahasi break; 44473300d9a9SClaudio Takahasi 44483300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 44493300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 44503300d9a9SClaudio Takahasi break; 44513300d9a9SClaudio Takahasi 44523300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 44533300d9a9SClaudio Takahasi break; 44543300d9a9SClaudio Takahasi 44553300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 44563300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 44573300d9a9SClaudio Takahasi break; 44583300d9a9SClaudio Takahasi 44593300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 44603300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 44613300d9a9SClaudio Takahasi break; 44623300d9a9SClaudio Takahasi 4463f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 4464f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 4465f94ff6ffSMat Martineau break; 4466f94ff6ffSMat Martineau 44678d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 44688d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 44698d5a04a1SMat Martineau break; 44708d5a04a1SMat Martineau 44718d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 44728d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 44738d5a04a1SMat Martineau break; 44748d5a04a1SMat Martineau 44758d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 44768d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 44778d5a04a1SMat Martineau break; 44788d5a04a1SMat Martineau 44798d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 44808d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 44818d5a04a1SMat Martineau break; 44828d5a04a1SMat Martineau 44833300d9a9SClaudio Takahasi default: 44843300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 44853300d9a9SClaudio Takahasi err = -EINVAL; 44863300d9a9SClaudio Takahasi break; 44873300d9a9SClaudio Takahasi } 44883300d9a9SClaudio Takahasi 44893300d9a9SClaudio Takahasi return err; 44903300d9a9SClaudio Takahasi } 44913300d9a9SClaudio Takahasi 44923300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 44933300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 44943300d9a9SClaudio Takahasi { 44953300d9a9SClaudio Takahasi switch (cmd->code) { 44963300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 44973300d9a9SClaudio Takahasi return 0; 44983300d9a9SClaudio Takahasi 44993300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 4500de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 45013300d9a9SClaudio Takahasi 45023300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 45033300d9a9SClaudio Takahasi return 0; 45043300d9a9SClaudio Takahasi 45053300d9a9SClaudio Takahasi default: 45063300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 45073300d9a9SClaudio Takahasi return -EINVAL; 45083300d9a9SClaudio Takahasi } 45093300d9a9SClaudio Takahasi } 45103300d9a9SClaudio Takahasi 45113300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 45123300d9a9SClaudio Takahasi struct sk_buff *skb) 45130a708f8fSGustavo F. Padovan { 45140a708f8fSGustavo F. Padovan u8 *data = skb->data; 45150a708f8fSGustavo F. Padovan int len = skb->len; 45160a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 45173300d9a9SClaudio Takahasi int err; 45180a708f8fSGustavo F. Padovan 45190a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 45200a708f8fSGustavo F. Padovan 45210a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 45220a708f8fSGustavo F. Padovan u16 cmd_len; 45230a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 45240a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 45250a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 45260a708f8fSGustavo F. Padovan 45270a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 45280a708f8fSGustavo F. Padovan 45292d792818SGustavo Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 45302d792818SGustavo Padovan cmd.ident); 45310a708f8fSGustavo F. Padovan 45320a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 45330a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 45340a708f8fSGustavo F. Padovan break; 45350a708f8fSGustavo F. Padovan } 45360a708f8fSGustavo F. Padovan 45373300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 45383300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 45393300d9a9SClaudio Takahasi else 45403300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 45410a708f8fSGustavo F. Padovan 45420a708f8fSGustavo F. Padovan if (err) { 4543e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 45442c6d1a2eSGustavo F. Padovan 45452c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 45460a708f8fSGustavo F. Padovan 45470a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 4548ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 45492d792818SGustavo Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 45502d792818SGustavo Padovan sizeof(rej), &rej); 45510a708f8fSGustavo F. Padovan } 45520a708f8fSGustavo F. Padovan 45530a708f8fSGustavo F. Padovan data += cmd_len; 45540a708f8fSGustavo F. Padovan len -= cmd_len; 45550a708f8fSGustavo F. Padovan } 45560a708f8fSGustavo F. Padovan 45570a708f8fSGustavo F. Padovan kfree_skb(skb); 45580a708f8fSGustavo F. Padovan } 45590a708f8fSGustavo F. Padovan 456047d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 45610a708f8fSGustavo F. Padovan { 45620a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 4563e4ca6d98SAndrei Emeltchenko int hdr_size; 4564e4ca6d98SAndrei Emeltchenko 4565e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 4566e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 4567e4ca6d98SAndrei Emeltchenko else 4568e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 45690a708f8fSGustavo F. Padovan 457047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 457103a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 45720a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 45730a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 45740a708f8fSGustavo F. Padovan 45750a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 45760a708f8fSGustavo F. Padovan return -EBADMSG; 45770a708f8fSGustavo F. Padovan } 45780a708f8fSGustavo F. Padovan return 0; 45790a708f8fSGustavo F. Padovan } 45800a708f8fSGustavo F. Padovan 45816ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 45820a708f8fSGustavo F. Padovan { 4583e31f7633SMat Martineau struct l2cap_ctrl control; 45840a708f8fSGustavo F. Padovan 4585e31f7633SMat Martineau BT_DBG("chan %p", chan); 45860a708f8fSGustavo F. Padovan 4587e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 4588e31f7633SMat Martineau control.sframe = 1; 4589e31f7633SMat Martineau control.final = 1; 4590e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 4591e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 45920a708f8fSGustavo F. Padovan 4593e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4594e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 4595e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 45960a708f8fSGustavo F. Padovan } 45970a708f8fSGustavo F. Padovan 4598e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 4599e31f7633SMat Martineau chan->unacked_frames > 0) 4600e31f7633SMat Martineau __set_retrans_timer(chan); 46010a708f8fSGustavo F. Padovan 4602e31f7633SMat Martineau /* Send pending iframes */ 4603525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 46040a708f8fSGustavo F. Padovan 4605e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 4606e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 4607e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 4608e31f7633SMat Martineau * send it now. 4609e31f7633SMat Martineau */ 4610e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 4611e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 46120a708f8fSGustavo F. Padovan } 46130a708f8fSGustavo F. Padovan } 46140a708f8fSGustavo F. Padovan 46152d792818SGustavo Padovan static void append_skb_frag(struct sk_buff *skb, struct sk_buff *new_frag, 46162d792818SGustavo Padovan struct sk_buff **last_frag) 46170a708f8fSGustavo F. Padovan { 461884084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 461984084a31SMat Martineau * skb->data_len reflects only data in fragments 462084084a31SMat Martineau */ 462184084a31SMat Martineau if (!skb_has_frag_list(skb)) 462284084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 462384084a31SMat Martineau 462484084a31SMat Martineau new_frag->next = NULL; 462584084a31SMat Martineau 462684084a31SMat Martineau (*last_frag)->next = new_frag; 462784084a31SMat Martineau *last_frag = new_frag; 462884084a31SMat Martineau 462984084a31SMat Martineau skb->len += new_frag->len; 463084084a31SMat Martineau skb->data_len += new_frag->len; 463184084a31SMat Martineau skb->truesize += new_frag->truesize; 463284084a31SMat Martineau } 463384084a31SMat Martineau 46344b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 46354b51dae9SMat Martineau struct l2cap_ctrl *control) 463684084a31SMat Martineau { 463784084a31SMat Martineau int err = -EINVAL; 46380a708f8fSGustavo F. Padovan 46394b51dae9SMat Martineau switch (control->sar) { 46407e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 464184084a31SMat Martineau if (chan->sdu) 464284084a31SMat Martineau break; 46430a708f8fSGustavo F. Padovan 464480b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 464584084a31SMat Martineau break; 46460a708f8fSGustavo F. Padovan 46477e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 464884084a31SMat Martineau if (chan->sdu) 464984084a31SMat Martineau break; 46500a708f8fSGustavo F. Padovan 46516f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 465203a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 46530a708f8fSGustavo F. Padovan 465484084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 465584084a31SMat Martineau err = -EMSGSIZE; 465684084a31SMat Martineau break; 465784084a31SMat Martineau } 46580a708f8fSGustavo F. Padovan 465984084a31SMat Martineau if (skb->len >= chan->sdu_len) 466084084a31SMat Martineau break; 466184084a31SMat Martineau 466284084a31SMat Martineau chan->sdu = skb; 466384084a31SMat Martineau chan->sdu_last_frag = skb; 466484084a31SMat Martineau 466584084a31SMat Martineau skb = NULL; 466684084a31SMat Martineau err = 0; 46670a708f8fSGustavo F. Padovan break; 46680a708f8fSGustavo F. Padovan 46697e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 46706f61fd47SGustavo F. Padovan if (!chan->sdu) 467184084a31SMat Martineau break; 46720a708f8fSGustavo F. Padovan 467384084a31SMat Martineau append_skb_frag(chan->sdu, skb, 467484084a31SMat Martineau &chan->sdu_last_frag); 467584084a31SMat Martineau skb = NULL; 46760a708f8fSGustavo F. Padovan 467784084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 467884084a31SMat Martineau break; 46790a708f8fSGustavo F. Padovan 468084084a31SMat Martineau err = 0; 46810a708f8fSGustavo F. Padovan break; 46820a708f8fSGustavo F. Padovan 46837e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 46846f61fd47SGustavo F. Padovan if (!chan->sdu) 468584084a31SMat Martineau break; 46860a708f8fSGustavo F. Padovan 468784084a31SMat Martineau append_skb_frag(chan->sdu, skb, 468884084a31SMat Martineau &chan->sdu_last_frag); 468984084a31SMat Martineau skb = NULL; 46900a708f8fSGustavo F. Padovan 469184084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 469284084a31SMat Martineau break; 46930a708f8fSGustavo F. Padovan 469480b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 46950a708f8fSGustavo F. Padovan 469684084a31SMat Martineau if (!err) { 469784084a31SMat Martineau /* Reassembly complete */ 469884084a31SMat Martineau chan->sdu = NULL; 469984084a31SMat Martineau chan->sdu_last_frag = NULL; 470084084a31SMat Martineau chan->sdu_len = 0; 47010a708f8fSGustavo F. Padovan } 47020a708f8fSGustavo F. Padovan break; 47030a708f8fSGustavo F. Padovan } 47040a708f8fSGustavo F. Padovan 470584084a31SMat Martineau if (err) { 47060a708f8fSGustavo F. Padovan kfree_skb(skb); 47076f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 47086f61fd47SGustavo F. Padovan chan->sdu = NULL; 470984084a31SMat Martineau chan->sdu_last_frag = NULL; 471084084a31SMat Martineau chan->sdu_len = 0; 471184084a31SMat Martineau } 47120a708f8fSGustavo F. Padovan 471384084a31SMat Martineau return err; 47140a708f8fSGustavo F. Padovan } 47150a708f8fSGustavo F. Padovan 4716*32b32735SMat Martineau static int l2cap_resegment(struct l2cap_chan *chan) 4717*32b32735SMat Martineau { 4718*32b32735SMat Martineau /* Placeholder */ 4719*32b32735SMat Martineau return 0; 4720*32b32735SMat Martineau } 4721*32b32735SMat Martineau 4722e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 47230a708f8fSGustavo F. Padovan { 472461aa4f5bSMat Martineau u8 event; 472561aa4f5bSMat Martineau 472661aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 472761aa4f5bSMat Martineau return; 472861aa4f5bSMat Martineau 472961aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 4730401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 47310a708f8fSGustavo F. Padovan } 47320a708f8fSGustavo F. Padovan 4733d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 4734d2a7ac5dSMat Martineau { 473563838725SMat Martineau int err = 0; 473663838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 473763838725SMat Martineau * until a gap is encountered. 473863838725SMat Martineau */ 473963838725SMat Martineau 474063838725SMat Martineau BT_DBG("chan %p", chan); 474163838725SMat Martineau 474263838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 474363838725SMat Martineau struct sk_buff *skb; 474463838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 474563838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 474663838725SMat Martineau 474763838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 474863838725SMat Martineau 474963838725SMat Martineau if (!skb) 475063838725SMat Martineau break; 475163838725SMat Martineau 475263838725SMat Martineau skb_unlink(skb, &chan->srej_q); 475363838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 475463838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 475563838725SMat Martineau if (err) 475663838725SMat Martineau break; 475763838725SMat Martineau } 475863838725SMat Martineau 475963838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 476063838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 476163838725SMat Martineau l2cap_send_ack(chan); 476263838725SMat Martineau } 476363838725SMat Martineau 476463838725SMat Martineau return err; 4765d2a7ac5dSMat Martineau } 4766d2a7ac5dSMat Martineau 4767d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 4768d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4769d2a7ac5dSMat Martineau { 4770f80842a8SMat Martineau struct sk_buff *skb; 4771f80842a8SMat Martineau 4772f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 4773f80842a8SMat Martineau 4774f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 4775f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4776f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4777f80842a8SMat Martineau return; 4778f80842a8SMat Martineau } 4779f80842a8SMat Martineau 4780f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4781f80842a8SMat Martineau 4782f80842a8SMat Martineau if (skb == NULL) { 4783f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 4784f80842a8SMat Martineau control->reqseq); 4785f80842a8SMat Martineau return; 4786f80842a8SMat Martineau } 4787f80842a8SMat Martineau 4788f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 4789f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4790f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4791f80842a8SMat Martineau return; 4792f80842a8SMat Martineau } 4793f80842a8SMat Martineau 4794f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4795f80842a8SMat Martineau 4796f80842a8SMat Martineau if (control->poll) { 4797f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 4798f80842a8SMat Martineau 4799f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4800f80842a8SMat Martineau l2cap_retransmit(chan, control); 4801f80842a8SMat Martineau l2cap_ertm_send(chan); 4802f80842a8SMat Martineau 4803f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4804f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4805f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4806f80842a8SMat Martineau } 4807f80842a8SMat Martineau } else { 4808f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 4809f80842a8SMat Martineau 4810f80842a8SMat Martineau if (control->final) { 4811f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 4812f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 4813f80842a8SMat Martineau &chan->conn_state)) 4814f80842a8SMat Martineau l2cap_retransmit(chan, control); 4815f80842a8SMat Martineau } else { 4816f80842a8SMat Martineau l2cap_retransmit(chan, control); 4817f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4818f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4819f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4820f80842a8SMat Martineau } 4821f80842a8SMat Martineau } 4822f80842a8SMat Martineau } 4823d2a7ac5dSMat Martineau } 4824d2a7ac5dSMat Martineau 4825d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 4826d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4827d2a7ac5dSMat Martineau { 4828fcd289dfSMat Martineau struct sk_buff *skb; 4829fcd289dfSMat Martineau 4830fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 4831fcd289dfSMat Martineau 4832fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 4833fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4834fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4835fcd289dfSMat Martineau return; 4836fcd289dfSMat Martineau } 4837fcd289dfSMat Martineau 4838fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4839fcd289dfSMat Martineau 4840fcd289dfSMat Martineau if (chan->max_tx && skb && 4841fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 4842fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4843fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4844fcd289dfSMat Martineau return; 4845fcd289dfSMat Martineau } 4846fcd289dfSMat Martineau 4847fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4848fcd289dfSMat Martineau 4849fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 4850fcd289dfSMat Martineau 4851fcd289dfSMat Martineau if (control->final) { 4852fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 4853fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4854fcd289dfSMat Martineau } else { 4855fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4856fcd289dfSMat Martineau l2cap_ertm_send(chan); 4857fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 4858fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 4859fcd289dfSMat Martineau } 4860d2a7ac5dSMat Martineau } 4861d2a7ac5dSMat Martineau 48624b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 48634b51dae9SMat Martineau { 48644b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 48654b51dae9SMat Martineau 48664b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 48674b51dae9SMat Martineau chan->expected_tx_seq); 48684b51dae9SMat Martineau 48694b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 48704b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 48714b51dae9SMat Martineau chan->tx_win) { 48724b51dae9SMat Martineau /* See notes below regarding "double poll" and 48734b51dae9SMat Martineau * invalid packets. 48744b51dae9SMat Martineau */ 48754b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 48764b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 48774b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 48784b51dae9SMat Martineau } else { 48794b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 48804b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 48814b51dae9SMat Martineau } 48824b51dae9SMat Martineau } 48834b51dae9SMat Martineau 48844b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 48854b51dae9SMat Martineau BT_DBG("Expected SREJ"); 48864b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 48874b51dae9SMat Martineau } 48884b51dae9SMat Martineau 48894b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 48904b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 48914b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 48924b51dae9SMat Martineau } 48934b51dae9SMat Martineau 48944b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 48954b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 48964b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 48974b51dae9SMat Martineau } 48984b51dae9SMat Martineau } 48994b51dae9SMat Martineau 49004b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 49014b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 49024b51dae9SMat Martineau chan->tx_win) { 49034b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 49044b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 49054b51dae9SMat Martineau } else { 49064b51dae9SMat Martineau BT_DBG("Expected"); 49074b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 49084b51dae9SMat Martineau } 49094b51dae9SMat Martineau } 49104b51dae9SMat Martineau 49114b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 49122d792818SGustavo Padovan __seq_offset(chan, chan->expected_tx_seq, chan->last_acked_seq)) { 49134b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 49144b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 49154b51dae9SMat Martineau } 49164b51dae9SMat Martineau 49174b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 49184b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 49194b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 49204b51dae9SMat Martineau * the remote stack receives and processes both polls, 49214b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 49224b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 49234b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 49244b51dae9SMat Martineau * request. 49254b51dae9SMat Martineau * 49264b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 49274b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 49284b51dae9SMat Martineau * invalid frames to be safely ignored. 49294b51dae9SMat Martineau * 49304b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 49314b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 49324b51dae9SMat Martineau * causes a disconnect. 49334b51dae9SMat Martineau */ 49344b51dae9SMat Martineau 49354b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 49364b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 49374b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 49384b51dae9SMat Martineau } else { 49394b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 49404b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 49414b51dae9SMat Martineau } 49424b51dae9SMat Martineau } else { 49434b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 49444b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 49454b51dae9SMat Martineau } 49464b51dae9SMat Martineau } 49474b51dae9SMat Martineau 4948d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 4949d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4950d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4951d2a7ac5dSMat Martineau { 4952d2a7ac5dSMat Martineau int err = 0; 4953d2a7ac5dSMat Martineau bool skb_in_use = 0; 4954d2a7ac5dSMat Martineau 4955d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4956d2a7ac5dSMat Martineau event); 4957d2a7ac5dSMat Martineau 4958d2a7ac5dSMat Martineau switch (event) { 4959d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4960d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 4961d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4962d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4963d2a7ac5dSMat Martineau 4964d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4965d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 4966d2a7ac5dSMat Martineau control->txseq); 4967d2a7ac5dSMat Martineau break; 4968d2a7ac5dSMat Martineau } 4969d2a7ac5dSMat Martineau 4970d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 4971d2a7ac5dSMat Martineau control->txseq); 4972d2a7ac5dSMat Martineau 4973d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 4974d2a7ac5dSMat Martineau skb_in_use = 1; 4975d2a7ac5dSMat Martineau 4976d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 4977d2a7ac5dSMat Martineau if (err) 4978d2a7ac5dSMat Martineau break; 4979d2a7ac5dSMat Martineau 4980d2a7ac5dSMat Martineau if (control->final) { 4981d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4982d2a7ac5dSMat Martineau &chan->conn_state)) { 4983d2a7ac5dSMat Martineau control->final = 0; 4984d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4985d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4986d2a7ac5dSMat Martineau } 4987d2a7ac5dSMat Martineau } 4988d2a7ac5dSMat Martineau 4989d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 4990d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4991d2a7ac5dSMat Martineau break; 4992d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4993d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4994d2a7ac5dSMat Martineau 4995d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 4996d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 4997d2a7ac5dSMat Martineau * when local busy is exited. 4998d2a7ac5dSMat Martineau */ 4999d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5000d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 5001d2a7ac5dSMat Martineau control->txseq); 5002d2a7ac5dSMat Martineau break; 5003d2a7ac5dSMat Martineau } 5004d2a7ac5dSMat Martineau 5005d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 5006d2a7ac5dSMat Martineau * must be sent for each missing frame. The 5007d2a7ac5dSMat Martineau * current frame is stored for later use. 5008d2a7ac5dSMat Martineau */ 5009d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5010d2a7ac5dSMat Martineau skb_in_use = 1; 5011d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5012d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5013d2a7ac5dSMat Martineau 5014d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 5015d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 5016d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5017d2a7ac5dSMat Martineau 5018d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 5019d2a7ac5dSMat Martineau break; 5020d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5021d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 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 l2cap_send_i_or_rr_or_rnr(chan); 5046d2a7ac5dSMat Martineau } else { 5047d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5048d2a7ac5dSMat Martineau &chan->conn_state) && 5049d2a7ac5dSMat Martineau chan->unacked_frames) 5050d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5051d2a7ac5dSMat Martineau 5052d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5053d2a7ac5dSMat Martineau } 5054d2a7ac5dSMat Martineau break; 5055d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5056d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5057d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5058d2a7ac5dSMat Martineau if (control && control->poll) { 5059d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5060d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 5061d2a7ac5dSMat Martineau } 5062d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 5063d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 5064d2a7ac5dSMat Martineau break; 5065d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5066d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5067d2a7ac5dSMat Martineau break; 5068d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5069d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5070d2a7ac5dSMat Martineau break; 5071d2a7ac5dSMat Martineau default: 5072d2a7ac5dSMat Martineau break; 5073d2a7ac5dSMat Martineau } 5074d2a7ac5dSMat Martineau 5075d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5076d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5077d2a7ac5dSMat Martineau kfree_skb(skb); 5078d2a7ac5dSMat Martineau } 5079d2a7ac5dSMat Martineau 5080d2a7ac5dSMat Martineau return err; 5081d2a7ac5dSMat Martineau } 5082d2a7ac5dSMat Martineau 5083d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 5084d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5085d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5086d2a7ac5dSMat Martineau { 5087d2a7ac5dSMat Martineau int err = 0; 5088d2a7ac5dSMat Martineau u16 txseq = control->txseq; 5089d2a7ac5dSMat Martineau bool skb_in_use = 0; 5090d2a7ac5dSMat Martineau 5091d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5092d2a7ac5dSMat Martineau event); 5093d2a7ac5dSMat Martineau 5094d2a7ac5dSMat Martineau switch (event) { 5095d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5096d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 5097d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5098d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 5099d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5100d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5101d2a7ac5dSMat Martineau skb_in_use = 1; 5102d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5103d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5104d2a7ac5dSMat Martineau 5105d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 5106d2a7ac5dSMat Martineau break; 5107d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 5108d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 5109d2a7ac5dSMat Martineau 5110d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5111d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5112d2a7ac5dSMat Martineau skb_in_use = 1; 5113d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5114d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5115d2a7ac5dSMat Martineau 5116d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 5117d2a7ac5dSMat Martineau if (err) 5118d2a7ac5dSMat Martineau break; 5119d2a7ac5dSMat Martineau 5120d2a7ac5dSMat Martineau break; 5121d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5122d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 5123d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 5124d2a7ac5dSMat Martineau * the missing frames. 5125d2a7ac5dSMat Martineau */ 5126d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5127d2a7ac5dSMat Martineau skb_in_use = 1; 5128d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5129d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5130d2a7ac5dSMat Martineau 5131d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5132d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5133d2a7ac5dSMat Martineau break; 5134d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 5135d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 5136d2a7ac5dSMat Martineau * some expected retransmitted frames are 5137d2a7ac5dSMat Martineau * missing. Request retransmission of missing 5138d2a7ac5dSMat Martineau * SREJ'd frames. 5139d2a7ac5dSMat Martineau */ 5140d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5141d2a7ac5dSMat Martineau skb_in_use = 1; 5142d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5143d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5144d2a7ac5dSMat Martineau 5145d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5146d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 5147d2a7ac5dSMat Martineau break; 5148d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 5149d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 5150d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5151d2a7ac5dSMat Martineau break; 5152d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5153d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 5154d2a7ac5dSMat Martineau * was already received. Ignore it completely. 5155d2a7ac5dSMat Martineau */ 5156d2a7ac5dSMat Martineau break; 5157d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5158d2a7ac5dSMat Martineau break; 5159d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5160d2a7ac5dSMat Martineau default: 5161d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5162d2a7ac5dSMat Martineau ECONNRESET); 5163d2a7ac5dSMat Martineau break; 5164d2a7ac5dSMat Martineau } 5165d2a7ac5dSMat Martineau break; 5166d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5167d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5168d2a7ac5dSMat Martineau if (control->final) { 5169d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5170d2a7ac5dSMat Martineau 5171d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5172d2a7ac5dSMat Martineau &chan->conn_state)) { 5173d2a7ac5dSMat Martineau control->final = 0; 5174d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5175d2a7ac5dSMat Martineau } 5176d2a7ac5dSMat Martineau 5177d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5178d2a7ac5dSMat Martineau } else if (control->poll) { 5179d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5180d2a7ac5dSMat Martineau &chan->conn_state) && 5181d2a7ac5dSMat Martineau chan->unacked_frames) { 5182d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5183d2a7ac5dSMat Martineau } 5184d2a7ac5dSMat Martineau 5185d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5186d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5187d2a7ac5dSMat Martineau } else { 5188d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5189d2a7ac5dSMat Martineau &chan->conn_state) && 5190d2a7ac5dSMat Martineau chan->unacked_frames) 5191d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5192d2a7ac5dSMat Martineau 5193d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5194d2a7ac5dSMat Martineau } 5195d2a7ac5dSMat Martineau break; 5196d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5197d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5198d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5199d2a7ac5dSMat Martineau if (control->poll) { 5200d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5201d2a7ac5dSMat Martineau } else { 5202d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 5203d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 5204d2a7ac5dSMat Martineau rr_control.sframe = 1; 5205d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 5206d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 5207d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 5208d2a7ac5dSMat Martineau } 5209d2a7ac5dSMat Martineau 5210d2a7ac5dSMat Martineau break; 5211d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5212d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5213d2a7ac5dSMat Martineau break; 5214d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5215d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5216d2a7ac5dSMat Martineau break; 5217d2a7ac5dSMat Martineau } 5218d2a7ac5dSMat Martineau 5219d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5220d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5221d2a7ac5dSMat Martineau kfree_skb(skb); 5222d2a7ac5dSMat Martineau } 5223d2a7ac5dSMat Martineau 5224d2a7ac5dSMat Martineau return err; 5225d2a7ac5dSMat Martineau } 5226d2a7ac5dSMat Martineau 5227*32b32735SMat Martineau static int l2cap_finish_move(struct l2cap_chan *chan) 5228*32b32735SMat Martineau { 5229*32b32735SMat Martineau BT_DBG("chan %p", chan); 5230*32b32735SMat Martineau 5231*32b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 5232*32b32735SMat Martineau 5233*32b32735SMat Martineau if (chan->hs_hcon) 5234*32b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 5235*32b32735SMat Martineau else 5236*32b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 5237*32b32735SMat Martineau 5238*32b32735SMat Martineau return l2cap_resegment(chan); 5239*32b32735SMat Martineau } 5240*32b32735SMat Martineau 5241*32b32735SMat Martineau static int l2cap_rx_state_wait_p(struct l2cap_chan *chan, 5242*32b32735SMat Martineau struct l2cap_ctrl *control, 5243*32b32735SMat Martineau struct sk_buff *skb, u8 event) 5244*32b32735SMat Martineau { 5245*32b32735SMat Martineau int err; 5246*32b32735SMat Martineau 5247*32b32735SMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5248*32b32735SMat Martineau event); 5249*32b32735SMat Martineau 5250*32b32735SMat Martineau if (!control->poll) 5251*32b32735SMat Martineau return -EPROTO; 5252*32b32735SMat Martineau 5253*32b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 5254*32b32735SMat Martineau 5255*32b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 5256*32b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 5257*32b32735SMat Martineau else 5258*32b32735SMat Martineau chan->tx_send_head = NULL; 5259*32b32735SMat Martineau 5260*32b32735SMat Martineau /* Rewind next_tx_seq to the point expected 5261*32b32735SMat Martineau * by the receiver. 5262*32b32735SMat Martineau */ 5263*32b32735SMat Martineau chan->next_tx_seq = control->reqseq; 5264*32b32735SMat Martineau chan->unacked_frames = 0; 5265*32b32735SMat Martineau 5266*32b32735SMat Martineau err = l2cap_finish_move(chan); 5267*32b32735SMat Martineau if (err) 5268*32b32735SMat Martineau return err; 5269*32b32735SMat Martineau 5270*32b32735SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5271*32b32735SMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 5272*32b32735SMat Martineau 5273*32b32735SMat Martineau if (event == L2CAP_EV_RECV_IFRAME) 5274*32b32735SMat Martineau return -EPROTO; 5275*32b32735SMat Martineau 5276*32b32735SMat Martineau return l2cap_rx_state_recv(chan, control, NULL, event); 5277*32b32735SMat Martineau } 5278*32b32735SMat Martineau 5279*32b32735SMat Martineau static int l2cap_rx_state_wait_f(struct l2cap_chan *chan, 5280*32b32735SMat Martineau struct l2cap_ctrl *control, 5281*32b32735SMat Martineau struct sk_buff *skb, u8 event) 5282*32b32735SMat Martineau { 5283*32b32735SMat Martineau int err; 5284*32b32735SMat Martineau 5285*32b32735SMat Martineau if (!control->final) 5286*32b32735SMat Martineau return -EPROTO; 5287*32b32735SMat Martineau 5288*32b32735SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5289*32b32735SMat Martineau 5290*32b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 5291*32b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 5292*32b32735SMat Martineau 5293*32b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 5294*32b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 5295*32b32735SMat Martineau else 5296*32b32735SMat Martineau chan->tx_send_head = NULL; 5297*32b32735SMat Martineau 5298*32b32735SMat Martineau /* Rewind next_tx_seq to the point expected 5299*32b32735SMat Martineau * by the receiver. 5300*32b32735SMat Martineau */ 5301*32b32735SMat Martineau chan->next_tx_seq = control->reqseq; 5302*32b32735SMat Martineau chan->unacked_frames = 0; 5303*32b32735SMat Martineau 5304*32b32735SMat Martineau if (chan->hs_hcon) 5305*32b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 5306*32b32735SMat Martineau else 5307*32b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 5308*32b32735SMat Martineau 5309*32b32735SMat Martineau err = l2cap_resegment(chan); 5310*32b32735SMat Martineau 5311*32b32735SMat Martineau if (!err) 5312*32b32735SMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 5313*32b32735SMat Martineau 5314*32b32735SMat Martineau return err; 5315*32b32735SMat Martineau } 5316*32b32735SMat Martineau 5317d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 5318d2a7ac5dSMat Martineau { 5319d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 5320d2a7ac5dSMat Martineau u16 unacked; 5321d2a7ac5dSMat Martineau 5322d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 5323d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 5324d2a7ac5dSMat Martineau } 5325d2a7ac5dSMat Martineau 5326cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5327cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 53280a708f8fSGustavo F. Padovan { 5329d2a7ac5dSMat Martineau int err = 0; 5330d2a7ac5dSMat Martineau 5331d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 5332d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 5333d2a7ac5dSMat Martineau 5334d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 5335d2a7ac5dSMat Martineau switch (chan->rx_state) { 5336d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 5337d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 5338d2a7ac5dSMat Martineau break; 5339d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 5340d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 5341d2a7ac5dSMat Martineau event); 5342d2a7ac5dSMat Martineau break; 5343*32b32735SMat Martineau case L2CAP_RX_STATE_WAIT_P: 5344*32b32735SMat Martineau err = l2cap_rx_state_wait_p(chan, control, skb, event); 5345*32b32735SMat Martineau break; 5346*32b32735SMat Martineau case L2CAP_RX_STATE_WAIT_F: 5347*32b32735SMat Martineau err = l2cap_rx_state_wait_f(chan, control, skb, event); 5348*32b32735SMat Martineau break; 5349d2a7ac5dSMat Martineau default: 5350d2a7ac5dSMat Martineau /* shut it down */ 5351d2a7ac5dSMat Martineau break; 5352d2a7ac5dSMat Martineau } 5353d2a7ac5dSMat Martineau } else { 5354d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 5355d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 5356d2a7ac5dSMat Martineau chan->expected_ack_seq); 5357d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5358d2a7ac5dSMat Martineau } 5359d2a7ac5dSMat Martineau 5360d2a7ac5dSMat Martineau return err; 5361cec8ab6eSMat Martineau } 5362cec8ab6eSMat Martineau 5363cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5364cec8ab6eSMat Martineau struct sk_buff *skb) 5365cec8ab6eSMat Martineau { 53664b51dae9SMat Martineau int err = 0; 53674b51dae9SMat Martineau 53684b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 53694b51dae9SMat Martineau chan->rx_state); 53704b51dae9SMat Martineau 53714b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 53724b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 53734b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 53744b51dae9SMat Martineau 53754b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 53764b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 53774b51dae9SMat Martineau 53784b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 53794b51dae9SMat Martineau 53804b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 53814b51dae9SMat Martineau } else { 53824b51dae9SMat Martineau if (chan->sdu) { 53834b51dae9SMat Martineau kfree_skb(chan->sdu); 53844b51dae9SMat Martineau chan->sdu = NULL; 53854b51dae9SMat Martineau } 53864b51dae9SMat Martineau chan->sdu_last_frag = NULL; 53874b51dae9SMat Martineau chan->sdu_len = 0; 53884b51dae9SMat Martineau 53894b51dae9SMat Martineau if (skb) { 53904b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 53914b51dae9SMat Martineau kfree_skb(skb); 53924b51dae9SMat Martineau } 53934b51dae9SMat Martineau } 53944b51dae9SMat Martineau 53954b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 53964b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 53974b51dae9SMat Martineau 53984b51dae9SMat Martineau return err; 5399cec8ab6eSMat Martineau } 5400cec8ab6eSMat Martineau 5401cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 5402cec8ab6eSMat Martineau { 5403cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 5404cec8ab6eSMat Martineau u16 len; 5405cec8ab6eSMat Martineau u8 event; 54060a708f8fSGustavo F. Padovan 5407b76bbd66SMat Martineau __unpack_control(chan, skb); 5408b76bbd66SMat Martineau 54090a708f8fSGustavo F. Padovan len = skb->len; 54100a708f8fSGustavo F. Padovan 54110a708f8fSGustavo F. Padovan /* 54120a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 54130a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 5414cec8ab6eSMat Martineau * procedures and ask for retransmission. 54150a708f8fSGustavo F. Padovan */ 541647d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 54170a708f8fSGustavo F. Padovan goto drop; 54180a708f8fSGustavo F. Padovan 5419cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 542003a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 54210a708f8fSGustavo F. Padovan 542247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 542303a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 54240a708f8fSGustavo F. Padovan 542547d1ec61SGustavo F. Padovan if (len > chan->mps) { 54268c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 54270a708f8fSGustavo F. Padovan goto drop; 54280a708f8fSGustavo F. Padovan } 54290a708f8fSGustavo F. Padovan 5430cec8ab6eSMat Martineau if (!control->sframe) { 5431cec8ab6eSMat Martineau int err; 54320a708f8fSGustavo F. Padovan 5433cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 5434cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 5435cec8ab6eSMat Martineau control->txseq); 5436836be934SAndrei Emeltchenko 5437cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 5438cec8ab6eSMat Martineau * valid in TX WAIT_F 5439cec8ab6eSMat Martineau */ 5440cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 54410a708f8fSGustavo F. Padovan goto drop; 54420a708f8fSGustavo F. Padovan 5443cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 5444cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 5445cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 54460a708f8fSGustavo F. Padovan } else { 5447cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 5448cec8ab6eSMat Martineau } 5449cec8ab6eSMat Martineau 5450cec8ab6eSMat Martineau if (err) 5451cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5452cec8ab6eSMat Martineau ECONNRESET); 5453cec8ab6eSMat Martineau } else { 5454cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 5455cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 5456cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 5457cec8ab6eSMat Martineau }; 5458cec8ab6eSMat Martineau 5459cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 5460cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 5461cec8ab6eSMat Martineau goto drop; 5462cec8ab6eSMat Martineau 5463cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 5464cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 5465cec8ab6eSMat Martineau control->super); 5466cec8ab6eSMat Martineau 54670a708f8fSGustavo F. Padovan if (len != 0) { 54680a708f8fSGustavo F. Padovan BT_ERR("%d", len); 54698c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 54700a708f8fSGustavo F. Padovan goto drop; 54710a708f8fSGustavo F. Padovan } 54720a708f8fSGustavo F. Padovan 5473cec8ab6eSMat Martineau /* Validate F and P bits */ 5474cec8ab6eSMat Martineau if (control->final && (control->poll || 5475cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 5476cec8ab6eSMat Martineau goto drop; 5477cec8ab6eSMat Martineau 5478cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 5479cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 5480cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 54810a708f8fSGustavo F. Padovan } 54820a708f8fSGustavo F. Padovan 54830a708f8fSGustavo F. Padovan return 0; 54840a708f8fSGustavo F. Padovan 54850a708f8fSGustavo F. Padovan drop: 54860a708f8fSGustavo F. Padovan kfree_skb(skb); 54870a708f8fSGustavo F. Padovan return 0; 54880a708f8fSGustavo F. Padovan } 54890a708f8fSGustavo F. Padovan 549013ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 549113ca56e0SAndrei Emeltchenko struct sk_buff *skb) 54920a708f8fSGustavo F. Padovan { 549348454079SGustavo F. Padovan struct l2cap_chan *chan; 54940a708f8fSGustavo F. Padovan 5495baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 549648454079SGustavo F. Padovan if (!chan) { 549797e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 549897e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 549997e8e89dSAndrei Emeltchenko if (!chan) { 550097e8e89dSAndrei Emeltchenko kfree_skb(skb); 550113ca56e0SAndrei Emeltchenko return; 550297e8e89dSAndrei Emeltchenko } 550397e8e89dSAndrei Emeltchenko 550497e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 550597e8e89dSAndrei Emeltchenko } else { 55060a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 55076be36555SAndrei Emeltchenko /* Drop packet and return */ 55083379013bSDan Carpenter kfree_skb(skb); 550913ca56e0SAndrei Emeltchenko return; 55100a708f8fSGustavo F. Padovan } 551197e8e89dSAndrei Emeltchenko } 55120a708f8fSGustavo F. Padovan 551349208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 55140a708f8fSGustavo F. Padovan 551589bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 55160a708f8fSGustavo F. Padovan goto drop; 55170a708f8fSGustavo F. Padovan 55180c1bc5c6SGustavo F. Padovan switch (chan->mode) { 55190a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 55200a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 55210a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 55220a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 55230a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 55240a708f8fSGustavo F. Padovan 55250c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 55260a708f8fSGustavo F. Padovan goto drop; 55270a708f8fSGustavo F. Padovan 552880b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 55290a708f8fSGustavo F. Padovan goto done; 55300a708f8fSGustavo F. Padovan break; 55310a708f8fSGustavo F. Padovan 55320a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 55330a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 5534cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 55350a708f8fSGustavo F. Padovan goto done; 55360a708f8fSGustavo F. Padovan 55370a708f8fSGustavo F. Padovan default: 55380c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 55390a708f8fSGustavo F. Padovan break; 55400a708f8fSGustavo F. Padovan } 55410a708f8fSGustavo F. Padovan 55420a708f8fSGustavo F. Padovan drop: 55430a708f8fSGustavo F. Padovan kfree_skb(skb); 55440a708f8fSGustavo F. Padovan 55450a708f8fSGustavo F. Padovan done: 55466be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 55470a708f8fSGustavo F. Padovan } 55480a708f8fSGustavo F. Padovan 554984104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 555084104b24SAndrei Emeltchenko struct sk_buff *skb) 55510a708f8fSGustavo F. Padovan { 555223691d75SGustavo F. Padovan struct l2cap_chan *chan; 55530a708f8fSGustavo F. Padovan 5554c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 555523691d75SGustavo F. Padovan if (!chan) 55560a708f8fSGustavo F. Padovan goto drop; 55570a708f8fSGustavo F. Padovan 55585b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 55590a708f8fSGustavo F. Padovan 556089bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 55610a708f8fSGustavo F. Padovan goto drop; 55620a708f8fSGustavo F. Padovan 5563e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 55640a708f8fSGustavo F. Padovan goto drop; 55650a708f8fSGustavo F. Padovan 556680b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 556784104b24SAndrei Emeltchenko return; 55680a708f8fSGustavo F. Padovan 55690a708f8fSGustavo F. Padovan drop: 55700a708f8fSGustavo F. Padovan kfree_skb(skb); 55710a708f8fSGustavo F. Padovan } 55720a708f8fSGustavo F. Padovan 55736810fca7SAndrei Emeltchenko static void l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 5574d9b88702SAndrei Emeltchenko struct sk_buff *skb) 55759f69bda6SGustavo F. Padovan { 557623691d75SGustavo F. Padovan struct l2cap_chan *chan; 55779f69bda6SGustavo F. Padovan 5578c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 557923691d75SGustavo F. Padovan if (!chan) 55809f69bda6SGustavo F. Padovan goto drop; 55819f69bda6SGustavo F. Padovan 55825b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 55839f69bda6SGustavo F. Padovan 558489bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 55859f69bda6SGustavo F. Padovan goto drop; 55869f69bda6SGustavo F. Padovan 5587e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 55889f69bda6SGustavo F. Padovan goto drop; 55899f69bda6SGustavo F. Padovan 559080b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 55916810fca7SAndrei Emeltchenko return; 55929f69bda6SGustavo F. Padovan 55939f69bda6SGustavo F. Padovan drop: 55949f69bda6SGustavo F. Padovan kfree_skb(skb); 55959f69bda6SGustavo F. Padovan } 55969f69bda6SGustavo F. Padovan 55970a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 55980a708f8fSGustavo F. Padovan { 55990a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 56000a708f8fSGustavo F. Padovan u16 cid, len; 56010a708f8fSGustavo F. Padovan __le16 psm; 56020a708f8fSGustavo F. Padovan 56030a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 56040a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 56050a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 56060a708f8fSGustavo F. Padovan 56070a708f8fSGustavo F. Padovan if (len != skb->len) { 56080a708f8fSGustavo F. Padovan kfree_skb(skb); 56090a708f8fSGustavo F. Padovan return; 56100a708f8fSGustavo F. Padovan } 56110a708f8fSGustavo F. Padovan 56120a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 56130a708f8fSGustavo F. Padovan 56140a708f8fSGustavo F. Padovan switch (cid) { 56153300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 56160a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 56170a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 56180a708f8fSGustavo F. Padovan break; 56190a708f8fSGustavo F. Padovan 56200a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 5621097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 56220181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 56230a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 56240a708f8fSGustavo F. Padovan break; 56250a708f8fSGustavo F. Padovan 56269f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 56279f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 56289f69bda6SGustavo F. Padovan break; 56299f69bda6SGustavo F. Padovan 5630b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 5631b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 5632b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 5633b501d6a1SAnderson Briglia break; 5634b501d6a1SAnderson Briglia 56350a708f8fSGustavo F. Padovan default: 56360a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 56370a708f8fSGustavo F. Padovan break; 56380a708f8fSGustavo F. Padovan } 56390a708f8fSGustavo F. Padovan } 56400a708f8fSGustavo F. Padovan 56410a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 56420a708f8fSGustavo F. Padovan 5643686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 56440a708f8fSGustavo F. Padovan { 56450a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 564623691d75SGustavo F. Padovan struct l2cap_chan *c; 56470a708f8fSGustavo F. Padovan 56486ed93dc6SAndrei Emeltchenko BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 56490a708f8fSGustavo F. Padovan 56500a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 565123691d75SGustavo F. Padovan read_lock(&chan_list_lock); 565223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 565323691d75SGustavo F. Padovan struct sock *sk = c->sk; 56544343478fSGustavo F. Padovan 565589bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 56560a708f8fSGustavo F. Padovan continue; 56570a708f8fSGustavo F. Padovan 56580a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 56590a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 566043bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 56610a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 56620a708f8fSGustavo F. Padovan exact++; 56630a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 56640a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 566543bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 56660a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 56670a708f8fSGustavo F. Padovan } 56680a708f8fSGustavo F. Padovan } 566923691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 56700a708f8fSGustavo F. Padovan 56710a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 56720a708f8fSGustavo F. Padovan } 56730a708f8fSGustavo F. Padovan 56749e664631SAndrei Emeltchenko void l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 56750a708f8fSGustavo F. Padovan { 56760a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 56770a708f8fSGustavo F. Padovan 56786ed93dc6SAndrei Emeltchenko BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status); 56790a708f8fSGustavo F. Padovan 56800a708f8fSGustavo F. Padovan if (!status) { 56810a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 56820a708f8fSGustavo F. Padovan if (conn) 56830a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 56840a708f8fSGustavo F. Padovan } else 5685e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 56860a708f8fSGustavo F. Padovan 56870a708f8fSGustavo F. Padovan } 56880a708f8fSGustavo F. Padovan 5689686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 56900a708f8fSGustavo F. Padovan { 56910a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 56920a708f8fSGustavo F. Padovan 56930a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 56940a708f8fSGustavo F. Padovan 5695686ebf28SUlisses Furquim if (!conn) 56969f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 56970a708f8fSGustavo F. Padovan return conn->disc_reason; 56980a708f8fSGustavo F. Padovan } 56990a708f8fSGustavo F. Padovan 57009e664631SAndrei Emeltchenko void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 57010a708f8fSGustavo F. Padovan { 57020a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 57030a708f8fSGustavo F. Padovan 5704e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 57050a708f8fSGustavo F. Padovan } 57060a708f8fSGustavo F. Padovan 57074343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 57080a708f8fSGustavo F. Padovan { 5709715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 57100a708f8fSGustavo F. Padovan return; 57110a708f8fSGustavo F. Padovan 57120a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 57134343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 5714ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 57154343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 57160f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 57170a708f8fSGustavo F. Padovan } else { 57184343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 5719c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 57200a708f8fSGustavo F. Padovan } 57210a708f8fSGustavo F. Padovan } 57220a708f8fSGustavo F. Padovan 5723686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 57240a708f8fSGustavo F. Padovan { 57250a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 572648454079SGustavo F. Padovan struct l2cap_chan *chan; 57270a708f8fSGustavo F. Padovan 57280a708f8fSGustavo F. Padovan if (!conn) 57290a708f8fSGustavo F. Padovan return 0; 57300a708f8fSGustavo F. Padovan 573189d8b407SAndrei Emeltchenko BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt); 57320a708f8fSGustavo F. Padovan 5733160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 573435d4adccSHemant Gupta if (!status && encrypt) 5735160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 573617cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 5737160dc6acSVinicius Costa Gomes } 5738160dc6acSVinicius Costa Gomes 57393df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 57400a708f8fSGustavo F. Padovan 57413df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 57426be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 57430a708f8fSGustavo F. Padovan 574489d8b407SAndrei Emeltchenko BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid, 574589d8b407SAndrei Emeltchenko state_to_string(chan->state)); 5746f1cb9af5SVinicius Costa Gomes 574778eb2f98SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 574878eb2f98SAndrei Emeltchenko l2cap_chan_unlock(chan); 574978eb2f98SAndrei Emeltchenko continue; 575078eb2f98SAndrei Emeltchenko } 575178eb2f98SAndrei Emeltchenko 5752f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 5753f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 5754f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 5755cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 5756f1cb9af5SVinicius Costa Gomes } 5757f1cb9af5SVinicius Costa Gomes 57586be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 5759f1cb9af5SVinicius Costa Gomes continue; 5760f1cb9af5SVinicius Costa Gomes } 5761f1cb9af5SVinicius Costa Gomes 5762c1360a1cSGustavo F. Padovan if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 57636be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 57640a708f8fSGustavo F. Padovan continue; 57650a708f8fSGustavo F. Padovan } 57660a708f8fSGustavo F. Padovan 576789bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 576889bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 5769a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 5770a7d7723aSGustavo Padovan 5771c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 5772a7d7723aSGustavo Padovan sk->sk_state_change(sk); 5773a7d7723aSGustavo Padovan 57744343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 57756be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 57760a708f8fSGustavo F. Padovan continue; 57770a708f8fSGustavo F. Padovan } 57780a708f8fSGustavo F. Padovan 577989bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 57800a708f8fSGustavo F. Padovan if (!status) { 578193c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 57820a708f8fSGustavo F. Padovan } else { 5783ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 57840a708f8fSGustavo F. Padovan } 578589bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 57866be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 57870a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5788df3c3931SJohan Hedberg __u16 res, stat; 57890a708f8fSGustavo F. Padovan 57906be36555SAndrei Emeltchenko lock_sock(sk); 57916be36555SAndrei Emeltchenko 57920a708f8fSGustavo F. Padovan if (!status) { 5793c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 5794c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 5795df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 5796df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 57972dc4e510SGustavo Padovan chan->ops->defer(chan); 5798df3c3931SJohan Hedberg } else { 57990e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 5800df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 5801df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 5802df3c3931SJohan Hedberg } 58030a708f8fSGustavo F. Padovan } else { 58040e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 5805ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 5806df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 5807df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 58080a708f8fSGustavo F. Padovan } 58090a708f8fSGustavo F. Padovan 58106be36555SAndrei Emeltchenko release_sock(sk); 58116be36555SAndrei Emeltchenko 5812fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5813fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5814df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 5815df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 5816fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5817fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 58182d369359SMat Martineau 58192d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 58202d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 58212d369359SMat Martineau char buf[128]; 58222d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 58232d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 58242d369359SMat Martineau L2CAP_CONF_REQ, 58252d369359SMat Martineau l2cap_build_conf_req(chan, buf), 58262d369359SMat Martineau buf); 58272d369359SMat Martineau chan->num_conf_req++; 58282d369359SMat Martineau } 58290a708f8fSGustavo F. Padovan } 58300a708f8fSGustavo F. Padovan 58316be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 58320a708f8fSGustavo F. Padovan } 58330a708f8fSGustavo F. Padovan 58343df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 58350a708f8fSGustavo F. Padovan 58360a708f8fSGustavo F. Padovan return 0; 58370a708f8fSGustavo F. Padovan } 58380a708f8fSGustavo F. Padovan 5839686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 58400a708f8fSGustavo F. Padovan { 58410a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 5842d73a0988SAndrei Emeltchenko struct l2cap_hdr *hdr; 5843d73a0988SAndrei Emeltchenko int len; 58440a708f8fSGustavo F. Padovan 58451d13a254SAndrei Emeltchenko /* For AMP controller do not create l2cap conn */ 58461d13a254SAndrei Emeltchenko if (!conn && hcon->hdev->dev_type != HCI_BREDR) 58471d13a254SAndrei Emeltchenko goto drop; 58480a708f8fSGustavo F. Padovan 58490a708f8fSGustavo F. Padovan if (!conn) 58500a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 58510a708f8fSGustavo F. Padovan 58520a708f8fSGustavo F. Padovan if (!conn) 58530a708f8fSGustavo F. Padovan goto drop; 58540a708f8fSGustavo F. Padovan 58550a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 58560a708f8fSGustavo F. Padovan 5857d73a0988SAndrei Emeltchenko switch (flags) { 5858d73a0988SAndrei Emeltchenko case ACL_START: 5859d73a0988SAndrei Emeltchenko case ACL_START_NO_FLUSH: 5860d73a0988SAndrei Emeltchenko case ACL_COMPLETE: 58610a708f8fSGustavo F. Padovan if (conn->rx_len) { 58620a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 58630a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 58640a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 58650a708f8fSGustavo F. Padovan conn->rx_len = 0; 58660a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 58670a708f8fSGustavo F. Padovan } 58680a708f8fSGustavo F. Padovan 58690a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 58700a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 58710a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 58720a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 58730a708f8fSGustavo F. Padovan goto drop; 58740a708f8fSGustavo F. Padovan } 58750a708f8fSGustavo F. Padovan 58760a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 58770a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 58780a708f8fSGustavo F. Padovan 58790a708f8fSGustavo F. Padovan if (len == skb->len) { 58800a708f8fSGustavo F. Padovan /* Complete frame received */ 58810a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 58820a708f8fSGustavo F. Padovan return 0; 58830a708f8fSGustavo F. Padovan } 58840a708f8fSGustavo F. Padovan 58850a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 58860a708f8fSGustavo F. Padovan 58870a708f8fSGustavo F. Padovan if (skb->len > len) { 58880a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 58890a708f8fSGustavo F. Padovan skb->len, len); 58900a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 58910a708f8fSGustavo F. Padovan goto drop; 58920a708f8fSGustavo F. Padovan } 58930a708f8fSGustavo F. Padovan 58940a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 58958bcde1f2SGustavo Padovan conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL); 58960a708f8fSGustavo F. Padovan if (!conn->rx_skb) 58970a708f8fSGustavo F. Padovan goto drop; 58980a708f8fSGustavo F. Padovan 58990a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 59000a708f8fSGustavo F. Padovan skb->len); 59010a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 5902d73a0988SAndrei Emeltchenko break; 5903d73a0988SAndrei Emeltchenko 5904d73a0988SAndrei Emeltchenko case ACL_CONT: 59050a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 59060a708f8fSGustavo F. Padovan 59070a708f8fSGustavo F. Padovan if (!conn->rx_len) { 59080a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 59090a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 59100a708f8fSGustavo F. Padovan goto drop; 59110a708f8fSGustavo F. Padovan } 59120a708f8fSGustavo F. Padovan 59130a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 59140a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 59150a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 59160a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 59170a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 59180a708f8fSGustavo F. Padovan conn->rx_len = 0; 59190a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 59200a708f8fSGustavo F. Padovan goto drop; 59210a708f8fSGustavo F. Padovan } 59220a708f8fSGustavo F. Padovan 59230a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 59240a708f8fSGustavo F. Padovan skb->len); 59250a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 59260a708f8fSGustavo F. Padovan 59270a708f8fSGustavo F. Padovan if (!conn->rx_len) { 59280a708f8fSGustavo F. Padovan /* Complete frame received */ 59290a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 59300a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 59310a708f8fSGustavo F. Padovan } 5932d73a0988SAndrei Emeltchenko break; 59330a708f8fSGustavo F. Padovan } 59340a708f8fSGustavo F. Padovan 59350a708f8fSGustavo F. Padovan drop: 59360a708f8fSGustavo F. Padovan kfree_skb(skb); 59370a708f8fSGustavo F. Padovan return 0; 59380a708f8fSGustavo F. Padovan } 59390a708f8fSGustavo F. Padovan 59400a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 59410a708f8fSGustavo F. Padovan { 594223691d75SGustavo F. Padovan struct l2cap_chan *c; 59430a708f8fSGustavo F. Padovan 5944333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 59450a708f8fSGustavo F. Padovan 594623691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 594723691d75SGustavo F. Padovan struct sock *sk = c->sk; 59480a708f8fSGustavo F. Padovan 5949fcb73338SAndrei Emeltchenko seq_printf(f, "%pMR %pMR %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 5950fcb73338SAndrei Emeltchenko &bt_sk(sk)->src, &bt_sk(sk)->dst, 595189bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 595223691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 595323691d75SGustavo F. Padovan c->sec_level, c->mode); 59540a708f8fSGustavo F. Padovan } 59550a708f8fSGustavo F. Padovan 5956333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 59570a708f8fSGustavo F. Padovan 59580a708f8fSGustavo F. Padovan return 0; 59590a708f8fSGustavo F. Padovan } 59600a708f8fSGustavo F. Padovan 59610a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 59620a708f8fSGustavo F. Padovan { 59630a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 59640a708f8fSGustavo F. Padovan } 59650a708f8fSGustavo F. Padovan 59660a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 59670a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 59680a708f8fSGustavo F. Padovan .read = seq_read, 59690a708f8fSGustavo F. Padovan .llseek = seq_lseek, 59700a708f8fSGustavo F. Padovan .release = single_release, 59710a708f8fSGustavo F. Padovan }; 59720a708f8fSGustavo F. Padovan 59730a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 59740a708f8fSGustavo F. Padovan 597564274518SGustavo F. Padovan int __init l2cap_init(void) 59760a708f8fSGustavo F. Padovan { 59770a708f8fSGustavo F. Padovan int err; 59780a708f8fSGustavo F. Padovan 5979bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 59800a708f8fSGustavo F. Padovan if (err < 0) 59810a708f8fSGustavo F. Padovan return err; 59820a708f8fSGustavo F. Padovan 59830a708f8fSGustavo F. Padovan if (bt_debugfs) { 59842d792818SGustavo Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, bt_debugfs, 59852d792818SGustavo Padovan NULL, &l2cap_debugfs_fops); 59860a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 59870a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 59880a708f8fSGustavo F. Padovan } 59890a708f8fSGustavo F. Padovan 59900a708f8fSGustavo F. Padovan return 0; 59910a708f8fSGustavo F. Padovan } 59920a708f8fSGustavo F. Padovan 599364274518SGustavo F. Padovan void l2cap_exit(void) 59940a708f8fSGustavo F. Padovan { 59950a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 5996bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 59970a708f8fSGustavo F. Padovan } 59980a708f8fSGustavo F. Padovan 59990a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 60000a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 6001