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> 415ce66b59SAndrei Emeltchenko #include <net/bluetooth/amp.h> 420a708f8fSGustavo F. Padovan 43d1de6d46SMat Martineau bool disable_ertm; 440a708f8fSGustavo F. Padovan 450a708f8fSGustavo F. Padovan static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN; 4650a147cdSMat Martineau static u8 l2cap_fixed_chan[8] = { L2CAP_FC_L2CAP, }; 470a708f8fSGustavo F. Padovan 48b5ad8b7fSJohannes Berg static LIST_HEAD(chan_list); 49b5ad8b7fSJohannes Berg static DEFINE_RWLOCK(chan_list_lock); 500a708f8fSGustavo F. Padovan 510a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 520a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data); 534519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 544519de9aSGustavo F. Padovan void *data); 55710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data); 565e4e3972SAndrei Emeltchenko static void l2cap_send_disconn_req(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 1325b155ef9SMat Martineau static struct l2cap_chan *l2cap_get_chan_by_ident(struct l2cap_conn *conn, 1335b155ef9SMat Martineau u8 ident) 1345b155ef9SMat Martineau { 1355b155ef9SMat Martineau struct l2cap_chan *c; 1365b155ef9SMat Martineau 1375b155ef9SMat Martineau mutex_lock(&conn->chan_lock); 1385b155ef9SMat Martineau c = __l2cap_get_chan_by_ident(conn, ident); 1395b155ef9SMat Martineau if (c) 1405b155ef9SMat Martineau l2cap_chan_lock(c); 1415b155ef9SMat Martineau mutex_unlock(&conn->chan_lock); 1425b155ef9SMat Martineau 1435b155ef9SMat Martineau return c; 1445b155ef9SMat Martineau } 1455b155ef9SMat Martineau 14623691d75SGustavo F. Padovan static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src) 1479e4425ffSGustavo F. Padovan { 14823691d75SGustavo F. Padovan struct l2cap_chan *c; 1499e4425ffSGustavo F. Padovan 15023691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 15123691d75SGustavo F. Padovan if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src)) 15223691d75SGustavo F. Padovan return c; 1539e4425ffSGustavo F. Padovan } 154250938cbSSzymon Janc return NULL; 155250938cbSSzymon Janc } 1569e4425ffSGustavo F. Padovan 1579e4425ffSGustavo F. Padovan int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm) 1589e4425ffSGustavo F. Padovan { 15973b2ec18SGustavo F. Padovan int err; 16073b2ec18SGustavo F. Padovan 161333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1629e4425ffSGustavo F. Padovan 16323691d75SGustavo F. Padovan if (psm && __l2cap_global_chan_by_addr(psm, src)) { 16473b2ec18SGustavo F. Padovan err = -EADDRINUSE; 16573b2ec18SGustavo F. Padovan goto done; 1669e4425ffSGustavo F. Padovan } 1679e4425ffSGustavo F. Padovan 16873b2ec18SGustavo F. Padovan if (psm) { 1699e4425ffSGustavo F. Padovan chan->psm = psm; 1709e4425ffSGustavo F. Padovan chan->sport = psm; 17173b2ec18SGustavo F. Padovan err = 0; 17273b2ec18SGustavo F. Padovan } else { 17373b2ec18SGustavo F. Padovan u16 p; 1749e4425ffSGustavo F. Padovan 17573b2ec18SGustavo F. Padovan err = -EINVAL; 17673b2ec18SGustavo F. Padovan for (p = 0x1001; p < 0x1100; p += 2) 17723691d75SGustavo F. Padovan if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) { 17873b2ec18SGustavo F. Padovan chan->psm = cpu_to_le16(p); 17973b2ec18SGustavo F. Padovan chan->sport = cpu_to_le16(p); 18073b2ec18SGustavo F. Padovan err = 0; 18173b2ec18SGustavo F. Padovan break; 18273b2ec18SGustavo F. Padovan } 18373b2ec18SGustavo F. Padovan } 18473b2ec18SGustavo F. Padovan 18573b2ec18SGustavo F. Padovan done: 186333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 18773b2ec18SGustavo F. Padovan return err; 1889e4425ffSGustavo F. Padovan } 1899e4425ffSGustavo F. Padovan 1909e4425ffSGustavo F. Padovan int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid) 1919e4425ffSGustavo F. Padovan { 192333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1939e4425ffSGustavo F. Padovan 1949e4425ffSGustavo F. Padovan chan->scid = scid; 1959e4425ffSGustavo F. Padovan 196333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 1979e4425ffSGustavo F. Padovan 1989e4425ffSGustavo F. Padovan return 0; 1999e4425ffSGustavo F. Padovan } 2009e4425ffSGustavo F. Padovan 201baa7e1faSGustavo F. Padovan static u16 l2cap_alloc_cid(struct l2cap_conn *conn) 2020a708f8fSGustavo F. Padovan { 2030a708f8fSGustavo F. Padovan u16 cid = L2CAP_CID_DYN_START; 2040a708f8fSGustavo F. Padovan 2050a708f8fSGustavo F. Padovan for (; cid < L2CAP_CID_DYN_END; cid++) { 206baa7e1faSGustavo F. Padovan if (!__l2cap_get_chan_by_scid(conn, cid)) 2070a708f8fSGustavo F. Padovan return cid; 2080a708f8fSGustavo F. Padovan } 2090a708f8fSGustavo F. Padovan 2100a708f8fSGustavo F. Padovan return 0; 2110a708f8fSGustavo F. Padovan } 2120a708f8fSGustavo F. Padovan 2130e587be7SAndrei Emeltchenko static void __l2cap_state_change(struct l2cap_chan *chan, int state) 21489bc500eSGustavo F. Padovan { 21542d2d87cSAndrei Emeltchenko BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state), 216badaaa00SGustavo F. Padovan state_to_string(state)); 217badaaa00SGustavo F. Padovan 21889bc500eSGustavo F. Padovan chan->state = state; 21980b98027SGustavo Padovan chan->ops->state_change(chan, state); 22089bc500eSGustavo F. Padovan } 22189bc500eSGustavo F. Padovan 2220e587be7SAndrei Emeltchenko static void l2cap_state_change(struct l2cap_chan *chan, int state) 2230e587be7SAndrei Emeltchenko { 2240e587be7SAndrei Emeltchenko struct sock *sk = chan->sk; 2250e587be7SAndrei Emeltchenko 2260e587be7SAndrei Emeltchenko lock_sock(sk); 2270e587be7SAndrei Emeltchenko __l2cap_state_change(chan, state); 2280e587be7SAndrei Emeltchenko release_sock(sk); 2290e587be7SAndrei Emeltchenko } 2300e587be7SAndrei Emeltchenko 2312e0052e4SAndrei Emeltchenko static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2322e0052e4SAndrei Emeltchenko { 2332e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2342e0052e4SAndrei Emeltchenko 2352e0052e4SAndrei Emeltchenko sk->sk_err = err; 2362e0052e4SAndrei Emeltchenko } 2372e0052e4SAndrei Emeltchenko 2382e0052e4SAndrei Emeltchenko static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2392e0052e4SAndrei Emeltchenko { 2402e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2412e0052e4SAndrei Emeltchenko 2422e0052e4SAndrei Emeltchenko lock_sock(sk); 2432e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 2442e0052e4SAndrei Emeltchenko release_sock(sk); 2452e0052e4SAndrei Emeltchenko } 2462e0052e4SAndrei Emeltchenko 2474239d16fSMat Martineau static void __set_retrans_timer(struct l2cap_chan *chan) 2484239d16fSMat Martineau { 2494239d16fSMat Martineau if (!delayed_work_pending(&chan->monitor_timer) && 2504239d16fSMat Martineau chan->retrans_timeout) { 2514239d16fSMat Martineau l2cap_set_timer(chan, &chan->retrans_timer, 2524239d16fSMat Martineau msecs_to_jiffies(chan->retrans_timeout)); 2534239d16fSMat Martineau } 2544239d16fSMat Martineau } 2554239d16fSMat Martineau 2564239d16fSMat Martineau static void __set_monitor_timer(struct l2cap_chan *chan) 2574239d16fSMat Martineau { 2584239d16fSMat Martineau __clear_retrans_timer(chan); 2594239d16fSMat Martineau if (chan->monitor_timeout) { 2604239d16fSMat Martineau l2cap_set_timer(chan, &chan->monitor_timer, 2614239d16fSMat Martineau msecs_to_jiffies(chan->monitor_timeout)); 2624239d16fSMat Martineau } 2634239d16fSMat Martineau } 2644239d16fSMat Martineau 265608bcc6dSMat Martineau static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head, 266608bcc6dSMat Martineau u16 seq) 267608bcc6dSMat Martineau { 268608bcc6dSMat Martineau struct sk_buff *skb; 269608bcc6dSMat Martineau 270608bcc6dSMat Martineau skb_queue_walk(head, skb) { 271608bcc6dSMat Martineau if (bt_cb(skb)->control.txseq == seq) 272608bcc6dSMat Martineau return skb; 273608bcc6dSMat Martineau } 274608bcc6dSMat Martineau 275608bcc6dSMat Martineau return NULL; 276608bcc6dSMat Martineau } 277608bcc6dSMat Martineau 2783c588192SMat Martineau /* ---- L2CAP sequence number lists ---- */ 2793c588192SMat Martineau 2803c588192SMat Martineau /* For ERTM, ordered lists of sequence numbers must be tracked for 2813c588192SMat Martineau * SREJ requests that are received and for frames that are to be 2823c588192SMat Martineau * retransmitted. These seq_list functions implement a singly-linked 2833c588192SMat Martineau * list in an array, where membership in the list can also be checked 2843c588192SMat Martineau * in constant time. Items can also be added to the tail of the list 2853c588192SMat Martineau * and removed from the head in constant time, without further memory 2863c588192SMat Martineau * allocs or frees. 2873c588192SMat Martineau */ 2883c588192SMat Martineau 2893c588192SMat Martineau static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) 2903c588192SMat Martineau { 2913c588192SMat Martineau size_t alloc_size, i; 2923c588192SMat Martineau 2933c588192SMat Martineau /* Allocated size is a power of 2 to map sequence numbers 2943c588192SMat Martineau * (which may be up to 14 bits) in to a smaller array that is 2953c588192SMat Martineau * sized for the negotiated ERTM transmit windows. 2963c588192SMat Martineau */ 2973c588192SMat Martineau alloc_size = roundup_pow_of_two(size); 2983c588192SMat Martineau 2993c588192SMat Martineau seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); 3003c588192SMat Martineau if (!seq_list->list) 3013c588192SMat Martineau return -ENOMEM; 3023c588192SMat Martineau 3033c588192SMat Martineau seq_list->mask = alloc_size - 1; 3043c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3053c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3063c588192SMat Martineau for (i = 0; i < alloc_size; i++) 3073c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3083c588192SMat Martineau 3093c588192SMat Martineau return 0; 3103c588192SMat Martineau } 3113c588192SMat Martineau 3123c588192SMat Martineau static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list) 3133c588192SMat Martineau { 3143c588192SMat Martineau kfree(seq_list->list); 3153c588192SMat Martineau } 3163c588192SMat Martineau 3173c588192SMat Martineau static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list, 3183c588192SMat Martineau u16 seq) 3193c588192SMat Martineau { 3203c588192SMat Martineau /* Constant-time check for list membership */ 3213c588192SMat Martineau return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR; 3223c588192SMat Martineau } 3233c588192SMat Martineau 3243c588192SMat Martineau static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq) 3253c588192SMat Martineau { 3263c588192SMat Martineau u16 mask = seq_list->mask; 3273c588192SMat Martineau 3283c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) { 3293c588192SMat Martineau /* In case someone tries to pop the head of an empty list */ 3303c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3313c588192SMat Martineau } else if (seq_list->head == seq) { 3323c588192SMat Martineau /* Head can be removed in constant time */ 3333c588192SMat Martineau seq_list->head = seq_list->list[seq & mask]; 3343c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3353c588192SMat Martineau 3363c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_TAIL) { 3373c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3383c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3393c588192SMat Martineau } 3403c588192SMat Martineau } else { 3413c588192SMat Martineau /* Walk the list to find the sequence number */ 3423c588192SMat Martineau u16 prev = seq_list->head; 3433c588192SMat Martineau while (seq_list->list[prev & mask] != seq) { 3443c588192SMat Martineau prev = seq_list->list[prev & mask]; 3453c588192SMat Martineau if (prev == L2CAP_SEQ_LIST_TAIL) 3463c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3473c588192SMat Martineau } 3483c588192SMat Martineau 3493c588192SMat Martineau /* Unlink the number from the list and clear it */ 3503c588192SMat Martineau seq_list->list[prev & mask] = seq_list->list[seq & mask]; 3513c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3523c588192SMat Martineau if (seq_list->tail == seq) 3533c588192SMat Martineau seq_list->tail = prev; 3543c588192SMat Martineau } 3553c588192SMat Martineau return seq; 3563c588192SMat Martineau } 3573c588192SMat Martineau 3583c588192SMat Martineau static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list) 3593c588192SMat Martineau { 3603c588192SMat Martineau /* Remove the head in constant time */ 3613c588192SMat Martineau return l2cap_seq_list_remove(seq_list, seq_list->head); 3623c588192SMat Martineau } 3633c588192SMat Martineau 3643c588192SMat Martineau static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list) 3653c588192SMat Martineau { 3663c588192SMat Martineau u16 i; 367f522ae36SGustavo Padovan 368f522ae36SGustavo Padovan if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) 369f522ae36SGustavo Padovan return; 370f522ae36SGustavo Padovan 3713c588192SMat Martineau for (i = 0; i <= seq_list->mask; i++) 3723c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3733c588192SMat Martineau 3743c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3753c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3763c588192SMat Martineau } 3773c588192SMat Martineau 3783c588192SMat Martineau static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq) 3793c588192SMat Martineau { 3803c588192SMat Martineau u16 mask = seq_list->mask; 3813c588192SMat Martineau 3823c588192SMat Martineau /* All appends happen in constant time */ 3833c588192SMat Martineau 384f522ae36SGustavo Padovan if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR) 385f522ae36SGustavo Padovan return; 386f522ae36SGustavo Padovan 3873c588192SMat Martineau if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR) 3883c588192SMat Martineau seq_list->head = seq; 3893c588192SMat Martineau else 3903c588192SMat Martineau seq_list->list[seq_list->tail & mask] = seq; 3913c588192SMat Martineau 3923c588192SMat Martineau seq_list->tail = seq; 3933c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL; 3943c588192SMat Martineau } 3953c588192SMat Martineau 396721c4181SGustavo F. Padovan static void l2cap_chan_timeout(struct work_struct *work) 397ab07801dSGustavo F. Padovan { 398721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 399721c4181SGustavo F. Padovan chan_timer.work); 4003df91ea2SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 401ab07801dSGustavo F. Padovan int reason; 402ab07801dSGustavo F. Padovan 403e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s", chan, state_to_string(chan->state)); 404ab07801dSGustavo F. Padovan 4053df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 4066be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 407ab07801dSGustavo F. Padovan 40889bc500eSGustavo F. Padovan if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG) 409ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 41089bc500eSGustavo F. Padovan else if (chan->state == BT_CONNECT && 411ab07801dSGustavo F. Padovan chan->sec_level != BT_SECURITY_SDP) 412ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 413ab07801dSGustavo F. Padovan else 414ab07801dSGustavo F. Padovan reason = ETIMEDOUT; 415ab07801dSGustavo F. Padovan 4160f852724SGustavo F. Padovan l2cap_chan_close(chan, reason); 417ab07801dSGustavo F. Padovan 4186be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 419ab07801dSGustavo F. Padovan 42080b98027SGustavo Padovan chan->ops->close(chan); 4213df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 4223df91ea2SAndrei Emeltchenko 423371fd835SUlisses Furquim l2cap_chan_put(chan); 424ab07801dSGustavo F. Padovan } 425ab07801dSGustavo F. Padovan 426eef1d9b6SGustavo Padovan struct l2cap_chan *l2cap_chan_create(void) 4270a708f8fSGustavo F. Padovan { 42848454079SGustavo F. Padovan struct l2cap_chan *chan; 4290a708f8fSGustavo F. Padovan 43048454079SGustavo F. Padovan chan = kzalloc(sizeof(*chan), GFP_ATOMIC); 43148454079SGustavo F. Padovan if (!chan) 43248454079SGustavo F. Padovan return NULL; 4330a708f8fSGustavo F. Padovan 434c03b355eSAndrei Emeltchenko mutex_init(&chan->lock); 435c03b355eSAndrei Emeltchenko 436333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 43723691d75SGustavo F. Padovan list_add(&chan->global_l, &chan_list); 438333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 43923691d75SGustavo F. Padovan 440721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout); 441ab07801dSGustavo F. Padovan 44289bc500eSGustavo F. Padovan chan->state = BT_OPEN; 44389bc500eSGustavo F. Padovan 444144ad330SSyam Sidhardhan kref_init(&chan->kref); 44571ba0e56SGustavo F. Padovan 4462827011fSMat Martineau /* This flag is cleared in l2cap_chan_ready() */ 4472827011fSMat Martineau set_bit(CONF_NOT_COMPLETE, &chan->conf_state); 4482827011fSMat Martineau 449eef1d9b6SGustavo Padovan BT_DBG("chan %p", chan); 450abc545b8SSzymon Janc 45148454079SGustavo F. Padovan return chan; 4520a708f8fSGustavo F. Padovan } 4530a708f8fSGustavo F. Padovan 454144ad330SSyam Sidhardhan static void l2cap_chan_destroy(struct kref *kref) 4556ff5abbfSGustavo F. Padovan { 456144ad330SSyam Sidhardhan struct l2cap_chan *chan = container_of(kref, struct l2cap_chan, kref); 457144ad330SSyam Sidhardhan 4584af66c69SJaganath Kanakkassery BT_DBG("chan %p", chan); 4594af66c69SJaganath Kanakkassery 460333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 46123691d75SGustavo F. Padovan list_del(&chan->global_l); 462333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 46323691d75SGustavo F. Padovan 4644af66c69SJaganath Kanakkassery kfree(chan); 4656ff5abbfSGustavo F. Padovan } 4666ff5abbfSGustavo F. Padovan 46730648372SJaganath Kanakkassery void l2cap_chan_hold(struct l2cap_chan *c) 46830648372SJaganath Kanakkassery { 469144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 47030648372SJaganath Kanakkassery 471144ad330SSyam Sidhardhan kref_get(&c->kref); 47230648372SJaganath Kanakkassery } 47330648372SJaganath Kanakkassery 47430648372SJaganath Kanakkassery void l2cap_chan_put(struct l2cap_chan *c) 47530648372SJaganath Kanakkassery { 476144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 47730648372SJaganath Kanakkassery 478144ad330SSyam Sidhardhan kref_put(&c->kref, l2cap_chan_destroy); 47930648372SJaganath Kanakkassery } 48030648372SJaganath Kanakkassery 481bd4b1653SAndrei Emeltchenko void l2cap_chan_set_defaults(struct l2cap_chan *chan) 482bd4b1653SAndrei Emeltchenko { 483bd4b1653SAndrei Emeltchenko chan->fcs = L2CAP_FCS_CRC16; 484bd4b1653SAndrei Emeltchenko chan->max_tx = L2CAP_DEFAULT_MAX_TX; 485bd4b1653SAndrei Emeltchenko chan->tx_win = L2CAP_DEFAULT_TX_WINDOW; 486bd4b1653SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 487c20f8e35SMat Martineau chan->ack_win = L2CAP_DEFAULT_TX_WINDOW; 488bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 489bd4b1653SAndrei Emeltchenko 490bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 491bd4b1653SAndrei Emeltchenko } 492bd4b1653SAndrei Emeltchenko 49393c3e8f5SAndrei Emeltchenko void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4940a708f8fSGustavo F. Padovan { 4950a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 496097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4970a708f8fSGustavo F. Padovan 4989f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 4990a708f8fSGustavo F. Padovan 5008c1d787bSGustavo F. Padovan chan->conn = conn; 5010a708f8fSGustavo F. Padovan 5025491120eSAndrei Emeltchenko switch (chan->chan_type) { 5035491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 504b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 505b62f328bSVille Tervo /* LE connection */ 5066fcb06a2SAndre Guedes chan->omtu = L2CAP_DEFAULT_MTU; 507fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 508fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 509b62f328bSVille Tervo } else { 5100a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 511fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 5120c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 513b62f328bSVille Tervo } 5145491120eSAndrei Emeltchenko break; 5155491120eSAndrei Emeltchenko 5165491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 5170a708f8fSGustavo F. Padovan /* Connectionless socket */ 518fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 519fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 5200c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5215491120eSAndrei Emeltchenko break; 5225491120eSAndrei Emeltchenko 523416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 524416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 525416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 526416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 527416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 528416fa752SAndrei Emeltchenko break; 529416fa752SAndrei Emeltchenko 5305491120eSAndrei Emeltchenko default: 5310a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 532fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 533fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 5340c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5350a708f8fSGustavo F. Padovan } 5360a708f8fSGustavo F. Padovan 5378f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 5388f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 5398f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 5408f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 5418f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 5428936fa6dSAndrei Emeltchenko chan->local_flush_to = L2CAP_EFS_DEFAULT_FLUSH_TO; 5438f7975b1SAndrei Emeltchenko 544371fd835SUlisses Furquim l2cap_chan_hold(chan); 545baa7e1faSGustavo F. Padovan 5463df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 547643162a8SAndrei Emeltchenko } 548643162a8SAndrei Emeltchenko 549466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 550643162a8SAndrei Emeltchenko { 551643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 552643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 5533df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5540a708f8fSGustavo F. Padovan } 5550a708f8fSGustavo F. Padovan 556466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5570a708f8fSGustavo F. Padovan { 5588c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5590a708f8fSGustavo F. Padovan 560c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5610a708f8fSGustavo F. Padovan 56249208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5630a708f8fSGustavo F. Padovan 5640a708f8fSGustavo F. Padovan if (conn) { 56556f60984SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 566baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5673df91ea2SAndrei Emeltchenko list_del(&chan->list); 5683d57dc68SGustavo F. Padovan 569371fd835SUlisses Furquim l2cap_chan_put(chan); 570baa7e1faSGustavo F. Padovan 5718c1d787bSGustavo F. Padovan chan->conn = NULL; 5723cabbfdaSAndrei Emeltchenko 5733cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 57476a68ba0SDavid Herrmann hci_conn_drop(conn->hcon); 57556f60984SAndrei Emeltchenko 57656f60984SAndrei Emeltchenko if (mgr && mgr->bredr_chan == chan) 57756f60984SAndrei Emeltchenko mgr->bredr_chan = NULL; 5780a708f8fSGustavo F. Padovan } 5790a708f8fSGustavo F. Padovan 580419e08c1SAndrei Emeltchenko if (chan->hs_hchan) { 581419e08c1SAndrei Emeltchenko struct hci_chan *hs_hchan = chan->hs_hchan; 582419e08c1SAndrei Emeltchenko 583419e08c1SAndrei Emeltchenko BT_DBG("chan %p disconnect hs_hchan %p", chan, hs_hchan); 584419e08c1SAndrei Emeltchenko amp_disconnect_logical_link(hs_hchan); 585419e08c1SAndrei Emeltchenko } 586419e08c1SAndrei Emeltchenko 587c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5886be36555SAndrei Emeltchenko 5892827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5906ff5abbfSGustavo F. Padovan return; 5912ead70b8SGustavo F. Padovan 592ee556f66SGustavo Padovan switch(chan->mode) { 593ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 594ee556f66SGustavo Padovan break; 5950a708f8fSGustavo F. Padovan 596ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5971a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5981a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5991a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 6000a708f8fSGustavo F. Padovan 601f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 6020a708f8fSGustavo F. Padovan 6033c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 6043c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 605ee556f66SGustavo Padovan 606ee556f66SGustavo Padovan /* fall through */ 607ee556f66SGustavo Padovan 608ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 609ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 610ee556f66SGustavo Padovan break; 6110a708f8fSGustavo F. Padovan } 612ee556f66SGustavo Padovan 613ee556f66SGustavo Padovan return; 6140a708f8fSGustavo F. Padovan } 6150a708f8fSGustavo F. Padovan 6160f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 6174519de9aSGustavo F. Padovan { 6184519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6194519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 6204519de9aSGustavo F. Padovan 6212d792818SGustavo Padovan BT_DBG("chan %p state %s sk %p", chan, state_to_string(chan->state), 6222d792818SGustavo Padovan sk); 6234519de9aSGustavo F. Padovan 62489bc500eSGustavo F. Padovan switch (chan->state) { 6254519de9aSGustavo F. Padovan case BT_LISTEN: 626c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6274519de9aSGustavo F. Padovan break; 6284519de9aSGustavo F. Padovan 6294519de9aSGustavo F. Padovan case BT_CONNECTED: 6304519de9aSGustavo F. Padovan case BT_CONFIG: 631715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6324519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 633c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 6345e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, reason); 6354519de9aSGustavo F. Padovan } else 6364519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6374519de9aSGustavo F. Padovan break; 6384519de9aSGustavo F. Padovan 6394519de9aSGustavo F. Padovan case BT_CONNECT2: 640715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6414519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 6424519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6434519de9aSGustavo F. Padovan __u16 result; 6444519de9aSGustavo F. Padovan 645c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 6464519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 6474519de9aSGustavo F. Padovan else 6484519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 64989bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 6504519de9aSGustavo F. Padovan 6514519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6524519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6534519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 654ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 6554519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6564519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 6574519de9aSGustavo F. Padovan } 6584519de9aSGustavo F. Padovan 6594519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6604519de9aSGustavo F. Padovan break; 6614519de9aSGustavo F. Padovan 6624519de9aSGustavo F. Padovan case BT_CONNECT: 6634519de9aSGustavo F. Padovan case BT_DISCONN: 6644519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6654519de9aSGustavo F. Padovan break; 6664519de9aSGustavo F. Padovan 6674519de9aSGustavo F. Padovan default: 668c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6694519de9aSGustavo F. Padovan break; 6704519de9aSGustavo F. Padovan } 6714519de9aSGustavo F. Padovan } 6724519de9aSGustavo F. Padovan 6734343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6740a708f8fSGustavo F. Padovan { 675715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6764343478fSGustavo F. Padovan switch (chan->sec_level) { 6770a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6780a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6790a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6800a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6810a708f8fSGustavo F. Padovan default: 6820a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6830a708f8fSGustavo F. Padovan } 6842983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6854343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6864343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6870a708f8fSGustavo F. Padovan 6884343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6890a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6900a708f8fSGustavo F. Padovan else 6910a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6920a708f8fSGustavo F. Padovan } else { 6934343478fSGustavo F. Padovan switch (chan->sec_level) { 6940a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6950a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6960a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6970a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6980a708f8fSGustavo F. Padovan default: 6990a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 7000a708f8fSGustavo F. Padovan } 7010a708f8fSGustavo F. Padovan } 7020a708f8fSGustavo F. Padovan } 7030a708f8fSGustavo F. Padovan 7040a708f8fSGustavo F. Padovan /* Service level security */ 705d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 7060a708f8fSGustavo F. Padovan { 7078c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 7080a708f8fSGustavo F. Padovan __u8 auth_type; 7090a708f8fSGustavo F. Padovan 7104343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 7110a708f8fSGustavo F. Padovan 7124343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 7130a708f8fSGustavo F. Padovan } 7140a708f8fSGustavo F. Padovan 715b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 7160a708f8fSGustavo F. Padovan { 7170a708f8fSGustavo F. Padovan u8 id; 7180a708f8fSGustavo F. Padovan 7190a708f8fSGustavo F. Padovan /* Get next available identificator. 7200a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 7210a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 7220a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 7230a708f8fSGustavo F. Padovan */ 7240a708f8fSGustavo F. Padovan 725333055f2SGustavo F. Padovan spin_lock(&conn->lock); 7260a708f8fSGustavo F. Padovan 7270a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 7280a708f8fSGustavo F. Padovan conn->tx_ident = 1; 7290a708f8fSGustavo F. Padovan 7300a708f8fSGustavo F. Padovan id = conn->tx_ident; 7310a708f8fSGustavo F. Padovan 732333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 7330a708f8fSGustavo F. Padovan 7340a708f8fSGustavo F. Padovan return id; 7350a708f8fSGustavo F. Padovan } 7360a708f8fSGustavo F. Padovan 7372d792818SGustavo Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 7382d792818SGustavo Padovan void *data) 7390a708f8fSGustavo F. Padovan { 7400a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 7410a708f8fSGustavo F. Padovan u8 flags; 7420a708f8fSGustavo F. Padovan 7430a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 7440a708f8fSGustavo F. Padovan 7450a708f8fSGustavo F. Padovan if (!skb) 7460a708f8fSGustavo F. Padovan return; 7470a708f8fSGustavo F. Padovan 7480a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 7490a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 7500a708f8fSGustavo F. Padovan else 7510a708f8fSGustavo F. Padovan flags = ACL_START; 7520a708f8fSGustavo F. Padovan 75314b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 7545e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 75514b12d0bSJaikumar Ganesh 75673d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 7570a708f8fSGustavo F. Padovan } 7580a708f8fSGustavo F. Padovan 75902b0fbb9SMat Martineau static bool __chan_is_moving(struct l2cap_chan *chan) 76002b0fbb9SMat Martineau { 76102b0fbb9SMat Martineau return chan->move_state != L2CAP_MOVE_STABLE && 76202b0fbb9SMat Martineau chan->move_state != L2CAP_MOVE_WAIT_PREPARE; 76302b0fbb9SMat Martineau } 76402b0fbb9SMat Martineau 76573d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 76673d80debSLuiz Augusto von Dentz { 76773d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 76873d80debSLuiz Augusto von Dentz u16 flags; 76973d80debSLuiz Augusto von Dentz 77073d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 77173d80debSLuiz Augusto von Dentz skb->priority); 77273d80debSLuiz Augusto von Dentz 773d5f8a75dSMat Martineau if (chan->hs_hcon && !__chan_is_moving(chan)) { 774d5f8a75dSMat Martineau if (chan->hs_hchan) 775d5f8a75dSMat Martineau hci_send_acl(chan->hs_hchan, skb, ACL_COMPLETE); 776d5f8a75dSMat Martineau else 777d5f8a75dSMat Martineau kfree_skb(skb); 778d5f8a75dSMat Martineau 779d5f8a75dSMat Martineau return; 780d5f8a75dSMat Martineau } 781d5f8a75dSMat Martineau 78273d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 78373d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 78473d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 78573d80debSLuiz Augusto von Dentz else 78673d80debSLuiz Augusto von Dentz flags = ACL_START; 78773d80debSLuiz Augusto von Dentz 78873d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 78973d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7900a708f8fSGustavo F. Padovan } 7910a708f8fSGustavo F. Padovan 792b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 793b5c6aaedSMat Martineau { 794b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 795b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 796b5c6aaedSMat Martineau 797b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 798b5c6aaedSMat Martineau /* S-Frame */ 799b5c6aaedSMat Martineau control->sframe = 1; 800b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 801b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 802b5c6aaedSMat Martineau 803b5c6aaedSMat Martineau control->sar = 0; 804b5c6aaedSMat Martineau control->txseq = 0; 805b5c6aaedSMat Martineau } else { 806b5c6aaedSMat Martineau /* I-Frame */ 807b5c6aaedSMat Martineau control->sframe = 0; 808b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 809b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 810b5c6aaedSMat Martineau 811b5c6aaedSMat Martineau control->poll = 0; 812b5c6aaedSMat Martineau control->super = 0; 813b5c6aaedSMat Martineau } 814b5c6aaedSMat Martineau } 815b5c6aaedSMat Martineau 816b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 817b5c6aaedSMat Martineau { 818b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 819b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 820b5c6aaedSMat Martineau 821b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 822b5c6aaedSMat Martineau /* S-Frame */ 823b5c6aaedSMat Martineau control->sframe = 1; 824b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 825b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 826b5c6aaedSMat Martineau 827b5c6aaedSMat Martineau control->sar = 0; 828b5c6aaedSMat Martineau control->txseq = 0; 829b5c6aaedSMat Martineau } else { 830b5c6aaedSMat Martineau /* I-Frame */ 831b5c6aaedSMat Martineau control->sframe = 0; 832b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 833b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 834b5c6aaedSMat Martineau 835b5c6aaedSMat Martineau control->poll = 0; 836b5c6aaedSMat Martineau control->super = 0; 837b5c6aaedSMat Martineau } 838b5c6aaedSMat Martineau } 839b5c6aaedSMat Martineau 840b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 841b5c6aaedSMat Martineau struct sk_buff *skb) 842b5c6aaedSMat Martineau { 843b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 844b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 845b5c6aaedSMat Martineau &bt_cb(skb)->control); 846cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 847b5c6aaedSMat Martineau } else { 848b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 849b5c6aaedSMat Martineau &bt_cb(skb)->control); 850cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 851b5c6aaedSMat Martineau } 852b5c6aaedSMat Martineau } 853b5c6aaedSMat Martineau 854b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 855b5c6aaedSMat Martineau { 856b5c6aaedSMat Martineau u32 packed; 857b5c6aaedSMat Martineau 858b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 859b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 860b5c6aaedSMat Martineau 861b5c6aaedSMat Martineau if (control->sframe) { 862b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 863b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 864b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 865b5c6aaedSMat Martineau } else { 866b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 867b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 868b5c6aaedSMat Martineau } 869b5c6aaedSMat Martineau 870b5c6aaedSMat Martineau return packed; 871b5c6aaedSMat Martineau } 872b5c6aaedSMat Martineau 873b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 874b5c6aaedSMat Martineau { 875b5c6aaedSMat Martineau u16 packed; 876b5c6aaedSMat Martineau 877b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 878b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 879b5c6aaedSMat Martineau 880b5c6aaedSMat Martineau if (control->sframe) { 881b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 882b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 883b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 884b5c6aaedSMat Martineau } else { 885b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 886b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 887b5c6aaedSMat Martineau } 888b5c6aaedSMat Martineau 889b5c6aaedSMat Martineau return packed; 890b5c6aaedSMat Martineau } 891b5c6aaedSMat Martineau 892b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 893b5c6aaedSMat Martineau struct l2cap_ctrl *control, 894b5c6aaedSMat Martineau struct sk_buff *skb) 895b5c6aaedSMat Martineau { 896b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 897b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 898b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 899b5c6aaedSMat Martineau } else { 900b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 901b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 902b5c6aaedSMat Martineau } 903b5c6aaedSMat Martineau } 904b5c6aaedSMat Martineau 905ba7aa64fSGustavo Padovan static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan) 906ba7aa64fSGustavo Padovan { 907ba7aa64fSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 908ba7aa64fSGustavo Padovan return L2CAP_EXT_HDR_SIZE; 909ba7aa64fSGustavo Padovan else 910ba7aa64fSGustavo Padovan return L2CAP_ENH_HDR_SIZE; 911ba7aa64fSGustavo Padovan } 912ba7aa64fSGustavo Padovan 913a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 914a67d7f6fSMat Martineau u32 control) 9150a708f8fSGustavo F. Padovan { 9160a708f8fSGustavo F. Padovan struct sk_buff *skb; 9170a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 918ba7aa64fSGustavo Padovan int hlen = __ertm_hdr_size(chan); 9190a708f8fSGustavo F. Padovan 9200a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 92103a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 9220a708f8fSGustavo F. Padovan 923a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 9240a708f8fSGustavo F. Padovan 9250a708f8fSGustavo F. Padovan if (!skb) 926a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 9270a708f8fSGustavo F. Padovan 9280a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 9290a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 930fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 93188843ab0SAndrei Emeltchenko 932a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 933a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 934a67d7f6fSMat Martineau else 935a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 9360a708f8fSGustavo F. Padovan 93747d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 938a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 93903a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 9400a708f8fSGustavo F. Padovan } 9410a708f8fSGustavo F. Padovan 94273d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 943a67d7f6fSMat Martineau return skb; 944a67d7f6fSMat Martineau } 945a67d7f6fSMat Martineau 946a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 947a67d7f6fSMat Martineau struct l2cap_ctrl *control) 948a67d7f6fSMat Martineau { 949a67d7f6fSMat Martineau struct sk_buff *skb; 950a67d7f6fSMat Martineau u32 control_field; 951a67d7f6fSMat Martineau 952a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 953a67d7f6fSMat Martineau 954a67d7f6fSMat Martineau if (!control->sframe) 955a67d7f6fSMat Martineau return; 956a67d7f6fSMat Martineau 957b99e13adSMat Martineau if (__chan_is_moving(chan)) 958b99e13adSMat Martineau return; 959b99e13adSMat Martineau 960a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 961a67d7f6fSMat Martineau !control->poll) 962a67d7f6fSMat Martineau control->final = 1; 963a67d7f6fSMat Martineau 964a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 965a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 966a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 967a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 968a67d7f6fSMat Martineau 969a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 970a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 971a67d7f6fSMat Martineau __clear_ack_timer(chan); 972a67d7f6fSMat Martineau } 973a67d7f6fSMat Martineau 974a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 975a67d7f6fSMat Martineau control->final, control->poll, control->super); 976a67d7f6fSMat Martineau 977a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 978a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 979a67d7f6fSMat Martineau else 980a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 981a67d7f6fSMat Martineau 982a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 983a67d7f6fSMat Martineau if (!IS_ERR(skb)) 98473d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9850a708f8fSGustavo F. Padovan } 9860a708f8fSGustavo F. Padovan 987c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9880a708f8fSGustavo F. Padovan { 989c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9900a708f8fSGustavo F. Padovan 991c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 992c9e3d5e0SMat Martineau 993c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 994c9e3d5e0SMat Martineau control.sframe = 1; 995c9e3d5e0SMat Martineau control.poll = poll; 996c9e3d5e0SMat Martineau 997c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 998c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 999c9e3d5e0SMat Martineau else 1000c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 1001c9e3d5e0SMat Martineau 1002c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 1003c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 10040a708f8fSGustavo F. Padovan } 10050a708f8fSGustavo F. Padovan 1006b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 10070a708f8fSGustavo F. Padovan { 1008c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 10090a708f8fSGustavo F. Padovan } 10100a708f8fSGustavo F. Padovan 101193c3e8f5SAndrei Emeltchenko static bool __amp_capable(struct l2cap_chan *chan) 101293c3e8f5SAndrei Emeltchenko { 101393c3e8f5SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 101493c3e8f5SAndrei Emeltchenko 101593c3e8f5SAndrei Emeltchenko if (enable_hs && 10165d05416eSAndrei Emeltchenko hci_amp_capable() && 101793c3e8f5SAndrei Emeltchenko chan->chan_policy == BT_CHANNEL_POLICY_AMP_PREFERRED && 101893c3e8f5SAndrei Emeltchenko conn->fixed_chan_mask & L2CAP_FC_A2MP) 101993c3e8f5SAndrei Emeltchenko return true; 102093c3e8f5SAndrei Emeltchenko else 102193c3e8f5SAndrei Emeltchenko return false; 102293c3e8f5SAndrei Emeltchenko } 102393c3e8f5SAndrei Emeltchenko 10245ce66b59SAndrei Emeltchenko static bool l2cap_check_efs(struct l2cap_chan *chan) 10255ce66b59SAndrei Emeltchenko { 10265ce66b59SAndrei Emeltchenko /* Check EFS parameters */ 10275ce66b59SAndrei Emeltchenko return true; 10285ce66b59SAndrei Emeltchenko } 10295ce66b59SAndrei Emeltchenko 10302766be48SAndrei Emeltchenko void l2cap_send_conn_req(struct l2cap_chan *chan) 10319b27f350SAndrei Emeltchenko { 10329b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 10339b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 10349b27f350SAndrei Emeltchenko 10359b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 10369b27f350SAndrei Emeltchenko req.psm = chan->psm; 10379b27f350SAndrei Emeltchenko 10389b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 10399b27f350SAndrei Emeltchenko 10409b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 10419b27f350SAndrei Emeltchenko 10429b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 10439b27f350SAndrei Emeltchenko } 10449b27f350SAndrei Emeltchenko 10458eb200bdSMat Martineau static void l2cap_send_create_chan_req(struct l2cap_chan *chan, u8 amp_id) 10468eb200bdSMat Martineau { 10478eb200bdSMat Martineau struct l2cap_create_chan_req req; 10488eb200bdSMat Martineau req.scid = cpu_to_le16(chan->scid); 10498eb200bdSMat Martineau req.psm = chan->psm; 10508eb200bdSMat Martineau req.amp_id = amp_id; 10518eb200bdSMat Martineau 10528eb200bdSMat Martineau chan->ident = l2cap_get_ident(chan->conn); 10538eb200bdSMat Martineau 10548eb200bdSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_REQ, 10558eb200bdSMat Martineau sizeof(req), &req); 10568eb200bdSMat Martineau } 10578eb200bdSMat Martineau 105802b0fbb9SMat Martineau static void l2cap_move_setup(struct l2cap_chan *chan) 105902b0fbb9SMat Martineau { 106002b0fbb9SMat Martineau struct sk_buff *skb; 106102b0fbb9SMat Martineau 106202b0fbb9SMat Martineau BT_DBG("chan %p", chan); 106302b0fbb9SMat Martineau 106402b0fbb9SMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 106502b0fbb9SMat Martineau return; 106602b0fbb9SMat Martineau 106702b0fbb9SMat Martineau __clear_retrans_timer(chan); 106802b0fbb9SMat Martineau __clear_monitor_timer(chan); 106902b0fbb9SMat Martineau __clear_ack_timer(chan); 107002b0fbb9SMat Martineau 107102b0fbb9SMat Martineau chan->retry_count = 0; 107202b0fbb9SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 107302b0fbb9SMat Martineau if (bt_cb(skb)->control.retries) 107402b0fbb9SMat Martineau bt_cb(skb)->control.retries = 1; 107502b0fbb9SMat Martineau else 107602b0fbb9SMat Martineau break; 107702b0fbb9SMat Martineau } 107802b0fbb9SMat Martineau 107902b0fbb9SMat Martineau chan->expected_tx_seq = chan->buffer_seq; 108002b0fbb9SMat Martineau 108102b0fbb9SMat Martineau clear_bit(CONN_REJ_ACT, &chan->conn_state); 108202b0fbb9SMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 108302b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 108402b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->srej_list); 108502b0fbb9SMat Martineau skb_queue_purge(&chan->srej_q); 108602b0fbb9SMat Martineau 108702b0fbb9SMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 108802b0fbb9SMat Martineau chan->rx_state = L2CAP_RX_STATE_MOVE; 108902b0fbb9SMat Martineau 109002b0fbb9SMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 109102b0fbb9SMat Martineau } 109202b0fbb9SMat Martineau 10935f3847a4SMat Martineau static void l2cap_move_done(struct l2cap_chan *chan) 10945f3847a4SMat Martineau { 10955f3847a4SMat Martineau u8 move_role = chan->move_role; 10965f3847a4SMat Martineau BT_DBG("chan %p", chan); 10975f3847a4SMat Martineau 10985f3847a4SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 10995f3847a4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 11005f3847a4SMat Martineau 11015f3847a4SMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 11025f3847a4SMat Martineau return; 11035f3847a4SMat Martineau 11045f3847a4SMat Martineau switch (move_role) { 11055f3847a4SMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 11065f3847a4SMat Martineau l2cap_tx(chan, NULL, NULL, L2CAP_EV_EXPLICIT_POLL); 11075f3847a4SMat Martineau chan->rx_state = L2CAP_RX_STATE_WAIT_F; 11085f3847a4SMat Martineau break; 11095f3847a4SMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 11105f3847a4SMat Martineau chan->rx_state = L2CAP_RX_STATE_WAIT_P; 11115f3847a4SMat Martineau break; 11125f3847a4SMat Martineau } 11135f3847a4SMat Martineau } 11145f3847a4SMat Martineau 11159f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 11169f0caeb1SVinicius Costa Gomes { 11172827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 11189f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 11199f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 11209f0caeb1SVinicius Costa Gomes 112154a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 11229f0caeb1SVinicius Costa Gomes 112354a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 11249f0caeb1SVinicius Costa Gomes } 11259f0caeb1SVinicius Costa Gomes 112693c3e8f5SAndrei Emeltchenko static void l2cap_start_connection(struct l2cap_chan *chan) 112793c3e8f5SAndrei Emeltchenko { 112893c3e8f5SAndrei Emeltchenko if (__amp_capable(chan)) { 112993c3e8f5SAndrei Emeltchenko BT_DBG("chan %p AMP capable: discover AMPs", chan); 113093c3e8f5SAndrei Emeltchenko a2mp_discover_amp(chan); 113193c3e8f5SAndrei Emeltchenko } else { 113293c3e8f5SAndrei Emeltchenko l2cap_send_conn_req(chan); 113393c3e8f5SAndrei Emeltchenko } 113493c3e8f5SAndrei Emeltchenko } 113593c3e8f5SAndrei Emeltchenko 1136fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 11370a708f8fSGustavo F. Padovan { 11388c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 11390a708f8fSGustavo F. Padovan 11409f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 11419f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 11429f0caeb1SVinicius Costa Gomes return; 11439f0caeb1SVinicius Costa Gomes } 11449f0caeb1SVinicius Costa Gomes 11450a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 11460a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 11470a708f8fSGustavo F. Padovan return; 11480a708f8fSGustavo F. Padovan 1149d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 115093c3e8f5SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) { 115193c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 115293c3e8f5SAndrei Emeltchenko } 11530a708f8fSGustavo F. Padovan } else { 11540a708f8fSGustavo F. Padovan struct l2cap_info_req req; 1155ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 11560a708f8fSGustavo F. Padovan 11570a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 11580a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 11590a708f8fSGustavo F. Padovan 1160ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 11610a708f8fSGustavo F. Padovan 11622d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 11632d792818SGustavo Padovan sizeof(req), &req); 11640a708f8fSGustavo F. Padovan } 11650a708f8fSGustavo F. Padovan } 11660a708f8fSGustavo F. Padovan 11670a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 11680a708f8fSGustavo F. Padovan { 11690a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 11700a708f8fSGustavo F. Padovan if (!disable_ertm) 11710a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 11720a708f8fSGustavo F. Padovan 11730a708f8fSGustavo F. Padovan switch (mode) { 11740a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 11750a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 11760a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 11770a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 11780a708f8fSGustavo F. Padovan default: 11790a708f8fSGustavo F. Padovan return 0x00; 11800a708f8fSGustavo F. Padovan } 11810a708f8fSGustavo F. Padovan } 11820a708f8fSGustavo F. Padovan 11835e4e3972SAndrei Emeltchenko static void l2cap_send_disconn_req(struct l2cap_chan *chan, int err) 11840a708f8fSGustavo F. Padovan { 11856be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 11865e4e3972SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 11870a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 11880a708f8fSGustavo F. Padovan 11890a708f8fSGustavo F. Padovan if (!conn) 11900a708f8fSGustavo F. Padovan return; 11910a708f8fSGustavo F. Padovan 1192aad3d0e3SAndrei Emeltchenko if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) { 11931a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 11941a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 11951a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 11960a708f8fSGustavo F. Padovan } 11970a708f8fSGustavo F. Padovan 1198416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1199d117773cSGustavo Padovan l2cap_state_change(chan, BT_DISCONN); 1200416fa752SAndrei Emeltchenko return; 1201416fa752SAndrei Emeltchenko } 1202416fa752SAndrei Emeltchenko 1203fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1204fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 12052d792818SGustavo Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_DISCONN_REQ, 12062d792818SGustavo Padovan sizeof(req), &req); 12070a708f8fSGustavo F. Padovan 12086be36555SAndrei Emeltchenko lock_sock(sk); 12090e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 12102e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 12116be36555SAndrei Emeltchenko release_sock(sk); 12120a708f8fSGustavo F. Padovan } 12130a708f8fSGustavo F. Padovan 12140a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 12150a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 12160a708f8fSGustavo F. Padovan { 12173df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 12180a708f8fSGustavo F. Padovan 12190a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12200a708f8fSGustavo F. Padovan 12213df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12220a708f8fSGustavo F. Padovan 12233df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 122448454079SGustavo F. Padovan struct sock *sk = chan->sk; 1225baa7e1faSGustavo F. Padovan 12266be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12270a708f8fSGustavo F. Padovan 1228715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12296be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12300a708f8fSGustavo F. Padovan continue; 12310a708f8fSGustavo F. Padovan } 12320a708f8fSGustavo F. Padovan 123389bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1234d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1235b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 12366be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12370a708f8fSGustavo F. Padovan continue; 12380a708f8fSGustavo F. Padovan } 12390a708f8fSGustavo F. Padovan 1240c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1241c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1242c1360a1cSGustavo F. Padovan &chan->conf_state)) { 12430f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 12446be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12450a708f8fSGustavo F. Padovan continue; 12460a708f8fSGustavo F. Padovan } 12470a708f8fSGustavo F. Padovan 124893c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 12490a708f8fSGustavo F. Padovan 125089bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 12510a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 12520a708f8fSGustavo F. Padovan char buf[128]; 1253fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1254fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 12550a708f8fSGustavo F. Padovan 1256d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 12576be36555SAndrei Emeltchenko lock_sock(sk); 1258c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1259c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 1260ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1261ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 12622dc4e510SGustavo Padovan chan->ops->defer(chan); 12630a708f8fSGustavo F. Padovan 12640a708f8fSGustavo F. Padovan } else { 12650e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1266ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1267ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 12680a708f8fSGustavo F. Padovan } 12696be36555SAndrei Emeltchenko release_sock(sk); 12700a708f8fSGustavo F. Padovan } else { 1271ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1272ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 12730a708f8fSGustavo F. Padovan } 12740a708f8fSGustavo F. Padovan 1275fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1276fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 12770a708f8fSGustavo F. Padovan 1278c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 12790a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 12806be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12810a708f8fSGustavo F. Padovan continue; 12820a708f8fSGustavo F. Padovan } 12830a708f8fSGustavo F. Padovan 1284c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 12850a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 128673ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 128773ffa904SGustavo F. Padovan chan->num_conf_req++; 12880a708f8fSGustavo F. Padovan } 12890a708f8fSGustavo F. Padovan 12906be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12910a708f8fSGustavo F. Padovan } 12920a708f8fSGustavo F. Padovan 12933df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12940a708f8fSGustavo F. Padovan } 12950a708f8fSGustavo F. Padovan 1296c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1297b62f328bSVille Tervo * Returns closest match, locked. 1298b62f328bSVille Tervo */ 1299d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1300c2287681SIdo Yariv bdaddr_t *src, 1301c2287681SIdo Yariv bdaddr_t *dst) 1302b62f328bSVille Tervo { 130323691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1304b62f328bSVille Tervo 130523691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1306b62f328bSVille Tervo 130723691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 130823691d75SGustavo F. Padovan struct sock *sk = c->sk; 1309fe4128e0SGustavo F. Padovan 131089bc500eSGustavo F. Padovan if (state && c->state != state) 1311b62f328bSVille Tervo continue; 1312b62f328bSVille Tervo 131323691d75SGustavo F. Padovan if (c->scid == cid) { 1314c2287681SIdo Yariv int src_match, dst_match; 1315c2287681SIdo Yariv int src_any, dst_any; 1316c2287681SIdo Yariv 1317b62f328bSVille Tervo /* Exact match. */ 1318c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1319c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1320c2287681SIdo Yariv if (src_match && dst_match) { 132123691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 132223691d75SGustavo F. Padovan return c; 132323691d75SGustavo F. Padovan } 1324b62f328bSVille Tervo 1325b62f328bSVille Tervo /* Closest match */ 1326c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1327c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1328c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1329c2287681SIdo Yariv (src_any && dst_any)) 133023691d75SGustavo F. Padovan c1 = c; 1331b62f328bSVille Tervo } 1332b62f328bSVille Tervo } 1333280f294fSGustavo F. Padovan 133423691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1335b62f328bSVille Tervo 133623691d75SGustavo F. Padovan return c1; 1337b62f328bSVille Tervo } 1338b62f328bSVille Tervo 1339b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1340b62f328bSVille Tervo { 1341c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 134223691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1343b62f328bSVille Tervo 1344b62f328bSVille Tervo BT_DBG(""); 1345b62f328bSVille Tervo 1346b62f328bSVille Tervo /* Check if we have socket listening on cid */ 134723691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1348c2287681SIdo Yariv conn->src, conn->dst); 134923691d75SGustavo F. Padovan if (!pchan) 1350b62f328bSVille Tervo return; 1351b62f328bSVille Tervo 135223691d75SGustavo F. Padovan parent = pchan->sk; 135323691d75SGustavo F. Padovan 1354aa2ac881SGustavo F. Padovan lock_sock(parent); 135562f3a2cfSGustavo F. Padovan 135680b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 135780808e43SGustavo F. Padovan if (!chan) 1358b62f328bSVille Tervo goto clean; 1359b62f328bSVille Tervo 136080808e43SGustavo F. Padovan sk = chan->sk; 13615d41ce1dSGustavo F. Padovan 1362b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1363a9ea3ed9SSzymon Janc conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT; 1364b62f328bSVille Tervo 1365b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1366b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1367b62f328bSVille Tervo 13683d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 136948454079SGustavo F. Padovan 13706754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1371b62f328bSVille Tervo 1372b62f328bSVille Tervo clean: 1373aa2ac881SGustavo F. Padovan release_sock(parent); 1374b62f328bSVille Tervo } 1375b62f328bSVille Tervo 13760a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 13770a708f8fSGustavo F. Padovan { 137848454079SGustavo F. Padovan struct l2cap_chan *chan; 1379cc110922SVinicius Costa Gomes struct hci_conn *hcon = conn->hcon; 13800a708f8fSGustavo F. Padovan 13810a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 13820a708f8fSGustavo F. Padovan 1383cc110922SVinicius Costa Gomes if (!hcon->out && hcon->type == LE_LINK) 1384b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1385b62f328bSVille Tervo 1386cc110922SVinicius Costa Gomes if (hcon->out && hcon->type == LE_LINK) 1387cc110922SVinicius Costa Gomes smp_conn_security(hcon, hcon->pending_sec_level); 1388160dc6acSVinicius Costa Gomes 13893df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 13900a708f8fSGustavo F. Padovan 13913df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1392baa7e1faSGustavo F. Padovan 13936be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 13940a708f8fSGustavo F. Padovan 1395416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1396416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1397416fa752SAndrei Emeltchenko continue; 1398416fa752SAndrei Emeltchenko } 1399416fa752SAndrei Emeltchenko 1400cc110922SVinicius Costa Gomes if (hcon->type == LE_LINK) { 1401cc110922SVinicius Costa Gomes if (smp_conn_security(hcon, chan->sec_level)) 1402cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1403acd7d370SVille Tervo 140463128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 14056be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1406c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 14076be36555SAndrei Emeltchenko lock_sock(sk); 14080e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 14090a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 14106be36555SAndrei Emeltchenko release_sock(sk); 1411b501d6a1SAnderson Briglia 141289bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1413fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 14140a708f8fSGustavo F. Padovan 14156be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 14160a708f8fSGustavo F. Padovan } 14170a708f8fSGustavo F. Padovan 14183df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14190a708f8fSGustavo F. Padovan } 14200a708f8fSGustavo F. Padovan 14210a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 14220a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 14230a708f8fSGustavo F. Padovan { 142448454079SGustavo F. Padovan struct l2cap_chan *chan; 14250a708f8fSGustavo F. Padovan 14260a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 14270a708f8fSGustavo F. Padovan 14283df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 14290a708f8fSGustavo F. Padovan 14303df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1431ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 14321d8b1fd5SGustavo Padovan l2cap_chan_set_err(chan, err); 14330a708f8fSGustavo F. Padovan } 14340a708f8fSGustavo F. Padovan 14353df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14360a708f8fSGustavo F. Padovan } 14370a708f8fSGustavo F. Padovan 1438f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 14390a708f8fSGustavo F. Padovan { 1440f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1441030013d8SGustavo F. Padovan info_timer.work); 14420a708f8fSGustavo F. Padovan 14430a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 14440a708f8fSGustavo F. Padovan conn->info_ident = 0; 14450a708f8fSGustavo F. Padovan 14460a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 14470a708f8fSGustavo F. Padovan } 14480a708f8fSGustavo F. Padovan 14495d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 14505d3de7dfSVinicius Costa Gomes { 14515d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 14525d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 14535d3de7dfSVinicius Costa Gomes 14545d3de7dfSVinicius Costa Gomes if (!conn) 14555d3de7dfSVinicius Costa Gomes return; 14565d3de7dfSVinicius Costa Gomes 14575d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 14585d3de7dfSVinicius Costa Gomes 14595d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 14605d3de7dfSVinicius Costa Gomes 14613df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 14623df91ea2SAndrei Emeltchenko 14635d3de7dfSVinicius Costa Gomes /* Kill channels */ 14645d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 146561d6ef3eSMat Martineau l2cap_chan_hold(chan); 14666be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 14676be36555SAndrei Emeltchenko 14685d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 14696be36555SAndrei Emeltchenko 14706be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 14716be36555SAndrei Emeltchenko 147280b98027SGustavo Padovan chan->ops->close(chan); 147361d6ef3eSMat Martineau l2cap_chan_put(chan); 14745d3de7dfSVinicius Costa Gomes } 14755d3de7dfSVinicius Costa Gomes 14763df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14773df91ea2SAndrei Emeltchenko 147873d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 147973d80debSLuiz Augusto von Dentz 14805d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1481127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 14825d3de7dfSVinicius Costa Gomes 148351a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1484127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 14858aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1486d26a2345SVinicius Costa Gomes } 14875d3de7dfSVinicius Costa Gomes 14885d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 14895d3de7dfSVinicius Costa Gomes kfree(conn); 14905d3de7dfSVinicius Costa Gomes } 14915d3de7dfSVinicius Costa Gomes 14926c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 14935d3de7dfSVinicius Costa Gomes { 14946c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 14956c9d42a1SGustavo F. Padovan security_timer.work); 14965d3de7dfSVinicius Costa Gomes 1497d06cc416SJohan Hedberg BT_DBG("conn %p", conn); 1498d06cc416SJohan Hedberg 1499d06cc416SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 1500d06cc416SJohan Hedberg smp_chan_destroy(conn); 15015d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 15025d3de7dfSVinicius Costa Gomes } 1503d06cc416SJohan Hedberg } 15045d3de7dfSVinicius Costa Gomes 15050a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 15060a708f8fSGustavo F. Padovan { 15070a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 150873d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 15090a708f8fSGustavo F. Padovan 15100a708f8fSGustavo F. Padovan if (conn || status) 15110a708f8fSGustavo F. Padovan return conn; 15120a708f8fSGustavo F. Padovan 151373d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 151473d80debSLuiz Augusto von Dentz if (!hchan) 15150a708f8fSGustavo F. Padovan return NULL; 15160a708f8fSGustavo F. Padovan 15178bcde1f2SGustavo Padovan conn = kzalloc(sizeof(struct l2cap_conn), GFP_KERNEL); 151873d80debSLuiz Augusto von Dentz if (!conn) { 151973d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 152073d80debSLuiz Augusto von Dentz return NULL; 152173d80debSLuiz Augusto von Dentz } 152273d80debSLuiz Augusto von Dentz 15230a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 15240a708f8fSGustavo F. Padovan conn->hcon = hcon; 152573d80debSLuiz Augusto von Dentz conn->hchan = hchan; 15260a708f8fSGustavo F. Padovan 152773d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 15280a708f8fSGustavo F. Padovan 1529dcc042d5SAndrei Emeltchenko switch (hcon->type) { 1530dcc042d5SAndrei Emeltchenko case LE_LINK: 1531dcc042d5SAndrei Emeltchenko if (hcon->hdev->le_mtu) { 1532acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1533dcc042d5SAndrei Emeltchenko break; 1534dcc042d5SAndrei Emeltchenko } 1535dcc042d5SAndrei Emeltchenko /* fall through */ 1536dcc042d5SAndrei Emeltchenko default: 15370a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1538dcc042d5SAndrei Emeltchenko break; 1539dcc042d5SAndrei Emeltchenko } 1540acd7d370SVille Tervo 15410a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 15420a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 15430a708f8fSGustavo F. Padovan 15440a708f8fSGustavo F. Padovan conn->feat_mask = 0; 15450a708f8fSGustavo F. Padovan 15460a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 15473df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1548baa7e1faSGustavo F. Padovan 1549baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 15500a708f8fSGustavo F. Padovan 15515d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 15526c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 15535d3de7dfSVinicius Costa Gomes else 1554030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 15550a708f8fSGustavo F. Padovan 15569f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 15570a708f8fSGustavo F. Padovan 15580a708f8fSGustavo F. Padovan return conn; 15590a708f8fSGustavo F. Padovan } 15600a708f8fSGustavo F. Padovan 15610a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 15620a708f8fSGustavo F. Padovan 1563c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 15640a708f8fSGustavo F. Padovan * Returns closest match. 15650a708f8fSGustavo F. Padovan */ 1566c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1567c2287681SIdo Yariv bdaddr_t *src, 1568c2287681SIdo Yariv bdaddr_t *dst) 15690a708f8fSGustavo F. Padovan { 157023691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 15710a708f8fSGustavo F. Padovan 157223691d75SGustavo F. Padovan read_lock(&chan_list_lock); 15730a708f8fSGustavo F. Padovan 157423691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 157523691d75SGustavo F. Padovan struct sock *sk = c->sk; 1576fe4128e0SGustavo F. Padovan 157789bc500eSGustavo F. Padovan if (state && c->state != state) 15780a708f8fSGustavo F. Padovan continue; 15790a708f8fSGustavo F. Padovan 158023691d75SGustavo F. Padovan if (c->psm == psm) { 1581c2287681SIdo Yariv int src_match, dst_match; 1582c2287681SIdo Yariv int src_any, dst_any; 1583c2287681SIdo Yariv 15840a708f8fSGustavo F. Padovan /* Exact match. */ 1585c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1586c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1587c2287681SIdo Yariv if (src_match && dst_match) { 1588a7567b20SJohannes Berg read_unlock(&chan_list_lock); 158923691d75SGustavo F. Padovan return c; 159023691d75SGustavo F. Padovan } 15910a708f8fSGustavo F. Padovan 15920a708f8fSGustavo F. Padovan /* Closest match */ 1593c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1594c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1595c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1596c2287681SIdo Yariv (src_any && dst_any)) 159723691d75SGustavo F. Padovan c1 = c; 15980a708f8fSGustavo F. Padovan } 15990a708f8fSGustavo F. Padovan } 16000a708f8fSGustavo F. Padovan 160123691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 16020a708f8fSGustavo F. Padovan 160323691d75SGustavo F. Padovan return c1; 16040a708f8fSGustavo F. Padovan } 16050a708f8fSGustavo F. Padovan 16068e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 16078e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 16080a708f8fSGustavo F. Padovan { 16095d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 16100a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 16110a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 16120a708f8fSGustavo F. Padovan struct hci_conn *hcon; 16130a708f8fSGustavo F. Padovan struct hci_dev *hdev; 16140a708f8fSGustavo F. Padovan __u8 auth_type; 16150a708f8fSGustavo F. Padovan int err; 16160a708f8fSGustavo F. Padovan 16176ed93dc6SAndrei Emeltchenko BT_DBG("%pMR -> %pMR (type %u) psm 0x%2.2x", src, dst, 1618ab19516aSSyam Sidhardhan dst_type, __le16_to_cpu(psm)); 16190a708f8fSGustavo F. Padovan 16200a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 16210a708f8fSGustavo F. Padovan if (!hdev) 16220a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 16230a708f8fSGustavo F. Padovan 162409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16250a708f8fSGustavo F. Padovan 16266be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 162703a00194SGustavo F. Padovan 162803a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 162903a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 163003a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 163103a00194SGustavo F. Padovan err = -EINVAL; 163203a00194SGustavo F. Padovan goto done; 163303a00194SGustavo F. Padovan } 163403a00194SGustavo F. Padovan 163503a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 163603a00194SGustavo F. Padovan err = -EINVAL; 163703a00194SGustavo F. Padovan goto done; 163803a00194SGustavo F. Padovan } 163903a00194SGustavo F. Padovan 164003a00194SGustavo F. Padovan switch (chan->mode) { 164103a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 164203a00194SGustavo F. Padovan break; 164303a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 164403a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 164503a00194SGustavo F. Padovan if (!disable_ertm) 164603a00194SGustavo F. Padovan break; 164703a00194SGustavo F. Padovan /* fall through */ 164803a00194SGustavo F. Padovan default: 164903a00194SGustavo F. Padovan err = -ENOTSUPP; 165003a00194SGustavo F. Padovan goto done; 165103a00194SGustavo F. Padovan } 165203a00194SGustavo F. Padovan 16530797e01dSGustavo Padovan switch (chan->state) { 165403a00194SGustavo F. Padovan case BT_CONNECT: 165503a00194SGustavo F. Padovan case BT_CONNECT2: 165603a00194SGustavo F. Padovan case BT_CONFIG: 165703a00194SGustavo F. Padovan /* Already connecting */ 165803a00194SGustavo F. Padovan err = 0; 165903a00194SGustavo F. Padovan goto done; 166003a00194SGustavo F. Padovan 166103a00194SGustavo F. Padovan case BT_CONNECTED: 166203a00194SGustavo F. Padovan /* Already connected */ 166303a00194SGustavo F. Padovan err = -EISCONN; 166403a00194SGustavo F. Padovan goto done; 166503a00194SGustavo F. Padovan 166603a00194SGustavo F. Padovan case BT_OPEN: 166703a00194SGustavo F. Padovan case BT_BOUND: 166803a00194SGustavo F. Padovan /* Can connect */ 166903a00194SGustavo F. Padovan break; 167003a00194SGustavo F. Padovan 167103a00194SGustavo F. Padovan default: 167203a00194SGustavo F. Padovan err = -EBADFD; 167303a00194SGustavo F. Padovan goto done; 167403a00194SGustavo F. Padovan } 167503a00194SGustavo F. Padovan 167603a00194SGustavo F. Padovan /* Set destination address and psm */ 16770797e01dSGustavo Padovan lock_sock(sk); 16789219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 16796be36555SAndrei Emeltchenko release_sock(sk); 16806be36555SAndrei Emeltchenko 168103a00194SGustavo F. Padovan chan->psm = psm; 168203a00194SGustavo F. Padovan chan->dcid = cid; 16830a708f8fSGustavo F. Padovan 16844343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 16850a708f8fSGustavo F. Padovan 1686fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 16878e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 16884343478fSGustavo F. Padovan chan->sec_level, auth_type); 1689acd7d370SVille Tervo else 16908e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 16914343478fSGustavo F. Padovan chan->sec_level, auth_type); 1692acd7d370SVille Tervo 169330e76272SVille Tervo if (IS_ERR(hcon)) { 169430e76272SVille Tervo err = PTR_ERR(hcon); 16950a708f8fSGustavo F. Padovan goto done; 169630e76272SVille Tervo } 16970a708f8fSGustavo F. Padovan 16980a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 16990a708f8fSGustavo F. Padovan if (!conn) { 170076a68ba0SDavid Herrmann hci_conn_drop(hcon); 170130e76272SVille Tervo err = -ENOMEM; 17020a708f8fSGustavo F. Padovan goto done; 17030a708f8fSGustavo F. Padovan } 17040a708f8fSGustavo F. Padovan 17059f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 17069f0caeb1SVinicius Costa Gomes err = 0; 17079f0caeb1SVinicius Costa Gomes 17089f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 17099f0caeb1SVinicius Costa Gomes err = -EBUSY; 171076a68ba0SDavid Herrmann hci_conn_drop(hcon); 17119f0caeb1SVinicius Costa Gomes } 17129f0caeb1SVinicius Costa Gomes 17139f0caeb1SVinicius Costa Gomes if (err) 17149f0caeb1SVinicius Costa Gomes goto done; 17159f0caeb1SVinicius Costa Gomes } 17169f0caeb1SVinicius Costa Gomes 17170a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 17180a708f8fSGustavo F. Padovan bacpy(src, conn->src); 17190a708f8fSGustavo F. Padovan 17206be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 172148454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 17226be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 172348454079SGustavo F. Padovan 17246be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1725c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 17260a708f8fSGustavo F. Padovan 17270a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1728715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1729c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1730d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 17316be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 17320a708f8fSGustavo F. Padovan } else 1733fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 17340a708f8fSGustavo F. Padovan } 17350a708f8fSGustavo F. Padovan 173630e76272SVille Tervo err = 0; 173730e76272SVille Tervo 17380a708f8fSGustavo F. Padovan done: 17396be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 174009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17410a708f8fSGustavo F. Padovan hci_dev_put(hdev); 17420a708f8fSGustavo F. Padovan return err; 17430a708f8fSGustavo F. Padovan } 17440a708f8fSGustavo F. Padovan 1745dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 17460a708f8fSGustavo F. Padovan { 17478c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 17480a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 17490a708f8fSGustavo F. Padovan int err = 0; 17500a708f8fSGustavo F. Padovan int timeo = HZ/5; 17510a708f8fSGustavo F. Padovan 17520a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 17530a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1754a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 17550a708f8fSGustavo F. Padovan if (!timeo) 17560a708f8fSGustavo F. Padovan timeo = HZ/5; 17570a708f8fSGustavo F. Padovan 17580a708f8fSGustavo F. Padovan if (signal_pending(current)) { 17590a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 17600a708f8fSGustavo F. Padovan break; 17610a708f8fSGustavo F. Padovan } 17620a708f8fSGustavo F. Padovan 17630a708f8fSGustavo F. Padovan release_sock(sk); 17640a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 17650a708f8fSGustavo F. Padovan lock_sock(sk); 1766a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 17670a708f8fSGustavo F. Padovan 17680a708f8fSGustavo F. Padovan err = sock_error(sk); 17690a708f8fSGustavo F. Padovan if (err) 17700a708f8fSGustavo F. Padovan break; 17710a708f8fSGustavo F. Padovan } 17720a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 17730a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 17740a708f8fSGustavo F. Padovan return err; 17750a708f8fSGustavo F. Padovan } 17760a708f8fSGustavo F. Padovan 1777721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 17780a708f8fSGustavo F. Padovan { 1779721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1780721c4181SGustavo F. Padovan monitor_timer.work); 17810a708f8fSGustavo F. Padovan 1782525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 17830a708f8fSGustavo F. Padovan 17846be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 17856be36555SAndrei Emeltchenko 178680909e04SMat Martineau if (!chan->conn) { 17876be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 17888d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 17890a708f8fSGustavo F. Padovan return; 17900a708f8fSGustavo F. Padovan } 17910a708f8fSGustavo F. Padovan 1792401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 17930a708f8fSGustavo F. Padovan 17946be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 17958d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 17960a708f8fSGustavo F. Padovan } 17970a708f8fSGustavo F. Padovan 1798721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 17990a708f8fSGustavo F. Padovan { 1800721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1801721c4181SGustavo F. Padovan retrans_timer.work); 18020a708f8fSGustavo F. Padovan 180349208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 18040a708f8fSGustavo F. Padovan 18056be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 18066be36555SAndrei Emeltchenko 180780909e04SMat Martineau if (!chan->conn) { 180880909e04SMat Martineau l2cap_chan_unlock(chan); 180980909e04SMat Martineau l2cap_chan_put(chan); 181080909e04SMat Martineau return; 181180909e04SMat Martineau } 18120a708f8fSGustavo F. Padovan 1813401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 18146be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 18158d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 18160a708f8fSGustavo F. Padovan } 18170a708f8fSGustavo F. Padovan 1818d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 18193733937dSMat Martineau struct sk_buff_head *skbs) 18200a708f8fSGustavo F. Padovan { 18210a708f8fSGustavo F. Padovan struct sk_buff *skb; 18223733937dSMat Martineau struct l2cap_ctrl *control; 18230a708f8fSGustavo F. Padovan 18243733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 18253733937dSMat Martineau 1826b99e13adSMat Martineau if (__chan_is_moving(chan)) 1827b99e13adSMat Martineau return; 1828b99e13adSMat Martineau 18293733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 18303733937dSMat Martineau 18313733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 18323733937dSMat Martineau 18333733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 18343733937dSMat Martineau 18353733937dSMat Martineau bt_cb(skb)->control.retries = 1; 18363733937dSMat Martineau control = &bt_cb(skb)->control; 18373733937dSMat Martineau 18383733937dSMat Martineau control->reqseq = 0; 18393733937dSMat Martineau control->txseq = chan->next_tx_seq; 18403733937dSMat Martineau 18413733937dSMat Martineau __pack_control(chan, control, skb); 18420a708f8fSGustavo F. Padovan 184347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 18443733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 18453733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 18460a708f8fSGustavo F. Padovan } 18470a708f8fSGustavo F. Padovan 18484343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 18490a708f8fSGustavo F. Padovan 1850b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 18513733937dSMat Martineau 1852836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 18533733937dSMat Martineau chan->frames_sent++; 18540a708f8fSGustavo F. Padovan } 18550a708f8fSGustavo F. Padovan } 18560a708f8fSGustavo F. Padovan 185767c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 18580a708f8fSGustavo F. Padovan { 18590a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 186018a48e76SMat Martineau struct l2cap_ctrl *control; 186118a48e76SMat Martineau int sent = 0; 186218a48e76SMat Martineau 186318a48e76SMat Martineau BT_DBG("chan %p", chan); 18640a708f8fSGustavo F. Padovan 186589bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 18660a708f8fSGustavo F. Padovan return -ENOTCONN; 18670a708f8fSGustavo F. Padovan 186894122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 186994122bbeSMat Martineau return 0; 187094122bbeSMat Martineau 1871b99e13adSMat Martineau if (__chan_is_moving(chan)) 1872b99e13adSMat Martineau return 0; 1873b99e13adSMat Martineau 187418a48e76SMat Martineau while (chan->tx_send_head && 187518a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 187618a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 18770a708f8fSGustavo F. Padovan 187818a48e76SMat Martineau skb = chan->tx_send_head; 18790a708f8fSGustavo F. Padovan 188018a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 188118a48e76SMat Martineau control = &bt_cb(skb)->control; 18820a708f8fSGustavo F. Padovan 1883e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 188418a48e76SMat Martineau control->final = 1; 1885e2ab4353SGustavo F. Padovan 188618a48e76SMat Martineau control->reqseq = chan->buffer_seq; 188718a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 188818a48e76SMat Martineau control->txseq = chan->next_tx_seq; 18890a708f8fSGustavo F. Padovan 189018a48e76SMat Martineau __pack_control(chan, control, skb); 18910a708f8fSGustavo F. Padovan 189247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 189318a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 189418a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 18950a708f8fSGustavo F. Padovan } 18960a708f8fSGustavo F. Padovan 189718a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 189818a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 189918a48e76SMat Martineau */ 190018a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 190118a48e76SMat Martineau 190218a48e76SMat Martineau if (!tx_skb) 190318a48e76SMat Martineau break; 19040a708f8fSGustavo F. Padovan 19051a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 19060a708f8fSGustavo F. Padovan 1907836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 19086a026610SGustavo F. Padovan chan->unacked_frames++; 19096a026610SGustavo F. Padovan chan->frames_sent++; 191018a48e76SMat Martineau sent++; 19110a708f8fSGustavo F. Padovan 191258d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 191358d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 19140a708f8fSGustavo F. Padovan else 191558d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 191618a48e76SMat Martineau 191718a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 1918b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 19190a708f8fSGustavo F. Padovan } 19200a708f8fSGustavo F. Padovan 1921b4400672SAndrei Emeltchenko BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent, 1922b4400672SAndrei Emeltchenko chan->unacked_frames, skb_queue_len(&chan->tx_q)); 192318a48e76SMat Martineau 192418a48e76SMat Martineau return sent; 19250a708f8fSGustavo F. Padovan } 19260a708f8fSGustavo F. Padovan 1927e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1928e1fbd4c1SMat Martineau { 1929e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1930e1fbd4c1SMat Martineau struct sk_buff *skb; 1931e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1932e1fbd4c1SMat Martineau u16 seq; 1933e1fbd4c1SMat Martineau 1934e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1935e1fbd4c1SMat Martineau 1936e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1937e1fbd4c1SMat Martineau return; 1938e1fbd4c1SMat Martineau 1939b99e13adSMat Martineau if (__chan_is_moving(chan)) 1940b99e13adSMat Martineau return; 1941b99e13adSMat Martineau 1942e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1943e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1944e1fbd4c1SMat Martineau 1945e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1946e1fbd4c1SMat Martineau if (!skb) { 1947e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1948e1fbd4c1SMat Martineau seq); 1949e1fbd4c1SMat Martineau continue; 1950e1fbd4c1SMat Martineau } 1951e1fbd4c1SMat Martineau 1952e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1953e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1954e1fbd4c1SMat Martineau 1955e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1956e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1957e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 19585e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 1959e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1960e1fbd4c1SMat Martineau break; 1961e1fbd4c1SMat Martineau } 1962e1fbd4c1SMat Martineau 1963e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1964e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1965e1fbd4c1SMat Martineau control.final = 1; 1966e1fbd4c1SMat Martineau else 1967e1fbd4c1SMat Martineau control.final = 0; 1968e1fbd4c1SMat Martineau 1969e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1970e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1971e1fbd4c1SMat Martineau * writeable copy 1972e1fbd4c1SMat Martineau */ 19738bcde1f2SGustavo Padovan tx_skb = skb_copy(skb, GFP_KERNEL); 1974e1fbd4c1SMat Martineau } else { 19758bcde1f2SGustavo Padovan tx_skb = skb_clone(skb, GFP_KERNEL); 1976e1fbd4c1SMat Martineau } 1977e1fbd4c1SMat Martineau 1978e1fbd4c1SMat Martineau if (!tx_skb) { 1979e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1980e1fbd4c1SMat Martineau break; 1981e1fbd4c1SMat Martineau } 1982e1fbd4c1SMat Martineau 1983e1fbd4c1SMat Martineau /* Update skb contents */ 1984e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1985e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1986e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1987e1fbd4c1SMat Martineau } else { 1988e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1989e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1990e1fbd4c1SMat Martineau } 1991e1fbd4c1SMat Martineau 1992e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1993e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1994e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1995e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1996e1fbd4c1SMat Martineau } 1997e1fbd4c1SMat Martineau 1998e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1999e1fbd4c1SMat Martineau 2000e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 2001e1fbd4c1SMat Martineau 2002e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 2003e1fbd4c1SMat Martineau } 2004e1fbd4c1SMat Martineau } 2005e1fbd4c1SMat Martineau 2006f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 2007f80842a8SMat Martineau struct l2cap_ctrl *control) 2008f80842a8SMat Martineau { 2009f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2010f80842a8SMat Martineau 2011f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 2012f80842a8SMat Martineau l2cap_ertm_resend(chan); 2013f80842a8SMat Martineau } 2014f80842a8SMat Martineau 2015d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 2016d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 2017d2a7ac5dSMat Martineau { 2018e1fbd4c1SMat Martineau struct sk_buff *skb; 2019e1fbd4c1SMat Martineau 2020e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2021e1fbd4c1SMat Martineau 2022e1fbd4c1SMat Martineau if (control->poll) 2023e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 2024e1fbd4c1SMat Martineau 2025e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2026e1fbd4c1SMat Martineau 2027e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 2028e1fbd4c1SMat Martineau return; 2029e1fbd4c1SMat Martineau 2030e1fbd4c1SMat Martineau if (chan->unacked_frames) { 2031e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 2032e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 2033e1fbd4c1SMat Martineau skb == chan->tx_send_head) 2034e1fbd4c1SMat Martineau break; 2035e1fbd4c1SMat Martineau } 2036e1fbd4c1SMat Martineau 2037e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 2038e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 2039e1fbd4c1SMat Martineau break; 2040e1fbd4c1SMat Martineau 2041e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 2042e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 2043e1fbd4c1SMat Martineau } 2044e1fbd4c1SMat Martineau 2045e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 2046e1fbd4c1SMat Martineau } 2047d2a7ac5dSMat Martineau } 2048d2a7ac5dSMat Martineau 2049b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 2050b17e73bbSSzymon Janc { 20510a0aba42SMat Martineau struct l2cap_ctrl control; 20520a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 20530a0aba42SMat Martineau chan->last_acked_seq); 20540a0aba42SMat Martineau int threshold; 20550a0aba42SMat Martineau 20560a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 20570a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 20580a0aba42SMat Martineau 20590a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 20600a0aba42SMat Martineau control.sframe = 1; 20610a0aba42SMat Martineau 20620a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 20630a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 2064b17e73bbSSzymon Janc __clear_ack_timer(chan); 20650a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 20660a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 20670a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 20680a0aba42SMat Martineau } else { 20690a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 20700a0aba42SMat Martineau l2cap_ertm_send(chan); 20710a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 20720a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 20730a0aba42SMat Martineau frames_to_ack = 0; 20740a0aba42SMat Martineau } 20750a0aba42SMat Martineau 2076c20f8e35SMat Martineau /* Ack now if the window is 3/4ths full. 20770a0aba42SMat Martineau * Calculate without mul or div 20780a0aba42SMat Martineau */ 2079c20f8e35SMat Martineau threshold = chan->ack_win; 20800a0aba42SMat Martineau threshold += threshold << 1; 20810a0aba42SMat Martineau threshold >>= 2; 20820a0aba42SMat Martineau 2083b4400672SAndrei Emeltchenko BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack, 20840a0aba42SMat Martineau threshold); 20850a0aba42SMat Martineau 20860a0aba42SMat Martineau if (frames_to_ack >= threshold) { 20870a0aba42SMat Martineau __clear_ack_timer(chan); 20880a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 20890a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 20900a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 20910a0aba42SMat Martineau frames_to_ack = 0; 20920a0aba42SMat Martineau } 20930a0aba42SMat Martineau 20940a0aba42SMat Martineau if (frames_to_ack) 20950a0aba42SMat Martineau __set_ack_timer(chan); 20960a0aba42SMat Martineau } 2097b17e73bbSSzymon Janc } 2098b17e73bbSSzymon Janc 209904124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 210004124681SGustavo F. Padovan struct msghdr *msg, int len, 210104124681SGustavo F. Padovan int count, struct sk_buff *skb) 21020a708f8fSGustavo F. Padovan { 21030952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 21040a708f8fSGustavo F. Padovan struct sk_buff **frag; 210590338947SGustavo Padovan int sent = 0; 21060a708f8fSGustavo F. Padovan 21070a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 21080a708f8fSGustavo F. Padovan return -EFAULT; 21090a708f8fSGustavo F. Padovan 21100a708f8fSGustavo F. Padovan sent += count; 21110a708f8fSGustavo F. Padovan len -= count; 21120a708f8fSGustavo F. Padovan 21130a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 21140a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 21150a708f8fSGustavo F. Padovan while (len) { 2116fbe00700SGustavo Padovan struct sk_buff *tmp; 2117fbe00700SGustavo Padovan 21180a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 21190a708f8fSGustavo F. Padovan 2120fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 212190338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 2122fbe00700SGustavo Padovan if (IS_ERR(tmp)) 2123fbe00700SGustavo Padovan return PTR_ERR(tmp); 21242f7719ceSAndrei Emeltchenko 2125fbe00700SGustavo Padovan *frag = tmp; 2126fbe00700SGustavo Padovan 21270a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 21280a708f8fSGustavo F. Padovan return -EFAULT; 21290a708f8fSGustavo F. Padovan 21305e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 21315e59b791SLuiz Augusto von Dentz 21320a708f8fSGustavo F. Padovan sent += count; 21330a708f8fSGustavo F. Padovan len -= count; 21340a708f8fSGustavo F. Padovan 21352d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 21362d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 21372d0ed3d5SGustavo Padovan 21380a708f8fSGustavo F. Padovan frag = &(*frag)->next; 21390a708f8fSGustavo F. Padovan } 21400a708f8fSGustavo F. Padovan 21410a708f8fSGustavo F. Padovan return sent; 21420a708f8fSGustavo F. Padovan } 21430a708f8fSGustavo F. Padovan 21445e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 21455e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 21465e59b791SLuiz Augusto von Dentz u32 priority) 21470a708f8fSGustavo F. Padovan { 21488c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 21490a708f8fSGustavo F. Padovan struct sk_buff *skb; 215003a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 21510a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 21520a708f8fSGustavo F. Padovan 2153b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu priority %u", chan, len, priority); 21540a708f8fSGustavo F. Padovan 21550a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 21562f7719ceSAndrei Emeltchenko 21572f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 215890338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 215990338947SGustavo Padovan if (IS_ERR(skb)) 216090338947SGustavo Padovan return skb; 21610a708f8fSGustavo F. Padovan 21625e59b791SLuiz Augusto von Dentz skb->priority = priority; 21635e59b791SLuiz Augusto von Dentz 21640a708f8fSGustavo F. Padovan /* Create L2CAP header */ 21650a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2166fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 2167daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 2168daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 21690a708f8fSGustavo F. Padovan 21700952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 21710a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 21720a708f8fSGustavo F. Padovan kfree_skb(skb); 21730a708f8fSGustavo F. Padovan return ERR_PTR(err); 21740a708f8fSGustavo F. Padovan } 21750a708f8fSGustavo F. Padovan return skb; 21760a708f8fSGustavo F. Padovan } 21770a708f8fSGustavo F. Padovan 21785e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 21795e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 21805e59b791SLuiz Augusto von Dentz u32 priority) 21810a708f8fSGustavo F. Padovan { 21828c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 21830a708f8fSGustavo F. Padovan struct sk_buff *skb; 2184f2ba7faeSGustavo Padovan int err, count; 21850a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 21860a708f8fSGustavo F. Padovan 2187b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 21880a708f8fSGustavo F. Padovan 2189f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 21902f7719ceSAndrei Emeltchenko 2191f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 219290338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 219390338947SGustavo Padovan if (IS_ERR(skb)) 219490338947SGustavo Padovan return skb; 21950a708f8fSGustavo F. Padovan 21965e59b791SLuiz Augusto von Dentz skb->priority = priority; 21975e59b791SLuiz Augusto von Dentz 21980a708f8fSGustavo F. Padovan /* Create L2CAP header */ 21990a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2200fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 22016ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 22020a708f8fSGustavo F. Padovan 22030952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 22040a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 22050a708f8fSGustavo F. Padovan kfree_skb(skb); 22060a708f8fSGustavo F. Padovan return ERR_PTR(err); 22070a708f8fSGustavo F. Padovan } 22080a708f8fSGustavo F. Padovan return skb; 22090a708f8fSGustavo F. Padovan } 22100a708f8fSGustavo F. Padovan 2211ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2212ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 221394122bbeSMat Martineau u16 sdulen) 22140a708f8fSGustavo F. Padovan { 22158c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 22160a708f8fSGustavo F. Padovan struct sk_buff *skb; 2217e4ca6d98SAndrei Emeltchenko int err, count, hlen; 22180a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 22190a708f8fSGustavo F. Padovan 2220b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 22210a708f8fSGustavo F. Padovan 22220a708f8fSGustavo F. Padovan if (!conn) 22230a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 22240a708f8fSGustavo F. Padovan 2225ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2226e4ca6d98SAndrei Emeltchenko 22270a708f8fSGustavo F. Padovan if (sdulen) 222803a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 22290a708f8fSGustavo F. Padovan 223047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 223103a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 22320a708f8fSGustavo F. Padovan 22330a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 22342f7719ceSAndrei Emeltchenko 22352f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 223690338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 223790338947SGustavo Padovan if (IS_ERR(skb)) 223890338947SGustavo Padovan return skb; 22390a708f8fSGustavo F. Padovan 22400a708f8fSGustavo F. Padovan /* Create L2CAP header */ 22410a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2242fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 22430a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 224488843ab0SAndrei Emeltchenko 224518a48e76SMat Martineau /* Control header is populated later */ 224618a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 224718a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 224818a48e76SMat Martineau else 224918a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 225088843ab0SAndrei Emeltchenko 22510a708f8fSGustavo F. Padovan if (sdulen) 225203a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 22530a708f8fSGustavo F. Padovan 22540952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 22550a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 22560a708f8fSGustavo F. Padovan kfree_skb(skb); 22570a708f8fSGustavo F. Padovan return ERR_PTR(err); 22580a708f8fSGustavo F. Padovan } 22590a708f8fSGustavo F. Padovan 226018a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 22613ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 22620a708f8fSGustavo F. Padovan return skb; 22630a708f8fSGustavo F. Padovan } 22640a708f8fSGustavo F. Padovan 226594122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 226694122bbeSMat Martineau struct sk_buff_head *seg_queue, 226794122bbeSMat Martineau struct msghdr *msg, size_t len) 22680a708f8fSGustavo F. Padovan { 22690a708f8fSGustavo F. Padovan struct sk_buff *skb; 227094122bbeSMat Martineau u16 sdu_len; 227194122bbeSMat Martineau size_t pdu_len; 227294122bbeSMat Martineau u8 sar; 22730a708f8fSGustavo F. Padovan 2274b4400672SAndrei Emeltchenko BT_DBG("chan %p, msg %p, len %zu", chan, msg, len); 22750a708f8fSGustavo F. Padovan 227694122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 227794122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 227894122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 227994122bbeSMat Martineau */ 228094122bbeSMat Martineau 228194122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 228294122bbeSMat Martineau pdu_len = chan->conn->mtu; 228394122bbeSMat Martineau 2284a549574dSMat Martineau /* Constrain PDU size for BR/EDR connections */ 2285a549574dSMat Martineau if (!chan->hs_hcon) 228694122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 228794122bbeSMat Martineau 228894122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 228935d401dfSGustavo Padovan if (chan->fcs) 229035d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 229135d401dfSGustavo Padovan 2292ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 229394122bbeSMat Martineau 229494122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 229594122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 229694122bbeSMat Martineau 229794122bbeSMat Martineau if (len <= pdu_len) { 229894122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 229994122bbeSMat Martineau sdu_len = 0; 230094122bbeSMat Martineau pdu_len = len; 230194122bbeSMat Martineau } else { 230294122bbeSMat Martineau sar = L2CAP_SAR_START; 230394122bbeSMat Martineau sdu_len = len; 230494122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 230594122bbeSMat Martineau } 23060a708f8fSGustavo F. Padovan 23070a708f8fSGustavo F. Padovan while (len > 0) { 230894122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 23090a708f8fSGustavo F. Padovan 23100a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 231194122bbeSMat Martineau __skb_queue_purge(seg_queue); 23120a708f8fSGustavo F. Padovan return PTR_ERR(skb); 23130a708f8fSGustavo F. Padovan } 23140a708f8fSGustavo F. Padovan 231594122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 231694122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 23170a708f8fSGustavo F. Padovan 231894122bbeSMat Martineau len -= pdu_len; 231994122bbeSMat Martineau if (sdu_len) { 232094122bbeSMat Martineau sdu_len = 0; 232194122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 232294122bbeSMat Martineau } 232394122bbeSMat Martineau 232494122bbeSMat Martineau if (len <= pdu_len) { 232594122bbeSMat Martineau sar = L2CAP_SAR_END; 232694122bbeSMat Martineau pdu_len = len; 232794122bbeSMat Martineau } else { 232894122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 232994122bbeSMat Martineau } 233094122bbeSMat Martineau } 233194122bbeSMat Martineau 2332f0f62799SGustavo Padovan return 0; 23330a708f8fSGustavo F. Padovan } 23340a708f8fSGustavo F. Padovan 23355e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 23365e59b791SLuiz Augusto von Dentz u32 priority) 23379a91a04aSGustavo F. Padovan { 23389a91a04aSGustavo F. Padovan struct sk_buff *skb; 23399a91a04aSGustavo F. Padovan int err; 234094122bbeSMat Martineau struct sk_buff_head seg_queue; 23419a91a04aSGustavo F. Padovan 23429a91a04aSGustavo F. Padovan /* Connectionless channel */ 2343715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 23445e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 23459a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 23469a91a04aSGustavo F. Padovan return PTR_ERR(skb); 23479a91a04aSGustavo F. Padovan 23489a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 23499a91a04aSGustavo F. Padovan return len; 23509a91a04aSGustavo F. Padovan } 23519a91a04aSGustavo F. Padovan 23529a91a04aSGustavo F. Padovan switch (chan->mode) { 23539a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 23549a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 23559a91a04aSGustavo F. Padovan if (len > chan->omtu) 23569a91a04aSGustavo F. Padovan return -EMSGSIZE; 23579a91a04aSGustavo F. Padovan 23589a91a04aSGustavo F. Padovan /* Create a basic PDU */ 23595e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 23609a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 23619a91a04aSGustavo F. Padovan return PTR_ERR(skb); 23629a91a04aSGustavo F. Padovan 23639a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 23649a91a04aSGustavo F. Padovan err = len; 23659a91a04aSGustavo F. Padovan break; 23669a91a04aSGustavo F. Padovan 23679a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 23689a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 236994122bbeSMat Martineau /* Check outgoing MTU */ 237094122bbeSMat Martineau if (len > chan->omtu) { 237194122bbeSMat Martineau err = -EMSGSIZE; 23729a91a04aSGustavo F. Padovan break; 23739a91a04aSGustavo F. Padovan } 23749a91a04aSGustavo F. Padovan 237594122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 237694122bbeSMat Martineau 237794122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 237894122bbeSMat Martineau * since it's possible to block while waiting for memory 237994122bbeSMat Martineau * allocation. 238094122bbeSMat Martineau */ 238194122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 238294122bbeSMat Martineau 238394122bbeSMat Martineau /* The channel could have been closed while segmenting, 238494122bbeSMat Martineau * check that it is still connected. 238594122bbeSMat Martineau */ 238694122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 238794122bbeSMat Martineau __skb_queue_purge(&seg_queue); 238894122bbeSMat Martineau err = -ENOTCONN; 23899a91a04aSGustavo F. Padovan } 23909a91a04aSGustavo F. Padovan 239194122bbeSMat Martineau if (err) 239294122bbeSMat Martineau break; 239394122bbeSMat Martineau 23943733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2395d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 23963733937dSMat Martineau else 2397d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 239894122bbeSMat Martineau 23999a91a04aSGustavo F. Padovan err = len; 24009a91a04aSGustavo F. Padovan 240194122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 240294122bbeSMat Martineau * seg_queue and need to be purged. 240394122bbeSMat Martineau */ 240494122bbeSMat Martineau __skb_queue_purge(&seg_queue); 24059a91a04aSGustavo F. Padovan break; 24069a91a04aSGustavo F. Padovan 24079a91a04aSGustavo F. Padovan default: 24089a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 24099a91a04aSGustavo F. Padovan err = -EBADFD; 24109a91a04aSGustavo F. Padovan } 24119a91a04aSGustavo F. Padovan 24129a91a04aSGustavo F. Padovan return err; 24139a91a04aSGustavo F. Padovan } 24149a91a04aSGustavo F. Padovan 2415d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2416d2a7ac5dSMat Martineau { 2417bed68bdeSMat Martineau struct l2cap_ctrl control; 2418bed68bdeSMat Martineau u16 seq; 2419bed68bdeSMat Martineau 2420b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2421bed68bdeSMat Martineau 2422bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2423bed68bdeSMat Martineau control.sframe = 1; 2424bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2425bed68bdeSMat Martineau 2426bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2427bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2428bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2429bed68bdeSMat Martineau control.reqseq = seq; 2430bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2431bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2432bed68bdeSMat Martineau } 2433bed68bdeSMat Martineau } 2434bed68bdeSMat Martineau 2435bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2436d2a7ac5dSMat Martineau } 2437d2a7ac5dSMat Martineau 2438d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2439d2a7ac5dSMat Martineau { 2440bed68bdeSMat Martineau struct l2cap_ctrl control; 2441bed68bdeSMat Martineau 2442bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2443bed68bdeSMat Martineau 2444bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2445bed68bdeSMat Martineau return; 2446bed68bdeSMat Martineau 2447bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2448bed68bdeSMat Martineau control.sframe = 1; 2449bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2450bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2451bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2452d2a7ac5dSMat Martineau } 2453d2a7ac5dSMat Martineau 2454d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2455d2a7ac5dSMat Martineau { 2456bed68bdeSMat Martineau struct l2cap_ctrl control; 2457bed68bdeSMat Martineau u16 initial_head; 2458bed68bdeSMat Martineau u16 seq; 2459bed68bdeSMat Martineau 2460b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2461bed68bdeSMat Martineau 2462bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2463bed68bdeSMat Martineau control.sframe = 1; 2464bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2465bed68bdeSMat Martineau 2466bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2467bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2468bed68bdeSMat Martineau 2469bed68bdeSMat Martineau do { 2470bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2471bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2472bed68bdeSMat Martineau break; 2473bed68bdeSMat Martineau 2474bed68bdeSMat Martineau control.reqseq = seq; 2475bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2476bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2477bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2478d2a7ac5dSMat Martineau } 2479d2a7ac5dSMat Martineau 2480608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2481608bcc6dSMat Martineau { 2482608bcc6dSMat Martineau struct sk_buff *acked_skb; 2483608bcc6dSMat Martineau u16 ackseq; 2484608bcc6dSMat Martineau 2485b4400672SAndrei Emeltchenko BT_DBG("chan %p, reqseq %u", chan, reqseq); 2486608bcc6dSMat Martineau 2487608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2488608bcc6dSMat Martineau return; 2489608bcc6dSMat Martineau 2490b4400672SAndrei Emeltchenko BT_DBG("expected_ack_seq %u, unacked_frames %u", 2491608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2492608bcc6dSMat Martineau 2493608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2494608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2495608bcc6dSMat Martineau 2496608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2497608bcc6dSMat Martineau if (acked_skb) { 2498608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2499608bcc6dSMat Martineau kfree_skb(acked_skb); 2500608bcc6dSMat Martineau chan->unacked_frames--; 2501608bcc6dSMat Martineau } 2502608bcc6dSMat Martineau } 2503608bcc6dSMat Martineau 2504608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2505608bcc6dSMat Martineau 2506608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2507608bcc6dSMat Martineau __clear_retrans_timer(chan); 2508608bcc6dSMat Martineau 2509b4400672SAndrei Emeltchenko BT_DBG("unacked_frames %u", chan->unacked_frames); 2510608bcc6dSMat Martineau } 2511608bcc6dSMat Martineau 2512608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2513608bcc6dSMat Martineau { 2514608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2515608bcc6dSMat Martineau 2516608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2517608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2518608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2519608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2520608bcc6dSMat Martineau } 2521608bcc6dSMat Martineau 2522d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2523608bcc6dSMat Martineau struct l2cap_ctrl *control, 2524608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2525608bcc6dSMat Martineau { 2526608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2527608bcc6dSMat Martineau event); 2528608bcc6dSMat Martineau 2529608bcc6dSMat Martineau switch (event) { 2530608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2531608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2532608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2533608bcc6dSMat Martineau 2534608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2535608bcc6dSMat Martineau l2cap_ertm_send(chan); 2536608bcc6dSMat Martineau break; 2537608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2538608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2539608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2540608bcc6dSMat Martineau 2541608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2542608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2543608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2544608bcc6dSMat Martineau */ 2545608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2546608bcc6dSMat Martineau } 2547608bcc6dSMat Martineau 2548608bcc6dSMat Martineau l2cap_send_ack(chan); 2549608bcc6dSMat Martineau 2550608bcc6dSMat Martineau break; 2551608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2552608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2553608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2554608bcc6dSMat Martineau 2555608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2556608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2557608bcc6dSMat Martineau 2558608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2559608bcc6dSMat Martineau local_control.sframe = 1; 2560608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2561608bcc6dSMat Martineau local_control.poll = 1; 2562608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2563a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2564608bcc6dSMat Martineau 2565608bcc6dSMat Martineau chan->retry_count = 1; 2566608bcc6dSMat Martineau __set_monitor_timer(chan); 2567608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2568608bcc6dSMat Martineau } 2569608bcc6dSMat Martineau break; 2570608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2571608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2572608bcc6dSMat Martineau break; 2573608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2574608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2575608bcc6dSMat Martineau chan->retry_count = 1; 2576608bcc6dSMat Martineau __set_monitor_timer(chan); 2577608bcc6dSMat Martineau __clear_ack_timer(chan); 2578608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2579608bcc6dSMat Martineau break; 2580608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2581608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2582608bcc6dSMat Martineau chan->retry_count = 1; 2583608bcc6dSMat Martineau __set_monitor_timer(chan); 2584608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2585608bcc6dSMat Martineau break; 2586608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2587608bcc6dSMat Martineau /* Nothing to process */ 2588608bcc6dSMat Martineau break; 2589608bcc6dSMat Martineau default: 2590608bcc6dSMat Martineau break; 2591608bcc6dSMat Martineau } 2592608bcc6dSMat Martineau } 2593608bcc6dSMat Martineau 2594d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2595608bcc6dSMat Martineau struct l2cap_ctrl *control, 2596608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2597608bcc6dSMat Martineau { 2598608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2599608bcc6dSMat Martineau event); 2600608bcc6dSMat Martineau 2601608bcc6dSMat Martineau switch (event) { 2602608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2603608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2604608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2605608bcc6dSMat Martineau /* Queue data, but don't send. */ 2606608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2607608bcc6dSMat Martineau break; 2608608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2609608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2610608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2611608bcc6dSMat Martineau 2612608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2613608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2614608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2615608bcc6dSMat Martineau */ 2616608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2617608bcc6dSMat Martineau } 2618608bcc6dSMat Martineau 2619608bcc6dSMat Martineau l2cap_send_ack(chan); 2620608bcc6dSMat Martineau 2621608bcc6dSMat Martineau break; 2622608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2623608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2624608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2625608bcc6dSMat Martineau 2626608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2627608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2628608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2629608bcc6dSMat Martineau local_control.sframe = 1; 2630608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2631608bcc6dSMat Martineau local_control.poll = 1; 2632608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2633a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2634608bcc6dSMat Martineau 2635608bcc6dSMat Martineau chan->retry_count = 1; 2636608bcc6dSMat Martineau __set_monitor_timer(chan); 2637608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2638608bcc6dSMat Martineau } 2639608bcc6dSMat Martineau break; 2640608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2641608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2642608bcc6dSMat Martineau 2643608bcc6dSMat Martineau /* Fall through */ 2644608bcc6dSMat Martineau 2645608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2646608bcc6dSMat Martineau if (control && control->final) { 2647608bcc6dSMat Martineau __clear_monitor_timer(chan); 2648608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2649608bcc6dSMat Martineau __set_retrans_timer(chan); 2650608bcc6dSMat Martineau chan->retry_count = 0; 2651608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2652608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2653608bcc6dSMat Martineau } 2654608bcc6dSMat Martineau break; 2655608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2656608bcc6dSMat Martineau /* Ignore */ 2657608bcc6dSMat Martineau break; 2658608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2659608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2660608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2661608bcc6dSMat Martineau __set_monitor_timer(chan); 2662608bcc6dSMat Martineau chan->retry_count++; 2663608bcc6dSMat Martineau } else { 26645e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNABORTED); 2665608bcc6dSMat Martineau } 2666608bcc6dSMat Martineau break; 2667608bcc6dSMat Martineau default: 2668608bcc6dSMat Martineau break; 2669608bcc6dSMat Martineau } 2670608bcc6dSMat Martineau } 2671608bcc6dSMat Martineau 2672d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2673608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2674608bcc6dSMat Martineau { 2675608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2676608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2677608bcc6dSMat Martineau 2678608bcc6dSMat Martineau switch (chan->tx_state) { 2679608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2680d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2681608bcc6dSMat Martineau break; 2682608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2683d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2684608bcc6dSMat Martineau break; 2685608bcc6dSMat Martineau default: 2686608bcc6dSMat Martineau /* Ignore event */ 2687608bcc6dSMat Martineau break; 2688608bcc6dSMat Martineau } 2689608bcc6dSMat Martineau } 2690608bcc6dSMat Martineau 26914b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 26924b51dae9SMat Martineau struct l2cap_ctrl *control) 26934b51dae9SMat Martineau { 26944b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2695401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 26964b51dae9SMat Martineau } 26974b51dae9SMat Martineau 2698f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2699f80842a8SMat Martineau struct l2cap_ctrl *control) 2700f80842a8SMat Martineau { 2701f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2702401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2703f80842a8SMat Martineau } 2704f80842a8SMat Martineau 27050a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 27060a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 27070a708f8fSGustavo F. Padovan { 27080a708f8fSGustavo F. Padovan struct sk_buff *nskb; 270948454079SGustavo F. Padovan struct l2cap_chan *chan; 27100a708f8fSGustavo F. Padovan 27110a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 27120a708f8fSGustavo F. Padovan 27133df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 27143d57dc68SGustavo F. Padovan 27153df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 271648454079SGustavo F. Padovan struct sock *sk = chan->sk; 2717715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 27180a708f8fSGustavo F. Padovan continue; 27190a708f8fSGustavo F. Padovan 27200a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 27210a708f8fSGustavo F. Padovan if (skb->sk == sk) 27220a708f8fSGustavo F. Padovan continue; 27238bcde1f2SGustavo Padovan nskb = skb_clone(skb, GFP_KERNEL); 27240a708f8fSGustavo F. Padovan if (!nskb) 27250a708f8fSGustavo F. Padovan continue; 27260a708f8fSGustavo F. Padovan 272780b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 27280a708f8fSGustavo F. Padovan kfree_skb(nskb); 27290a708f8fSGustavo F. Padovan } 27303d57dc68SGustavo F. Padovan 27313df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 27320a708f8fSGustavo F. Padovan } 27330a708f8fSGustavo F. Padovan 27340a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 2735b4400672SAndrei Emeltchenko static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code, 2736b4400672SAndrei Emeltchenko u8 ident, u16 dlen, void *data) 27370a708f8fSGustavo F. Padovan { 27380a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 27390a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 27400a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 27410a708f8fSGustavo F. Padovan int len, count; 27420a708f8fSGustavo F. Padovan 2743b4400672SAndrei Emeltchenko BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u", 27440a708f8fSGustavo F. Padovan conn, code, ident, dlen); 27450a708f8fSGustavo F. Padovan 27460a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 27470a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 27480a708f8fSGustavo F. Padovan 27498bcde1f2SGustavo Padovan skb = bt_skb_alloc(count, GFP_KERNEL); 27500a708f8fSGustavo F. Padovan if (!skb) 27510a708f8fSGustavo F. Padovan return NULL; 27520a708f8fSGustavo F. Padovan 27530a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 27540a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 27553300d9a9SClaudio Takahasi 27563300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2757ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 27583300d9a9SClaudio Takahasi else 2759ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 27600a708f8fSGustavo F. Padovan 27610a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 27620a708f8fSGustavo F. Padovan cmd->code = code; 27630a708f8fSGustavo F. Padovan cmd->ident = ident; 27640a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 27650a708f8fSGustavo F. Padovan 27660a708f8fSGustavo F. Padovan if (dlen) { 27670a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 27680a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 27690a708f8fSGustavo F. Padovan data += count; 27700a708f8fSGustavo F. Padovan } 27710a708f8fSGustavo F. Padovan 27720a708f8fSGustavo F. Padovan len -= skb->len; 27730a708f8fSGustavo F. Padovan 27740a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 27750a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 27760a708f8fSGustavo F. Padovan while (len) { 27770a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 27780a708f8fSGustavo F. Padovan 27798bcde1f2SGustavo Padovan *frag = bt_skb_alloc(count, GFP_KERNEL); 27800a708f8fSGustavo F. Padovan if (!*frag) 27810a708f8fSGustavo F. Padovan goto fail; 27820a708f8fSGustavo F. Padovan 27830a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 27840a708f8fSGustavo F. Padovan 27850a708f8fSGustavo F. Padovan len -= count; 27860a708f8fSGustavo F. Padovan data += count; 27870a708f8fSGustavo F. Padovan 27880a708f8fSGustavo F. Padovan frag = &(*frag)->next; 27890a708f8fSGustavo F. Padovan } 27900a708f8fSGustavo F. Padovan 27910a708f8fSGustavo F. Padovan return skb; 27920a708f8fSGustavo F. Padovan 27930a708f8fSGustavo F. Padovan fail: 27940a708f8fSGustavo F. Padovan kfree_skb(skb); 27950a708f8fSGustavo F. Padovan return NULL; 27960a708f8fSGustavo F. Padovan } 27970a708f8fSGustavo F. Padovan 27982d792818SGustavo Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, 27992d792818SGustavo Padovan unsigned long *val) 28000a708f8fSGustavo F. Padovan { 28010a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 28020a708f8fSGustavo F. Padovan int len; 28030a708f8fSGustavo F. Padovan 28040a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 28050a708f8fSGustavo F. Padovan *ptr += len; 28060a708f8fSGustavo F. Padovan 28070a708f8fSGustavo F. Padovan *type = opt->type; 28080a708f8fSGustavo F. Padovan *olen = opt->len; 28090a708f8fSGustavo F. Padovan 28100a708f8fSGustavo F. Padovan switch (opt->len) { 28110a708f8fSGustavo F. Padovan case 1: 28120a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 28130a708f8fSGustavo F. Padovan break; 28140a708f8fSGustavo F. Padovan 28150a708f8fSGustavo F. Padovan case 2: 28160a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 28170a708f8fSGustavo F. Padovan break; 28180a708f8fSGustavo F. Padovan 28190a708f8fSGustavo F. Padovan case 4: 28200a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 28210a708f8fSGustavo F. Padovan break; 28220a708f8fSGustavo F. Padovan 28230a708f8fSGustavo F. Padovan default: 28240a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 28250a708f8fSGustavo F. Padovan break; 28260a708f8fSGustavo F. Padovan } 28270a708f8fSGustavo F. Padovan 2828b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val); 28290a708f8fSGustavo F. Padovan return len; 28300a708f8fSGustavo F. Padovan } 28310a708f8fSGustavo F. Padovan 28320a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 28330a708f8fSGustavo F. Padovan { 28340a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 28350a708f8fSGustavo F. Padovan 2836b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val); 28370a708f8fSGustavo F. Padovan 28380a708f8fSGustavo F. Padovan opt->type = type; 28390a708f8fSGustavo F. Padovan opt->len = len; 28400a708f8fSGustavo F. Padovan 28410a708f8fSGustavo F. Padovan switch (len) { 28420a708f8fSGustavo F. Padovan case 1: 28430a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 28440a708f8fSGustavo F. Padovan break; 28450a708f8fSGustavo F. Padovan 28460a708f8fSGustavo F. Padovan case 2: 28470a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 28480a708f8fSGustavo F. Padovan break; 28490a708f8fSGustavo F. Padovan 28500a708f8fSGustavo F. Padovan case 4: 28510a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 28520a708f8fSGustavo F. Padovan break; 28530a708f8fSGustavo F. Padovan 28540a708f8fSGustavo F. Padovan default: 28550a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 28560a708f8fSGustavo F. Padovan break; 28570a708f8fSGustavo F. Padovan } 28580a708f8fSGustavo F. Padovan 28590a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 28600a708f8fSGustavo F. Padovan } 28610a708f8fSGustavo F. Padovan 2862f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2863f89cef09SAndrei Emeltchenko { 2864f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2865f89cef09SAndrei Emeltchenko 2866f89cef09SAndrei Emeltchenko switch (chan->mode) { 2867f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2868f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2869f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2870f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2871f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2872ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 28738936fa6dSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_EFS_DEFAULT_FLUSH_TO); 2874f89cef09SAndrei Emeltchenko break; 2875f89cef09SAndrei Emeltchenko 2876f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2877f89cef09SAndrei Emeltchenko efs.id = 1; 2878f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2879f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2880f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2881f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2882f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2883f89cef09SAndrei Emeltchenko break; 2884f89cef09SAndrei Emeltchenko 2885f89cef09SAndrei Emeltchenko default: 2886f89cef09SAndrei Emeltchenko return; 2887f89cef09SAndrei Emeltchenko } 2888f89cef09SAndrei Emeltchenko 2889f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2890f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2891f89cef09SAndrei Emeltchenko } 2892f89cef09SAndrei Emeltchenko 2893721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 28940a708f8fSGustavo F. Padovan { 2895721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2896721c4181SGustavo F. Padovan ack_timer.work); 28970362520bSMat Martineau u16 frames_to_ack; 28980a708f8fSGustavo F. Padovan 28992fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 29002fb9b3d4SGustavo F. Padovan 29016be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 29026be36555SAndrei Emeltchenko 29030362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 29040362520bSMat Martineau chan->last_acked_seq); 29050362520bSMat Martineau 29060362520bSMat Martineau if (frames_to_ack) 29070362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 29086be36555SAndrei Emeltchenko 29096be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 291009bfb2eeSSzymon Janc l2cap_chan_put(chan); 29110a708f8fSGustavo F. Padovan } 29120a708f8fSGustavo F. Padovan 2913466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 29140a708f8fSGustavo F. Padovan { 29153c588192SMat Martineau int err; 29163c588192SMat Martineau 2917105bdf9eSMat Martineau chan->next_tx_seq = 0; 2918105bdf9eSMat Martineau chan->expected_tx_seq = 0; 291942e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 29206a026610SGustavo F. Padovan chan->unacked_frames = 0; 292142e5c802SGustavo F. Padovan chan->buffer_seq = 0; 29226a026610SGustavo F. Padovan chan->frames_sent = 0; 2923105bdf9eSMat Martineau chan->last_acked_seq = 0; 2924105bdf9eSMat Martineau chan->sdu = NULL; 2925105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2926105bdf9eSMat Martineau chan->sdu_len = 0; 2927105bdf9eSMat Martineau 2928d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2929d34c34fbSMat Martineau 293008333283SMat Martineau chan->local_amp_id = 0; 293108333283SMat Martineau chan->move_id = 0; 293208333283SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 293308333283SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 293408333283SMat Martineau 2935105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2936105bdf9eSMat Martineau return 0; 2937105bdf9eSMat Martineau 2938105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2939105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 29400a708f8fSGustavo F. Padovan 2941721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2942721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2943721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 29440a708f8fSGustavo F. Padovan 2945f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 29460a708f8fSGustavo F. Padovan 29473c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 29483c588192SMat Martineau if (err < 0) 29493c588192SMat Martineau return err; 29503c588192SMat Martineau 29519dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 29529dc9affcSMat Martineau if (err < 0) 29539dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 29549dc9affcSMat Martineau 29559dc9affcSMat Martineau return err; 29560a708f8fSGustavo F. Padovan } 29570a708f8fSGustavo F. Padovan 29580a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 29590a708f8fSGustavo F. Padovan { 29600a708f8fSGustavo F. Padovan switch (mode) { 29610a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 29620a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 29630a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 29640a708f8fSGustavo F. Padovan return mode; 29650a708f8fSGustavo F. Padovan /* fall through */ 29660a708f8fSGustavo F. Padovan default: 29670a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 29680a708f8fSGustavo F. Padovan } 29690a708f8fSGustavo F. Padovan } 29700a708f8fSGustavo F. Padovan 29716327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 29726327eb98SAndrei Emeltchenko { 29736327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 29746327eb98SAndrei Emeltchenko } 29756327eb98SAndrei Emeltchenko 2976f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2977f89cef09SAndrei Emeltchenko { 2978f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2979f89cef09SAndrei Emeltchenko } 2980f89cef09SAndrei Emeltchenko 298136c86c85SMat Martineau static void __l2cap_set_ertm_timeouts(struct l2cap_chan *chan, 298236c86c85SMat Martineau struct l2cap_conf_rfc *rfc) 298336c86c85SMat Martineau { 298436c86c85SMat Martineau if (chan->local_amp_id && chan->hs_hcon) { 298536c86c85SMat Martineau u64 ertm_to = chan->hs_hcon->hdev->amp_be_flush_to; 298636c86c85SMat Martineau 298736c86c85SMat Martineau /* Class 1 devices have must have ERTM timeouts 298836c86c85SMat Martineau * exceeding the Link Supervision Timeout. The 298936c86c85SMat Martineau * default Link Supervision Timeout for AMP 299036c86c85SMat Martineau * controllers is 10 seconds. 299136c86c85SMat Martineau * 299236c86c85SMat Martineau * Class 1 devices use 0xffffffff for their 299336c86c85SMat Martineau * best-effort flush timeout, so the clamping logic 299436c86c85SMat Martineau * will result in a timeout that meets the above 299536c86c85SMat Martineau * requirement. ERTM timeouts are 16-bit values, so 299636c86c85SMat Martineau * the maximum timeout is 65.535 seconds. 299736c86c85SMat Martineau */ 299836c86c85SMat Martineau 299936c86c85SMat Martineau /* Convert timeout to milliseconds and round */ 300036c86c85SMat Martineau ertm_to = DIV_ROUND_UP_ULL(ertm_to, 1000); 300136c86c85SMat Martineau 300236c86c85SMat Martineau /* This is the recommended formula for class 2 devices 300336c86c85SMat Martineau * that start ERTM timers when packets are sent to the 300436c86c85SMat Martineau * controller. 300536c86c85SMat Martineau */ 300636c86c85SMat Martineau ertm_to = 3 * ertm_to + 500; 300736c86c85SMat Martineau 300836c86c85SMat Martineau if (ertm_to > 0xffff) 300936c86c85SMat Martineau ertm_to = 0xffff; 301036c86c85SMat Martineau 301136c86c85SMat Martineau rfc->retrans_timeout = cpu_to_le16((u16) ertm_to); 301236c86c85SMat Martineau rfc->monitor_timeout = rfc->retrans_timeout; 301336c86c85SMat Martineau } else { 301436c86c85SMat Martineau rfc->retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 301536c86c85SMat Martineau rfc->monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 301636c86c85SMat Martineau } 301736c86c85SMat Martineau } 301836c86c85SMat Martineau 30196327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 30206327eb98SAndrei Emeltchenko { 30216327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 3022836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 30236327eb98SAndrei Emeltchenko /* use extended control field */ 30246327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 3025836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 3026836be934SAndrei Emeltchenko } else { 30276327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 30286327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 3029836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 3030836be934SAndrei Emeltchenko } 3031c20f8e35SMat Martineau chan->ack_win = chan->tx_win; 30326327eb98SAndrei Emeltchenko } 30336327eb98SAndrei Emeltchenko 3034710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 30350a708f8fSGustavo F. Padovan { 30360a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 30370c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 30380a708f8fSGustavo F. Padovan void *ptr = req->data; 3039c8f79162SAndrei Emeltchenko u16 size; 30400a708f8fSGustavo F. Padovan 304149208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 30420a708f8fSGustavo F. Padovan 304373ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 30440a708f8fSGustavo F. Padovan goto done; 30450a708f8fSGustavo F. Padovan 30460c1bc5c6SGustavo F. Padovan switch (chan->mode) { 30470a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 30480a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3049c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 30500a708f8fSGustavo F. Padovan break; 30510a708f8fSGustavo F. Padovan 3052f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 3053f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 3054f89cef09SAndrei Emeltchenko 30550a708f8fSGustavo F. Padovan /* fall through */ 30560a708f8fSGustavo F. Padovan default: 30578c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 30580a708f8fSGustavo F. Padovan break; 30590a708f8fSGustavo F. Padovan } 30600a708f8fSGustavo F. Padovan 30610a708f8fSGustavo F. Padovan done: 30620c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 30630c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 30640a708f8fSGustavo F. Padovan 30650c1bc5c6SGustavo F. Padovan switch (chan->mode) { 30660a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 30678c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 30688c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 30690a708f8fSGustavo F. Padovan break; 30700a708f8fSGustavo F. Padovan 30710a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 30720a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 30730a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 30740a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 30750a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 30760a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 30770a708f8fSGustavo F. Padovan 30780a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 30790a708f8fSGustavo F. Padovan (unsigned long) &rfc); 30800a708f8fSGustavo F. Padovan break; 30810a708f8fSGustavo F. Padovan 30820a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30830a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 308447d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 308536c86c85SMat Martineau 308636c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 3087c8f79162SAndrei Emeltchenko 3088c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 30892d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3090c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3091c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 30920a708f8fSGustavo F. Padovan 30936327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 30946327eb98SAndrei Emeltchenko 30956327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 30966327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 30970a708f8fSGustavo F. Padovan 30980a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 30990a708f8fSGustavo F. Padovan (unsigned long) &rfc); 31000a708f8fSGustavo F. Padovan 3101f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3102f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3103f89cef09SAndrei Emeltchenko 31046327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 31056327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 31066327eb98SAndrei Emeltchenko chan->tx_win); 310760918918SAndrei Emeltchenko 310860918918SAndrei Emeltchenko if (chan->conn->feat_mask & L2CAP_FEAT_FCS) 310960918918SAndrei Emeltchenko if (chan->fcs == L2CAP_FCS_NONE || 3110f2592d3eSAndrei Emeltchenko test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) { 311160918918SAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 311260918918SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, 311360918918SAndrei Emeltchenko chan->fcs); 311460918918SAndrei Emeltchenko } 31150a708f8fSGustavo F. Padovan break; 31160a708f8fSGustavo F. Padovan 31170a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3118273759e2SMat Martineau l2cap_txwin_setup(chan); 31190a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 31200a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 31210a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 31220a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 31230a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 3124c8f79162SAndrei Emeltchenko 3125c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 31262d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3127c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3128c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 31290a708f8fSGustavo F. Padovan 31300a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 31310a708f8fSGustavo F. Padovan (unsigned long) &rfc); 31320a708f8fSGustavo F. Padovan 3133f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3134f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3135f89cef09SAndrei Emeltchenko 313660918918SAndrei Emeltchenko if (chan->conn->feat_mask & L2CAP_FEAT_FCS) 313747d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 3138f2592d3eSAndrei Emeltchenko test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) { 313947d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 314060918918SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, 314160918918SAndrei Emeltchenko chan->fcs); 31420a708f8fSGustavo F. Padovan } 31430a708f8fSGustavo F. Padovan break; 31440a708f8fSGustavo F. Padovan } 31450a708f8fSGustavo F. Padovan 3146fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 314759e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 31480a708f8fSGustavo F. Padovan 31490a708f8fSGustavo F. Padovan return ptr - data; 31500a708f8fSGustavo F. Padovan } 31510a708f8fSGustavo F. Padovan 315273ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 31530a708f8fSGustavo F. Padovan { 31540a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 31550a708f8fSGustavo F. Padovan void *ptr = rsp->data; 315673ffa904SGustavo F. Padovan void *req = chan->conf_req; 315773ffa904SGustavo F. Padovan int len = chan->conf_len; 31580a708f8fSGustavo F. Padovan int type, hint, olen; 31590a708f8fSGustavo F. Padovan unsigned long val; 31600a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 316142dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 316242dceae2SAndrei Emeltchenko u8 remote_efs = 0; 31630a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 31640a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 3165c8f79162SAndrei Emeltchenko u16 size; 31660a708f8fSGustavo F. Padovan 316773ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 31680a708f8fSGustavo F. Padovan 31690a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 31700a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 31710a708f8fSGustavo F. Padovan 31720a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 31730a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 31740a708f8fSGustavo F. Padovan 31750a708f8fSGustavo F. Padovan switch (type) { 31760a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 31770a708f8fSGustavo F. Padovan mtu = val; 31780a708f8fSGustavo F. Padovan break; 31790a708f8fSGustavo F. Padovan 31800a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 31810c1bc5c6SGustavo F. Padovan chan->flush_to = val; 31820a708f8fSGustavo F. Padovan break; 31830a708f8fSGustavo F. Padovan 31840a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 31850a708f8fSGustavo F. Padovan break; 31860a708f8fSGustavo F. Padovan 31870a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 31880a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 31890a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 31900a708f8fSGustavo F. Padovan break; 31910a708f8fSGustavo F. Padovan 31920a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 31930a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 3194f2592d3eSAndrei Emeltchenko set_bit(CONF_RECV_NO_FCS, &chan->conf_state); 319542dceae2SAndrei Emeltchenko break; 31960a708f8fSGustavo F. Padovan 319742dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 319842dceae2SAndrei Emeltchenko remote_efs = 1; 319942dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 320042dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 32010a708f8fSGustavo F. Padovan break; 32020a708f8fSGustavo F. Padovan 32036327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 32046327eb98SAndrei Emeltchenko if (!enable_hs) 32056327eb98SAndrei Emeltchenko return -ECONNREFUSED; 32066327eb98SAndrei Emeltchenko 32076327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 32086327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 3209836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 32106327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 32110a708f8fSGustavo F. Padovan break; 32120a708f8fSGustavo F. Padovan 32130a708f8fSGustavo F. Padovan default: 32140a708f8fSGustavo F. Padovan if (hint) 32150a708f8fSGustavo F. Padovan break; 32160a708f8fSGustavo F. Padovan 32170a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 32180a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 32190a708f8fSGustavo F. Padovan break; 32200a708f8fSGustavo F. Padovan } 32210a708f8fSGustavo F. Padovan } 32220a708f8fSGustavo F. Padovan 322373ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 32240a708f8fSGustavo F. Padovan goto done; 32250a708f8fSGustavo F. Padovan 32260c1bc5c6SGustavo F. Padovan switch (chan->mode) { 32270a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 32280a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3229c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 32300c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 32318c1d787bSGustavo F. Padovan chan->conn->feat_mask); 32320a708f8fSGustavo F. Padovan break; 32330a708f8fSGustavo F. Padovan } 32340a708f8fSGustavo F. Padovan 323542dceae2SAndrei Emeltchenko if (remote_efs) { 323642dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 323742dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 323842dceae2SAndrei Emeltchenko else 323942dceae2SAndrei Emeltchenko return -ECONNREFUSED; 324042dceae2SAndrei Emeltchenko } 324142dceae2SAndrei Emeltchenko 32420c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 32430a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32440a708f8fSGustavo F. Padovan 32450a708f8fSGustavo F. Padovan break; 32460a708f8fSGustavo F. Padovan } 32470a708f8fSGustavo F. Padovan 32480a708f8fSGustavo F. Padovan done: 32490c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 32500a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 32510c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 32520a708f8fSGustavo F. Padovan 325373ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 32540a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32550a708f8fSGustavo F. Padovan 32562d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 32572d792818SGustavo Padovan (unsigned long) &rfc); 32580a708f8fSGustavo F. Padovan } 32590a708f8fSGustavo F. Padovan 32600a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 32610a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 32620a708f8fSGustavo F. Padovan * which ones we don't like. */ 32630a708f8fSGustavo F. Padovan 32640a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 32650a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 32660a708f8fSGustavo F. Padovan else { 32670c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3268c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 32690a708f8fSGustavo F. Padovan } 32700c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 32710a708f8fSGustavo F. Padovan 327242dceae2SAndrei Emeltchenko if (remote_efs) { 327342dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 327442dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 327542dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 327642dceae2SAndrei Emeltchenko 327742dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 327842dceae2SAndrei Emeltchenko 327942dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 328042dceae2SAndrei Emeltchenko return -ECONNREFUSED; 328142dceae2SAndrei Emeltchenko 328242dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 328342dceae2SAndrei Emeltchenko sizeof(efs), 328442dceae2SAndrei Emeltchenko (unsigned long) &efs); 32850e8b207eSAndrei Emeltchenko } else { 32863e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 32870e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 32880e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 328942dceae2SAndrei Emeltchenko } 329042dceae2SAndrei Emeltchenko } 329142dceae2SAndrei Emeltchenko 32920a708f8fSGustavo F. Padovan switch (rfc.mode) { 32930a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 329447d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3295c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 32960a708f8fSGustavo F. Padovan break; 32970a708f8fSGustavo F. Padovan 32980a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 32996327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 33002c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 33016327eb98SAndrei Emeltchenko else 33026327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 33036327eb98SAndrei Emeltchenko 33042c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 33050a708f8fSGustavo F. Padovan 3306c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 33072d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 33082d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3309c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3310c8f79162SAndrei Emeltchenko chan->remote_mps = size; 33110a708f8fSGustavo F. Padovan 331236c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 33130a708f8fSGustavo F. Padovan 3314c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 33150a708f8fSGustavo F. Padovan 33160a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 33170a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 33180a708f8fSGustavo F. Padovan 331942dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 332042dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 332142dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 332242dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 332342dceae2SAndrei Emeltchenko chan->remote_flush_to = 332442dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 332542dceae2SAndrei Emeltchenko chan->remote_acc_lat = 332642dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 332742dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 332842dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 332942dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 33302d792818SGustavo Padovan sizeof(efs), 33312d792818SGustavo Padovan (unsigned long) &efs); 333242dceae2SAndrei Emeltchenko } 33330a708f8fSGustavo F. Padovan break; 33340a708f8fSGustavo F. Padovan 33350a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3336c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 33372d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 33382d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3339c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3340c8f79162SAndrei Emeltchenko chan->remote_mps = size; 33410a708f8fSGustavo F. Padovan 3342c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 33430a708f8fSGustavo F. Padovan 33442d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 33452d792818SGustavo Padovan (unsigned long) &rfc); 33460a708f8fSGustavo F. Padovan 33470a708f8fSGustavo F. Padovan break; 33480a708f8fSGustavo F. Padovan 33490a708f8fSGustavo F. Padovan default: 33500a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 33510a708f8fSGustavo F. Padovan 33520a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 33530c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 33540a708f8fSGustavo F. Padovan } 33550a708f8fSGustavo F. Padovan 33560a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3357c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 33580a708f8fSGustavo F. Padovan } 3359fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 33600a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 336159e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 33620a708f8fSGustavo F. Padovan 33630a708f8fSGustavo F. Padovan return ptr - data; 33640a708f8fSGustavo F. Padovan } 33650a708f8fSGustavo F. Padovan 33662d792818SGustavo Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, 33672d792818SGustavo Padovan void *data, u16 *result) 33680a708f8fSGustavo F. Padovan { 33690a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 33700a708f8fSGustavo F. Padovan void *ptr = req->data; 33710a708f8fSGustavo F. Padovan int type, olen; 33720a708f8fSGustavo F. Padovan unsigned long val; 337336e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 337466af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 33750a708f8fSGustavo F. Padovan 3376fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 33770a708f8fSGustavo F. Padovan 33780a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 33790a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 33800a708f8fSGustavo F. Padovan 33810a708f8fSGustavo F. Padovan switch (type) { 33820a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 33830a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 33840a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 33850c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 33860a708f8fSGustavo F. Padovan } else 33870c1bc5c6SGustavo F. Padovan chan->imtu = val; 33880c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 33890a708f8fSGustavo F. Padovan break; 33900a708f8fSGustavo F. Padovan 33910a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 33920c1bc5c6SGustavo F. Padovan chan->flush_to = val; 33930a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 33940c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 33950a708f8fSGustavo F. Padovan break; 33960a708f8fSGustavo F. Padovan 33970a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 33980a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 33990a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 34000a708f8fSGustavo F. Padovan 3401c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 34020c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 34030a708f8fSGustavo F. Padovan return -ECONNREFUSED; 34040a708f8fSGustavo F. Padovan 340547d1ec61SGustavo F. Padovan chan->fcs = 0; 34060a708f8fSGustavo F. Padovan 34070a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 34080a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 34090a708f8fSGustavo F. Padovan break; 34106327eb98SAndrei Emeltchenko 34116327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 3412c20f8e35SMat Martineau chan->ack_win = min_t(u16, val, chan->ack_win); 34133e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 34143e6b3b95SGustavo F. Padovan chan->tx_win); 34156327eb98SAndrei Emeltchenko break; 341666af7aafSAndrei Emeltchenko 341766af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 341866af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 341966af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 342066af7aafSAndrei Emeltchenko 342166af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 342266af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 342366af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 342466af7aafSAndrei Emeltchenko return -ECONNREFUSED; 342566af7aafSAndrei Emeltchenko 34262d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, sizeof(efs), 34272d792818SGustavo Padovan (unsigned long) &efs); 342866af7aafSAndrei Emeltchenko break; 3429cbabee78SAndrei Emeltchenko 3430cbabee78SAndrei Emeltchenko case L2CAP_CONF_FCS: 3431cbabee78SAndrei Emeltchenko if (*result == L2CAP_CONF_PENDING) 3432cbabee78SAndrei Emeltchenko if (val == L2CAP_FCS_NONE) 3433f2592d3eSAndrei Emeltchenko set_bit(CONF_RECV_NO_FCS, 3434cbabee78SAndrei Emeltchenko &chan->conf_state); 3435cbabee78SAndrei Emeltchenko break; 34360a708f8fSGustavo F. Padovan } 34370a708f8fSGustavo F. Padovan } 34380a708f8fSGustavo F. Padovan 34390c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 34400a708f8fSGustavo F. Padovan return -ECONNREFUSED; 34410a708f8fSGustavo F. Padovan 34420c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 34430a708f8fSGustavo F. Padovan 34440e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 34450a708f8fSGustavo F. Padovan switch (rfc.mode) { 34460a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 344747d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 344847d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 344947d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3450c20f8e35SMat Martineau if (!test_bit(FLAG_EXT_CTRL, &chan->flags)) 3451c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3452c20f8e35SMat Martineau rfc.txwin_size); 345366af7aafSAndrei Emeltchenko 345466af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 345566af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 345666af7aafSAndrei Emeltchenko chan->local_sdu_itime = 345766af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 345866af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 345966af7aafSAndrei Emeltchenko chan->local_flush_to = 346066af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 346166af7aafSAndrei Emeltchenko } 34620a708f8fSGustavo F. Padovan break; 346366af7aafSAndrei Emeltchenko 34640a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 346547d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 34660a708f8fSGustavo F. Padovan } 34670a708f8fSGustavo F. Padovan } 34680a708f8fSGustavo F. Padovan 3469fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 347059e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 34710a708f8fSGustavo F. Padovan 34720a708f8fSGustavo F. Padovan return ptr - data; 34730a708f8fSGustavo F. Padovan } 34740a708f8fSGustavo F. Padovan 34752d792818SGustavo Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, 34762d792818SGustavo Padovan u16 result, u16 flags) 34770a708f8fSGustavo F. Padovan { 34780a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 34790a708f8fSGustavo F. Padovan void *ptr = rsp->data; 34800a708f8fSGustavo F. Padovan 3481fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 34820a708f8fSGustavo F. Padovan 3483fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 34840a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 34850a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 34860a708f8fSGustavo F. Padovan 34870a708f8fSGustavo F. Padovan return ptr - data; 34880a708f8fSGustavo F. Padovan } 34890a708f8fSGustavo F. Padovan 34908c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3491710f9b0aSGustavo F. Padovan { 3492710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 34938c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3494710f9b0aSGustavo F. Padovan u8 buf[128]; 3495439f34acSAndrei Emeltchenko u8 rsp_code; 3496710f9b0aSGustavo F. Padovan 3497fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3498fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3499ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3500ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3501439f34acSAndrei Emeltchenko 3502439f34acSAndrei Emeltchenko if (chan->hs_hcon) 3503439f34acSAndrei Emeltchenko rsp_code = L2CAP_CREATE_CHAN_RSP; 3504439f34acSAndrei Emeltchenko else 3505439f34acSAndrei Emeltchenko rsp_code = L2CAP_CONN_RSP; 3506439f34acSAndrei Emeltchenko 3507439f34acSAndrei Emeltchenko BT_DBG("chan %p rsp_code %u", chan, rsp_code); 3508439f34acSAndrei Emeltchenko 3509439f34acSAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, rsp_code, sizeof(rsp), &rsp); 3510710f9b0aSGustavo F. Padovan 3511c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3512710f9b0aSGustavo F. Padovan return; 3513710f9b0aSGustavo F. Padovan 3514710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3515710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3516710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3517710f9b0aSGustavo F. Padovan } 3518710f9b0aSGustavo F. Padovan 351947d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 35200a708f8fSGustavo F. Padovan { 35210a708f8fSGustavo F. Padovan int type, olen; 35220a708f8fSGustavo F. Padovan unsigned long val; 3523c20f8e35SMat Martineau /* Use sane default values in case a misbehaving remote device 3524c20f8e35SMat Martineau * did not send an RFC or extended window size option. 3525c20f8e35SMat Martineau */ 3526c20f8e35SMat Martineau u16 txwin_ext = chan->ack_win; 3527c20f8e35SMat Martineau struct l2cap_conf_rfc rfc = { 3528c20f8e35SMat Martineau .mode = chan->mode, 3529c20f8e35SMat Martineau .retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO), 3530c20f8e35SMat Martineau .monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO), 3531c20f8e35SMat Martineau .max_pdu_size = cpu_to_le16(chan->imtu), 3532c20f8e35SMat Martineau .txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW), 3533c20f8e35SMat Martineau }; 35340a708f8fSGustavo F. Padovan 353547d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 35360a708f8fSGustavo F. Padovan 35370c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 35380a708f8fSGustavo F. Padovan return; 35390a708f8fSGustavo F. Padovan 35400a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 35410a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 35420a708f8fSGustavo F. Padovan 3543c20f8e35SMat Martineau switch (type) { 3544c20f8e35SMat Martineau case L2CAP_CONF_RFC: 3545c20f8e35SMat Martineau if (olen == sizeof(rfc)) 35460a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 3547c20f8e35SMat Martineau break; 3548c20f8e35SMat Martineau case L2CAP_CONF_EWS: 3549c20f8e35SMat Martineau txwin_ext = val; 3550c20f8e35SMat Martineau break; 3551c20f8e35SMat Martineau } 35520a708f8fSGustavo F. Padovan } 35530a708f8fSGustavo F. Padovan 35540a708f8fSGustavo F. Padovan switch (rfc.mode) { 35550a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 355647d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 355747d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 355847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3559c20f8e35SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 3560c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, txwin_ext); 3561c20f8e35SMat Martineau else 3562c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3563c20f8e35SMat Martineau rfc.txwin_size); 35640a708f8fSGustavo F. Padovan break; 35650a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 356647d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 35670a708f8fSGustavo F. Padovan } 35680a708f8fSGustavo F. Padovan } 35690a708f8fSGustavo F. Padovan 35702d792818SGustavo Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, 35712d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 35720a708f8fSGustavo F. Padovan { 3573e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 35740a708f8fSGustavo F. Padovan 3575e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 35760a708f8fSGustavo F. Padovan return 0; 35770a708f8fSGustavo F. Padovan 35780a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 35790a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 358017cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 35810a708f8fSGustavo F. Padovan 35820a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 35830a708f8fSGustavo F. Padovan conn->info_ident = 0; 35840a708f8fSGustavo F. Padovan 35850a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 35860a708f8fSGustavo F. Padovan } 35870a708f8fSGustavo F. Padovan 35880a708f8fSGustavo F. Padovan return 0; 35890a708f8fSGustavo F. Padovan } 35900a708f8fSGustavo F. Padovan 35911700915fSMat Martineau static struct l2cap_chan *l2cap_connect(struct l2cap_conn *conn, 35921700915fSMat Martineau struct l2cap_cmd_hdr *cmd, 35934c89b6aaSMat Martineau u8 *data, u8 rsp_code, u8 amp_id) 35940a708f8fSGustavo F. Padovan { 35950a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 35960a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 359723691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 35980a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 35990a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 36000a708f8fSGustavo F. Padovan 36010a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 36020a708f8fSGustavo F. Padovan __le16 psm = req->psm; 36030a708f8fSGustavo F. Padovan 3604097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 36050a708f8fSGustavo F. Padovan 36060a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3607c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 360823691d75SGustavo F. Padovan if (!pchan) { 36090a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 36100a708f8fSGustavo F. Padovan goto sendresp; 36110a708f8fSGustavo F. Padovan } 36120a708f8fSGustavo F. Padovan 361323691d75SGustavo F. Padovan parent = pchan->sk; 361423691d75SGustavo F. Padovan 36153df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3616aa2ac881SGustavo F. Padovan lock_sock(parent); 36170a708f8fSGustavo F. Padovan 36180a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 36192983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 36200a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 36219f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 36220a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 36230a708f8fSGustavo F. Padovan goto response; 36240a708f8fSGustavo F. Padovan } 36250a708f8fSGustavo F. Padovan 36260a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 36270a708f8fSGustavo F. Padovan 36282dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 36292dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 36302dfa1003SGustavo Padovan goto response; 36312dfa1003SGustavo Padovan 363280b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 363380808e43SGustavo F. Padovan if (!chan) 36340a708f8fSGustavo F. Padovan goto response; 36350a708f8fSGustavo F. Padovan 363680808e43SGustavo F. Padovan sk = chan->sk; 363780808e43SGustavo F. Padovan 36380a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 36390a708f8fSGustavo F. Padovan 36400a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 36410a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3642fe4128e0SGustavo F. Padovan chan->psm = psm; 3643fe4128e0SGustavo F. Padovan chan->dcid = scid; 36441700915fSMat Martineau chan->local_amp_id = amp_id; 36450a708f8fSGustavo F. Padovan 36466be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 364748454079SGustavo F. Padovan 3648fe4128e0SGustavo F. Padovan dcid = chan->scid; 36490a708f8fSGustavo F. Padovan 3650c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 36510a708f8fSGustavo F. Padovan 3652fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 36530a708f8fSGustavo F. Padovan 36540a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3655d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3656c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 36570e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 36580a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 36590a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 36602dc4e510SGustavo Padovan chan->ops->defer(chan); 36610a708f8fSGustavo F. Padovan } else { 36621700915fSMat Martineau /* Force pending result for AMP controllers. 36631700915fSMat Martineau * The connection will succeed after the 36641700915fSMat Martineau * physical link is up. 36651700915fSMat Martineau */ 36661700915fSMat Martineau if (amp_id) { 36671700915fSMat Martineau __l2cap_state_change(chan, BT_CONNECT2); 36681700915fSMat Martineau result = L2CAP_CR_PEND; 36691700915fSMat Martineau } else { 36700e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 36710a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 36721700915fSMat Martineau } 36730a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 36740a708f8fSGustavo F. Padovan } 36750a708f8fSGustavo F. Padovan } else { 36760e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 36770a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 36780a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 36790a708f8fSGustavo F. Padovan } 36800a708f8fSGustavo F. Padovan } else { 36810e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 36820a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 36830a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 36840a708f8fSGustavo F. Padovan } 36850a708f8fSGustavo F. Padovan 36860a708f8fSGustavo F. Padovan response: 3687aa2ac881SGustavo F. Padovan release_sock(parent); 36883df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 36890a708f8fSGustavo F. Padovan 36900a708f8fSGustavo F. Padovan sendresp: 36910a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 36920a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 36930a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 36940a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 36954c89b6aaSMat Martineau l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp); 36960a708f8fSGustavo F. Padovan 36970a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 36980a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3699ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 37000a708f8fSGustavo F. Padovan 37010a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 37020a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 37030a708f8fSGustavo F. Padovan 3704ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 37050a708f8fSGustavo F. Padovan 37062d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 37072d792818SGustavo Padovan sizeof(info), &info); 37080a708f8fSGustavo F. Padovan } 37090a708f8fSGustavo F. Padovan 3710c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 37110a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 37120a708f8fSGustavo F. Padovan u8 buf[128]; 3713c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 37140a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 371573ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 371673ffa904SGustavo F. Padovan chan->num_conf_req++; 37170a708f8fSGustavo F. Padovan } 37181700915fSMat Martineau 37191700915fSMat Martineau return chan; 37204c89b6aaSMat Martineau } 37210a708f8fSGustavo F. Padovan 37224c89b6aaSMat Martineau static int l2cap_connect_req(struct l2cap_conn *conn, 37234c89b6aaSMat Martineau struct l2cap_cmd_hdr *cmd, u8 *data) 37244c89b6aaSMat Martineau { 37257b064edaSJaganath Kanakkassery struct hci_dev *hdev = conn->hcon->hdev; 37267b064edaSJaganath Kanakkassery struct hci_conn *hcon = conn->hcon; 37277b064edaSJaganath Kanakkassery 37287b064edaSJaganath Kanakkassery hci_dev_lock(hdev); 37297b064edaSJaganath Kanakkassery if (test_bit(HCI_MGMT, &hdev->dev_flags) && 37307b064edaSJaganath Kanakkassery !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &hcon->flags)) 37317b064edaSJaganath Kanakkassery mgmt_device_connected(hdev, &hcon->dst, hcon->type, 37327b064edaSJaganath Kanakkassery hcon->dst_type, 0, NULL, 0, 37337b064edaSJaganath Kanakkassery hcon->dev_class); 37347b064edaSJaganath Kanakkassery hci_dev_unlock(hdev); 37357b064edaSJaganath Kanakkassery 3736300229f9SGustavo Padovan l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP, 0); 37370a708f8fSGustavo F. Padovan return 0; 37380a708f8fSGustavo F. Padovan } 37390a708f8fSGustavo F. Padovan 37405909cf30SMat Martineau static int l2cap_connect_create_rsp(struct l2cap_conn *conn, 37412d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 37420a708f8fSGustavo F. Padovan { 37430a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 37440a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 374548454079SGustavo F. Padovan struct l2cap_chan *chan; 37460a708f8fSGustavo F. Padovan u8 req[128]; 37473df91ea2SAndrei Emeltchenko int err; 37480a708f8fSGustavo F. Padovan 37490a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 37500a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 37510a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 37520a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 37530a708f8fSGustavo F. Padovan 37541b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 37551b009c98SAndrei Emeltchenko dcid, scid, result, status); 37560a708f8fSGustavo F. Padovan 37573df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37583df91ea2SAndrei Emeltchenko 37590a708f8fSGustavo F. Padovan if (scid) { 37603df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 37613df91ea2SAndrei Emeltchenko if (!chan) { 37623df91ea2SAndrei Emeltchenko err = -EFAULT; 37633df91ea2SAndrei Emeltchenko goto unlock; 37643df91ea2SAndrei Emeltchenko } 37650a708f8fSGustavo F. Padovan } else { 37663df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 37673df91ea2SAndrei Emeltchenko if (!chan) { 37683df91ea2SAndrei Emeltchenko err = -EFAULT; 37693df91ea2SAndrei Emeltchenko goto unlock; 37703df91ea2SAndrei Emeltchenko } 37710a708f8fSGustavo F. Padovan } 37720a708f8fSGustavo F. Padovan 37733df91ea2SAndrei Emeltchenko err = 0; 37743df91ea2SAndrei Emeltchenko 37756be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 377648454079SGustavo F. Padovan 37770a708f8fSGustavo F. Padovan switch (result) { 37780a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 377989bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3780fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3781fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3782c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 37830a708f8fSGustavo F. Padovan 3784c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 37850a708f8fSGustavo F. Padovan break; 37860a708f8fSGustavo F. Padovan 37870a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 378873ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 378973ffa904SGustavo F. Padovan chan->num_conf_req++; 37900a708f8fSGustavo F. Padovan break; 37910a708f8fSGustavo F. Padovan 37920a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3793c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 37940a708f8fSGustavo F. Padovan break; 37950a708f8fSGustavo F. Padovan 37960a708f8fSGustavo F. Padovan default: 379748454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 37980a708f8fSGustavo F. Padovan break; 37990a708f8fSGustavo F. Padovan } 38000a708f8fSGustavo F. Padovan 38016be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 38023df91ea2SAndrei Emeltchenko 38033df91ea2SAndrei Emeltchenko unlock: 38043df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38053df91ea2SAndrei Emeltchenko 38063df91ea2SAndrei Emeltchenko return err; 38070a708f8fSGustavo F. Padovan } 38080a708f8fSGustavo F. Padovan 380947d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 38100a708f8fSGustavo F. Padovan { 38110a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 38120a708f8fSGustavo F. Padovan * sides request it. 38130a708f8fSGustavo F. Padovan */ 38140c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 381547d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3816f2592d3eSAndrei Emeltchenko else if (!test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) 381747d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 38180a708f8fSGustavo F. Padovan } 38190a708f8fSGustavo F. Padovan 382029d8a590SAndrei Emeltchenko static void l2cap_send_efs_conf_rsp(struct l2cap_chan *chan, void *data, 382129d8a590SAndrei Emeltchenko u8 ident, u16 flags) 382229d8a590SAndrei Emeltchenko { 382329d8a590SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 382429d8a590SAndrei Emeltchenko 382529d8a590SAndrei Emeltchenko BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident, 382629d8a590SAndrei Emeltchenko flags); 382729d8a590SAndrei Emeltchenko 382829d8a590SAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 382929d8a590SAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 383029d8a590SAndrei Emeltchenko 383129d8a590SAndrei Emeltchenko l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP, 383229d8a590SAndrei Emeltchenko l2cap_build_conf_rsp(chan, data, 383329d8a590SAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), data); 383429d8a590SAndrei Emeltchenko } 383529d8a590SAndrei Emeltchenko 38362d792818SGustavo Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, 38372d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 38382d792818SGustavo Padovan u8 *data) 38390a708f8fSGustavo F. Padovan { 38400a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 38410a708f8fSGustavo F. Padovan u16 dcid, flags; 38420a708f8fSGustavo F. Padovan u8 rsp[64]; 384348454079SGustavo F. Padovan struct l2cap_chan *chan; 38443c588192SMat Martineau int len, err = 0; 38450a708f8fSGustavo F. Padovan 38460a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 38470a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 38480a708f8fSGustavo F. Padovan 38490a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 38500a708f8fSGustavo F. Padovan 3851baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 385248454079SGustavo F. Padovan if (!chan) 38530a708f8fSGustavo F. Padovan return -ENOENT; 38540a708f8fSGustavo F. Padovan 3855033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3856e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 38570a708f8fSGustavo F. Padovan 3858ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3859e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3860e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3861e2fd318eSIlia Kolomisnky 38620a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 38630a708f8fSGustavo F. Padovan sizeof(rej), &rej); 38640a708f8fSGustavo F. Padovan goto unlock; 38650a708f8fSGustavo F. Padovan } 38660a708f8fSGustavo F. Padovan 38670a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 38680a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 38697ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 38700a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3871fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 38720a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 38730a708f8fSGustavo F. Padovan goto unlock; 38740a708f8fSGustavo F. Padovan } 38750a708f8fSGustavo F. Padovan 38760a708f8fSGustavo F. Padovan /* Store config. */ 387773ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 387873ffa904SGustavo F. Padovan chan->conf_len += len; 38790a708f8fSGustavo F. Padovan 388059e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 38810a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 38820a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3883fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 38845325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 38850a708f8fSGustavo F. Padovan goto unlock; 38860a708f8fSGustavo F. Padovan } 38870a708f8fSGustavo F. Padovan 38880a708f8fSGustavo F. Padovan /* Complete config. */ 388973ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 38900a708f8fSGustavo F. Padovan if (len < 0) { 38915e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 38920a708f8fSGustavo F. Padovan goto unlock; 38930a708f8fSGustavo F. Padovan } 38940a708f8fSGustavo F. Padovan 38951500109bSMat Martineau chan->ident = cmd->ident; 38960a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 389773ffa904SGustavo F. Padovan chan->num_conf_rsp++; 38980a708f8fSGustavo F. Padovan 38990a708f8fSGustavo F. Padovan /* Reset config buffer. */ 390073ffa904SGustavo F. Padovan chan->conf_len = 0; 39010a708f8fSGustavo F. Padovan 3902c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 39030a708f8fSGustavo F. Padovan goto unlock; 39040a708f8fSGustavo F. Padovan 3905c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 390647d1ec61SGustavo F. Padovan set_default_fcs(chan); 39070a708f8fSGustavo F. Padovan 3908105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3909105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 39103c588192SMat Martineau err = l2cap_ertm_init(chan); 39110a708f8fSGustavo F. Padovan 39123c588192SMat Martineau if (err < 0) 39135e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 39143c588192SMat Martineau else 3915cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 39163c588192SMat Martineau 39170a708f8fSGustavo F. Padovan goto unlock; 39180a708f8fSGustavo F. Padovan } 39190a708f8fSGustavo F. Padovan 3920c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 39210a708f8fSGustavo F. Padovan u8 buf[64]; 39220a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 392373ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 392473ffa904SGustavo F. Padovan chan->num_conf_req++; 39250a708f8fSGustavo F. Padovan } 39260a708f8fSGustavo F. Padovan 39270e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 39280e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 39290e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 39300e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 39310e8b207eSAndrei Emeltchenko 39320e8b207eSAndrei Emeltchenko /* check compatibility */ 39330e8b207eSAndrei Emeltchenko 393479de886dSAndrei Emeltchenko /* Send rsp for BR/EDR channel */ 3935f351bc72SAndrei Emeltchenko if (!chan->hs_hcon) 393629d8a590SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, rsp, cmd->ident, flags); 393779de886dSAndrei Emeltchenko else 393879de886dSAndrei Emeltchenko chan->ident = cmd->ident; 39390e8b207eSAndrei Emeltchenko } 39400e8b207eSAndrei Emeltchenko 39410a708f8fSGustavo F. Padovan unlock: 39426be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39433c588192SMat Martineau return err; 39440a708f8fSGustavo F. Padovan } 39450a708f8fSGustavo F. Padovan 39462d792818SGustavo Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, 39472d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39480a708f8fSGustavo F. Padovan { 39490a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 39500a708f8fSGustavo F. Padovan u16 scid, flags, result; 395148454079SGustavo F. Padovan struct l2cap_chan *chan; 395261386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 39533c588192SMat Martineau int err = 0; 39540a708f8fSGustavo F. Padovan 39550a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 39560a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 39570a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 39580a708f8fSGustavo F. Padovan 395961386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 396061386cbaSAndrei Emeltchenko result, len); 39610a708f8fSGustavo F. Padovan 3962baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 396348454079SGustavo F. Padovan if (!chan) 39640a708f8fSGustavo F. Padovan return 0; 39650a708f8fSGustavo F. Padovan 39660a708f8fSGustavo F. Padovan switch (result) { 39670a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 396847d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 39690e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 39700a708f8fSGustavo F. Padovan break; 39710a708f8fSGustavo F. Padovan 39720e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 39730e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 39740e8b207eSAndrei Emeltchenko 39750e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 39760e8b207eSAndrei Emeltchenko char buf[64]; 39770e8b207eSAndrei Emeltchenko 39780e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 39790e8b207eSAndrei Emeltchenko buf, &result); 39800e8b207eSAndrei Emeltchenko if (len < 0) { 39815e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 39820e8b207eSAndrei Emeltchenko goto done; 39830e8b207eSAndrei Emeltchenko } 39840e8b207eSAndrei Emeltchenko 3985f351bc72SAndrei Emeltchenko if (!chan->hs_hcon) { 398679de886dSAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, buf, cmd->ident, 398779de886dSAndrei Emeltchenko 0); 39885ce66b59SAndrei Emeltchenko } else { 39895ce66b59SAndrei Emeltchenko if (l2cap_check_efs(chan)) { 39905ce66b59SAndrei Emeltchenko amp_create_logical_link(chan); 399179de886dSAndrei Emeltchenko chan->ident = cmd->ident; 39920e8b207eSAndrei Emeltchenko } 39935ce66b59SAndrei Emeltchenko } 39945ce66b59SAndrei Emeltchenko } 39950e8b207eSAndrei Emeltchenko goto done; 39960e8b207eSAndrei Emeltchenko 39970a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 399873ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 39990a708f8fSGustavo F. Padovan char req[64]; 40000a708f8fSGustavo F. Padovan 40010a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 40025e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 40030a708f8fSGustavo F. Padovan goto done; 40040a708f8fSGustavo F. Padovan } 40050a708f8fSGustavo F. Padovan 40060a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 40070a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 4008b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 4009b4450035SGustavo F. Padovan req, &result); 40100a708f8fSGustavo F. Padovan if (len < 0) { 40115e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 40120a708f8fSGustavo F. Padovan goto done; 40130a708f8fSGustavo F. Padovan } 40140a708f8fSGustavo F. Padovan 40150a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 40160a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 401773ffa904SGustavo F. Padovan chan->num_conf_req++; 40180a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 40190a708f8fSGustavo F. Padovan goto done; 40200a708f8fSGustavo F. Padovan break; 40210a708f8fSGustavo F. Padovan } 40220a708f8fSGustavo F. Padovan 40230a708f8fSGustavo F. Padovan default: 40246be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 40252e0052e4SAndrei Emeltchenko 4026ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 40275e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 40280a708f8fSGustavo F. Padovan goto done; 40290a708f8fSGustavo F. Padovan } 40300a708f8fSGustavo F. Padovan 403159e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 40320a708f8fSGustavo F. Padovan goto done; 40330a708f8fSGustavo F. Padovan 4034c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 40350a708f8fSGustavo F. Padovan 4036c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 403747d1ec61SGustavo F. Padovan set_default_fcs(chan); 40380a708f8fSGustavo F. Padovan 4039105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 4040105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 40413c588192SMat Martineau err = l2cap_ertm_init(chan); 40420a708f8fSGustavo F. Padovan 40433c588192SMat Martineau if (err < 0) 40445e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 40453c588192SMat Martineau else 4046cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 40470a708f8fSGustavo F. Padovan } 40480a708f8fSGustavo F. Padovan 40490a708f8fSGustavo F. Padovan done: 40506be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 40513c588192SMat Martineau return err; 40520a708f8fSGustavo F. Padovan } 40530a708f8fSGustavo F. Padovan 40542d792818SGustavo Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, 40552d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 40560a708f8fSGustavo F. Padovan { 40570a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 40580a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 40590a708f8fSGustavo F. Padovan u16 dcid, scid; 406048454079SGustavo F. Padovan struct l2cap_chan *chan; 40610a708f8fSGustavo F. Padovan struct sock *sk; 40620a708f8fSGustavo F. Padovan 40630a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 40640a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 40650a708f8fSGustavo F. Padovan 40660a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 40670a708f8fSGustavo F. Padovan 40683df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 40693df91ea2SAndrei Emeltchenko 40703df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 40713df91ea2SAndrei Emeltchenko if (!chan) { 40723df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 40730a708f8fSGustavo F. Padovan return 0; 40743df91ea2SAndrei Emeltchenko } 40750a708f8fSGustavo F. Padovan 40766be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 40776be36555SAndrei Emeltchenko 407848454079SGustavo F. Padovan sk = chan->sk; 407948454079SGustavo F. Padovan 4080fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 4081fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 40820a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 40830a708f8fSGustavo F. Padovan 40846be36555SAndrei Emeltchenko lock_sock(sk); 40850a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 40866be36555SAndrei Emeltchenko release_sock(sk); 40870a708f8fSGustavo F. Padovan 408861d6ef3eSMat Martineau l2cap_chan_hold(chan); 408948454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 40906be36555SAndrei Emeltchenko 40916be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 40920a708f8fSGustavo F. Padovan 409380b98027SGustavo Padovan chan->ops->close(chan); 409461d6ef3eSMat Martineau l2cap_chan_put(chan); 40953df91ea2SAndrei Emeltchenko 40963df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 40973df91ea2SAndrei Emeltchenko 40980a708f8fSGustavo F. Padovan return 0; 40990a708f8fSGustavo F. Padovan } 41000a708f8fSGustavo F. Padovan 41012d792818SGustavo Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, 41022d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 41030a708f8fSGustavo F. Padovan { 41040a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 41050a708f8fSGustavo F. Padovan u16 dcid, scid; 410648454079SGustavo F. Padovan struct l2cap_chan *chan; 41070a708f8fSGustavo F. Padovan 41080a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 41090a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 41100a708f8fSGustavo F. Padovan 41110a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 41120a708f8fSGustavo F. Padovan 41133df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 41143df91ea2SAndrei Emeltchenko 41153df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 41163df91ea2SAndrei Emeltchenko if (!chan) { 41173df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 41180a708f8fSGustavo F. Padovan return 0; 41193df91ea2SAndrei Emeltchenko } 41200a708f8fSGustavo F. Padovan 41216be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 412248454079SGustavo F. Padovan 412361d6ef3eSMat Martineau l2cap_chan_hold(chan); 412448454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 41256be36555SAndrei Emeltchenko 41266be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 41270a708f8fSGustavo F. Padovan 412880b98027SGustavo Padovan chan->ops->close(chan); 412961d6ef3eSMat Martineau l2cap_chan_put(chan); 41303df91ea2SAndrei Emeltchenko 41313df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 41323df91ea2SAndrei Emeltchenko 41330a708f8fSGustavo F. Padovan return 0; 41340a708f8fSGustavo F. Padovan } 41350a708f8fSGustavo F. Padovan 41362d792818SGustavo Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, 41372d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 41380a708f8fSGustavo F. Padovan { 41390a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 41400a708f8fSGustavo F. Padovan u16 type; 41410a708f8fSGustavo F. Padovan 41420a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 41430a708f8fSGustavo F. Padovan 41440a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 41450a708f8fSGustavo F. Padovan 41460a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 41470a708f8fSGustavo F. Padovan u8 buf[8]; 41480a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 41490a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 4150ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 4151ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 41520a708f8fSGustavo F. Padovan if (!disable_ertm) 41530a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 41540a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 4155a5fd6f30SAndrei Emeltchenko if (enable_hs) 41566327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 41576327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 4158a5fd6f30SAndrei Emeltchenko 41590a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 41602d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 41612d792818SGustavo Padovan buf); 41620a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 41630a708f8fSGustavo F. Padovan u8 buf[12]; 41640a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 416550a147cdSMat Martineau 416650a147cdSMat Martineau if (enable_hs) 416750a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 416850a147cdSMat Martineau else 416950a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 417050a147cdSMat Martineau 4171ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 4172ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 4173c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 41742d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 41752d792818SGustavo Padovan buf); 41760a708f8fSGustavo F. Padovan } else { 41770a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 41780a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 4179ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 41802d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), 41812d792818SGustavo Padovan &rsp); 41820a708f8fSGustavo F. Padovan } 41830a708f8fSGustavo F. Padovan 41840a708f8fSGustavo F. Padovan return 0; 41850a708f8fSGustavo F. Padovan } 41860a708f8fSGustavo F. Padovan 41872d792818SGustavo Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, 41882d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 41890a708f8fSGustavo F. Padovan { 41900a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 41910a708f8fSGustavo F. Padovan u16 type, result; 41920a708f8fSGustavo F. Padovan 41930a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 41940a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 41950a708f8fSGustavo F. Padovan 41960a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 41970a708f8fSGustavo F. Padovan 4198e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 4199e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 4200e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 4201e90165beSAndrei Emeltchenko return 0; 4202e90165beSAndrei Emeltchenko 420317cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 42040a708f8fSGustavo F. Padovan 42050a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 42060a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 42070a708f8fSGustavo F. Padovan conn->info_ident = 0; 42080a708f8fSGustavo F. Padovan 42090a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 42100a708f8fSGustavo F. Padovan 42110a708f8fSGustavo F. Padovan return 0; 42120a708f8fSGustavo F. Padovan } 42130a708f8fSGustavo F. Padovan 4214978c93b9SAndrei Emeltchenko switch (type) { 4215978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 42160a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 42170a708f8fSGustavo F. Padovan 42180a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 42190a708f8fSGustavo F. Padovan struct l2cap_info_req req; 4220ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 42210a708f8fSGustavo F. Padovan 42220a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 42230a708f8fSGustavo F. Padovan 42240a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 42250a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 42260a708f8fSGustavo F. Padovan } else { 42270a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 42280a708f8fSGustavo F. Padovan conn->info_ident = 0; 42290a708f8fSGustavo F. Padovan 42300a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 42310a708f8fSGustavo F. Padovan } 4232978c93b9SAndrei Emeltchenko break; 4233978c93b9SAndrei Emeltchenko 4234978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 4235978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 42360a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 42370a708f8fSGustavo F. Padovan conn->info_ident = 0; 42380a708f8fSGustavo F. Padovan 42390a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 4240978c93b9SAndrei Emeltchenko break; 42410a708f8fSGustavo F. Padovan } 42420a708f8fSGustavo F. Padovan 42430a708f8fSGustavo F. Padovan return 0; 42440a708f8fSGustavo F. Padovan } 42450a708f8fSGustavo F. Padovan 42461700915fSMat Martineau static int l2cap_create_channel_req(struct l2cap_conn *conn, 42472d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 42482d792818SGustavo Padovan u16 cmd_len, void *data) 4249f94ff6ffSMat Martineau { 4250f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 42516e1df6a6SAndrei Emeltchenko struct l2cap_create_chan_rsp rsp; 42521700915fSMat Martineau struct l2cap_chan *chan; 42536e1df6a6SAndrei Emeltchenko struct hci_dev *hdev; 4254f94ff6ffSMat Martineau u16 psm, scid; 4255f94ff6ffSMat Martineau 4256f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 4257f94ff6ffSMat Martineau return -EPROTO; 4258f94ff6ffSMat Martineau 4259f94ff6ffSMat Martineau if (!enable_hs) 4260f94ff6ffSMat Martineau return -EINVAL; 4261f94ff6ffSMat Martineau 4262f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 4263f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 4264f94ff6ffSMat Martineau 4265ad0ac6caSAndrei Emeltchenko BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id); 4266f94ff6ffSMat Martineau 42676e1df6a6SAndrei Emeltchenko /* For controller id 0 make BR/EDR connection */ 42686e1df6a6SAndrei Emeltchenko if (req->amp_id == HCI_BREDR_ID) { 42696e1df6a6SAndrei Emeltchenko l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 42706e1df6a6SAndrei Emeltchenko req->amp_id); 42716e1df6a6SAndrei Emeltchenko return 0; 42726e1df6a6SAndrei Emeltchenko } 42731700915fSMat Martineau 42741700915fSMat Martineau /* Validate AMP controller id */ 42751700915fSMat Martineau hdev = hci_dev_get(req->amp_id); 42766e1df6a6SAndrei Emeltchenko if (!hdev) 42776e1df6a6SAndrei Emeltchenko goto error; 42781700915fSMat Martineau 42796e1df6a6SAndrei Emeltchenko if (hdev->dev_type != HCI_AMP || !test_bit(HCI_UP, &hdev->flags)) { 42806e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 42816e1df6a6SAndrei Emeltchenko goto error; 42826e1df6a6SAndrei Emeltchenko } 42836e1df6a6SAndrei Emeltchenko 42846e1df6a6SAndrei Emeltchenko chan = l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 42856e1df6a6SAndrei Emeltchenko req->amp_id); 42866e1df6a6SAndrei Emeltchenko if (chan) { 42876e1df6a6SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 42886e1df6a6SAndrei Emeltchenko struct hci_conn *hs_hcon; 42896e1df6a6SAndrei Emeltchenko 42906e1df6a6SAndrei Emeltchenko hs_hcon = hci_conn_hash_lookup_ba(hdev, AMP_LINK, conn->dst); 42916e1df6a6SAndrei Emeltchenko if (!hs_hcon) { 42926e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 42936e1df6a6SAndrei Emeltchenko return -EFAULT; 42946e1df6a6SAndrei Emeltchenko } 42956e1df6a6SAndrei Emeltchenko 42966e1df6a6SAndrei Emeltchenko BT_DBG("mgr %p bredr_chan %p hs_hcon %p", mgr, chan, hs_hcon); 42976e1df6a6SAndrei Emeltchenko 42986e1df6a6SAndrei Emeltchenko mgr->bredr_chan = chan; 42996e1df6a6SAndrei Emeltchenko chan->hs_hcon = hs_hcon; 4300fd45bf4cSAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 43016e1df6a6SAndrei Emeltchenko conn->mtu = hdev->block_mtu; 43026e1df6a6SAndrei Emeltchenko } 43036e1df6a6SAndrei Emeltchenko 43046e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 43056e1df6a6SAndrei Emeltchenko 43066e1df6a6SAndrei Emeltchenko return 0; 43076e1df6a6SAndrei Emeltchenko 43086e1df6a6SAndrei Emeltchenko error: 4309f94ff6ffSMat Martineau rsp.dcid = 0; 4310f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 43111700915fSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_CR_BAD_AMP); 43128ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 4313f94ff6ffSMat Martineau 4314f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 4315f94ff6ffSMat Martineau sizeof(rsp), &rsp); 4316f94ff6ffSMat Martineau 43176e1df6a6SAndrei Emeltchenko return -EFAULT; 4318f94ff6ffSMat Martineau } 4319f94ff6ffSMat Martineau 43208eb200bdSMat Martineau static void l2cap_send_move_chan_req(struct l2cap_chan *chan, u8 dest_amp_id) 43218eb200bdSMat Martineau { 43228eb200bdSMat Martineau struct l2cap_move_chan_req req; 43238eb200bdSMat Martineau u8 ident; 43248eb200bdSMat Martineau 43258eb200bdSMat Martineau BT_DBG("chan %p, dest_amp_id %d", chan, dest_amp_id); 43268eb200bdSMat Martineau 43278eb200bdSMat Martineau ident = l2cap_get_ident(chan->conn); 43288eb200bdSMat Martineau chan->ident = ident; 43298eb200bdSMat Martineau 43308eb200bdSMat Martineau req.icid = cpu_to_le16(chan->scid); 43318eb200bdSMat Martineau req.dest_amp_id = dest_amp_id; 43328eb200bdSMat Martineau 43338eb200bdSMat Martineau l2cap_send_cmd(chan->conn, ident, L2CAP_MOVE_CHAN_REQ, sizeof(req), 43348eb200bdSMat Martineau &req); 43358eb200bdSMat Martineau 43368eb200bdSMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 43378eb200bdSMat Martineau } 43388eb200bdSMat Martineau 43391500109bSMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_chan *chan, u16 result) 43408d5a04a1SMat Martineau { 43418d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 43428d5a04a1SMat Martineau 43431500109bSMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 43448d5a04a1SMat Martineau 43451500109bSMat Martineau rsp.icid = cpu_to_le16(chan->dcid); 43468d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 43478d5a04a1SMat Martineau 43481500109bSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_RSP, 43491500109bSMat Martineau sizeof(rsp), &rsp); 43508d5a04a1SMat Martineau } 43518d5a04a1SMat Martineau 43525b155ef9SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_chan *chan, u16 result) 43538d5a04a1SMat Martineau { 43548d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 43558d5a04a1SMat Martineau 43565b155ef9SMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 43578d5a04a1SMat Martineau 43585b155ef9SMat Martineau chan->ident = l2cap_get_ident(chan->conn); 43598d5a04a1SMat Martineau 43605b155ef9SMat Martineau cfm.icid = cpu_to_le16(chan->scid); 43618d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 43628d5a04a1SMat Martineau 43635b155ef9SMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_CFM, 43645b155ef9SMat Martineau sizeof(cfm), &cfm); 43655b155ef9SMat Martineau 43665b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 43675b155ef9SMat Martineau } 43685b155ef9SMat Martineau 43695b155ef9SMat Martineau static void l2cap_send_move_chan_cfm_icid(struct l2cap_conn *conn, u16 icid) 43705b155ef9SMat Martineau { 43715b155ef9SMat Martineau struct l2cap_move_chan_cfm cfm; 43725b155ef9SMat Martineau 43735b155ef9SMat Martineau BT_DBG("conn %p, icid 0x%4.4x", conn, icid); 43745b155ef9SMat Martineau 43755b155ef9SMat Martineau cfm.icid = cpu_to_le16(icid); 43765b155ef9SMat Martineau cfm.result = __constant_cpu_to_le16(L2CAP_MC_UNCONFIRMED); 43775b155ef9SMat Martineau 43785b155ef9SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_MOVE_CHAN_CFM, 43795b155ef9SMat Martineau sizeof(cfm), &cfm); 43808d5a04a1SMat Martineau } 43818d5a04a1SMat Martineau 43828d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 43838d5a04a1SMat Martineau u16 icid) 43848d5a04a1SMat Martineau { 43858d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 43868d5a04a1SMat Martineau 4387ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 43888d5a04a1SMat Martineau 43898d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 43908d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 43918d5a04a1SMat Martineau } 43928d5a04a1SMat Martineau 43935f3847a4SMat Martineau static void __release_logical_link(struct l2cap_chan *chan) 43945f3847a4SMat Martineau { 43955f3847a4SMat Martineau chan->hs_hchan = NULL; 43965f3847a4SMat Martineau chan->hs_hcon = NULL; 43975f3847a4SMat Martineau 43985f3847a4SMat Martineau /* Placeholder - release the logical link */ 43995f3847a4SMat Martineau } 44005f3847a4SMat Martineau 44011500109bSMat Martineau static void l2cap_logical_fail(struct l2cap_chan *chan) 44021500109bSMat Martineau { 44031500109bSMat Martineau /* Logical link setup failed */ 44041500109bSMat Martineau if (chan->state != BT_CONNECTED) { 44051500109bSMat Martineau /* Create channel failure, disconnect */ 44065e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 44071500109bSMat Martineau return; 44081500109bSMat Martineau } 44091500109bSMat Martineau 44101500109bSMat Martineau switch (chan->move_role) { 44111500109bSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 44121500109bSMat Martineau l2cap_move_done(chan); 44131500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_SUPP); 44141500109bSMat Martineau break; 44151500109bSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 44161500109bSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_COMP || 44171500109bSMat Martineau chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_CFM) { 44181500109bSMat Martineau /* Remote has only sent pending or 44191500109bSMat Martineau * success responses, clean up 44201500109bSMat Martineau */ 44211500109bSMat Martineau l2cap_move_done(chan); 44221500109bSMat Martineau } 44231500109bSMat Martineau 44241500109bSMat Martineau /* Other amp move states imply that the move 44251500109bSMat Martineau * has already aborted 44261500109bSMat Martineau */ 44271500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 44281500109bSMat Martineau break; 44291500109bSMat Martineau } 44301500109bSMat Martineau } 44311500109bSMat Martineau 44321500109bSMat Martineau static void l2cap_logical_finish_create(struct l2cap_chan *chan, 44331500109bSMat Martineau struct hci_chan *hchan) 44341500109bSMat Martineau { 44351500109bSMat Martineau struct l2cap_conf_rsp rsp; 44361500109bSMat Martineau 4437336178a3SAndrei Emeltchenko chan->hs_hchan = hchan; 44381500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 44391500109bSMat Martineau 444035ba9561SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, &rsp, chan->ident, 0); 44411500109bSMat Martineau 44421500109bSMat Martineau if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 4443fe79c6feSAndrei Emeltchenko int err; 44441500109bSMat Martineau 44451500109bSMat Martineau set_default_fcs(chan); 44461500109bSMat Martineau 44471500109bSMat Martineau err = l2cap_ertm_init(chan); 44481500109bSMat Martineau if (err < 0) 44495e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 44501500109bSMat Martineau else 44511500109bSMat Martineau l2cap_chan_ready(chan); 44521500109bSMat Martineau } 44531500109bSMat Martineau } 44541500109bSMat Martineau 44551500109bSMat Martineau static void l2cap_logical_finish_move(struct l2cap_chan *chan, 44561500109bSMat Martineau struct hci_chan *hchan) 44571500109bSMat Martineau { 44581500109bSMat Martineau chan->hs_hcon = hchan->conn; 44591500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 44601500109bSMat Martineau 44611500109bSMat Martineau BT_DBG("move_state %d", chan->move_state); 44621500109bSMat Martineau 44631500109bSMat Martineau switch (chan->move_state) { 44641500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 44651500109bSMat Martineau /* Move confirm will be sent after a success 44661500109bSMat Martineau * response is received 44671500109bSMat Martineau */ 44681500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 44691500109bSMat Martineau break; 44701500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_CFM: 44711500109bSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 44721500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 44731500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 44741500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 44751500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 44761500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 44771500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 44781500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 44791500109bSMat Martineau } 44801500109bSMat Martineau break; 44811500109bSMat Martineau default: 44821500109bSMat Martineau /* Move was not in expected state, free the channel */ 44831500109bSMat Martineau __release_logical_link(chan); 44841500109bSMat Martineau 44851500109bSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 44861500109bSMat Martineau } 44871500109bSMat Martineau } 44881500109bSMat Martineau 44891500109bSMat Martineau /* Call with chan locked */ 449027695fb4SAndrei Emeltchenko void l2cap_logical_cfm(struct l2cap_chan *chan, struct hci_chan *hchan, 44915b155ef9SMat Martineau u8 status) 44925b155ef9SMat Martineau { 44931500109bSMat Martineau BT_DBG("chan %p, hchan %p, status %d", chan, hchan, status); 44941500109bSMat Martineau 44951500109bSMat Martineau if (status) { 44961500109bSMat Martineau l2cap_logical_fail(chan); 44971500109bSMat Martineau __release_logical_link(chan); 44985b155ef9SMat Martineau return; 44995b155ef9SMat Martineau } 45005b155ef9SMat Martineau 45011500109bSMat Martineau if (chan->state != BT_CONNECTED) { 45021500109bSMat Martineau /* Ignore logical link if channel is on BR/EDR */ 45031500109bSMat Martineau if (chan->local_amp_id) 45041500109bSMat Martineau l2cap_logical_finish_create(chan, hchan); 45051500109bSMat Martineau } else { 45061500109bSMat Martineau l2cap_logical_finish_move(chan, hchan); 45071500109bSMat Martineau } 45081500109bSMat Martineau } 45091500109bSMat Martineau 45103f7a56c4SMat Martineau void l2cap_move_start(struct l2cap_chan *chan) 45113f7a56c4SMat Martineau { 45123f7a56c4SMat Martineau BT_DBG("chan %p", chan); 45133f7a56c4SMat Martineau 45143f7a56c4SMat Martineau if (chan->local_amp_id == HCI_BREDR_ID) { 45153f7a56c4SMat Martineau if (chan->chan_policy != BT_CHANNEL_POLICY_AMP_PREFERRED) 45163f7a56c4SMat Martineau return; 45173f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 45183f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 45193f7a56c4SMat Martineau /* Placeholder - start physical link setup */ 45203f7a56c4SMat Martineau } else { 45213f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 45223f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 45233f7a56c4SMat Martineau chan->move_id = 0; 45243f7a56c4SMat Martineau l2cap_move_setup(chan); 45253f7a56c4SMat Martineau l2cap_send_move_chan_req(chan, 0); 45263f7a56c4SMat Martineau } 45273f7a56c4SMat Martineau } 45283f7a56c4SMat Martineau 45298eb200bdSMat Martineau static void l2cap_do_create(struct l2cap_chan *chan, int result, 45308eb200bdSMat Martineau u8 local_amp_id, u8 remote_amp_id) 45318eb200bdSMat Martineau { 453262748ca1SAndrei Emeltchenko BT_DBG("chan %p state %s %u -> %u", chan, state_to_string(chan->state), 453362748ca1SAndrei Emeltchenko local_amp_id, remote_amp_id); 453462748ca1SAndrei Emeltchenko 453512d6cc60SAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 453612d6cc60SAndrei Emeltchenko 453762748ca1SAndrei Emeltchenko /* Outgoing channel on AMP */ 453862748ca1SAndrei Emeltchenko if (chan->state == BT_CONNECT) { 453962748ca1SAndrei Emeltchenko if (result == L2CAP_CR_SUCCESS) { 454062748ca1SAndrei Emeltchenko chan->local_amp_id = local_amp_id; 454162748ca1SAndrei Emeltchenko l2cap_send_create_chan_req(chan, remote_amp_id); 454262748ca1SAndrei Emeltchenko } else { 454362748ca1SAndrei Emeltchenko /* Revert to BR/EDR connect */ 454462748ca1SAndrei Emeltchenko l2cap_send_conn_req(chan); 454562748ca1SAndrei Emeltchenko } 454662748ca1SAndrei Emeltchenko 454762748ca1SAndrei Emeltchenko return; 454862748ca1SAndrei Emeltchenko } 454962748ca1SAndrei Emeltchenko 455062748ca1SAndrei Emeltchenko /* Incoming channel on AMP */ 455162748ca1SAndrei Emeltchenko if (__l2cap_no_conn_pending(chan)) { 45528eb200bdSMat Martineau struct l2cap_conn_rsp rsp; 45538eb200bdSMat Martineau char buf[128]; 45548eb200bdSMat Martineau rsp.scid = cpu_to_le16(chan->dcid); 45558eb200bdSMat Martineau rsp.dcid = cpu_to_le16(chan->scid); 45568eb200bdSMat Martineau 45578eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 45588eb200bdSMat Martineau /* Send successful response */ 455962cd50e2SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 456062cd50e2SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 45618eb200bdSMat Martineau } else { 45628eb200bdSMat Martineau /* Send negative response */ 456362cd50e2SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_NO_MEM); 456462cd50e2SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 45658eb200bdSMat Martineau } 45668eb200bdSMat Martineau 45678eb200bdSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_RSP, 45688eb200bdSMat Martineau sizeof(rsp), &rsp); 45698eb200bdSMat Martineau 45708eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 45718eb200bdSMat Martineau __l2cap_state_change(chan, BT_CONFIG); 45728eb200bdSMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 45738eb200bdSMat Martineau l2cap_send_cmd(chan->conn, l2cap_get_ident(chan->conn), 45748eb200bdSMat Martineau L2CAP_CONF_REQ, 45758eb200bdSMat Martineau l2cap_build_conf_req(chan, buf), buf); 45768eb200bdSMat Martineau chan->num_conf_req++; 45778eb200bdSMat Martineau } 45788eb200bdSMat Martineau } 45798eb200bdSMat Martineau } 45808eb200bdSMat Martineau 45818eb200bdSMat Martineau static void l2cap_do_move_initiate(struct l2cap_chan *chan, u8 local_amp_id, 45828eb200bdSMat Martineau u8 remote_amp_id) 45838eb200bdSMat Martineau { 45848eb200bdSMat Martineau l2cap_move_setup(chan); 45858eb200bdSMat Martineau chan->move_id = local_amp_id; 45868eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP; 45878eb200bdSMat Martineau 45888eb200bdSMat Martineau l2cap_send_move_chan_req(chan, remote_amp_id); 45898eb200bdSMat Martineau } 45908eb200bdSMat Martineau 45918eb200bdSMat Martineau static void l2cap_do_move_respond(struct l2cap_chan *chan, int result) 45928eb200bdSMat Martineau { 45938eb200bdSMat Martineau struct hci_chan *hchan = NULL; 45948eb200bdSMat Martineau 45958eb200bdSMat Martineau /* Placeholder - get hci_chan for logical link */ 45968eb200bdSMat Martineau 45978eb200bdSMat Martineau if (hchan) { 45988eb200bdSMat Martineau if (hchan->state == BT_CONNECTED) { 45998eb200bdSMat Martineau /* Logical link is ready to go */ 46008eb200bdSMat Martineau chan->hs_hcon = hchan->conn; 46018eb200bdSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 46028eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 46038eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 46048eb200bdSMat Martineau 46058eb200bdSMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 46068eb200bdSMat Martineau } else { 46078eb200bdSMat Martineau /* Wait for logical link to be ready */ 46088eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 46098eb200bdSMat Martineau } 46108eb200bdSMat Martineau } else { 46118eb200bdSMat Martineau /* Logical link not available */ 46128eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_ALLOWED); 46138eb200bdSMat Martineau } 46148eb200bdSMat Martineau } 46158eb200bdSMat Martineau 46168eb200bdSMat Martineau static void l2cap_do_move_cancel(struct l2cap_chan *chan, int result) 46178eb200bdSMat Martineau { 46188eb200bdSMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 46198eb200bdSMat Martineau u8 rsp_result; 46208eb200bdSMat Martineau if (result == -EINVAL) 46218eb200bdSMat Martineau rsp_result = L2CAP_MR_BAD_ID; 46228eb200bdSMat Martineau else 46238eb200bdSMat Martineau rsp_result = L2CAP_MR_NOT_ALLOWED; 46248eb200bdSMat Martineau 46258eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, rsp_result); 46268eb200bdSMat Martineau } 46278eb200bdSMat Martineau 46288eb200bdSMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 46298eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 46308eb200bdSMat Martineau 46318eb200bdSMat Martineau /* Restart data transmission */ 46328eb200bdSMat Martineau l2cap_ertm_send(chan); 46338eb200bdSMat Martineau } 46348eb200bdSMat Martineau 4635a514b17fSAndrei Emeltchenko /* Invoke with locked chan */ 4636a514b17fSAndrei Emeltchenko void __l2cap_physical_cfm(struct l2cap_chan *chan, int result) 46378eb200bdSMat Martineau { 4638770bfefaSAndrei Emeltchenko u8 local_amp_id = chan->local_amp_id; 4639fffadc08SAndrei Emeltchenko u8 remote_amp_id = chan->remote_amp_id; 4640770bfefaSAndrei Emeltchenko 46418eb200bdSMat Martineau BT_DBG("chan %p, result %d, local_amp_id %d, remote_amp_id %d", 46428eb200bdSMat Martineau chan, result, local_amp_id, remote_amp_id); 46438eb200bdSMat Martineau 46448eb200bdSMat Martineau if (chan->state == BT_DISCONN || chan->state == BT_CLOSED) { 46458eb200bdSMat Martineau l2cap_chan_unlock(chan); 46468eb200bdSMat Martineau return; 46478eb200bdSMat Martineau } 46488eb200bdSMat Martineau 46498eb200bdSMat Martineau if (chan->state != BT_CONNECTED) { 46508eb200bdSMat Martineau l2cap_do_create(chan, result, local_amp_id, remote_amp_id); 46518eb200bdSMat Martineau } else if (result != L2CAP_MR_SUCCESS) { 46528eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 46538eb200bdSMat Martineau } else { 46548eb200bdSMat Martineau switch (chan->move_role) { 46558eb200bdSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 46568eb200bdSMat Martineau l2cap_do_move_initiate(chan, local_amp_id, 46578eb200bdSMat Martineau remote_amp_id); 46588eb200bdSMat Martineau break; 46598eb200bdSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 46608eb200bdSMat Martineau l2cap_do_move_respond(chan, result); 46618eb200bdSMat Martineau break; 46628eb200bdSMat Martineau default: 46638eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 46648eb200bdSMat Martineau break; 46658eb200bdSMat Martineau } 46668eb200bdSMat Martineau } 46678eb200bdSMat Martineau } 46688eb200bdSMat Martineau 46698d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 4670ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4671ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 46728d5a04a1SMat Martineau { 46738d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 46741500109bSMat Martineau struct l2cap_move_chan_rsp rsp; 467502b0fbb9SMat Martineau struct l2cap_chan *chan; 46768d5a04a1SMat Martineau u16 icid = 0; 46778d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 46788d5a04a1SMat Martineau 46798d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 46808d5a04a1SMat Martineau return -EPROTO; 46818d5a04a1SMat Martineau 46828d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 46838d5a04a1SMat Martineau 4684ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id); 46858d5a04a1SMat Martineau 46868d5a04a1SMat Martineau if (!enable_hs) 46878d5a04a1SMat Martineau return -EINVAL; 46888d5a04a1SMat Martineau 468902b0fbb9SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 469002b0fbb9SMat Martineau if (!chan) { 46911500109bSMat Martineau rsp.icid = cpu_to_le16(icid); 46921500109bSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_MR_NOT_ALLOWED); 46931500109bSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_MOVE_CHAN_RSP, 46941500109bSMat Martineau sizeof(rsp), &rsp); 469502b0fbb9SMat Martineau return 0; 469602b0fbb9SMat Martineau } 469702b0fbb9SMat Martineau 46981500109bSMat Martineau chan->ident = cmd->ident; 46991500109bSMat Martineau 470002b0fbb9SMat Martineau if (chan->scid < L2CAP_CID_DYN_START || 470102b0fbb9SMat Martineau chan->chan_policy == BT_CHANNEL_POLICY_BREDR_ONLY || 470202b0fbb9SMat Martineau (chan->mode != L2CAP_MODE_ERTM && 470302b0fbb9SMat Martineau chan->mode != L2CAP_MODE_STREAMING)) { 470402b0fbb9SMat Martineau result = L2CAP_MR_NOT_ALLOWED; 470502b0fbb9SMat Martineau goto send_move_response; 470602b0fbb9SMat Martineau } 470702b0fbb9SMat Martineau 470802b0fbb9SMat Martineau if (chan->local_amp_id == req->dest_amp_id) { 470902b0fbb9SMat Martineau result = L2CAP_MR_SAME_ID; 471002b0fbb9SMat Martineau goto send_move_response; 471102b0fbb9SMat Martineau } 471202b0fbb9SMat Martineau 471302b0fbb9SMat Martineau if (req->dest_amp_id) { 471402b0fbb9SMat Martineau struct hci_dev *hdev; 471502b0fbb9SMat Martineau hdev = hci_dev_get(req->dest_amp_id); 471602b0fbb9SMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 471702b0fbb9SMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 471802b0fbb9SMat Martineau if (hdev) 471902b0fbb9SMat Martineau hci_dev_put(hdev); 472002b0fbb9SMat Martineau 472102b0fbb9SMat Martineau result = L2CAP_MR_BAD_ID; 472202b0fbb9SMat Martineau goto send_move_response; 472302b0fbb9SMat Martineau } 472402b0fbb9SMat Martineau hci_dev_put(hdev); 472502b0fbb9SMat Martineau } 472602b0fbb9SMat Martineau 472702b0fbb9SMat Martineau /* Detect a move collision. Only send a collision response 472802b0fbb9SMat Martineau * if this side has "lost", otherwise proceed with the move. 472902b0fbb9SMat Martineau * The winner has the larger bd_addr. 473002b0fbb9SMat Martineau */ 473102b0fbb9SMat Martineau if ((__chan_is_moving(chan) || 473202b0fbb9SMat Martineau chan->move_role != L2CAP_MOVE_ROLE_NONE) && 473302b0fbb9SMat Martineau bacmp(conn->src, conn->dst) > 0) { 473402b0fbb9SMat Martineau result = L2CAP_MR_COLLISION; 473502b0fbb9SMat Martineau goto send_move_response; 473602b0fbb9SMat Martineau } 473702b0fbb9SMat Martineau 473802b0fbb9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 473902b0fbb9SMat Martineau l2cap_move_setup(chan); 474002b0fbb9SMat Martineau chan->move_id = req->dest_amp_id; 474102b0fbb9SMat Martineau icid = chan->dcid; 474202b0fbb9SMat Martineau 474302b0fbb9SMat Martineau if (!req->dest_amp_id) { 474402b0fbb9SMat Martineau /* Moving to BR/EDR */ 474502b0fbb9SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 474602b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 474702b0fbb9SMat Martineau result = L2CAP_MR_PEND; 474802b0fbb9SMat Martineau } else { 474902b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 475002b0fbb9SMat Martineau result = L2CAP_MR_SUCCESS; 475102b0fbb9SMat Martineau } 475202b0fbb9SMat Martineau } else { 475302b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 475402b0fbb9SMat Martineau /* Placeholder - uncomment when amp functions are available */ 475502b0fbb9SMat Martineau /*amp_accept_physical(chan, req->dest_amp_id);*/ 475602b0fbb9SMat Martineau result = L2CAP_MR_PEND; 475702b0fbb9SMat Martineau } 475802b0fbb9SMat Martineau 475902b0fbb9SMat Martineau send_move_response: 47601500109bSMat Martineau l2cap_send_move_chan_rsp(chan, result); 47618d5a04a1SMat Martineau 476202b0fbb9SMat Martineau l2cap_chan_unlock(chan); 476302b0fbb9SMat Martineau 47648d5a04a1SMat Martineau return 0; 47658d5a04a1SMat Martineau } 47668d5a04a1SMat Martineau 47675b155ef9SMat Martineau static void l2cap_move_continue(struct l2cap_conn *conn, u16 icid, u16 result) 47685b155ef9SMat Martineau { 47695b155ef9SMat Martineau struct l2cap_chan *chan; 47705b155ef9SMat Martineau struct hci_chan *hchan = NULL; 47715b155ef9SMat Martineau 47725b155ef9SMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 47735b155ef9SMat Martineau if (!chan) { 47745b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 47755b155ef9SMat Martineau return; 47765b155ef9SMat Martineau } 47775b155ef9SMat Martineau 47785b155ef9SMat Martineau __clear_chan_timer(chan); 47795b155ef9SMat Martineau if (result == L2CAP_MR_PEND) 47805b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_ERTX_TIMEOUT); 47815b155ef9SMat Martineau 47825b155ef9SMat Martineau switch (chan->move_state) { 47835b155ef9SMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 47845b155ef9SMat Martineau /* Move confirm will be sent when logical link 47855b155ef9SMat Martineau * is complete. 47865b155ef9SMat Martineau */ 47875b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 47885b155ef9SMat Martineau break; 47895b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP_SUCCESS: 47905b155ef9SMat Martineau if (result == L2CAP_MR_PEND) { 47915b155ef9SMat Martineau break; 47925b155ef9SMat Martineau } else if (test_bit(CONN_LOCAL_BUSY, 47935b155ef9SMat Martineau &chan->conn_state)) { 47945b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 47955b155ef9SMat Martineau } else { 47965b155ef9SMat Martineau /* Logical link is up or moving to BR/EDR, 47975b155ef9SMat Martineau * proceed with move 47985b155ef9SMat Martineau */ 47995b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 48005b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 48015b155ef9SMat Martineau } 48025b155ef9SMat Martineau break; 48035b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP: 48045b155ef9SMat Martineau /* Moving to AMP */ 48055b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 48065b155ef9SMat Martineau /* Remote is ready, send confirm immediately 48075b155ef9SMat Martineau * after logical link is ready 48085b155ef9SMat Martineau */ 48095b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 48105b155ef9SMat Martineau } else { 48115b155ef9SMat Martineau /* Both logical link and move success 48125b155ef9SMat Martineau * are required to confirm 48135b155ef9SMat Martineau */ 48145b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_COMP; 48155b155ef9SMat Martineau } 48165b155ef9SMat Martineau 48175b155ef9SMat Martineau /* Placeholder - get hci_chan for logical link */ 48185b155ef9SMat Martineau if (!hchan) { 48195b155ef9SMat Martineau /* Logical link not available */ 48205b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 48215b155ef9SMat Martineau break; 48225b155ef9SMat Martineau } 48235b155ef9SMat Martineau 48245b155ef9SMat Martineau /* If the logical link is not yet connected, do not 48255b155ef9SMat Martineau * send confirmation. 48265b155ef9SMat Martineau */ 48275b155ef9SMat Martineau if (hchan->state != BT_CONNECTED) 48285b155ef9SMat Martineau break; 48295b155ef9SMat Martineau 48305b155ef9SMat Martineau /* Logical link is already ready to go */ 48315b155ef9SMat Martineau 48325b155ef9SMat Martineau chan->hs_hcon = hchan->conn; 48335b155ef9SMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 48345b155ef9SMat Martineau 48355b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 48365b155ef9SMat Martineau /* Can confirm now */ 48375b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 48385b155ef9SMat Martineau } else { 48395b155ef9SMat Martineau /* Now only need move success 48405b155ef9SMat Martineau * to confirm 48415b155ef9SMat Martineau */ 48425b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 48435b155ef9SMat Martineau } 48445b155ef9SMat Martineau 48455b155ef9SMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 48465b155ef9SMat Martineau break; 48475b155ef9SMat Martineau default: 48485b155ef9SMat Martineau /* Any other amp move state means the move failed. */ 48495b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 48505b155ef9SMat Martineau l2cap_move_done(chan); 48515b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 48525b155ef9SMat Martineau } 48535b155ef9SMat Martineau 48545b155ef9SMat Martineau l2cap_chan_unlock(chan); 48555b155ef9SMat Martineau } 48565b155ef9SMat Martineau 48575b155ef9SMat Martineau static void l2cap_move_fail(struct l2cap_conn *conn, u8 ident, u16 icid, 48585b155ef9SMat Martineau u16 result) 48595b155ef9SMat Martineau { 48605b155ef9SMat Martineau struct l2cap_chan *chan; 48615b155ef9SMat Martineau 48625b155ef9SMat Martineau chan = l2cap_get_chan_by_ident(conn, ident); 48635b155ef9SMat Martineau if (!chan) { 48645b155ef9SMat Martineau /* Could not locate channel, icid is best guess */ 48655b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 48665b155ef9SMat Martineau return; 48675b155ef9SMat Martineau } 48685b155ef9SMat Martineau 48695b155ef9SMat Martineau __clear_chan_timer(chan); 48705b155ef9SMat Martineau 48715b155ef9SMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 48725b155ef9SMat Martineau if (result == L2CAP_MR_COLLISION) { 48735b155ef9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 48745b155ef9SMat Martineau } else { 48755b155ef9SMat Martineau /* Cleanup - cancel move */ 48765b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 48775b155ef9SMat Martineau l2cap_move_done(chan); 48785b155ef9SMat Martineau } 48795b155ef9SMat Martineau } 48805b155ef9SMat Martineau 48815b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 48825b155ef9SMat Martineau 48835b155ef9SMat Martineau l2cap_chan_unlock(chan); 48845b155ef9SMat Martineau } 48855b155ef9SMat Martineau 48865b155ef9SMat Martineau static int l2cap_move_channel_rsp(struct l2cap_conn *conn, 4887ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4888ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 48898d5a04a1SMat Martineau { 48908d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 48918d5a04a1SMat Martineau u16 icid, result; 48928d5a04a1SMat Martineau 48938d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 48948d5a04a1SMat Martineau return -EPROTO; 48958d5a04a1SMat Martineau 48968d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 48978d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 48988d5a04a1SMat Martineau 4899ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 49008d5a04a1SMat Martineau 49015b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS || result == L2CAP_MR_PEND) 49025b155ef9SMat Martineau l2cap_move_continue(conn, icid, result); 49035b155ef9SMat Martineau else 49045b155ef9SMat Martineau l2cap_move_fail(conn, cmd->ident, icid, result); 49058d5a04a1SMat Martineau 49068d5a04a1SMat Martineau return 0; 49078d5a04a1SMat Martineau } 49088d5a04a1SMat Martineau 49095f3847a4SMat Martineau static int l2cap_move_channel_confirm(struct l2cap_conn *conn, 4910ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4911ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 49128d5a04a1SMat Martineau { 49138d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 49145f3847a4SMat Martineau struct l2cap_chan *chan; 49158d5a04a1SMat Martineau u16 icid, result; 49168d5a04a1SMat Martineau 49178d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 49188d5a04a1SMat Martineau return -EPROTO; 49198d5a04a1SMat Martineau 49208d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 49218d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 49228d5a04a1SMat Martineau 4923ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 49248d5a04a1SMat Martineau 49255f3847a4SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 49265f3847a4SMat Martineau if (!chan) { 49275f3847a4SMat Martineau /* Spec requires a response even if the icid was not found */ 49288d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 49295f3847a4SMat Martineau return 0; 49305f3847a4SMat Martineau } 49315f3847a4SMat Martineau 49325f3847a4SMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM) { 49335f3847a4SMat Martineau if (result == L2CAP_MC_CONFIRMED) { 49345f3847a4SMat Martineau chan->local_amp_id = chan->move_id; 49355f3847a4SMat Martineau if (!chan->local_amp_id) 49365f3847a4SMat Martineau __release_logical_link(chan); 49375f3847a4SMat Martineau } else { 49385f3847a4SMat Martineau chan->move_id = chan->local_amp_id; 49395f3847a4SMat Martineau } 49405f3847a4SMat Martineau 49415f3847a4SMat Martineau l2cap_move_done(chan); 49425f3847a4SMat Martineau } 49435f3847a4SMat Martineau 49445f3847a4SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 49455f3847a4SMat Martineau 49465f3847a4SMat Martineau l2cap_chan_unlock(chan); 49478d5a04a1SMat Martineau 49488d5a04a1SMat Martineau return 0; 49498d5a04a1SMat Martineau } 49508d5a04a1SMat Martineau 49518d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 4952ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4953ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 49548d5a04a1SMat Martineau { 49558d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 49563fd71a0aSMat Martineau struct l2cap_chan *chan; 49578d5a04a1SMat Martineau u16 icid; 49588d5a04a1SMat Martineau 49598d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 49608d5a04a1SMat Martineau return -EPROTO; 49618d5a04a1SMat Martineau 49628d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 49638d5a04a1SMat Martineau 4964ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 49658d5a04a1SMat Martineau 49663fd71a0aSMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 49673fd71a0aSMat Martineau if (!chan) 49683fd71a0aSMat Martineau return 0; 49693fd71a0aSMat Martineau 49703fd71a0aSMat Martineau __clear_chan_timer(chan); 49713fd71a0aSMat Martineau 49723fd71a0aSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM_RSP) { 49733fd71a0aSMat Martineau chan->local_amp_id = chan->move_id; 49743fd71a0aSMat Martineau 49753fd71a0aSMat Martineau if (!chan->local_amp_id && chan->hs_hchan) 49763fd71a0aSMat Martineau __release_logical_link(chan); 49773fd71a0aSMat Martineau 49783fd71a0aSMat Martineau l2cap_move_done(chan); 49793fd71a0aSMat Martineau } 49803fd71a0aSMat Martineau 49813fd71a0aSMat Martineau l2cap_chan_unlock(chan); 49823fd71a0aSMat Martineau 49838d5a04a1SMat Martineau return 0; 49848d5a04a1SMat Martineau } 49858d5a04a1SMat Martineau 4986e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4987de73115aSClaudio Takahasi u16 to_multiplier) 4988de73115aSClaudio Takahasi { 4989de73115aSClaudio Takahasi u16 max_latency; 4990de73115aSClaudio Takahasi 4991de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4992de73115aSClaudio Takahasi return -EINVAL; 4993de73115aSClaudio Takahasi 4994de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4995de73115aSClaudio Takahasi return -EINVAL; 4996de73115aSClaudio Takahasi 4997de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4998de73115aSClaudio Takahasi return -EINVAL; 4999de73115aSClaudio Takahasi 5000de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 5001de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 5002de73115aSClaudio Takahasi return -EINVAL; 5003de73115aSClaudio Takahasi 5004de73115aSClaudio Takahasi return 0; 5005de73115aSClaudio Takahasi } 5006de73115aSClaudio Takahasi 5007de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 50082d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 50092d792818SGustavo Padovan u8 *data) 5010de73115aSClaudio Takahasi { 5011de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 5012de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 5013de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 5014de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 50152ce603ebSClaudio Takahasi int err; 5016de73115aSClaudio Takahasi 5017de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 5018de73115aSClaudio Takahasi return -EINVAL; 5019de73115aSClaudio Takahasi 5020de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 5021de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 5022de73115aSClaudio Takahasi return -EPROTO; 5023de73115aSClaudio Takahasi 5024de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 5025de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 5026de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 5027de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 5028de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 5029de73115aSClaudio Takahasi 5030de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 5031de73115aSClaudio Takahasi min, max, latency, to_multiplier); 5032de73115aSClaudio Takahasi 5033de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 50342ce603ebSClaudio Takahasi 50352ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 50362ce603ebSClaudio Takahasi if (err) 5037ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 5038de73115aSClaudio Takahasi else 5039ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 5040de73115aSClaudio Takahasi 5041de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 5042de73115aSClaudio Takahasi sizeof(rsp), &rsp); 5043de73115aSClaudio Takahasi 50442ce603ebSClaudio Takahasi if (!err) 50452ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 50462ce603ebSClaudio Takahasi 5047de73115aSClaudio Takahasi return 0; 5048de73115aSClaudio Takahasi } 5049de73115aSClaudio Takahasi 50503300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 50512d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 50522d792818SGustavo Padovan u8 *data) 50533300d9a9SClaudio Takahasi { 50543300d9a9SClaudio Takahasi int err = 0; 50553300d9a9SClaudio Takahasi 50563300d9a9SClaudio Takahasi switch (cmd->code) { 50573300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 50583300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 50593300d9a9SClaudio Takahasi break; 50603300d9a9SClaudio Takahasi 50613300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 50623300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 50633300d9a9SClaudio Takahasi break; 50643300d9a9SClaudio Takahasi 50653300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 5066f5a2598dSMat Martineau case L2CAP_CREATE_CHAN_RSP: 50675909cf30SMat Martineau err = l2cap_connect_create_rsp(conn, cmd, data); 50683300d9a9SClaudio Takahasi break; 50693300d9a9SClaudio Takahasi 50703300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 50713300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 50723300d9a9SClaudio Takahasi break; 50733300d9a9SClaudio Takahasi 50743300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 50753300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 50763300d9a9SClaudio Takahasi break; 50773300d9a9SClaudio Takahasi 50783300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 50793300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 50803300d9a9SClaudio Takahasi break; 50813300d9a9SClaudio Takahasi 50823300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 50833300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 50843300d9a9SClaudio Takahasi break; 50853300d9a9SClaudio Takahasi 50863300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 50873300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 50883300d9a9SClaudio Takahasi break; 50893300d9a9SClaudio Takahasi 50903300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 50913300d9a9SClaudio Takahasi break; 50923300d9a9SClaudio Takahasi 50933300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 50943300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 50953300d9a9SClaudio Takahasi break; 50963300d9a9SClaudio Takahasi 50973300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 50983300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 50993300d9a9SClaudio Takahasi break; 51003300d9a9SClaudio Takahasi 5101f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 5102f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 5103f94ff6ffSMat Martineau break; 5104f94ff6ffSMat Martineau 51058d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 51068d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 51078d5a04a1SMat Martineau break; 51088d5a04a1SMat Martineau 51098d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 51108d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 51118d5a04a1SMat Martineau break; 51128d5a04a1SMat Martineau 51138d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 51148d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 51158d5a04a1SMat Martineau break; 51168d5a04a1SMat Martineau 51178d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 51188d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 51198d5a04a1SMat Martineau break; 51208d5a04a1SMat Martineau 51213300d9a9SClaudio Takahasi default: 51223300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 51233300d9a9SClaudio Takahasi err = -EINVAL; 51243300d9a9SClaudio Takahasi break; 51253300d9a9SClaudio Takahasi } 51263300d9a9SClaudio Takahasi 51273300d9a9SClaudio Takahasi return err; 51283300d9a9SClaudio Takahasi } 51293300d9a9SClaudio Takahasi 51303300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 51313300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 51323300d9a9SClaudio Takahasi { 51333300d9a9SClaudio Takahasi switch (cmd->code) { 51343300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 51353300d9a9SClaudio Takahasi return 0; 51363300d9a9SClaudio Takahasi 51373300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 5138de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 51393300d9a9SClaudio Takahasi 51403300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 51413300d9a9SClaudio Takahasi return 0; 51423300d9a9SClaudio Takahasi 51433300d9a9SClaudio Takahasi default: 51443300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 51453300d9a9SClaudio Takahasi return -EINVAL; 51463300d9a9SClaudio Takahasi } 51473300d9a9SClaudio Takahasi } 51483300d9a9SClaudio Takahasi 51493300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 51503300d9a9SClaudio Takahasi struct sk_buff *skb) 51510a708f8fSGustavo F. Padovan { 51520a708f8fSGustavo F. Padovan u8 *data = skb->data; 51530a708f8fSGustavo F. Padovan int len = skb->len; 51540a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 51553300d9a9SClaudio Takahasi int err; 51560a708f8fSGustavo F. Padovan 51570a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 51580a708f8fSGustavo F. Padovan 51590a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 51600a708f8fSGustavo F. Padovan u16 cmd_len; 51610a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 51620a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 51630a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 51640a708f8fSGustavo F. Padovan 51650a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 51660a708f8fSGustavo F. Padovan 51672d792818SGustavo Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 51682d792818SGustavo Padovan cmd.ident); 51690a708f8fSGustavo F. Padovan 51700a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 51710a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 51720a708f8fSGustavo F. Padovan break; 51730a708f8fSGustavo F. Padovan } 51740a708f8fSGustavo F. Padovan 51753300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 51763300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 51773300d9a9SClaudio Takahasi else 51783300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 51790a708f8fSGustavo F. Padovan 51800a708f8fSGustavo F. Padovan if (err) { 5181e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 51822c6d1a2eSGustavo F. Padovan 51832c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 51840a708f8fSGustavo F. Padovan 51850a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 5186ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 51872d792818SGustavo Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 51882d792818SGustavo Padovan sizeof(rej), &rej); 51890a708f8fSGustavo F. Padovan } 51900a708f8fSGustavo F. Padovan 51910a708f8fSGustavo F. Padovan data += cmd_len; 51920a708f8fSGustavo F. Padovan len -= cmd_len; 51930a708f8fSGustavo F. Padovan } 51940a708f8fSGustavo F. Padovan 51950a708f8fSGustavo F. Padovan kfree_skb(skb); 51960a708f8fSGustavo F. Padovan } 51970a708f8fSGustavo F. Padovan 519847d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 51990a708f8fSGustavo F. Padovan { 52000a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 5201e4ca6d98SAndrei Emeltchenko int hdr_size; 5202e4ca6d98SAndrei Emeltchenko 5203e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 5204e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 5205e4ca6d98SAndrei Emeltchenko else 5206e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 52070a708f8fSGustavo F. Padovan 520847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 520903a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 52100a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 52110a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 52120a708f8fSGustavo F. Padovan 52130a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 52140a708f8fSGustavo F. Padovan return -EBADMSG; 52150a708f8fSGustavo F. Padovan } 52160a708f8fSGustavo F. Padovan return 0; 52170a708f8fSGustavo F. Padovan } 52180a708f8fSGustavo F. Padovan 52196ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 52200a708f8fSGustavo F. Padovan { 5221e31f7633SMat Martineau struct l2cap_ctrl control; 52220a708f8fSGustavo F. Padovan 5223e31f7633SMat Martineau BT_DBG("chan %p", chan); 52240a708f8fSGustavo F. Padovan 5225e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 5226e31f7633SMat Martineau control.sframe = 1; 5227e31f7633SMat Martineau control.final = 1; 5228e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 5229e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 52300a708f8fSGustavo F. Padovan 5231e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5232e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 5233e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 52340a708f8fSGustavo F. Padovan } 52350a708f8fSGustavo F. Padovan 5236e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 5237e31f7633SMat Martineau chan->unacked_frames > 0) 5238e31f7633SMat Martineau __set_retrans_timer(chan); 52390a708f8fSGustavo F. Padovan 5240e31f7633SMat Martineau /* Send pending iframes */ 5241525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 52420a708f8fSGustavo F. Padovan 5243e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 5244e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 5245e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 5246e31f7633SMat Martineau * send it now. 5247e31f7633SMat Martineau */ 5248e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 5249e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 52500a708f8fSGustavo F. Padovan } 52510a708f8fSGustavo F. Padovan } 52520a708f8fSGustavo F. Padovan 52532d792818SGustavo Padovan static void append_skb_frag(struct sk_buff *skb, struct sk_buff *new_frag, 52542d792818SGustavo Padovan struct sk_buff **last_frag) 52550a708f8fSGustavo F. Padovan { 525684084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 525784084a31SMat Martineau * skb->data_len reflects only data in fragments 525884084a31SMat Martineau */ 525984084a31SMat Martineau if (!skb_has_frag_list(skb)) 526084084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 526184084a31SMat Martineau 526284084a31SMat Martineau new_frag->next = NULL; 526384084a31SMat Martineau 526484084a31SMat Martineau (*last_frag)->next = new_frag; 526584084a31SMat Martineau *last_frag = new_frag; 526684084a31SMat Martineau 526784084a31SMat Martineau skb->len += new_frag->len; 526884084a31SMat Martineau skb->data_len += new_frag->len; 526984084a31SMat Martineau skb->truesize += new_frag->truesize; 527084084a31SMat Martineau } 527184084a31SMat Martineau 52724b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 52734b51dae9SMat Martineau struct l2cap_ctrl *control) 527484084a31SMat Martineau { 527584084a31SMat Martineau int err = -EINVAL; 52760a708f8fSGustavo F. Padovan 52774b51dae9SMat Martineau switch (control->sar) { 52787e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 527984084a31SMat Martineau if (chan->sdu) 528084084a31SMat Martineau break; 52810a708f8fSGustavo F. Padovan 528280b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 528384084a31SMat Martineau break; 52840a708f8fSGustavo F. Padovan 52857e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 528684084a31SMat Martineau if (chan->sdu) 528784084a31SMat Martineau break; 52880a708f8fSGustavo F. Padovan 52896f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 529003a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 52910a708f8fSGustavo F. Padovan 529284084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 529384084a31SMat Martineau err = -EMSGSIZE; 529484084a31SMat Martineau break; 529584084a31SMat Martineau } 52960a708f8fSGustavo F. Padovan 529784084a31SMat Martineau if (skb->len >= chan->sdu_len) 529884084a31SMat Martineau break; 529984084a31SMat Martineau 530084084a31SMat Martineau chan->sdu = skb; 530184084a31SMat Martineau chan->sdu_last_frag = skb; 530284084a31SMat Martineau 530384084a31SMat Martineau skb = NULL; 530484084a31SMat Martineau err = 0; 53050a708f8fSGustavo F. Padovan break; 53060a708f8fSGustavo F. Padovan 53077e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 53086f61fd47SGustavo F. Padovan if (!chan->sdu) 530984084a31SMat Martineau break; 53100a708f8fSGustavo F. Padovan 531184084a31SMat Martineau append_skb_frag(chan->sdu, skb, 531284084a31SMat Martineau &chan->sdu_last_frag); 531384084a31SMat Martineau skb = NULL; 53140a708f8fSGustavo F. Padovan 531584084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 531684084a31SMat Martineau break; 53170a708f8fSGustavo F. Padovan 531884084a31SMat Martineau err = 0; 53190a708f8fSGustavo F. Padovan break; 53200a708f8fSGustavo F. Padovan 53217e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 53226f61fd47SGustavo F. Padovan if (!chan->sdu) 532384084a31SMat Martineau break; 53240a708f8fSGustavo F. Padovan 532584084a31SMat Martineau append_skb_frag(chan->sdu, skb, 532684084a31SMat Martineau &chan->sdu_last_frag); 532784084a31SMat Martineau skb = NULL; 53280a708f8fSGustavo F. Padovan 532984084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 533084084a31SMat Martineau break; 53310a708f8fSGustavo F. Padovan 533280b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 53330a708f8fSGustavo F. Padovan 533484084a31SMat Martineau if (!err) { 533584084a31SMat Martineau /* Reassembly complete */ 533684084a31SMat Martineau chan->sdu = NULL; 533784084a31SMat Martineau chan->sdu_last_frag = NULL; 533884084a31SMat Martineau chan->sdu_len = 0; 53390a708f8fSGustavo F. Padovan } 53400a708f8fSGustavo F. Padovan break; 53410a708f8fSGustavo F. Padovan } 53420a708f8fSGustavo F. Padovan 534384084a31SMat Martineau if (err) { 53440a708f8fSGustavo F. Padovan kfree_skb(skb); 53456f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 53466f61fd47SGustavo F. Padovan chan->sdu = NULL; 534784084a31SMat Martineau chan->sdu_last_frag = NULL; 534884084a31SMat Martineau chan->sdu_len = 0; 534984084a31SMat Martineau } 53500a708f8fSGustavo F. Padovan 535184084a31SMat Martineau return err; 53520a708f8fSGustavo F. Padovan } 53530a708f8fSGustavo F. Padovan 535432b32735SMat Martineau static int l2cap_resegment(struct l2cap_chan *chan) 535532b32735SMat Martineau { 535632b32735SMat Martineau /* Placeholder */ 535732b32735SMat Martineau return 0; 535832b32735SMat Martineau } 535932b32735SMat Martineau 5360e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 53610a708f8fSGustavo F. Padovan { 536261aa4f5bSMat Martineau u8 event; 536361aa4f5bSMat Martineau 536461aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 536561aa4f5bSMat Martineau return; 536661aa4f5bSMat Martineau 536761aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 5368401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 53690a708f8fSGustavo F. Padovan } 53700a708f8fSGustavo F. Padovan 5371d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 5372d2a7ac5dSMat Martineau { 537363838725SMat Martineau int err = 0; 537463838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 537563838725SMat Martineau * until a gap is encountered. 537663838725SMat Martineau */ 537763838725SMat Martineau 537863838725SMat Martineau BT_DBG("chan %p", chan); 537963838725SMat Martineau 538063838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 538163838725SMat Martineau struct sk_buff *skb; 538263838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 538363838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 538463838725SMat Martineau 538563838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 538663838725SMat Martineau 538763838725SMat Martineau if (!skb) 538863838725SMat Martineau break; 538963838725SMat Martineau 539063838725SMat Martineau skb_unlink(skb, &chan->srej_q); 539163838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 539263838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 539363838725SMat Martineau if (err) 539463838725SMat Martineau break; 539563838725SMat Martineau } 539663838725SMat Martineau 539763838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 539863838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 539963838725SMat Martineau l2cap_send_ack(chan); 540063838725SMat Martineau } 540163838725SMat Martineau 540263838725SMat Martineau return err; 5403d2a7ac5dSMat Martineau } 5404d2a7ac5dSMat Martineau 5405d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 5406d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5407d2a7ac5dSMat Martineau { 5408f80842a8SMat Martineau struct sk_buff *skb; 5409f80842a8SMat Martineau 5410f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 5411f80842a8SMat Martineau 5412f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 5413f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 54145e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5415f80842a8SMat Martineau return; 5416f80842a8SMat Martineau } 5417f80842a8SMat Martineau 5418f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5419f80842a8SMat Martineau 5420f80842a8SMat Martineau if (skb == NULL) { 5421f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 5422f80842a8SMat Martineau control->reqseq); 5423f80842a8SMat Martineau return; 5424f80842a8SMat Martineau } 5425f80842a8SMat Martineau 5426f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 5427f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 54285e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5429f80842a8SMat Martineau return; 5430f80842a8SMat Martineau } 5431f80842a8SMat Martineau 5432f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5433f80842a8SMat Martineau 5434f80842a8SMat Martineau if (control->poll) { 5435f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 5436f80842a8SMat Martineau 5437f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5438f80842a8SMat Martineau l2cap_retransmit(chan, control); 5439f80842a8SMat Martineau l2cap_ertm_send(chan); 5440f80842a8SMat Martineau 5441f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 5442f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 5443f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 5444f80842a8SMat Martineau } 5445f80842a8SMat Martineau } else { 5446f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 5447f80842a8SMat Martineau 5448f80842a8SMat Martineau if (control->final) { 5449f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 5450f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 5451f80842a8SMat Martineau &chan->conn_state)) 5452f80842a8SMat Martineau l2cap_retransmit(chan, control); 5453f80842a8SMat Martineau } else { 5454f80842a8SMat Martineau l2cap_retransmit(chan, control); 5455f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 5456f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 5457f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 5458f80842a8SMat Martineau } 5459f80842a8SMat Martineau } 5460f80842a8SMat Martineau } 5461d2a7ac5dSMat Martineau } 5462d2a7ac5dSMat Martineau 5463d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 5464d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5465d2a7ac5dSMat Martineau { 5466fcd289dfSMat Martineau struct sk_buff *skb; 5467fcd289dfSMat Martineau 5468fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 5469fcd289dfSMat Martineau 5470fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 5471fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 54725e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5473fcd289dfSMat Martineau return; 5474fcd289dfSMat Martineau } 5475fcd289dfSMat Martineau 5476fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5477fcd289dfSMat Martineau 5478fcd289dfSMat Martineau if (chan->max_tx && skb && 5479fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 5480fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 54815e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5482fcd289dfSMat Martineau return; 5483fcd289dfSMat Martineau } 5484fcd289dfSMat Martineau 5485fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5486fcd289dfSMat Martineau 5487fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 5488fcd289dfSMat Martineau 5489fcd289dfSMat Martineau if (control->final) { 5490fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 5491fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5492fcd289dfSMat Martineau } else { 5493fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5494fcd289dfSMat Martineau l2cap_ertm_send(chan); 5495fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 5496fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 5497fcd289dfSMat Martineau } 5498d2a7ac5dSMat Martineau } 5499d2a7ac5dSMat Martineau 55004b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 55014b51dae9SMat Martineau { 55024b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 55034b51dae9SMat Martineau 55044b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 55054b51dae9SMat Martineau chan->expected_tx_seq); 55064b51dae9SMat Martineau 55074b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 55084b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 55094b51dae9SMat Martineau chan->tx_win) { 55104b51dae9SMat Martineau /* See notes below regarding "double poll" and 55114b51dae9SMat Martineau * invalid packets. 55124b51dae9SMat Martineau */ 55134b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 55144b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 55154b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 55164b51dae9SMat Martineau } else { 55174b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 55184b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 55194b51dae9SMat Martineau } 55204b51dae9SMat Martineau } 55214b51dae9SMat Martineau 55224b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 55234b51dae9SMat Martineau BT_DBG("Expected SREJ"); 55244b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 55254b51dae9SMat Martineau } 55264b51dae9SMat Martineau 55274b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 55284b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 55294b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 55304b51dae9SMat Martineau } 55314b51dae9SMat Martineau 55324b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 55334b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 55344b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 55354b51dae9SMat Martineau } 55364b51dae9SMat Martineau } 55374b51dae9SMat Martineau 55384b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 55394b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 55404b51dae9SMat Martineau chan->tx_win) { 55414b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 55424b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 55434b51dae9SMat Martineau } else { 55444b51dae9SMat Martineau BT_DBG("Expected"); 55454b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 55464b51dae9SMat Martineau } 55474b51dae9SMat Martineau } 55484b51dae9SMat Martineau 55494b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 55502d792818SGustavo Padovan __seq_offset(chan, chan->expected_tx_seq, chan->last_acked_seq)) { 55514b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 55524b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 55534b51dae9SMat Martineau } 55544b51dae9SMat Martineau 55554b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 55564b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 55574b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 55584b51dae9SMat Martineau * the remote stack receives and processes both polls, 55594b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 55604b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 55614b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 55624b51dae9SMat Martineau * request. 55634b51dae9SMat Martineau * 55644b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 55654b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 55664b51dae9SMat Martineau * invalid frames to be safely ignored. 55674b51dae9SMat Martineau * 55684b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 55694b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 55704b51dae9SMat Martineau * causes a disconnect. 55714b51dae9SMat Martineau */ 55724b51dae9SMat Martineau 55734b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 55744b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 55754b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 55764b51dae9SMat Martineau } else { 55774b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 55784b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 55794b51dae9SMat Martineau } 55804b51dae9SMat Martineau } else { 55814b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 55824b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 55834b51dae9SMat Martineau } 55844b51dae9SMat Martineau } 55854b51dae9SMat Martineau 5586d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 5587d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5588d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5589d2a7ac5dSMat Martineau { 5590d2a7ac5dSMat Martineau int err = 0; 5591d2a7ac5dSMat Martineau bool skb_in_use = 0; 5592d2a7ac5dSMat Martineau 5593d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5594d2a7ac5dSMat Martineau event); 5595d2a7ac5dSMat Martineau 5596d2a7ac5dSMat Martineau switch (event) { 5597d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5598d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 5599d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5600d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5601d2a7ac5dSMat Martineau 5602d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5603d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 5604d2a7ac5dSMat Martineau control->txseq); 5605d2a7ac5dSMat Martineau break; 5606d2a7ac5dSMat Martineau } 5607d2a7ac5dSMat Martineau 5608d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 5609d2a7ac5dSMat Martineau control->txseq); 5610d2a7ac5dSMat Martineau 5611d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 5612d2a7ac5dSMat Martineau skb_in_use = 1; 5613d2a7ac5dSMat Martineau 5614d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 5615d2a7ac5dSMat Martineau if (err) 5616d2a7ac5dSMat Martineau break; 5617d2a7ac5dSMat Martineau 5618d2a7ac5dSMat Martineau if (control->final) { 5619d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5620d2a7ac5dSMat Martineau &chan->conn_state)) { 5621d2a7ac5dSMat Martineau control->final = 0; 5622d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5623d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5624d2a7ac5dSMat Martineau } 5625d2a7ac5dSMat Martineau } 5626d2a7ac5dSMat Martineau 5627d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 5628d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5629d2a7ac5dSMat Martineau break; 5630d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5631d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5632d2a7ac5dSMat Martineau 5633d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 5634d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 5635d2a7ac5dSMat Martineau * when local busy is exited. 5636d2a7ac5dSMat Martineau */ 5637d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5638d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 5639d2a7ac5dSMat Martineau control->txseq); 5640d2a7ac5dSMat Martineau break; 5641d2a7ac5dSMat Martineau } 5642d2a7ac5dSMat Martineau 5643d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 5644d2a7ac5dSMat Martineau * must be sent for each missing frame. The 5645d2a7ac5dSMat Martineau * current frame is stored for later use. 5646d2a7ac5dSMat Martineau */ 5647d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5648d2a7ac5dSMat Martineau skb_in_use = 1; 5649d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5650d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5651d2a7ac5dSMat Martineau 5652d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 5653d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 5654d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5655d2a7ac5dSMat Martineau 5656d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 5657d2a7ac5dSMat Martineau break; 5658d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5659d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5660d2a7ac5dSMat Martineau break; 5661d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5662d2a7ac5dSMat Martineau break; 5663d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5664d2a7ac5dSMat Martineau default: 56655e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5666d2a7ac5dSMat Martineau break; 5667d2a7ac5dSMat Martineau } 5668d2a7ac5dSMat Martineau break; 5669d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5670d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5671d2a7ac5dSMat Martineau if (control->final) { 5672d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5673d2a7ac5dSMat Martineau 5674e6a3ee6eSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state) && 5675e6a3ee6eSMat Martineau !__chan_is_moving(chan)) { 5676d2a7ac5dSMat Martineau control->final = 0; 5677d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5678d2a7ac5dSMat Martineau } 5679d2a7ac5dSMat Martineau 5680d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5681d2a7ac5dSMat Martineau } else if (control->poll) { 5682d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 5683d2a7ac5dSMat Martineau } else { 5684d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5685d2a7ac5dSMat Martineau &chan->conn_state) && 5686d2a7ac5dSMat Martineau chan->unacked_frames) 5687d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5688d2a7ac5dSMat Martineau 5689d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5690d2a7ac5dSMat Martineau } 5691d2a7ac5dSMat Martineau break; 5692d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5693d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5694d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5695d2a7ac5dSMat Martineau if (control && control->poll) { 5696d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5697d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 5698d2a7ac5dSMat Martineau } 5699d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 5700d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 5701d2a7ac5dSMat Martineau break; 5702d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5703d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5704d2a7ac5dSMat Martineau break; 5705d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5706d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5707d2a7ac5dSMat Martineau break; 5708d2a7ac5dSMat Martineau default: 5709d2a7ac5dSMat Martineau break; 5710d2a7ac5dSMat Martineau } 5711d2a7ac5dSMat Martineau 5712d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5713d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5714d2a7ac5dSMat Martineau kfree_skb(skb); 5715d2a7ac5dSMat Martineau } 5716d2a7ac5dSMat Martineau 5717d2a7ac5dSMat Martineau return err; 5718d2a7ac5dSMat Martineau } 5719d2a7ac5dSMat Martineau 5720d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 5721d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5722d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5723d2a7ac5dSMat Martineau { 5724d2a7ac5dSMat Martineau int err = 0; 5725d2a7ac5dSMat Martineau u16 txseq = control->txseq; 5726d2a7ac5dSMat Martineau bool skb_in_use = 0; 5727d2a7ac5dSMat Martineau 5728d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5729d2a7ac5dSMat Martineau event); 5730d2a7ac5dSMat Martineau 5731d2a7ac5dSMat Martineau switch (event) { 5732d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5733d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 5734d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5735d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 5736d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5737d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5738d2a7ac5dSMat Martineau skb_in_use = 1; 5739d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5740d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5741d2a7ac5dSMat Martineau 5742d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 5743d2a7ac5dSMat Martineau break; 5744d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 5745d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 5746d2a7ac5dSMat Martineau 5747d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5748d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5749d2a7ac5dSMat Martineau skb_in_use = 1; 5750d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5751d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5752d2a7ac5dSMat Martineau 5753d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 5754d2a7ac5dSMat Martineau if (err) 5755d2a7ac5dSMat Martineau break; 5756d2a7ac5dSMat Martineau 5757d2a7ac5dSMat Martineau break; 5758d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5759d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 5760d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 5761d2a7ac5dSMat Martineau * the missing frames. 5762d2a7ac5dSMat Martineau */ 5763d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5764d2a7ac5dSMat Martineau skb_in_use = 1; 5765d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5766d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5767d2a7ac5dSMat Martineau 5768d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5769d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5770d2a7ac5dSMat Martineau break; 5771d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 5772d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 5773d2a7ac5dSMat Martineau * some expected retransmitted frames are 5774d2a7ac5dSMat Martineau * missing. Request retransmission of missing 5775d2a7ac5dSMat Martineau * SREJ'd frames. 5776d2a7ac5dSMat Martineau */ 5777d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5778d2a7ac5dSMat Martineau skb_in_use = 1; 5779d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5780d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5781d2a7ac5dSMat Martineau 5782d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5783d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 5784d2a7ac5dSMat Martineau break; 5785d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 5786d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 5787d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5788d2a7ac5dSMat Martineau break; 5789d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5790d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 5791d2a7ac5dSMat Martineau * was already received. Ignore it completely. 5792d2a7ac5dSMat Martineau */ 5793d2a7ac5dSMat Martineau break; 5794d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5795d2a7ac5dSMat Martineau break; 5796d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5797d2a7ac5dSMat Martineau default: 57985e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5799d2a7ac5dSMat Martineau break; 5800d2a7ac5dSMat Martineau } 5801d2a7ac5dSMat Martineau break; 5802d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5803d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5804d2a7ac5dSMat Martineau if (control->final) { 5805d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5806d2a7ac5dSMat Martineau 5807d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5808d2a7ac5dSMat Martineau &chan->conn_state)) { 5809d2a7ac5dSMat Martineau control->final = 0; 5810d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5811d2a7ac5dSMat Martineau } 5812d2a7ac5dSMat Martineau 5813d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5814d2a7ac5dSMat Martineau } else if (control->poll) { 5815d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5816d2a7ac5dSMat Martineau &chan->conn_state) && 5817d2a7ac5dSMat Martineau chan->unacked_frames) { 5818d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5819d2a7ac5dSMat Martineau } 5820d2a7ac5dSMat Martineau 5821d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5822d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5823d2a7ac5dSMat Martineau } else { 5824d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5825d2a7ac5dSMat Martineau &chan->conn_state) && 5826d2a7ac5dSMat Martineau chan->unacked_frames) 5827d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5828d2a7ac5dSMat Martineau 5829d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5830d2a7ac5dSMat Martineau } 5831d2a7ac5dSMat Martineau break; 5832d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5833d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5834d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5835d2a7ac5dSMat Martineau if (control->poll) { 5836d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5837d2a7ac5dSMat Martineau } else { 5838d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 5839d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 5840d2a7ac5dSMat Martineau rr_control.sframe = 1; 5841d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 5842d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 5843d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 5844d2a7ac5dSMat Martineau } 5845d2a7ac5dSMat Martineau 5846d2a7ac5dSMat Martineau break; 5847d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5848d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5849d2a7ac5dSMat Martineau break; 5850d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5851d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5852d2a7ac5dSMat Martineau break; 5853d2a7ac5dSMat Martineau } 5854d2a7ac5dSMat Martineau 5855d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5856d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5857d2a7ac5dSMat Martineau kfree_skb(skb); 5858d2a7ac5dSMat Martineau } 5859d2a7ac5dSMat Martineau 5860d2a7ac5dSMat Martineau return err; 5861d2a7ac5dSMat Martineau } 5862d2a7ac5dSMat Martineau 586332b32735SMat Martineau static int l2cap_finish_move(struct l2cap_chan *chan) 586432b32735SMat Martineau { 586532b32735SMat Martineau BT_DBG("chan %p", chan); 586632b32735SMat Martineau 586732b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 586832b32735SMat Martineau 586932b32735SMat Martineau if (chan->hs_hcon) 587032b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 587132b32735SMat Martineau else 587232b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 587332b32735SMat Martineau 587432b32735SMat Martineau return l2cap_resegment(chan); 587532b32735SMat Martineau } 587632b32735SMat Martineau 587732b32735SMat Martineau static int l2cap_rx_state_wait_p(struct l2cap_chan *chan, 587832b32735SMat Martineau struct l2cap_ctrl *control, 587932b32735SMat Martineau struct sk_buff *skb, u8 event) 588032b32735SMat Martineau { 588132b32735SMat Martineau int err; 588232b32735SMat Martineau 588332b32735SMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 588432b32735SMat Martineau event); 588532b32735SMat Martineau 588632b32735SMat Martineau if (!control->poll) 588732b32735SMat Martineau return -EPROTO; 588832b32735SMat Martineau 588932b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 589032b32735SMat Martineau 589132b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 589232b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 589332b32735SMat Martineau else 589432b32735SMat Martineau chan->tx_send_head = NULL; 589532b32735SMat Martineau 589632b32735SMat Martineau /* Rewind next_tx_seq to the point expected 589732b32735SMat Martineau * by the receiver. 589832b32735SMat Martineau */ 589932b32735SMat Martineau chan->next_tx_seq = control->reqseq; 590032b32735SMat Martineau chan->unacked_frames = 0; 590132b32735SMat Martineau 590232b32735SMat Martineau err = l2cap_finish_move(chan); 590332b32735SMat Martineau if (err) 590432b32735SMat Martineau return err; 590532b32735SMat Martineau 590632b32735SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 590732b32735SMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 590832b32735SMat Martineau 590932b32735SMat Martineau if (event == L2CAP_EV_RECV_IFRAME) 591032b32735SMat Martineau return -EPROTO; 591132b32735SMat Martineau 591232b32735SMat Martineau return l2cap_rx_state_recv(chan, control, NULL, event); 591332b32735SMat Martineau } 591432b32735SMat Martineau 591532b32735SMat Martineau static int l2cap_rx_state_wait_f(struct l2cap_chan *chan, 591632b32735SMat Martineau struct l2cap_ctrl *control, 591732b32735SMat Martineau struct sk_buff *skb, u8 event) 591832b32735SMat Martineau { 591932b32735SMat Martineau int err; 592032b32735SMat Martineau 592132b32735SMat Martineau if (!control->final) 592232b32735SMat Martineau return -EPROTO; 592332b32735SMat Martineau 592432b32735SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 592532b32735SMat Martineau 592632b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 592732b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 592832b32735SMat Martineau 592932b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 593032b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 593132b32735SMat Martineau else 593232b32735SMat Martineau chan->tx_send_head = NULL; 593332b32735SMat Martineau 593432b32735SMat Martineau /* Rewind next_tx_seq to the point expected 593532b32735SMat Martineau * by the receiver. 593632b32735SMat Martineau */ 593732b32735SMat Martineau chan->next_tx_seq = control->reqseq; 593832b32735SMat Martineau chan->unacked_frames = 0; 593932b32735SMat Martineau 594032b32735SMat Martineau if (chan->hs_hcon) 594132b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 594232b32735SMat Martineau else 594332b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 594432b32735SMat Martineau 594532b32735SMat Martineau err = l2cap_resegment(chan); 594632b32735SMat Martineau 594732b32735SMat Martineau if (!err) 594832b32735SMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 594932b32735SMat Martineau 595032b32735SMat Martineau return err; 595132b32735SMat Martineau } 595232b32735SMat Martineau 5953d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 5954d2a7ac5dSMat Martineau { 5955d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 5956d2a7ac5dSMat Martineau u16 unacked; 5957d2a7ac5dSMat Martineau 5958d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 5959d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 5960d2a7ac5dSMat Martineau } 5961d2a7ac5dSMat Martineau 5962cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5963cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 59640a708f8fSGustavo F. Padovan { 5965d2a7ac5dSMat Martineau int err = 0; 5966d2a7ac5dSMat Martineau 5967d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 5968d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 5969d2a7ac5dSMat Martineau 5970d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 5971d2a7ac5dSMat Martineau switch (chan->rx_state) { 5972d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 5973d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 5974d2a7ac5dSMat Martineau break; 5975d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 5976d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 5977d2a7ac5dSMat Martineau event); 5978d2a7ac5dSMat Martineau break; 597932b32735SMat Martineau case L2CAP_RX_STATE_WAIT_P: 598032b32735SMat Martineau err = l2cap_rx_state_wait_p(chan, control, skb, event); 598132b32735SMat Martineau break; 598232b32735SMat Martineau case L2CAP_RX_STATE_WAIT_F: 598332b32735SMat Martineau err = l2cap_rx_state_wait_f(chan, control, skb, event); 598432b32735SMat Martineau break; 5985d2a7ac5dSMat Martineau default: 5986d2a7ac5dSMat Martineau /* shut it down */ 5987d2a7ac5dSMat Martineau break; 5988d2a7ac5dSMat Martineau } 5989d2a7ac5dSMat Martineau } else { 5990d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 5991d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 5992d2a7ac5dSMat Martineau chan->expected_ack_seq); 59935e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5994d2a7ac5dSMat Martineau } 5995d2a7ac5dSMat Martineau 5996d2a7ac5dSMat Martineau return err; 5997cec8ab6eSMat Martineau } 5998cec8ab6eSMat Martineau 5999cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 6000cec8ab6eSMat Martineau struct sk_buff *skb) 6001cec8ab6eSMat Martineau { 60024b51dae9SMat Martineau int err = 0; 60034b51dae9SMat Martineau 60044b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 60054b51dae9SMat Martineau chan->rx_state); 60064b51dae9SMat Martineau 60074b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 60084b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 60094b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 60104b51dae9SMat Martineau 60114b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 60124b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 60134b51dae9SMat Martineau 60144b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 60154b51dae9SMat Martineau 60164b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 60174b51dae9SMat Martineau } else { 60184b51dae9SMat Martineau if (chan->sdu) { 60194b51dae9SMat Martineau kfree_skb(chan->sdu); 60204b51dae9SMat Martineau chan->sdu = NULL; 60214b51dae9SMat Martineau } 60224b51dae9SMat Martineau chan->sdu_last_frag = NULL; 60234b51dae9SMat Martineau chan->sdu_len = 0; 60244b51dae9SMat Martineau 60254b51dae9SMat Martineau if (skb) { 60264b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 60274b51dae9SMat Martineau kfree_skb(skb); 60284b51dae9SMat Martineau } 60294b51dae9SMat Martineau } 60304b51dae9SMat Martineau 60314b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 60324b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 60334b51dae9SMat Martineau 60344b51dae9SMat Martineau return err; 6035cec8ab6eSMat Martineau } 6036cec8ab6eSMat Martineau 6037cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 6038cec8ab6eSMat Martineau { 6039cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 6040cec8ab6eSMat Martineau u16 len; 6041cec8ab6eSMat Martineau u8 event; 60420a708f8fSGustavo F. Padovan 6043b76bbd66SMat Martineau __unpack_control(chan, skb); 6044b76bbd66SMat Martineau 60450a708f8fSGustavo F. Padovan len = skb->len; 60460a708f8fSGustavo F. Padovan 60470a708f8fSGustavo F. Padovan /* 60480a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 60490a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 6050cec8ab6eSMat Martineau * procedures and ask for retransmission. 60510a708f8fSGustavo F. Padovan */ 605247d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 60530a708f8fSGustavo F. Padovan goto drop; 60540a708f8fSGustavo F. Padovan 6055cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 605603a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 60570a708f8fSGustavo F. Padovan 605847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 605903a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 60600a708f8fSGustavo F. Padovan 606147d1ec61SGustavo F. Padovan if (len > chan->mps) { 60625e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 60630a708f8fSGustavo F. Padovan goto drop; 60640a708f8fSGustavo F. Padovan } 60650a708f8fSGustavo F. Padovan 6066cec8ab6eSMat Martineau if (!control->sframe) { 6067cec8ab6eSMat Martineau int err; 60680a708f8fSGustavo F. Padovan 6069cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 6070cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 6071cec8ab6eSMat Martineau control->txseq); 6072836be934SAndrei Emeltchenko 6073cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 6074cec8ab6eSMat Martineau * valid in TX WAIT_F 6075cec8ab6eSMat Martineau */ 6076cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 60770a708f8fSGustavo F. Padovan goto drop; 60780a708f8fSGustavo F. Padovan 6079cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 6080cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 6081cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 60820a708f8fSGustavo F. Padovan } else { 6083cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 6084cec8ab6eSMat Martineau } 6085cec8ab6eSMat Martineau 6086cec8ab6eSMat Martineau if (err) 60875e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 6088cec8ab6eSMat Martineau } else { 6089cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 6090cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 6091cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 6092cec8ab6eSMat Martineau }; 6093cec8ab6eSMat Martineau 6094cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 6095cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 6096cec8ab6eSMat Martineau goto drop; 6097cec8ab6eSMat Martineau 6098cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 6099cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 6100cec8ab6eSMat Martineau control->super); 6101cec8ab6eSMat Martineau 61020a708f8fSGustavo F. Padovan if (len != 0) { 61031bb166e6SAndrei Emeltchenko BT_ERR("Trailing bytes: %d in sframe", len); 61045e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 61050a708f8fSGustavo F. Padovan goto drop; 61060a708f8fSGustavo F. Padovan } 61070a708f8fSGustavo F. Padovan 6108cec8ab6eSMat Martineau /* Validate F and P bits */ 6109cec8ab6eSMat Martineau if (control->final && (control->poll || 6110cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 6111cec8ab6eSMat Martineau goto drop; 6112cec8ab6eSMat Martineau 6113cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 6114cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 61155e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 61160a708f8fSGustavo F. Padovan } 61170a708f8fSGustavo F. Padovan 61180a708f8fSGustavo F. Padovan return 0; 61190a708f8fSGustavo F. Padovan 61200a708f8fSGustavo F. Padovan drop: 61210a708f8fSGustavo F. Padovan kfree_skb(skb); 61220a708f8fSGustavo F. Padovan return 0; 61230a708f8fSGustavo F. Padovan } 61240a708f8fSGustavo F. Padovan 612513ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 612613ca56e0SAndrei Emeltchenko struct sk_buff *skb) 61270a708f8fSGustavo F. Padovan { 612848454079SGustavo F. Padovan struct l2cap_chan *chan; 61290a708f8fSGustavo F. Padovan 6130baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 613148454079SGustavo F. Padovan if (!chan) { 613297e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 613397e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 613497e8e89dSAndrei Emeltchenko if (!chan) { 613597e8e89dSAndrei Emeltchenko kfree_skb(skb); 613613ca56e0SAndrei Emeltchenko return; 613797e8e89dSAndrei Emeltchenko } 613897e8e89dSAndrei Emeltchenko 613997e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 614097e8e89dSAndrei Emeltchenko } else { 61410a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 61426be36555SAndrei Emeltchenko /* Drop packet and return */ 61433379013bSDan Carpenter kfree_skb(skb); 614413ca56e0SAndrei Emeltchenko return; 61450a708f8fSGustavo F. Padovan } 614697e8e89dSAndrei Emeltchenko } 61470a708f8fSGustavo F. Padovan 614849208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 61490a708f8fSGustavo F. Padovan 615089bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 61510a708f8fSGustavo F. Padovan goto drop; 61520a708f8fSGustavo F. Padovan 61530c1bc5c6SGustavo F. Padovan switch (chan->mode) { 61540a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 61550a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 61560a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 61570a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 61580a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 61590a708f8fSGustavo F. Padovan 61600c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 61610a708f8fSGustavo F. Padovan goto drop; 61620a708f8fSGustavo F. Padovan 616380b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 61640a708f8fSGustavo F. Padovan goto done; 61650a708f8fSGustavo F. Padovan break; 61660a708f8fSGustavo F. Padovan 61670a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 61680a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 6169cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 61700a708f8fSGustavo F. Padovan goto done; 61710a708f8fSGustavo F. Padovan 61720a708f8fSGustavo F. Padovan default: 61730c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 61740a708f8fSGustavo F. Padovan break; 61750a708f8fSGustavo F. Padovan } 61760a708f8fSGustavo F. Padovan 61770a708f8fSGustavo F. Padovan drop: 61780a708f8fSGustavo F. Padovan kfree_skb(skb); 61790a708f8fSGustavo F. Padovan 61800a708f8fSGustavo F. Padovan done: 61816be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 61820a708f8fSGustavo F. Padovan } 61830a708f8fSGustavo F. Padovan 618484104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 618584104b24SAndrei Emeltchenko struct sk_buff *skb) 61860a708f8fSGustavo F. Padovan { 618723691d75SGustavo F. Padovan struct l2cap_chan *chan; 61880a708f8fSGustavo F. Padovan 6189c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 619023691d75SGustavo F. Padovan if (!chan) 61910a708f8fSGustavo F. Padovan goto drop; 61920a708f8fSGustavo F. Padovan 61935b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 61940a708f8fSGustavo F. Padovan 619589bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 61960a708f8fSGustavo F. Padovan goto drop; 61970a708f8fSGustavo F. Padovan 6198e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 61990a708f8fSGustavo F. Padovan goto drop; 62000a708f8fSGustavo F. Padovan 620180b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 620284104b24SAndrei Emeltchenko return; 62030a708f8fSGustavo F. Padovan 62040a708f8fSGustavo F. Padovan drop: 62050a708f8fSGustavo F. Padovan kfree_skb(skb); 62060a708f8fSGustavo F. Padovan } 62070a708f8fSGustavo F. Padovan 62086810fca7SAndrei Emeltchenko static void l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 6209d9b88702SAndrei Emeltchenko struct sk_buff *skb) 62109f69bda6SGustavo F. Padovan { 621123691d75SGustavo F. Padovan struct l2cap_chan *chan; 62129f69bda6SGustavo F. Padovan 6213c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 621423691d75SGustavo F. Padovan if (!chan) 62159f69bda6SGustavo F. Padovan goto drop; 62169f69bda6SGustavo F. Padovan 62175b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 62189f69bda6SGustavo F. Padovan 621989bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 62209f69bda6SGustavo F. Padovan goto drop; 62219f69bda6SGustavo F. Padovan 6222e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 62239f69bda6SGustavo F. Padovan goto drop; 62249f69bda6SGustavo F. Padovan 622580b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 62266810fca7SAndrei Emeltchenko return; 62279f69bda6SGustavo F. Padovan 62289f69bda6SGustavo F. Padovan drop: 62299f69bda6SGustavo F. Padovan kfree_skb(skb); 62309f69bda6SGustavo F. Padovan } 62319f69bda6SGustavo F. Padovan 62320a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 62330a708f8fSGustavo F. Padovan { 62340a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 62350a708f8fSGustavo F. Padovan u16 cid, len; 62360a708f8fSGustavo F. Padovan __le16 psm; 62370a708f8fSGustavo F. Padovan 62380a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 62390a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 62400a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 62410a708f8fSGustavo F. Padovan 62420a708f8fSGustavo F. Padovan if (len != skb->len) { 62430a708f8fSGustavo F. Padovan kfree_skb(skb); 62440a708f8fSGustavo F. Padovan return; 62450a708f8fSGustavo F. Padovan } 62460a708f8fSGustavo F. Padovan 62470a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 62480a708f8fSGustavo F. Padovan 62490a708f8fSGustavo F. Padovan switch (cid) { 62503300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 62510a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 62520a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 62530a708f8fSGustavo F. Padovan break; 62540a708f8fSGustavo F. Padovan 62550a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 6256097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 62570181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 62580a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 62590a708f8fSGustavo F. Padovan break; 62600a708f8fSGustavo F. Padovan 62619f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 62629f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 62639f69bda6SGustavo F. Padovan break; 62649f69bda6SGustavo F. Padovan 6265b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 6266b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 6267b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 6268b501d6a1SAnderson Briglia break; 6269b501d6a1SAnderson Briglia 62700a708f8fSGustavo F. Padovan default: 62710a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 62720a708f8fSGustavo F. Padovan break; 62730a708f8fSGustavo F. Padovan } 62740a708f8fSGustavo F. Padovan } 62750a708f8fSGustavo F. Padovan 62760a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 62770a708f8fSGustavo F. Padovan 6278686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 62790a708f8fSGustavo F. Padovan { 62800a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 628123691d75SGustavo F. Padovan struct l2cap_chan *c; 62820a708f8fSGustavo F. Padovan 62836ed93dc6SAndrei Emeltchenko BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 62840a708f8fSGustavo F. Padovan 62850a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 628623691d75SGustavo F. Padovan read_lock(&chan_list_lock); 628723691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 628823691d75SGustavo F. Padovan struct sock *sk = c->sk; 62894343478fSGustavo F. Padovan 629089bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 62910a708f8fSGustavo F. Padovan continue; 62920a708f8fSGustavo F. Padovan 62930a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 62940a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 629543bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 62960a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 62970a708f8fSGustavo F. Padovan exact++; 62980a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 62990a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 630043bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 63010a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 63020a708f8fSGustavo F. Padovan } 63030a708f8fSGustavo F. Padovan } 630423691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 63050a708f8fSGustavo F. Padovan 63060a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 63070a708f8fSGustavo F. Padovan } 63080a708f8fSGustavo F. Padovan 63099e664631SAndrei Emeltchenko void l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 63100a708f8fSGustavo F. Padovan { 63110a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 63120a708f8fSGustavo F. Padovan 63136ed93dc6SAndrei Emeltchenko BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status); 63140a708f8fSGustavo F. Padovan 63150a708f8fSGustavo F. Padovan if (!status) { 63160a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 63170a708f8fSGustavo F. Padovan if (conn) 63180a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 6319ba6fc317SAndrei Emeltchenko } else { 6320e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 6321ba6fc317SAndrei Emeltchenko } 63220a708f8fSGustavo F. Padovan } 63230a708f8fSGustavo F. Padovan 6324686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 63250a708f8fSGustavo F. Padovan { 63260a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 63270a708f8fSGustavo F. Padovan 63280a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 63290a708f8fSGustavo F. Padovan 6330686ebf28SUlisses Furquim if (!conn) 63319f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 63320a708f8fSGustavo F. Padovan return conn->disc_reason; 63330a708f8fSGustavo F. Padovan } 63340a708f8fSGustavo F. Padovan 63359e664631SAndrei Emeltchenko void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 63360a708f8fSGustavo F. Padovan { 63370a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 63380a708f8fSGustavo F. Padovan 6339e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 63400a708f8fSGustavo F. Padovan } 63410a708f8fSGustavo F. Padovan 63424343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 63430a708f8fSGustavo F. Padovan { 6344715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 63450a708f8fSGustavo F. Padovan return; 63460a708f8fSGustavo F. Padovan 63470a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 63484343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 6349ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 63504343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 63510f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 63520a708f8fSGustavo F. Padovan } else { 63534343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 6354c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 63550a708f8fSGustavo F. Padovan } 63560a708f8fSGustavo F. Padovan } 63570a708f8fSGustavo F. Padovan 6358686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 63590a708f8fSGustavo F. Padovan { 63600a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 636148454079SGustavo F. Padovan struct l2cap_chan *chan; 63620a708f8fSGustavo F. Padovan 63630a708f8fSGustavo F. Padovan if (!conn) 63640a708f8fSGustavo F. Padovan return 0; 63650a708f8fSGustavo F. Padovan 636689d8b407SAndrei Emeltchenko BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt); 63670a708f8fSGustavo F. Padovan 6368160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 636935d4adccSHemant Gupta if (!status && encrypt) 6370160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 637117cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 6372160dc6acSVinicius Costa Gomes } 6373160dc6acSVinicius Costa Gomes 63743df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 63750a708f8fSGustavo F. Padovan 63763df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 63776be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 63780a708f8fSGustavo F. Padovan 637989d8b407SAndrei Emeltchenko BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid, 638089d8b407SAndrei Emeltchenko state_to_string(chan->state)); 6381f1cb9af5SVinicius Costa Gomes 638278eb2f98SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 638378eb2f98SAndrei Emeltchenko l2cap_chan_unlock(chan); 638478eb2f98SAndrei Emeltchenko continue; 638578eb2f98SAndrei Emeltchenko } 638678eb2f98SAndrei Emeltchenko 6387f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 6388f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 6389f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 6390cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 6391f1cb9af5SVinicius Costa Gomes } 6392f1cb9af5SVinicius Costa Gomes 63936be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 6394f1cb9af5SVinicius Costa Gomes continue; 6395f1cb9af5SVinicius Costa Gomes } 6396f1cb9af5SVinicius Costa Gomes 639796eff46eSAndrei Emeltchenko if (!__l2cap_no_conn_pending(chan)) { 63986be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 63990a708f8fSGustavo F. Padovan continue; 64000a708f8fSGustavo F. Padovan } 64010a708f8fSGustavo F. Padovan 640289bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 640389bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 6404a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 6405a7d7723aSGustavo Padovan 6406c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 6407a7d7723aSGustavo Padovan sk->sk_state_change(sk); 6408a7d7723aSGustavo Padovan 64094343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 64106be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 64110a708f8fSGustavo F. Padovan continue; 64120a708f8fSGustavo F. Padovan } 64130a708f8fSGustavo F. Padovan 641489bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 64150a708f8fSGustavo F. Padovan if (!status) { 641693c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 64170a708f8fSGustavo F. Padovan } else { 6418ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 64190a708f8fSGustavo F. Padovan } 642089bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 64216be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 64220a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6423df3c3931SJohan Hedberg __u16 res, stat; 64240a708f8fSGustavo F. Padovan 64256be36555SAndrei Emeltchenko lock_sock(sk); 64266be36555SAndrei Emeltchenko 64270a708f8fSGustavo F. Padovan if (!status) { 6428c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 6429c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 6430df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 6431df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 64322dc4e510SGustavo Padovan chan->ops->defer(chan); 6433df3c3931SJohan Hedberg } else { 64340e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 6435df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 6436df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 6437df3c3931SJohan Hedberg } 64380a708f8fSGustavo F. Padovan } else { 64390e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 6440ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 6441df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 6442df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 64430a708f8fSGustavo F. Padovan } 64440a708f8fSGustavo F. Padovan 64456be36555SAndrei Emeltchenko release_sock(sk); 64466be36555SAndrei Emeltchenko 6447fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6448fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6449df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 6450df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 6451fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6452fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 64532d369359SMat Martineau 64542d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 64552d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 64562d369359SMat Martineau char buf[128]; 64572d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 64582d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 64592d369359SMat Martineau L2CAP_CONF_REQ, 64602d369359SMat Martineau l2cap_build_conf_req(chan, buf), 64612d369359SMat Martineau buf); 64622d369359SMat Martineau chan->num_conf_req++; 64632d369359SMat Martineau } 64640a708f8fSGustavo F. Padovan } 64650a708f8fSGustavo F. Padovan 64666be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 64670a708f8fSGustavo F. Padovan } 64680a708f8fSGustavo F. Padovan 64693df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 64700a708f8fSGustavo F. Padovan 64710a708f8fSGustavo F. Padovan return 0; 64720a708f8fSGustavo F. Padovan } 64730a708f8fSGustavo F. Padovan 6474686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 64750a708f8fSGustavo F. Padovan { 64760a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 6477d73a0988SAndrei Emeltchenko struct l2cap_hdr *hdr; 6478d73a0988SAndrei Emeltchenko int len; 64790a708f8fSGustavo F. Padovan 64801d13a254SAndrei Emeltchenko /* For AMP controller do not create l2cap conn */ 64811d13a254SAndrei Emeltchenko if (!conn && hcon->hdev->dev_type != HCI_BREDR) 64821d13a254SAndrei Emeltchenko goto drop; 64830a708f8fSGustavo F. Padovan 64840a708f8fSGustavo F. Padovan if (!conn) 64850a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 64860a708f8fSGustavo F. Padovan 64870a708f8fSGustavo F. Padovan if (!conn) 64880a708f8fSGustavo F. Padovan goto drop; 64890a708f8fSGustavo F. Padovan 64900a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 64910a708f8fSGustavo F. Padovan 6492d73a0988SAndrei Emeltchenko switch (flags) { 6493d73a0988SAndrei Emeltchenko case ACL_START: 6494d73a0988SAndrei Emeltchenko case ACL_START_NO_FLUSH: 6495d73a0988SAndrei Emeltchenko case ACL_COMPLETE: 64960a708f8fSGustavo F. Padovan if (conn->rx_len) { 64970a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 64980a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 64990a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 65000a708f8fSGustavo F. Padovan conn->rx_len = 0; 65010a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 65020a708f8fSGustavo F. Padovan } 65030a708f8fSGustavo F. Padovan 65040a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 65050a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 65060a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 65070a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 65080a708f8fSGustavo F. Padovan goto drop; 65090a708f8fSGustavo F. Padovan } 65100a708f8fSGustavo F. Padovan 65110a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 65120a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 65130a708f8fSGustavo F. Padovan 65140a708f8fSGustavo F. Padovan if (len == skb->len) { 65150a708f8fSGustavo F. Padovan /* Complete frame received */ 65160a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 65170a708f8fSGustavo F. Padovan return 0; 65180a708f8fSGustavo F. Padovan } 65190a708f8fSGustavo F. Padovan 65200a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 65210a708f8fSGustavo F. Padovan 65220a708f8fSGustavo F. Padovan if (skb->len > len) { 65230a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 65240a708f8fSGustavo F. Padovan skb->len, len); 65250a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 65260a708f8fSGustavo F. Padovan goto drop; 65270a708f8fSGustavo F. Padovan } 65280a708f8fSGustavo F. Padovan 65290a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 65308bcde1f2SGustavo Padovan conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL); 65310a708f8fSGustavo F. Padovan if (!conn->rx_skb) 65320a708f8fSGustavo F. Padovan goto drop; 65330a708f8fSGustavo F. Padovan 65340a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 65350a708f8fSGustavo F. Padovan skb->len); 65360a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 6537d73a0988SAndrei Emeltchenko break; 6538d73a0988SAndrei Emeltchenko 6539d73a0988SAndrei Emeltchenko case ACL_CONT: 65400a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 65410a708f8fSGustavo F. Padovan 65420a708f8fSGustavo F. Padovan if (!conn->rx_len) { 65430a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 65440a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 65450a708f8fSGustavo F. Padovan goto drop; 65460a708f8fSGustavo F. Padovan } 65470a708f8fSGustavo F. Padovan 65480a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 65490a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 65500a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 65510a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 65520a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 65530a708f8fSGustavo F. Padovan conn->rx_len = 0; 65540a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 65550a708f8fSGustavo F. Padovan goto drop; 65560a708f8fSGustavo F. Padovan } 65570a708f8fSGustavo F. Padovan 65580a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 65590a708f8fSGustavo F. Padovan skb->len); 65600a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 65610a708f8fSGustavo F. Padovan 65620a708f8fSGustavo F. Padovan if (!conn->rx_len) { 65630a708f8fSGustavo F. Padovan /* Complete frame received */ 65640a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 65650a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 65660a708f8fSGustavo F. Padovan } 6567d73a0988SAndrei Emeltchenko break; 65680a708f8fSGustavo F. Padovan } 65690a708f8fSGustavo F. Padovan 65700a708f8fSGustavo F. Padovan drop: 65710a708f8fSGustavo F. Padovan kfree_skb(skb); 65720a708f8fSGustavo F. Padovan return 0; 65730a708f8fSGustavo F. Padovan } 65740a708f8fSGustavo F. Padovan 65750a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 65760a708f8fSGustavo F. Padovan { 657723691d75SGustavo F. Padovan struct l2cap_chan *c; 65780a708f8fSGustavo F. Padovan 6579333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 65800a708f8fSGustavo F. Padovan 658123691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 658223691d75SGustavo F. Padovan struct sock *sk = c->sk; 65830a708f8fSGustavo F. Padovan 6584fcb73338SAndrei Emeltchenko seq_printf(f, "%pMR %pMR %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 6585fcb73338SAndrei Emeltchenko &bt_sk(sk)->src, &bt_sk(sk)->dst, 658689bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 658723691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 658823691d75SGustavo F. Padovan c->sec_level, c->mode); 65890a708f8fSGustavo F. Padovan } 65900a708f8fSGustavo F. Padovan 6591333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 65920a708f8fSGustavo F. Padovan 65930a708f8fSGustavo F. Padovan return 0; 65940a708f8fSGustavo F. Padovan } 65950a708f8fSGustavo F. Padovan 65960a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 65970a708f8fSGustavo F. Padovan { 65980a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 65990a708f8fSGustavo F. Padovan } 66000a708f8fSGustavo F. Padovan 66010a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 66020a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 66030a708f8fSGustavo F. Padovan .read = seq_read, 66040a708f8fSGustavo F. Padovan .llseek = seq_lseek, 66050a708f8fSGustavo F. Padovan .release = single_release, 66060a708f8fSGustavo F. Padovan }; 66070a708f8fSGustavo F. Padovan 66080a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 66090a708f8fSGustavo F. Padovan 661064274518SGustavo F. Padovan int __init l2cap_init(void) 66110a708f8fSGustavo F. Padovan { 66120a708f8fSGustavo F. Padovan int err; 66130a708f8fSGustavo F. Padovan 6614bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 66150a708f8fSGustavo F. Padovan if (err < 0) 66160a708f8fSGustavo F. Padovan return err; 66170a708f8fSGustavo F. Padovan 66180a708f8fSGustavo F. Padovan if (bt_debugfs) { 66192d792818SGustavo Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, bt_debugfs, 66202d792818SGustavo Padovan NULL, &l2cap_debugfs_fops); 66210a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 66220a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 66230a708f8fSGustavo F. Padovan } 66240a708f8fSGustavo F. Padovan 66250a708f8fSGustavo F. Padovan return 0; 66260a708f8fSGustavo F. Padovan } 66270a708f8fSGustavo F. Padovan 662864274518SGustavo F. Padovan void l2cap_exit(void) 66290a708f8fSGustavo F. Padovan { 66300a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 6631bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 66320a708f8fSGustavo F. Padovan } 66330a708f8fSGustavo F. Padovan 66340a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 66350a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 6636