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; 507073d1cf3SJohan Hedberg chan->scid = L2CAP_CID_ATT; 508073d1cf3SJohan Hedberg chan->dcid = L2CAP_CID_ATT; 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 */ 1347073d1cf3SJohan Hedberg pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_ATT, 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 14492c8e1411SDavid Herrmann /* 14502c8e1411SDavid Herrmann * l2cap_user 14512c8e1411SDavid Herrmann * External modules can register l2cap_user objects on l2cap_conn. The ->probe 14522c8e1411SDavid Herrmann * callback is called during registration. The ->remove callback is called 14532c8e1411SDavid Herrmann * during unregistration. 14542c8e1411SDavid Herrmann * An l2cap_user object can either be explicitly unregistered or when the 14552c8e1411SDavid Herrmann * underlying l2cap_conn object is deleted. This guarantees that l2cap->hcon, 14562c8e1411SDavid Herrmann * l2cap->hchan, .. are valid as long as the remove callback hasn't been called. 14572c8e1411SDavid Herrmann * External modules must own a reference to the l2cap_conn object if they intend 14582c8e1411SDavid Herrmann * to call l2cap_unregister_user(). The l2cap_conn object might get destroyed at 14592c8e1411SDavid Herrmann * any time if they don't. 14602c8e1411SDavid Herrmann */ 14612c8e1411SDavid Herrmann 14622c8e1411SDavid Herrmann int l2cap_register_user(struct l2cap_conn *conn, struct l2cap_user *user) 14632c8e1411SDavid Herrmann { 14642c8e1411SDavid Herrmann struct hci_dev *hdev = conn->hcon->hdev; 14652c8e1411SDavid Herrmann int ret; 14662c8e1411SDavid Herrmann 14672c8e1411SDavid Herrmann /* We need to check whether l2cap_conn is registered. If it is not, we 14682c8e1411SDavid Herrmann * must not register the l2cap_user. l2cap_conn_del() is unregisters 14692c8e1411SDavid Herrmann * l2cap_conn objects, but doesn't provide its own locking. Instead, it 14702c8e1411SDavid Herrmann * relies on the parent hci_conn object to be locked. This itself relies 14712c8e1411SDavid Herrmann * on the hci_dev object to be locked. So we must lock the hci device 14722c8e1411SDavid Herrmann * here, too. */ 14732c8e1411SDavid Herrmann 14742c8e1411SDavid Herrmann hci_dev_lock(hdev); 14752c8e1411SDavid Herrmann 14762c8e1411SDavid Herrmann if (user->list.next || user->list.prev) { 14772c8e1411SDavid Herrmann ret = -EINVAL; 14782c8e1411SDavid Herrmann goto out_unlock; 14792c8e1411SDavid Herrmann } 14802c8e1411SDavid Herrmann 14812c8e1411SDavid Herrmann /* conn->hchan is NULL after l2cap_conn_del() was called */ 14822c8e1411SDavid Herrmann if (!conn->hchan) { 14832c8e1411SDavid Herrmann ret = -ENODEV; 14842c8e1411SDavid Herrmann goto out_unlock; 14852c8e1411SDavid Herrmann } 14862c8e1411SDavid Herrmann 14872c8e1411SDavid Herrmann ret = user->probe(conn, user); 14882c8e1411SDavid Herrmann if (ret) 14892c8e1411SDavid Herrmann goto out_unlock; 14902c8e1411SDavid Herrmann 14912c8e1411SDavid Herrmann list_add(&user->list, &conn->users); 14922c8e1411SDavid Herrmann ret = 0; 14932c8e1411SDavid Herrmann 14942c8e1411SDavid Herrmann out_unlock: 14952c8e1411SDavid Herrmann hci_dev_unlock(hdev); 14962c8e1411SDavid Herrmann return ret; 14972c8e1411SDavid Herrmann } 14982c8e1411SDavid Herrmann EXPORT_SYMBOL(l2cap_register_user); 14992c8e1411SDavid Herrmann 15002c8e1411SDavid Herrmann void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user) 15012c8e1411SDavid Herrmann { 15022c8e1411SDavid Herrmann struct hci_dev *hdev = conn->hcon->hdev; 15032c8e1411SDavid Herrmann 15042c8e1411SDavid Herrmann hci_dev_lock(hdev); 15052c8e1411SDavid Herrmann 15062c8e1411SDavid Herrmann if (!user->list.next || !user->list.prev) 15072c8e1411SDavid Herrmann goto out_unlock; 15082c8e1411SDavid Herrmann 15092c8e1411SDavid Herrmann list_del(&user->list); 15102c8e1411SDavid Herrmann user->list.next = NULL; 15112c8e1411SDavid Herrmann user->list.prev = NULL; 15122c8e1411SDavid Herrmann user->remove(conn, user); 15132c8e1411SDavid Herrmann 15142c8e1411SDavid Herrmann out_unlock: 15152c8e1411SDavid Herrmann hci_dev_unlock(hdev); 15162c8e1411SDavid Herrmann } 15172c8e1411SDavid Herrmann EXPORT_SYMBOL(l2cap_unregister_user); 15182c8e1411SDavid Herrmann 15192c8e1411SDavid Herrmann static void l2cap_unregister_all_users(struct l2cap_conn *conn) 15202c8e1411SDavid Herrmann { 15212c8e1411SDavid Herrmann struct l2cap_user *user; 15222c8e1411SDavid Herrmann 15232c8e1411SDavid Herrmann while (!list_empty(&conn->users)) { 15242c8e1411SDavid Herrmann user = list_first_entry(&conn->users, struct l2cap_user, list); 15252c8e1411SDavid Herrmann list_del(&user->list); 15262c8e1411SDavid Herrmann user->list.next = NULL; 15272c8e1411SDavid Herrmann user->list.prev = NULL; 15282c8e1411SDavid Herrmann user->remove(conn, user); 15292c8e1411SDavid Herrmann } 15302c8e1411SDavid Herrmann } 15312c8e1411SDavid Herrmann 15325d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 15335d3de7dfSVinicius Costa Gomes { 15345d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 15355d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 15365d3de7dfSVinicius Costa Gomes 15375d3de7dfSVinicius Costa Gomes if (!conn) 15385d3de7dfSVinicius Costa Gomes return; 15395d3de7dfSVinicius Costa Gomes 15405d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 15415d3de7dfSVinicius Costa Gomes 15425d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 15435d3de7dfSVinicius Costa Gomes 15442c8e1411SDavid Herrmann l2cap_unregister_all_users(conn); 15452c8e1411SDavid Herrmann 15463df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 15473df91ea2SAndrei Emeltchenko 15485d3de7dfSVinicius Costa Gomes /* Kill channels */ 15495d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 155061d6ef3eSMat Martineau l2cap_chan_hold(chan); 15516be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 15526be36555SAndrei Emeltchenko 15535d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 15546be36555SAndrei Emeltchenko 15556be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 15566be36555SAndrei Emeltchenko 155780b98027SGustavo Padovan chan->ops->close(chan); 155861d6ef3eSMat Martineau l2cap_chan_put(chan); 15595d3de7dfSVinicius Costa Gomes } 15605d3de7dfSVinicius Costa Gomes 15613df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 15623df91ea2SAndrei Emeltchenko 156373d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 156473d80debSLuiz Augusto von Dentz 15655d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1566127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 15675d3de7dfSVinicius Costa Gomes 156851a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1569127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 15708aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1571d26a2345SVinicius Costa Gomes } 15725d3de7dfSVinicius Costa Gomes 15735d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 15749c903e37SDavid Herrmann conn->hchan = NULL; 15759c903e37SDavid Herrmann l2cap_conn_put(conn); 15765d3de7dfSVinicius Costa Gomes } 15775d3de7dfSVinicius Costa Gomes 15786c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 15795d3de7dfSVinicius Costa Gomes { 15806c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 15816c9d42a1SGustavo F. Padovan security_timer.work); 15825d3de7dfSVinicius Costa Gomes 1583d06cc416SJohan Hedberg BT_DBG("conn %p", conn); 1584d06cc416SJohan Hedberg 1585d06cc416SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 1586d06cc416SJohan Hedberg smp_chan_destroy(conn); 15875d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 15885d3de7dfSVinicius Costa Gomes } 1589d06cc416SJohan Hedberg } 15905d3de7dfSVinicius Costa Gomes 1591baf43251SClaudio Takahasi static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon) 15920a708f8fSGustavo F. Padovan { 15930a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 159473d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 15950a708f8fSGustavo F. Padovan 1596baf43251SClaudio Takahasi if (conn) 15970a708f8fSGustavo F. Padovan return conn; 15980a708f8fSGustavo F. Padovan 159973d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 160073d80debSLuiz Augusto von Dentz if (!hchan) 16010a708f8fSGustavo F. Padovan return NULL; 16020a708f8fSGustavo F. Padovan 16038bcde1f2SGustavo Padovan conn = kzalloc(sizeof(struct l2cap_conn), GFP_KERNEL); 160473d80debSLuiz Augusto von Dentz if (!conn) { 160573d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 160673d80debSLuiz Augusto von Dentz return NULL; 160773d80debSLuiz Augusto von Dentz } 160873d80debSLuiz Augusto von Dentz 16099c903e37SDavid Herrmann kref_init(&conn->ref); 16100a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 16110a708f8fSGustavo F. Padovan conn->hcon = hcon; 16129c903e37SDavid Herrmann hci_conn_get(conn->hcon); 161373d80debSLuiz Augusto von Dentz conn->hchan = hchan; 16140a708f8fSGustavo F. Padovan 161573d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 16160a708f8fSGustavo F. Padovan 1617dcc042d5SAndrei Emeltchenko switch (hcon->type) { 1618dcc042d5SAndrei Emeltchenko case LE_LINK: 1619dcc042d5SAndrei Emeltchenko if (hcon->hdev->le_mtu) { 1620acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1621dcc042d5SAndrei Emeltchenko break; 1622dcc042d5SAndrei Emeltchenko } 1623dcc042d5SAndrei Emeltchenko /* fall through */ 1624dcc042d5SAndrei Emeltchenko default: 16250a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1626dcc042d5SAndrei Emeltchenko break; 1627dcc042d5SAndrei Emeltchenko } 1628acd7d370SVille Tervo 16290a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 16300a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 16310a708f8fSGustavo F. Padovan 16320a708f8fSGustavo F. Padovan conn->feat_mask = 0; 16330a708f8fSGustavo F. Padovan 16340a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 16353df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1636baa7e1faSGustavo F. Padovan 1637baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 16382c8e1411SDavid Herrmann INIT_LIST_HEAD(&conn->users); 16390a708f8fSGustavo F. Padovan 16405d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 16416c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 16425d3de7dfSVinicius Costa Gomes else 1643030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 16440a708f8fSGustavo F. Padovan 16459f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 16460a708f8fSGustavo F. Padovan 16470a708f8fSGustavo F. Padovan return conn; 16480a708f8fSGustavo F. Padovan } 16490a708f8fSGustavo F. Padovan 16509c903e37SDavid Herrmann static void l2cap_conn_free(struct kref *ref) 16519c903e37SDavid Herrmann { 16529c903e37SDavid Herrmann struct l2cap_conn *conn = container_of(ref, struct l2cap_conn, ref); 16539c903e37SDavid Herrmann 16549c903e37SDavid Herrmann hci_conn_put(conn->hcon); 16559c903e37SDavid Herrmann kfree(conn); 16569c903e37SDavid Herrmann } 16579c903e37SDavid Herrmann 16589c903e37SDavid Herrmann void l2cap_conn_get(struct l2cap_conn *conn) 16599c903e37SDavid Herrmann { 16609c903e37SDavid Herrmann kref_get(&conn->ref); 16619c903e37SDavid Herrmann } 16629c903e37SDavid Herrmann EXPORT_SYMBOL(l2cap_conn_get); 16639c903e37SDavid Herrmann 16649c903e37SDavid Herrmann void l2cap_conn_put(struct l2cap_conn *conn) 16659c903e37SDavid Herrmann { 16669c903e37SDavid Herrmann kref_put(&conn->ref, l2cap_conn_free); 16679c903e37SDavid Herrmann } 16689c903e37SDavid Herrmann EXPORT_SYMBOL(l2cap_conn_put); 16699c903e37SDavid Herrmann 16700a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 16710a708f8fSGustavo F. Padovan 1672c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 16730a708f8fSGustavo F. Padovan * Returns closest match. 16740a708f8fSGustavo F. Padovan */ 1675c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1676c2287681SIdo Yariv bdaddr_t *src, 1677c2287681SIdo Yariv bdaddr_t *dst) 16780a708f8fSGustavo F. Padovan { 167923691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 16800a708f8fSGustavo F. Padovan 168123691d75SGustavo F. Padovan read_lock(&chan_list_lock); 16820a708f8fSGustavo F. Padovan 168323691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 168423691d75SGustavo F. Padovan struct sock *sk = c->sk; 1685fe4128e0SGustavo F. Padovan 168689bc500eSGustavo F. Padovan if (state && c->state != state) 16870a708f8fSGustavo F. Padovan continue; 16880a708f8fSGustavo F. Padovan 168923691d75SGustavo F. Padovan if (c->psm == psm) { 1690c2287681SIdo Yariv int src_match, dst_match; 1691c2287681SIdo Yariv int src_any, dst_any; 1692c2287681SIdo Yariv 16930a708f8fSGustavo F. Padovan /* Exact match. */ 1694c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1695c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1696c2287681SIdo Yariv if (src_match && dst_match) { 1697a7567b20SJohannes Berg read_unlock(&chan_list_lock); 169823691d75SGustavo F. Padovan return c; 169923691d75SGustavo F. Padovan } 17000a708f8fSGustavo F. Padovan 17010a708f8fSGustavo F. Padovan /* Closest match */ 1702c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1703c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1704c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1705c2287681SIdo Yariv (src_any && dst_any)) 170623691d75SGustavo F. Padovan c1 = c; 17070a708f8fSGustavo F. Padovan } 17080a708f8fSGustavo F. Padovan } 17090a708f8fSGustavo F. Padovan 171023691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 17110a708f8fSGustavo F. Padovan 171223691d75SGustavo F. Padovan return c1; 17130a708f8fSGustavo F. Padovan } 17140a708f8fSGustavo F. Padovan 17158e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 17168e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 17170a708f8fSGustavo F. Padovan { 17185d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 17190a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 17200a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 17210a708f8fSGustavo F. Padovan struct hci_conn *hcon; 17220a708f8fSGustavo F. Padovan struct hci_dev *hdev; 17230a708f8fSGustavo F. Padovan __u8 auth_type; 17240a708f8fSGustavo F. Padovan int err; 17250a708f8fSGustavo F. Padovan 17266ed93dc6SAndrei Emeltchenko BT_DBG("%pMR -> %pMR (type %u) psm 0x%2.2x", src, dst, 1727ab19516aSSyam Sidhardhan dst_type, __le16_to_cpu(psm)); 17280a708f8fSGustavo F. Padovan 17290a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 17300a708f8fSGustavo F. Padovan if (!hdev) 17310a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 17320a708f8fSGustavo F. Padovan 173309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17340a708f8fSGustavo F. Padovan 17356be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 173603a00194SGustavo F. Padovan 173703a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 173803a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 173903a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 174003a00194SGustavo F. Padovan err = -EINVAL; 174103a00194SGustavo F. Padovan goto done; 174203a00194SGustavo F. Padovan } 174303a00194SGustavo F. Padovan 174403a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 174503a00194SGustavo F. Padovan err = -EINVAL; 174603a00194SGustavo F. Padovan goto done; 174703a00194SGustavo F. Padovan } 174803a00194SGustavo F. Padovan 174903a00194SGustavo F. Padovan switch (chan->mode) { 175003a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 175103a00194SGustavo F. Padovan break; 175203a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 175303a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 175403a00194SGustavo F. Padovan if (!disable_ertm) 175503a00194SGustavo F. Padovan break; 175603a00194SGustavo F. Padovan /* fall through */ 175703a00194SGustavo F. Padovan default: 175803a00194SGustavo F. Padovan err = -ENOTSUPP; 175903a00194SGustavo F. Padovan goto done; 176003a00194SGustavo F. Padovan } 176103a00194SGustavo F. Padovan 17620797e01dSGustavo Padovan switch (chan->state) { 176303a00194SGustavo F. Padovan case BT_CONNECT: 176403a00194SGustavo F. Padovan case BT_CONNECT2: 176503a00194SGustavo F. Padovan case BT_CONFIG: 176603a00194SGustavo F. Padovan /* Already connecting */ 176703a00194SGustavo F. Padovan err = 0; 176803a00194SGustavo F. Padovan goto done; 176903a00194SGustavo F. Padovan 177003a00194SGustavo F. Padovan case BT_CONNECTED: 177103a00194SGustavo F. Padovan /* Already connected */ 177203a00194SGustavo F. Padovan err = -EISCONN; 177303a00194SGustavo F. Padovan goto done; 177403a00194SGustavo F. Padovan 177503a00194SGustavo F. Padovan case BT_OPEN: 177603a00194SGustavo F. Padovan case BT_BOUND: 177703a00194SGustavo F. Padovan /* Can connect */ 177803a00194SGustavo F. Padovan break; 177903a00194SGustavo F. Padovan 178003a00194SGustavo F. Padovan default: 178103a00194SGustavo F. Padovan err = -EBADFD; 178203a00194SGustavo F. Padovan goto done; 178303a00194SGustavo F. Padovan } 178403a00194SGustavo F. Padovan 178503a00194SGustavo F. Padovan /* Set destination address and psm */ 17860797e01dSGustavo Padovan lock_sock(sk); 17879219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 17886be36555SAndrei Emeltchenko release_sock(sk); 17896be36555SAndrei Emeltchenko 179003a00194SGustavo F. Padovan chan->psm = psm; 179103a00194SGustavo F. Padovan chan->dcid = cid; 17920a708f8fSGustavo F. Padovan 17934343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 17940a708f8fSGustavo F. Padovan 1795f224ca5fSJohan Hedberg if (bdaddr_type_is_le(dst_type)) 17968e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 17974343478fSGustavo F. Padovan chan->sec_level, auth_type); 1798acd7d370SVille Tervo else 17998e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 18004343478fSGustavo F. Padovan chan->sec_level, auth_type); 1801acd7d370SVille Tervo 180230e76272SVille Tervo if (IS_ERR(hcon)) { 180330e76272SVille Tervo err = PTR_ERR(hcon); 18040a708f8fSGustavo F. Padovan goto done; 180530e76272SVille Tervo } 18060a708f8fSGustavo F. Padovan 1807baf43251SClaudio Takahasi conn = l2cap_conn_add(hcon); 18080a708f8fSGustavo F. Padovan if (!conn) { 180976a68ba0SDavid Herrmann hci_conn_drop(hcon); 181030e76272SVille Tervo err = -ENOMEM; 18110a708f8fSGustavo F. Padovan goto done; 18120a708f8fSGustavo F. Padovan } 18130a708f8fSGustavo F. Padovan 18149f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 18159f0caeb1SVinicius Costa Gomes err = 0; 18169f0caeb1SVinicius Costa Gomes 18179f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 18189f0caeb1SVinicius Costa Gomes err = -EBUSY; 181976a68ba0SDavid Herrmann hci_conn_drop(hcon); 18209f0caeb1SVinicius Costa Gomes } 18219f0caeb1SVinicius Costa Gomes 18229f0caeb1SVinicius Costa Gomes if (err) 18239f0caeb1SVinicius Costa Gomes goto done; 18249f0caeb1SVinicius Costa Gomes } 18259f0caeb1SVinicius Costa Gomes 18260a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 18270a708f8fSGustavo F. Padovan bacpy(src, conn->src); 18280a708f8fSGustavo F. Padovan 18296be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 183048454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 18316be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 183248454079SGustavo F. Padovan 18336be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1834c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 18350a708f8fSGustavo F. Padovan 18360a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1837715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1838c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1839d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 18406be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 18410a708f8fSGustavo F. Padovan } else 1842fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 18430a708f8fSGustavo F. Padovan } 18440a708f8fSGustavo F. Padovan 184530e76272SVille Tervo err = 0; 184630e76272SVille Tervo 18470a708f8fSGustavo F. Padovan done: 18486be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 184909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18500a708f8fSGustavo F. Padovan hci_dev_put(hdev); 18510a708f8fSGustavo F. Padovan return err; 18520a708f8fSGustavo F. Padovan } 18530a708f8fSGustavo F. Padovan 1854dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 18550a708f8fSGustavo F. Padovan { 18568c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 18570a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 18580a708f8fSGustavo F. Padovan int err = 0; 18590a708f8fSGustavo F. Padovan int timeo = HZ/5; 18600a708f8fSGustavo F. Padovan 18610a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 18620a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1863a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 18640a708f8fSGustavo F. Padovan if (!timeo) 18650a708f8fSGustavo F. Padovan timeo = HZ/5; 18660a708f8fSGustavo F. Padovan 18670a708f8fSGustavo F. Padovan if (signal_pending(current)) { 18680a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 18690a708f8fSGustavo F. Padovan break; 18700a708f8fSGustavo F. Padovan } 18710a708f8fSGustavo F. Padovan 18720a708f8fSGustavo F. Padovan release_sock(sk); 18730a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 18740a708f8fSGustavo F. Padovan lock_sock(sk); 1875a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 18760a708f8fSGustavo F. Padovan 18770a708f8fSGustavo F. Padovan err = sock_error(sk); 18780a708f8fSGustavo F. Padovan if (err) 18790a708f8fSGustavo F. Padovan break; 18800a708f8fSGustavo F. Padovan } 18810a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 18820a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 18830a708f8fSGustavo F. Padovan return err; 18840a708f8fSGustavo F. Padovan } 18850a708f8fSGustavo F. Padovan 1886721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 18870a708f8fSGustavo F. Padovan { 1888721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1889721c4181SGustavo F. Padovan monitor_timer.work); 18900a708f8fSGustavo F. Padovan 1891525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 18920a708f8fSGustavo F. Padovan 18936be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 18946be36555SAndrei Emeltchenko 189580909e04SMat Martineau if (!chan->conn) { 18966be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 18978d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 18980a708f8fSGustavo F. Padovan return; 18990a708f8fSGustavo F. Padovan } 19000a708f8fSGustavo F. Padovan 1901401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 19020a708f8fSGustavo F. Padovan 19036be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 19048d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 19050a708f8fSGustavo F. Padovan } 19060a708f8fSGustavo F. Padovan 1907721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 19080a708f8fSGustavo F. Padovan { 1909721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1910721c4181SGustavo F. Padovan retrans_timer.work); 19110a708f8fSGustavo F. Padovan 191249208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 19130a708f8fSGustavo F. Padovan 19146be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 19156be36555SAndrei Emeltchenko 191680909e04SMat Martineau if (!chan->conn) { 191780909e04SMat Martineau l2cap_chan_unlock(chan); 191880909e04SMat Martineau l2cap_chan_put(chan); 191980909e04SMat Martineau return; 192080909e04SMat Martineau } 19210a708f8fSGustavo F. Padovan 1922401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 19236be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 19248d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 19250a708f8fSGustavo F. Padovan } 19260a708f8fSGustavo F. Padovan 1927d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 19283733937dSMat Martineau struct sk_buff_head *skbs) 19290a708f8fSGustavo F. Padovan { 19300a708f8fSGustavo F. Padovan struct sk_buff *skb; 19313733937dSMat Martineau struct l2cap_ctrl *control; 19320a708f8fSGustavo F. Padovan 19333733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 19343733937dSMat Martineau 1935b99e13adSMat Martineau if (__chan_is_moving(chan)) 1936b99e13adSMat Martineau return; 1937b99e13adSMat Martineau 19383733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 19393733937dSMat Martineau 19403733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 19413733937dSMat Martineau 19423733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 19433733937dSMat Martineau 19443733937dSMat Martineau bt_cb(skb)->control.retries = 1; 19453733937dSMat Martineau control = &bt_cb(skb)->control; 19463733937dSMat Martineau 19473733937dSMat Martineau control->reqseq = 0; 19483733937dSMat Martineau control->txseq = chan->next_tx_seq; 19493733937dSMat Martineau 19503733937dSMat Martineau __pack_control(chan, control, skb); 19510a708f8fSGustavo F. Padovan 195247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 19533733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 19543733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 19550a708f8fSGustavo F. Padovan } 19560a708f8fSGustavo F. Padovan 19574343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 19580a708f8fSGustavo F. Padovan 1959b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 19603733937dSMat Martineau 1961836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 19623733937dSMat Martineau chan->frames_sent++; 19630a708f8fSGustavo F. Padovan } 19640a708f8fSGustavo F. Padovan } 19650a708f8fSGustavo F. Padovan 196667c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 19670a708f8fSGustavo F. Padovan { 19680a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 196918a48e76SMat Martineau struct l2cap_ctrl *control; 197018a48e76SMat Martineau int sent = 0; 197118a48e76SMat Martineau 197218a48e76SMat Martineau BT_DBG("chan %p", chan); 19730a708f8fSGustavo F. Padovan 197489bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 19750a708f8fSGustavo F. Padovan return -ENOTCONN; 19760a708f8fSGustavo F. Padovan 197794122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 197894122bbeSMat Martineau return 0; 197994122bbeSMat Martineau 1980b99e13adSMat Martineau if (__chan_is_moving(chan)) 1981b99e13adSMat Martineau return 0; 1982b99e13adSMat Martineau 198318a48e76SMat Martineau while (chan->tx_send_head && 198418a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 198518a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 19860a708f8fSGustavo F. Padovan 198718a48e76SMat Martineau skb = chan->tx_send_head; 19880a708f8fSGustavo F. Padovan 198918a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 199018a48e76SMat Martineau control = &bt_cb(skb)->control; 19910a708f8fSGustavo F. Padovan 1992e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 199318a48e76SMat Martineau control->final = 1; 1994e2ab4353SGustavo F. Padovan 199518a48e76SMat Martineau control->reqseq = chan->buffer_seq; 199618a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 199718a48e76SMat Martineau control->txseq = chan->next_tx_seq; 19980a708f8fSGustavo F. Padovan 199918a48e76SMat Martineau __pack_control(chan, control, skb); 20000a708f8fSGustavo F. Padovan 200147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 200218a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 200318a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 20040a708f8fSGustavo F. Padovan } 20050a708f8fSGustavo F. Padovan 200618a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 200718a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 200818a48e76SMat Martineau */ 200918a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 201018a48e76SMat Martineau 201118a48e76SMat Martineau if (!tx_skb) 201218a48e76SMat Martineau break; 20130a708f8fSGustavo F. Padovan 20141a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 20150a708f8fSGustavo F. Padovan 2016836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 20176a026610SGustavo F. Padovan chan->unacked_frames++; 20186a026610SGustavo F. Padovan chan->frames_sent++; 201918a48e76SMat Martineau sent++; 20200a708f8fSGustavo F. Padovan 202158d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 202258d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 20230a708f8fSGustavo F. Padovan else 202458d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 202518a48e76SMat Martineau 202618a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 2027b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 20280a708f8fSGustavo F. Padovan } 20290a708f8fSGustavo F. Padovan 2030b4400672SAndrei Emeltchenko BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent, 2031b4400672SAndrei Emeltchenko chan->unacked_frames, skb_queue_len(&chan->tx_q)); 203218a48e76SMat Martineau 203318a48e76SMat Martineau return sent; 20340a708f8fSGustavo F. Padovan } 20350a708f8fSGustavo F. Padovan 2036e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 2037e1fbd4c1SMat Martineau { 2038e1fbd4c1SMat Martineau struct l2cap_ctrl control; 2039e1fbd4c1SMat Martineau struct sk_buff *skb; 2040e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 2041e1fbd4c1SMat Martineau u16 seq; 2042e1fbd4c1SMat Martineau 2043e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 2044e1fbd4c1SMat Martineau 2045e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 2046e1fbd4c1SMat Martineau return; 2047e1fbd4c1SMat Martineau 2048b99e13adSMat Martineau if (__chan_is_moving(chan)) 2049b99e13adSMat Martineau return; 2050b99e13adSMat Martineau 2051e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 2052e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 2053e1fbd4c1SMat Martineau 2054e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 2055e1fbd4c1SMat Martineau if (!skb) { 2056e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 2057e1fbd4c1SMat Martineau seq); 2058e1fbd4c1SMat Martineau continue; 2059e1fbd4c1SMat Martineau } 2060e1fbd4c1SMat Martineau 2061e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 2062e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 2063e1fbd4c1SMat Martineau 2064e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 2065e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 2066e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 20675e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 2068e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2069e1fbd4c1SMat Martineau break; 2070e1fbd4c1SMat Martineau } 2071e1fbd4c1SMat Martineau 2072e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 2073e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 2074e1fbd4c1SMat Martineau control.final = 1; 2075e1fbd4c1SMat Martineau else 2076e1fbd4c1SMat Martineau control.final = 0; 2077e1fbd4c1SMat Martineau 2078e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 2079e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 2080e1fbd4c1SMat Martineau * writeable copy 2081e1fbd4c1SMat Martineau */ 20828bcde1f2SGustavo Padovan tx_skb = skb_copy(skb, GFP_KERNEL); 2083e1fbd4c1SMat Martineau } else { 20848bcde1f2SGustavo Padovan tx_skb = skb_clone(skb, GFP_KERNEL); 2085e1fbd4c1SMat Martineau } 2086e1fbd4c1SMat Martineau 2087e1fbd4c1SMat Martineau if (!tx_skb) { 2088e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2089e1fbd4c1SMat Martineau break; 2090e1fbd4c1SMat Martineau } 2091e1fbd4c1SMat Martineau 2092e1fbd4c1SMat Martineau /* Update skb contents */ 2093e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 2094e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 2095e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 2096e1fbd4c1SMat Martineau } else { 2097e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 2098e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 2099e1fbd4c1SMat Martineau } 2100e1fbd4c1SMat Martineau 2101e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 2102e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 2103e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 2104e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 2105e1fbd4c1SMat Martineau } 2106e1fbd4c1SMat Martineau 2107e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 2108e1fbd4c1SMat Martineau 2109e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 2110e1fbd4c1SMat Martineau 2111e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 2112e1fbd4c1SMat Martineau } 2113e1fbd4c1SMat Martineau } 2114e1fbd4c1SMat Martineau 2115f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 2116f80842a8SMat Martineau struct l2cap_ctrl *control) 2117f80842a8SMat Martineau { 2118f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2119f80842a8SMat Martineau 2120f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 2121f80842a8SMat Martineau l2cap_ertm_resend(chan); 2122f80842a8SMat Martineau } 2123f80842a8SMat Martineau 2124d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 2125d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 2126d2a7ac5dSMat Martineau { 2127e1fbd4c1SMat Martineau struct sk_buff *skb; 2128e1fbd4c1SMat Martineau 2129e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2130e1fbd4c1SMat Martineau 2131e1fbd4c1SMat Martineau if (control->poll) 2132e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 2133e1fbd4c1SMat Martineau 2134e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2135e1fbd4c1SMat Martineau 2136e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 2137e1fbd4c1SMat Martineau return; 2138e1fbd4c1SMat Martineau 2139e1fbd4c1SMat Martineau if (chan->unacked_frames) { 2140e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 2141e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 2142e1fbd4c1SMat Martineau skb == chan->tx_send_head) 2143e1fbd4c1SMat Martineau break; 2144e1fbd4c1SMat Martineau } 2145e1fbd4c1SMat Martineau 2146e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 2147e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 2148e1fbd4c1SMat Martineau break; 2149e1fbd4c1SMat Martineau 2150e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 2151e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 2152e1fbd4c1SMat Martineau } 2153e1fbd4c1SMat Martineau 2154e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 2155e1fbd4c1SMat Martineau } 2156d2a7ac5dSMat Martineau } 2157d2a7ac5dSMat Martineau 2158b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 2159b17e73bbSSzymon Janc { 21600a0aba42SMat Martineau struct l2cap_ctrl control; 21610a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 21620a0aba42SMat Martineau chan->last_acked_seq); 21630a0aba42SMat Martineau int threshold; 21640a0aba42SMat Martineau 21650a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 21660a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 21670a0aba42SMat Martineau 21680a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 21690a0aba42SMat Martineau control.sframe = 1; 21700a0aba42SMat Martineau 21710a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 21720a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 2173b17e73bbSSzymon Janc __clear_ack_timer(chan); 21740a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 21750a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 21760a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 21770a0aba42SMat Martineau } else { 21780a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 21790a0aba42SMat Martineau l2cap_ertm_send(chan); 21800a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 21810a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 21820a0aba42SMat Martineau frames_to_ack = 0; 21830a0aba42SMat Martineau } 21840a0aba42SMat Martineau 2185c20f8e35SMat Martineau /* Ack now if the window is 3/4ths full. 21860a0aba42SMat Martineau * Calculate without mul or div 21870a0aba42SMat Martineau */ 2188c20f8e35SMat Martineau threshold = chan->ack_win; 21890a0aba42SMat Martineau threshold += threshold << 1; 21900a0aba42SMat Martineau threshold >>= 2; 21910a0aba42SMat Martineau 2192b4400672SAndrei Emeltchenko BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack, 21930a0aba42SMat Martineau threshold); 21940a0aba42SMat Martineau 21950a0aba42SMat Martineau if (frames_to_ack >= threshold) { 21960a0aba42SMat Martineau __clear_ack_timer(chan); 21970a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 21980a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 21990a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 22000a0aba42SMat Martineau frames_to_ack = 0; 22010a0aba42SMat Martineau } 22020a0aba42SMat Martineau 22030a0aba42SMat Martineau if (frames_to_ack) 22040a0aba42SMat Martineau __set_ack_timer(chan); 22050a0aba42SMat Martineau } 2206b17e73bbSSzymon Janc } 2207b17e73bbSSzymon Janc 220804124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 220904124681SGustavo F. Padovan struct msghdr *msg, int len, 221004124681SGustavo F. Padovan int count, struct sk_buff *skb) 22110a708f8fSGustavo F. Padovan { 22120952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 22130a708f8fSGustavo F. Padovan struct sk_buff **frag; 221490338947SGustavo Padovan int sent = 0; 22150a708f8fSGustavo F. Padovan 22160a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 22170a708f8fSGustavo F. Padovan return -EFAULT; 22180a708f8fSGustavo F. Padovan 22190a708f8fSGustavo F. Padovan sent += count; 22200a708f8fSGustavo F. Padovan len -= count; 22210a708f8fSGustavo F. Padovan 22220a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 22230a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 22240a708f8fSGustavo F. Padovan while (len) { 2225fbe00700SGustavo Padovan struct sk_buff *tmp; 2226fbe00700SGustavo Padovan 22270a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 22280a708f8fSGustavo F. Padovan 2229fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 223090338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 2231fbe00700SGustavo Padovan if (IS_ERR(tmp)) 2232fbe00700SGustavo Padovan return PTR_ERR(tmp); 22332f7719ceSAndrei Emeltchenko 2234fbe00700SGustavo Padovan *frag = tmp; 2235fbe00700SGustavo Padovan 22360a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 22370a708f8fSGustavo F. Padovan return -EFAULT; 22380a708f8fSGustavo F. Padovan 22395e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 22405e59b791SLuiz Augusto von Dentz 22410a708f8fSGustavo F. Padovan sent += count; 22420a708f8fSGustavo F. Padovan len -= count; 22430a708f8fSGustavo F. Padovan 22442d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 22452d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 22462d0ed3d5SGustavo Padovan 22470a708f8fSGustavo F. Padovan frag = &(*frag)->next; 22480a708f8fSGustavo F. Padovan } 22490a708f8fSGustavo F. Padovan 22500a708f8fSGustavo F. Padovan return sent; 22510a708f8fSGustavo F. Padovan } 22520a708f8fSGustavo F. Padovan 22535e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 22545e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 22555e59b791SLuiz Augusto von Dentz u32 priority) 22560a708f8fSGustavo F. Padovan { 22578c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 22580a708f8fSGustavo F. Padovan struct sk_buff *skb; 225903a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 22600a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 22610a708f8fSGustavo F. Padovan 2262b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu priority %u", chan, len, priority); 22630a708f8fSGustavo F. Padovan 22640a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 22652f7719ceSAndrei Emeltchenko 22662f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 226790338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 226890338947SGustavo Padovan if (IS_ERR(skb)) 226990338947SGustavo Padovan return skb; 22700a708f8fSGustavo F. Padovan 22715e59b791SLuiz Augusto von Dentz skb->priority = priority; 22725e59b791SLuiz Augusto von Dentz 22730a708f8fSGustavo F. Padovan /* Create L2CAP header */ 22740a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2275fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 2276daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 2277daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 22780a708f8fSGustavo F. Padovan 22790952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 22800a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 22810a708f8fSGustavo F. Padovan kfree_skb(skb); 22820a708f8fSGustavo F. Padovan return ERR_PTR(err); 22830a708f8fSGustavo F. Padovan } 22840a708f8fSGustavo F. Padovan return skb; 22850a708f8fSGustavo F. Padovan } 22860a708f8fSGustavo F. Padovan 22875e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 22885e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 22895e59b791SLuiz Augusto von Dentz u32 priority) 22900a708f8fSGustavo F. Padovan { 22918c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 22920a708f8fSGustavo F. Padovan struct sk_buff *skb; 2293f2ba7faeSGustavo Padovan int err, count; 22940a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 22950a708f8fSGustavo F. Padovan 2296b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 22970a708f8fSGustavo F. Padovan 2298f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 22992f7719ceSAndrei Emeltchenko 2300f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 230190338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 230290338947SGustavo Padovan if (IS_ERR(skb)) 230390338947SGustavo Padovan return skb; 23040a708f8fSGustavo F. Padovan 23055e59b791SLuiz Augusto von Dentz skb->priority = priority; 23065e59b791SLuiz Augusto von Dentz 23070a708f8fSGustavo F. Padovan /* Create L2CAP header */ 23080a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2309fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 23106ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 23110a708f8fSGustavo F. Padovan 23120952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 23130a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 23140a708f8fSGustavo F. Padovan kfree_skb(skb); 23150a708f8fSGustavo F. Padovan return ERR_PTR(err); 23160a708f8fSGustavo F. Padovan } 23170a708f8fSGustavo F. Padovan return skb; 23180a708f8fSGustavo F. Padovan } 23190a708f8fSGustavo F. Padovan 2320ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2321ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 232294122bbeSMat Martineau u16 sdulen) 23230a708f8fSGustavo F. Padovan { 23248c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 23250a708f8fSGustavo F. Padovan struct sk_buff *skb; 2326e4ca6d98SAndrei Emeltchenko int err, count, hlen; 23270a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 23280a708f8fSGustavo F. Padovan 2329b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 23300a708f8fSGustavo F. Padovan 23310a708f8fSGustavo F. Padovan if (!conn) 23320a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 23330a708f8fSGustavo F. Padovan 2334ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2335e4ca6d98SAndrei Emeltchenko 23360a708f8fSGustavo F. Padovan if (sdulen) 233703a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 23380a708f8fSGustavo F. Padovan 233947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 234003a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 23410a708f8fSGustavo F. Padovan 23420a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 23432f7719ceSAndrei Emeltchenko 23442f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 234590338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 234690338947SGustavo Padovan if (IS_ERR(skb)) 234790338947SGustavo Padovan return skb; 23480a708f8fSGustavo F. Padovan 23490a708f8fSGustavo F. Padovan /* Create L2CAP header */ 23500a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2351fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 23520a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 235388843ab0SAndrei Emeltchenko 235418a48e76SMat Martineau /* Control header is populated later */ 235518a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 235618a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 235718a48e76SMat Martineau else 235818a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 235988843ab0SAndrei Emeltchenko 23600a708f8fSGustavo F. Padovan if (sdulen) 236103a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 23620a708f8fSGustavo F. Padovan 23630952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 23640a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 23650a708f8fSGustavo F. Padovan kfree_skb(skb); 23660a708f8fSGustavo F. Padovan return ERR_PTR(err); 23670a708f8fSGustavo F. Padovan } 23680a708f8fSGustavo F. Padovan 236918a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 23703ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 23710a708f8fSGustavo F. Padovan return skb; 23720a708f8fSGustavo F. Padovan } 23730a708f8fSGustavo F. Padovan 237494122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 237594122bbeSMat Martineau struct sk_buff_head *seg_queue, 237694122bbeSMat Martineau struct msghdr *msg, size_t len) 23770a708f8fSGustavo F. Padovan { 23780a708f8fSGustavo F. Padovan struct sk_buff *skb; 237994122bbeSMat Martineau u16 sdu_len; 238094122bbeSMat Martineau size_t pdu_len; 238194122bbeSMat Martineau u8 sar; 23820a708f8fSGustavo F. Padovan 2383b4400672SAndrei Emeltchenko BT_DBG("chan %p, msg %p, len %zu", chan, msg, len); 23840a708f8fSGustavo F. Padovan 238594122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 238694122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 238794122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 238894122bbeSMat Martineau */ 238994122bbeSMat Martineau 239094122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 239194122bbeSMat Martineau pdu_len = chan->conn->mtu; 239294122bbeSMat Martineau 2393a549574dSMat Martineau /* Constrain PDU size for BR/EDR connections */ 2394a549574dSMat Martineau if (!chan->hs_hcon) 239594122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 239694122bbeSMat Martineau 239794122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 239835d401dfSGustavo Padovan if (chan->fcs) 239935d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 240035d401dfSGustavo Padovan 2401ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 240294122bbeSMat Martineau 240394122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 240494122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 240594122bbeSMat Martineau 240694122bbeSMat Martineau if (len <= pdu_len) { 240794122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 240894122bbeSMat Martineau sdu_len = 0; 240994122bbeSMat Martineau pdu_len = len; 241094122bbeSMat Martineau } else { 241194122bbeSMat Martineau sar = L2CAP_SAR_START; 241294122bbeSMat Martineau sdu_len = len; 241394122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 241494122bbeSMat Martineau } 24150a708f8fSGustavo F. Padovan 24160a708f8fSGustavo F. Padovan while (len > 0) { 241794122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 24180a708f8fSGustavo F. Padovan 24190a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 242094122bbeSMat Martineau __skb_queue_purge(seg_queue); 24210a708f8fSGustavo F. Padovan return PTR_ERR(skb); 24220a708f8fSGustavo F. Padovan } 24230a708f8fSGustavo F. Padovan 242494122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 242594122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 24260a708f8fSGustavo F. Padovan 242794122bbeSMat Martineau len -= pdu_len; 242894122bbeSMat Martineau if (sdu_len) { 242994122bbeSMat Martineau sdu_len = 0; 243094122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 243194122bbeSMat Martineau } 243294122bbeSMat Martineau 243394122bbeSMat Martineau if (len <= pdu_len) { 243494122bbeSMat Martineau sar = L2CAP_SAR_END; 243594122bbeSMat Martineau pdu_len = len; 243694122bbeSMat Martineau } else { 243794122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 243894122bbeSMat Martineau } 243994122bbeSMat Martineau } 244094122bbeSMat Martineau 2441f0f62799SGustavo Padovan return 0; 24420a708f8fSGustavo F. Padovan } 24430a708f8fSGustavo F. Padovan 24445e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 24455e59b791SLuiz Augusto von Dentz u32 priority) 24469a91a04aSGustavo F. Padovan { 24479a91a04aSGustavo F. Padovan struct sk_buff *skb; 24489a91a04aSGustavo F. Padovan int err; 244994122bbeSMat Martineau struct sk_buff_head seg_queue; 24509a91a04aSGustavo F. Padovan 24519a91a04aSGustavo F. Padovan /* Connectionless channel */ 2452715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 24535e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 24549a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 24559a91a04aSGustavo F. Padovan return PTR_ERR(skb); 24569a91a04aSGustavo F. Padovan 24579a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 24589a91a04aSGustavo F. Padovan return len; 24599a91a04aSGustavo F. Padovan } 24609a91a04aSGustavo F. Padovan 24619a91a04aSGustavo F. Padovan switch (chan->mode) { 24629a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 24639a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 24649a91a04aSGustavo F. Padovan if (len > chan->omtu) 24659a91a04aSGustavo F. Padovan return -EMSGSIZE; 24669a91a04aSGustavo F. Padovan 24679a91a04aSGustavo F. Padovan /* Create a basic PDU */ 24685e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 24699a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 24709a91a04aSGustavo F. Padovan return PTR_ERR(skb); 24719a91a04aSGustavo F. Padovan 24729a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 24739a91a04aSGustavo F. Padovan err = len; 24749a91a04aSGustavo F. Padovan break; 24759a91a04aSGustavo F. Padovan 24769a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 24779a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 247894122bbeSMat Martineau /* Check outgoing MTU */ 247994122bbeSMat Martineau if (len > chan->omtu) { 248094122bbeSMat Martineau err = -EMSGSIZE; 24819a91a04aSGustavo F. Padovan break; 24829a91a04aSGustavo F. Padovan } 24839a91a04aSGustavo F. Padovan 248494122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 248594122bbeSMat Martineau 248694122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 248794122bbeSMat Martineau * since it's possible to block while waiting for memory 248894122bbeSMat Martineau * allocation. 248994122bbeSMat Martineau */ 249094122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 249194122bbeSMat Martineau 249294122bbeSMat Martineau /* The channel could have been closed while segmenting, 249394122bbeSMat Martineau * check that it is still connected. 249494122bbeSMat Martineau */ 249594122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 249694122bbeSMat Martineau __skb_queue_purge(&seg_queue); 249794122bbeSMat Martineau err = -ENOTCONN; 24989a91a04aSGustavo F. Padovan } 24999a91a04aSGustavo F. Padovan 250094122bbeSMat Martineau if (err) 250194122bbeSMat Martineau break; 250294122bbeSMat Martineau 25033733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2504d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 25053733937dSMat Martineau else 2506d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 250794122bbeSMat Martineau 25089a91a04aSGustavo F. Padovan err = len; 25099a91a04aSGustavo F. Padovan 251094122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 251194122bbeSMat Martineau * seg_queue and need to be purged. 251294122bbeSMat Martineau */ 251394122bbeSMat Martineau __skb_queue_purge(&seg_queue); 25149a91a04aSGustavo F. Padovan break; 25159a91a04aSGustavo F. Padovan 25169a91a04aSGustavo F. Padovan default: 25179a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 25189a91a04aSGustavo F. Padovan err = -EBADFD; 25199a91a04aSGustavo F. Padovan } 25209a91a04aSGustavo F. Padovan 25219a91a04aSGustavo F. Padovan return err; 25229a91a04aSGustavo F. Padovan } 25239a91a04aSGustavo F. Padovan 2524d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2525d2a7ac5dSMat Martineau { 2526bed68bdeSMat Martineau struct l2cap_ctrl control; 2527bed68bdeSMat Martineau u16 seq; 2528bed68bdeSMat Martineau 2529b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2530bed68bdeSMat Martineau 2531bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2532bed68bdeSMat Martineau control.sframe = 1; 2533bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2534bed68bdeSMat Martineau 2535bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2536bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2537bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2538bed68bdeSMat Martineau control.reqseq = seq; 2539bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2540bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2541bed68bdeSMat Martineau } 2542bed68bdeSMat Martineau } 2543bed68bdeSMat Martineau 2544bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2545d2a7ac5dSMat Martineau } 2546d2a7ac5dSMat Martineau 2547d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2548d2a7ac5dSMat Martineau { 2549bed68bdeSMat Martineau struct l2cap_ctrl control; 2550bed68bdeSMat Martineau 2551bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2552bed68bdeSMat Martineau 2553bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2554bed68bdeSMat Martineau return; 2555bed68bdeSMat Martineau 2556bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2557bed68bdeSMat Martineau control.sframe = 1; 2558bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2559bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2560bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2561d2a7ac5dSMat Martineau } 2562d2a7ac5dSMat Martineau 2563d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2564d2a7ac5dSMat Martineau { 2565bed68bdeSMat Martineau struct l2cap_ctrl control; 2566bed68bdeSMat Martineau u16 initial_head; 2567bed68bdeSMat Martineau u16 seq; 2568bed68bdeSMat Martineau 2569b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2570bed68bdeSMat Martineau 2571bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2572bed68bdeSMat Martineau control.sframe = 1; 2573bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2574bed68bdeSMat Martineau 2575bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2576bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2577bed68bdeSMat Martineau 2578bed68bdeSMat Martineau do { 2579bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2580bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2581bed68bdeSMat Martineau break; 2582bed68bdeSMat Martineau 2583bed68bdeSMat Martineau control.reqseq = seq; 2584bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2585bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2586bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2587d2a7ac5dSMat Martineau } 2588d2a7ac5dSMat Martineau 2589608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2590608bcc6dSMat Martineau { 2591608bcc6dSMat Martineau struct sk_buff *acked_skb; 2592608bcc6dSMat Martineau u16 ackseq; 2593608bcc6dSMat Martineau 2594b4400672SAndrei Emeltchenko BT_DBG("chan %p, reqseq %u", chan, reqseq); 2595608bcc6dSMat Martineau 2596608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2597608bcc6dSMat Martineau return; 2598608bcc6dSMat Martineau 2599b4400672SAndrei Emeltchenko BT_DBG("expected_ack_seq %u, unacked_frames %u", 2600608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2601608bcc6dSMat Martineau 2602608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2603608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2604608bcc6dSMat Martineau 2605608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2606608bcc6dSMat Martineau if (acked_skb) { 2607608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2608608bcc6dSMat Martineau kfree_skb(acked_skb); 2609608bcc6dSMat Martineau chan->unacked_frames--; 2610608bcc6dSMat Martineau } 2611608bcc6dSMat Martineau } 2612608bcc6dSMat Martineau 2613608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2614608bcc6dSMat Martineau 2615608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2616608bcc6dSMat Martineau __clear_retrans_timer(chan); 2617608bcc6dSMat Martineau 2618b4400672SAndrei Emeltchenko BT_DBG("unacked_frames %u", chan->unacked_frames); 2619608bcc6dSMat Martineau } 2620608bcc6dSMat Martineau 2621608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2622608bcc6dSMat Martineau { 2623608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2624608bcc6dSMat Martineau 2625608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2626608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2627608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2628608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2629608bcc6dSMat Martineau } 2630608bcc6dSMat Martineau 2631d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2632608bcc6dSMat Martineau struct l2cap_ctrl *control, 2633608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2634608bcc6dSMat Martineau { 2635608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2636608bcc6dSMat Martineau event); 2637608bcc6dSMat Martineau 2638608bcc6dSMat Martineau switch (event) { 2639608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2640608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2641608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2642608bcc6dSMat Martineau 2643608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2644608bcc6dSMat Martineau l2cap_ertm_send(chan); 2645608bcc6dSMat Martineau break; 2646608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2647608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2648608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2649608bcc6dSMat Martineau 2650608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2651608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2652608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2653608bcc6dSMat Martineau */ 2654608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2655608bcc6dSMat Martineau } 2656608bcc6dSMat Martineau 2657608bcc6dSMat Martineau l2cap_send_ack(chan); 2658608bcc6dSMat Martineau 2659608bcc6dSMat Martineau break; 2660608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2661608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2662608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2663608bcc6dSMat Martineau 2664608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2665608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2666608bcc6dSMat Martineau 2667608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2668608bcc6dSMat Martineau local_control.sframe = 1; 2669608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2670608bcc6dSMat Martineau local_control.poll = 1; 2671608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2672a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2673608bcc6dSMat Martineau 2674608bcc6dSMat Martineau chan->retry_count = 1; 2675608bcc6dSMat Martineau __set_monitor_timer(chan); 2676608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2677608bcc6dSMat Martineau } 2678608bcc6dSMat Martineau break; 2679608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2680608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2681608bcc6dSMat Martineau break; 2682608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2683608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2684608bcc6dSMat Martineau chan->retry_count = 1; 2685608bcc6dSMat Martineau __set_monitor_timer(chan); 2686608bcc6dSMat Martineau __clear_ack_timer(chan); 2687608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2688608bcc6dSMat Martineau break; 2689608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2690608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2691608bcc6dSMat Martineau chan->retry_count = 1; 2692608bcc6dSMat Martineau __set_monitor_timer(chan); 2693608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2694608bcc6dSMat Martineau break; 2695608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2696608bcc6dSMat Martineau /* Nothing to process */ 2697608bcc6dSMat Martineau break; 2698608bcc6dSMat Martineau default: 2699608bcc6dSMat Martineau break; 2700608bcc6dSMat Martineau } 2701608bcc6dSMat Martineau } 2702608bcc6dSMat Martineau 2703d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2704608bcc6dSMat Martineau struct l2cap_ctrl *control, 2705608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2706608bcc6dSMat Martineau { 2707608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2708608bcc6dSMat Martineau event); 2709608bcc6dSMat Martineau 2710608bcc6dSMat Martineau switch (event) { 2711608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2712608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2713608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2714608bcc6dSMat Martineau /* Queue data, but don't send. */ 2715608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2716608bcc6dSMat Martineau break; 2717608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2718608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2719608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2720608bcc6dSMat Martineau 2721608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2722608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2723608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2724608bcc6dSMat Martineau */ 2725608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2726608bcc6dSMat Martineau } 2727608bcc6dSMat Martineau 2728608bcc6dSMat Martineau l2cap_send_ack(chan); 2729608bcc6dSMat Martineau 2730608bcc6dSMat Martineau break; 2731608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2732608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2733608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2734608bcc6dSMat Martineau 2735608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2736608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2737608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2738608bcc6dSMat Martineau local_control.sframe = 1; 2739608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2740608bcc6dSMat Martineau local_control.poll = 1; 2741608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2742a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2743608bcc6dSMat Martineau 2744608bcc6dSMat Martineau chan->retry_count = 1; 2745608bcc6dSMat Martineau __set_monitor_timer(chan); 2746608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2747608bcc6dSMat Martineau } 2748608bcc6dSMat Martineau break; 2749608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2750608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2751608bcc6dSMat Martineau 2752608bcc6dSMat Martineau /* Fall through */ 2753608bcc6dSMat Martineau 2754608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2755608bcc6dSMat Martineau if (control && control->final) { 2756608bcc6dSMat Martineau __clear_monitor_timer(chan); 2757608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2758608bcc6dSMat Martineau __set_retrans_timer(chan); 2759608bcc6dSMat Martineau chan->retry_count = 0; 2760608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2761608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2762608bcc6dSMat Martineau } 2763608bcc6dSMat Martineau break; 2764608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2765608bcc6dSMat Martineau /* Ignore */ 2766608bcc6dSMat Martineau break; 2767608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2768608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2769608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2770608bcc6dSMat Martineau __set_monitor_timer(chan); 2771608bcc6dSMat Martineau chan->retry_count++; 2772608bcc6dSMat Martineau } else { 27735e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNABORTED); 2774608bcc6dSMat Martineau } 2775608bcc6dSMat Martineau break; 2776608bcc6dSMat Martineau default: 2777608bcc6dSMat Martineau break; 2778608bcc6dSMat Martineau } 2779608bcc6dSMat Martineau } 2780608bcc6dSMat Martineau 2781d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2782608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2783608bcc6dSMat Martineau { 2784608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2785608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2786608bcc6dSMat Martineau 2787608bcc6dSMat Martineau switch (chan->tx_state) { 2788608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2789d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2790608bcc6dSMat Martineau break; 2791608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2792d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2793608bcc6dSMat Martineau break; 2794608bcc6dSMat Martineau default: 2795608bcc6dSMat Martineau /* Ignore event */ 2796608bcc6dSMat Martineau break; 2797608bcc6dSMat Martineau } 2798608bcc6dSMat Martineau } 2799608bcc6dSMat Martineau 28004b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 28014b51dae9SMat Martineau struct l2cap_ctrl *control) 28024b51dae9SMat Martineau { 28034b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2804401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 28054b51dae9SMat Martineau } 28064b51dae9SMat Martineau 2807f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2808f80842a8SMat Martineau struct l2cap_ctrl *control) 2809f80842a8SMat Martineau { 2810f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2811401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2812f80842a8SMat Martineau } 2813f80842a8SMat Martineau 28140a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 28150a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 28160a708f8fSGustavo F. Padovan { 28170a708f8fSGustavo F. Padovan struct sk_buff *nskb; 281848454079SGustavo F. Padovan struct l2cap_chan *chan; 28190a708f8fSGustavo F. Padovan 28200a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 28210a708f8fSGustavo F. Padovan 28223df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 28233d57dc68SGustavo F. Padovan 28243df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 282548454079SGustavo F. Padovan struct sock *sk = chan->sk; 2826715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 28270a708f8fSGustavo F. Padovan continue; 28280a708f8fSGustavo F. Padovan 28290a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 28300a708f8fSGustavo F. Padovan if (skb->sk == sk) 28310a708f8fSGustavo F. Padovan continue; 28328bcde1f2SGustavo Padovan nskb = skb_clone(skb, GFP_KERNEL); 28330a708f8fSGustavo F. Padovan if (!nskb) 28340a708f8fSGustavo F. Padovan continue; 28350a708f8fSGustavo F. Padovan 283680b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 28370a708f8fSGustavo F. Padovan kfree_skb(nskb); 28380a708f8fSGustavo F. Padovan } 28393d57dc68SGustavo F. Padovan 28403df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 28410a708f8fSGustavo F. Padovan } 28420a708f8fSGustavo F. Padovan 28430a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 2844b4400672SAndrei Emeltchenko static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code, 2845b4400672SAndrei Emeltchenko u8 ident, u16 dlen, void *data) 28460a708f8fSGustavo F. Padovan { 28470a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 28480a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 28490a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 28500a708f8fSGustavo F. Padovan int len, count; 28510a708f8fSGustavo F. Padovan 2852b4400672SAndrei Emeltchenko BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u", 28530a708f8fSGustavo F. Padovan conn, code, ident, dlen); 28540a708f8fSGustavo F. Padovan 2855300b962eSAnderson Lizardo if (conn->mtu < L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE) 2856300b962eSAnderson Lizardo return NULL; 2857300b962eSAnderson Lizardo 28580a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 28590a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 28600a708f8fSGustavo F. Padovan 28618bcde1f2SGustavo Padovan skb = bt_skb_alloc(count, GFP_KERNEL); 28620a708f8fSGustavo F. Padovan if (!skb) 28630a708f8fSGustavo F. Padovan return NULL; 28640a708f8fSGustavo F. Padovan 28650a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 28660a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 28673300d9a9SClaudio Takahasi 28683300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2869ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 28703300d9a9SClaudio Takahasi else 2871ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 28720a708f8fSGustavo F. Padovan 28730a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 28740a708f8fSGustavo F. Padovan cmd->code = code; 28750a708f8fSGustavo F. Padovan cmd->ident = ident; 28760a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 28770a708f8fSGustavo F. Padovan 28780a708f8fSGustavo F. Padovan if (dlen) { 28790a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 28800a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 28810a708f8fSGustavo F. Padovan data += count; 28820a708f8fSGustavo F. Padovan } 28830a708f8fSGustavo F. Padovan 28840a708f8fSGustavo F. Padovan len -= skb->len; 28850a708f8fSGustavo F. Padovan 28860a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 28870a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 28880a708f8fSGustavo F. Padovan while (len) { 28890a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 28900a708f8fSGustavo F. Padovan 28918bcde1f2SGustavo Padovan *frag = bt_skb_alloc(count, GFP_KERNEL); 28920a708f8fSGustavo F. Padovan if (!*frag) 28930a708f8fSGustavo F. Padovan goto fail; 28940a708f8fSGustavo F. Padovan 28950a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 28960a708f8fSGustavo F. Padovan 28970a708f8fSGustavo F. Padovan len -= count; 28980a708f8fSGustavo F. Padovan data += count; 28990a708f8fSGustavo F. Padovan 29000a708f8fSGustavo F. Padovan frag = &(*frag)->next; 29010a708f8fSGustavo F. Padovan } 29020a708f8fSGustavo F. Padovan 29030a708f8fSGustavo F. Padovan return skb; 29040a708f8fSGustavo F. Padovan 29050a708f8fSGustavo F. Padovan fail: 29060a708f8fSGustavo F. Padovan kfree_skb(skb); 29070a708f8fSGustavo F. Padovan return NULL; 29080a708f8fSGustavo F. Padovan } 29090a708f8fSGustavo F. Padovan 29102d792818SGustavo Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, 29112d792818SGustavo Padovan unsigned long *val) 29120a708f8fSGustavo F. Padovan { 29130a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 29140a708f8fSGustavo F. Padovan int len; 29150a708f8fSGustavo F. Padovan 29160a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 29170a708f8fSGustavo F. Padovan *ptr += len; 29180a708f8fSGustavo F. Padovan 29190a708f8fSGustavo F. Padovan *type = opt->type; 29200a708f8fSGustavo F. Padovan *olen = opt->len; 29210a708f8fSGustavo F. Padovan 29220a708f8fSGustavo F. Padovan switch (opt->len) { 29230a708f8fSGustavo F. Padovan case 1: 29240a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 29250a708f8fSGustavo F. Padovan break; 29260a708f8fSGustavo F. Padovan 29270a708f8fSGustavo F. Padovan case 2: 29280a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 29290a708f8fSGustavo F. Padovan break; 29300a708f8fSGustavo F. Padovan 29310a708f8fSGustavo F. Padovan case 4: 29320a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 29330a708f8fSGustavo F. Padovan break; 29340a708f8fSGustavo F. Padovan 29350a708f8fSGustavo F. Padovan default: 29360a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 29370a708f8fSGustavo F. Padovan break; 29380a708f8fSGustavo F. Padovan } 29390a708f8fSGustavo F. Padovan 2940b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val); 29410a708f8fSGustavo F. Padovan return len; 29420a708f8fSGustavo F. Padovan } 29430a708f8fSGustavo F. Padovan 29440a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 29450a708f8fSGustavo F. Padovan { 29460a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 29470a708f8fSGustavo F. Padovan 2948b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val); 29490a708f8fSGustavo F. Padovan 29500a708f8fSGustavo F. Padovan opt->type = type; 29510a708f8fSGustavo F. Padovan opt->len = len; 29520a708f8fSGustavo F. Padovan 29530a708f8fSGustavo F. Padovan switch (len) { 29540a708f8fSGustavo F. Padovan case 1: 29550a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 29560a708f8fSGustavo F. Padovan break; 29570a708f8fSGustavo F. Padovan 29580a708f8fSGustavo F. Padovan case 2: 29590a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 29600a708f8fSGustavo F. Padovan break; 29610a708f8fSGustavo F. Padovan 29620a708f8fSGustavo F. Padovan case 4: 29630a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 29640a708f8fSGustavo F. Padovan break; 29650a708f8fSGustavo F. Padovan 29660a708f8fSGustavo F. Padovan default: 29670a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 29680a708f8fSGustavo F. Padovan break; 29690a708f8fSGustavo F. Padovan } 29700a708f8fSGustavo F. Padovan 29710a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 29720a708f8fSGustavo F. Padovan } 29730a708f8fSGustavo F. Padovan 2974f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2975f89cef09SAndrei Emeltchenko { 2976f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2977f89cef09SAndrei Emeltchenko 2978f89cef09SAndrei Emeltchenko switch (chan->mode) { 2979f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2980f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2981f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2982f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2983f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2984ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 29858936fa6dSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_EFS_DEFAULT_FLUSH_TO); 2986f89cef09SAndrei Emeltchenko break; 2987f89cef09SAndrei Emeltchenko 2988f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2989f89cef09SAndrei Emeltchenko efs.id = 1; 2990f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2991f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2992f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2993f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2994f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2995f89cef09SAndrei Emeltchenko break; 2996f89cef09SAndrei Emeltchenko 2997f89cef09SAndrei Emeltchenko default: 2998f89cef09SAndrei Emeltchenko return; 2999f89cef09SAndrei Emeltchenko } 3000f89cef09SAndrei Emeltchenko 3001f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 3002f89cef09SAndrei Emeltchenko (unsigned long) &efs); 3003f89cef09SAndrei Emeltchenko } 3004f89cef09SAndrei Emeltchenko 3005721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 30060a708f8fSGustavo F. Padovan { 3007721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 3008721c4181SGustavo F. Padovan ack_timer.work); 30090362520bSMat Martineau u16 frames_to_ack; 30100a708f8fSGustavo F. Padovan 30112fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 30122fb9b3d4SGustavo F. Padovan 30136be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 30146be36555SAndrei Emeltchenko 30150362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 30160362520bSMat Martineau chan->last_acked_seq); 30170362520bSMat Martineau 30180362520bSMat Martineau if (frames_to_ack) 30190362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 30206be36555SAndrei Emeltchenko 30216be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 302209bfb2eeSSzymon Janc l2cap_chan_put(chan); 30230a708f8fSGustavo F. Padovan } 30240a708f8fSGustavo F. Padovan 3025466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 30260a708f8fSGustavo F. Padovan { 30273c588192SMat Martineau int err; 30283c588192SMat Martineau 3029105bdf9eSMat Martineau chan->next_tx_seq = 0; 3030105bdf9eSMat Martineau chan->expected_tx_seq = 0; 303142e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 30326a026610SGustavo F. Padovan chan->unacked_frames = 0; 303342e5c802SGustavo F. Padovan chan->buffer_seq = 0; 30346a026610SGustavo F. Padovan chan->frames_sent = 0; 3035105bdf9eSMat Martineau chan->last_acked_seq = 0; 3036105bdf9eSMat Martineau chan->sdu = NULL; 3037105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 3038105bdf9eSMat Martineau chan->sdu_len = 0; 3039105bdf9eSMat Martineau 3040d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 3041d34c34fbSMat Martineau 304208333283SMat Martineau chan->local_amp_id = 0; 304308333283SMat Martineau chan->move_id = 0; 304408333283SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 304508333283SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 304608333283SMat Martineau 3047105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 3048105bdf9eSMat Martineau return 0; 3049105bdf9eSMat Martineau 3050105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 3051105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 30520a708f8fSGustavo F. Padovan 3053721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 3054721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 3055721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 30560a708f8fSGustavo F. Padovan 3057f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 30580a708f8fSGustavo F. Padovan 30593c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 30603c588192SMat Martineau if (err < 0) 30613c588192SMat Martineau return err; 30623c588192SMat Martineau 30639dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 30649dc9affcSMat Martineau if (err < 0) 30659dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 30669dc9affcSMat Martineau 30679dc9affcSMat Martineau return err; 30680a708f8fSGustavo F. Padovan } 30690a708f8fSGustavo F. Padovan 30700a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 30710a708f8fSGustavo F. Padovan { 30720a708f8fSGustavo F. Padovan switch (mode) { 30730a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 30740a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30750a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 30760a708f8fSGustavo F. Padovan return mode; 30770a708f8fSGustavo F. Padovan /* fall through */ 30780a708f8fSGustavo F. Padovan default: 30790a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 30800a708f8fSGustavo F. Padovan } 30810a708f8fSGustavo F. Padovan } 30820a708f8fSGustavo F. Padovan 30836327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 30846327eb98SAndrei Emeltchenko { 30856327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 30866327eb98SAndrei Emeltchenko } 30876327eb98SAndrei Emeltchenko 3088f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 3089f89cef09SAndrei Emeltchenko { 3090f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 3091f89cef09SAndrei Emeltchenko } 3092f89cef09SAndrei Emeltchenko 309336c86c85SMat Martineau static void __l2cap_set_ertm_timeouts(struct l2cap_chan *chan, 309436c86c85SMat Martineau struct l2cap_conf_rfc *rfc) 309536c86c85SMat Martineau { 309636c86c85SMat Martineau if (chan->local_amp_id && chan->hs_hcon) { 309736c86c85SMat Martineau u64 ertm_to = chan->hs_hcon->hdev->amp_be_flush_to; 309836c86c85SMat Martineau 309936c86c85SMat Martineau /* Class 1 devices have must have ERTM timeouts 310036c86c85SMat Martineau * exceeding the Link Supervision Timeout. The 310136c86c85SMat Martineau * default Link Supervision Timeout for AMP 310236c86c85SMat Martineau * controllers is 10 seconds. 310336c86c85SMat Martineau * 310436c86c85SMat Martineau * Class 1 devices use 0xffffffff for their 310536c86c85SMat Martineau * best-effort flush timeout, so the clamping logic 310636c86c85SMat Martineau * will result in a timeout that meets the above 310736c86c85SMat Martineau * requirement. ERTM timeouts are 16-bit values, so 310836c86c85SMat Martineau * the maximum timeout is 65.535 seconds. 310936c86c85SMat Martineau */ 311036c86c85SMat Martineau 311136c86c85SMat Martineau /* Convert timeout to milliseconds and round */ 311236c86c85SMat Martineau ertm_to = DIV_ROUND_UP_ULL(ertm_to, 1000); 311336c86c85SMat Martineau 311436c86c85SMat Martineau /* This is the recommended formula for class 2 devices 311536c86c85SMat Martineau * that start ERTM timers when packets are sent to the 311636c86c85SMat Martineau * controller. 311736c86c85SMat Martineau */ 311836c86c85SMat Martineau ertm_to = 3 * ertm_to + 500; 311936c86c85SMat Martineau 312036c86c85SMat Martineau if (ertm_to > 0xffff) 312136c86c85SMat Martineau ertm_to = 0xffff; 312236c86c85SMat Martineau 312336c86c85SMat Martineau rfc->retrans_timeout = cpu_to_le16((u16) ertm_to); 312436c86c85SMat Martineau rfc->monitor_timeout = rfc->retrans_timeout; 312536c86c85SMat Martineau } else { 312636c86c85SMat Martineau rfc->retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 312736c86c85SMat Martineau rfc->monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 312836c86c85SMat Martineau } 312936c86c85SMat Martineau } 313036c86c85SMat Martineau 31316327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 31326327eb98SAndrei Emeltchenko { 31336327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 3134836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 31356327eb98SAndrei Emeltchenko /* use extended control field */ 31366327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 3137836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 3138836be934SAndrei Emeltchenko } else { 31396327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 31406327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 3141836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 3142836be934SAndrei Emeltchenko } 3143c20f8e35SMat Martineau chan->ack_win = chan->tx_win; 31446327eb98SAndrei Emeltchenko } 31456327eb98SAndrei Emeltchenko 3146710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 31470a708f8fSGustavo F. Padovan { 31480a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 31490c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 31500a708f8fSGustavo F. Padovan void *ptr = req->data; 3151c8f79162SAndrei Emeltchenko u16 size; 31520a708f8fSGustavo F. Padovan 315349208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 31540a708f8fSGustavo F. Padovan 315573ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 31560a708f8fSGustavo F. Padovan goto done; 31570a708f8fSGustavo F. Padovan 31580c1bc5c6SGustavo F. Padovan switch (chan->mode) { 31590a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 31600a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3161c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 31620a708f8fSGustavo F. Padovan break; 31630a708f8fSGustavo F. Padovan 3164f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 3165f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 3166f89cef09SAndrei Emeltchenko 31670a708f8fSGustavo F. Padovan /* fall through */ 31680a708f8fSGustavo F. Padovan default: 31698c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 31700a708f8fSGustavo F. Padovan break; 31710a708f8fSGustavo F. Padovan } 31720a708f8fSGustavo F. Padovan 31730a708f8fSGustavo F. Padovan done: 31740c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 31750c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 31760a708f8fSGustavo F. Padovan 31770c1bc5c6SGustavo F. Padovan switch (chan->mode) { 31780a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 31798c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 31808c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 31810a708f8fSGustavo F. Padovan break; 31820a708f8fSGustavo F. Padovan 31830a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 31840a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 31850a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 31860a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 31870a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 31880a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 31890a708f8fSGustavo F. Padovan 31900a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 31910a708f8fSGustavo F. Padovan (unsigned long) &rfc); 31920a708f8fSGustavo F. Padovan break; 31930a708f8fSGustavo F. Padovan 31940a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 31950a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 319647d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 319736c86c85SMat Martineau 319836c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 3199c8f79162SAndrei Emeltchenko 3200c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 32012d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3202c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3203c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 32040a708f8fSGustavo F. Padovan 32056327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 32066327eb98SAndrei Emeltchenko 32076327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 32086327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 32090a708f8fSGustavo F. Padovan 32100a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 32110a708f8fSGustavo F. Padovan (unsigned long) &rfc); 32120a708f8fSGustavo F. Padovan 3213f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3214f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3215f89cef09SAndrei Emeltchenko 32166327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 32176327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 32186327eb98SAndrei Emeltchenko chan->tx_win); 321960918918SAndrei Emeltchenko 322060918918SAndrei Emeltchenko if (chan->conn->feat_mask & L2CAP_FEAT_FCS) 322160918918SAndrei Emeltchenko if (chan->fcs == L2CAP_FCS_NONE || 3222f2592d3eSAndrei Emeltchenko test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) { 322360918918SAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 322460918918SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, 322560918918SAndrei Emeltchenko chan->fcs); 322660918918SAndrei Emeltchenko } 32270a708f8fSGustavo F. Padovan break; 32280a708f8fSGustavo F. Padovan 32290a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3230273759e2SMat Martineau l2cap_txwin_setup(chan); 32310a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 32320a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 32330a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 32340a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 32350a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 3236c8f79162SAndrei Emeltchenko 3237c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 32382d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3239c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3240c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 32410a708f8fSGustavo F. Padovan 32420a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 32430a708f8fSGustavo F. Padovan (unsigned long) &rfc); 32440a708f8fSGustavo F. Padovan 3245f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3246f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3247f89cef09SAndrei Emeltchenko 324860918918SAndrei Emeltchenko if (chan->conn->feat_mask & L2CAP_FEAT_FCS) 324947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 3250f2592d3eSAndrei Emeltchenko test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) { 325147d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 325260918918SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, 325360918918SAndrei Emeltchenko chan->fcs); 32540a708f8fSGustavo F. Padovan } 32550a708f8fSGustavo F. Padovan break; 32560a708f8fSGustavo F. Padovan } 32570a708f8fSGustavo F. Padovan 3258fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 325959e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 32600a708f8fSGustavo F. Padovan 32610a708f8fSGustavo F. Padovan return ptr - data; 32620a708f8fSGustavo F. Padovan } 32630a708f8fSGustavo F. Padovan 326473ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 32650a708f8fSGustavo F. Padovan { 32660a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 32670a708f8fSGustavo F. Padovan void *ptr = rsp->data; 326873ffa904SGustavo F. Padovan void *req = chan->conf_req; 326973ffa904SGustavo F. Padovan int len = chan->conf_len; 32700a708f8fSGustavo F. Padovan int type, hint, olen; 32710a708f8fSGustavo F. Padovan unsigned long val; 32720a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 327342dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 327442dceae2SAndrei Emeltchenko u8 remote_efs = 0; 32750a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 32760a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 3277c8f79162SAndrei Emeltchenko u16 size; 32780a708f8fSGustavo F. Padovan 327973ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 32800a708f8fSGustavo F. Padovan 32810a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32820a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 32830a708f8fSGustavo F. Padovan 32840a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 32850a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 32860a708f8fSGustavo F. Padovan 32870a708f8fSGustavo F. Padovan switch (type) { 32880a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 32890a708f8fSGustavo F. Padovan mtu = val; 32900a708f8fSGustavo F. Padovan break; 32910a708f8fSGustavo F. Padovan 32920a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 32930c1bc5c6SGustavo F. Padovan chan->flush_to = val; 32940a708f8fSGustavo F. Padovan break; 32950a708f8fSGustavo F. Padovan 32960a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 32970a708f8fSGustavo F. Padovan break; 32980a708f8fSGustavo F. Padovan 32990a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 33000a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 33010a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 33020a708f8fSGustavo F. Padovan break; 33030a708f8fSGustavo F. Padovan 33040a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 33050a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 3306f2592d3eSAndrei Emeltchenko set_bit(CONF_RECV_NO_FCS, &chan->conf_state); 330742dceae2SAndrei Emeltchenko break; 33080a708f8fSGustavo F. Padovan 330942dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 331042dceae2SAndrei Emeltchenko remote_efs = 1; 331142dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 331242dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 33130a708f8fSGustavo F. Padovan break; 33140a708f8fSGustavo F. Padovan 33156327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 33166327eb98SAndrei Emeltchenko if (!enable_hs) 33176327eb98SAndrei Emeltchenko return -ECONNREFUSED; 33186327eb98SAndrei Emeltchenko 33196327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 33206327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 3321836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 33226327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 33230a708f8fSGustavo F. Padovan break; 33240a708f8fSGustavo F. Padovan 33250a708f8fSGustavo F. Padovan default: 33260a708f8fSGustavo F. Padovan if (hint) 33270a708f8fSGustavo F. Padovan break; 33280a708f8fSGustavo F. Padovan 33290a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 33300a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 33310a708f8fSGustavo F. Padovan break; 33320a708f8fSGustavo F. Padovan } 33330a708f8fSGustavo F. Padovan } 33340a708f8fSGustavo F. Padovan 333573ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 33360a708f8fSGustavo F. Padovan goto done; 33370a708f8fSGustavo F. Padovan 33380c1bc5c6SGustavo F. Padovan switch (chan->mode) { 33390a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 33400a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3341c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 33420c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 33438c1d787bSGustavo F. Padovan chan->conn->feat_mask); 33440a708f8fSGustavo F. Padovan break; 33450a708f8fSGustavo F. Padovan } 33460a708f8fSGustavo F. Padovan 334742dceae2SAndrei Emeltchenko if (remote_efs) { 334842dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 334942dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 335042dceae2SAndrei Emeltchenko else 335142dceae2SAndrei Emeltchenko return -ECONNREFUSED; 335242dceae2SAndrei Emeltchenko } 335342dceae2SAndrei Emeltchenko 33540c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 33550a708f8fSGustavo F. Padovan return -ECONNREFUSED; 33560a708f8fSGustavo F. Padovan 33570a708f8fSGustavo F. Padovan break; 33580a708f8fSGustavo F. Padovan } 33590a708f8fSGustavo F. Padovan 33600a708f8fSGustavo F. Padovan done: 33610c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 33620a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 33630c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 33640a708f8fSGustavo F. Padovan 336573ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 33660a708f8fSGustavo F. Padovan return -ECONNREFUSED; 33670a708f8fSGustavo F. Padovan 33682d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 33692d792818SGustavo Padovan (unsigned long) &rfc); 33700a708f8fSGustavo F. Padovan } 33710a708f8fSGustavo F. Padovan 33720a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 33730a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 33740a708f8fSGustavo F. Padovan * which ones we don't like. */ 33750a708f8fSGustavo F. Padovan 33760a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 33770a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 33780a708f8fSGustavo F. Padovan else { 33790c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3380c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 33810a708f8fSGustavo F. Padovan } 33820c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 33830a708f8fSGustavo F. Padovan 338442dceae2SAndrei Emeltchenko if (remote_efs) { 338542dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 338642dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 338742dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 338842dceae2SAndrei Emeltchenko 338942dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 339042dceae2SAndrei Emeltchenko 339142dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 339242dceae2SAndrei Emeltchenko return -ECONNREFUSED; 339342dceae2SAndrei Emeltchenko 339442dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 339542dceae2SAndrei Emeltchenko sizeof(efs), 339642dceae2SAndrei Emeltchenko (unsigned long) &efs); 33970e8b207eSAndrei Emeltchenko } else { 33983e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 33990e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 34000e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 340142dceae2SAndrei Emeltchenko } 340242dceae2SAndrei Emeltchenko } 340342dceae2SAndrei Emeltchenko 34040a708f8fSGustavo F. Padovan switch (rfc.mode) { 34050a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 340647d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3407c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 34080a708f8fSGustavo F. Padovan break; 34090a708f8fSGustavo F. Padovan 34100a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 34116327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 34122c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 34136327eb98SAndrei Emeltchenko else 34146327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 34156327eb98SAndrei Emeltchenko 34162c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 34170a708f8fSGustavo F. Padovan 3418c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 34192d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 34202d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3421c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3422c8f79162SAndrei Emeltchenko chan->remote_mps = size; 34230a708f8fSGustavo F. Padovan 342436c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 34250a708f8fSGustavo F. Padovan 3426c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 34270a708f8fSGustavo F. Padovan 34280a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 34290a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 34300a708f8fSGustavo F. Padovan 343142dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 343242dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 343342dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 343442dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 343542dceae2SAndrei Emeltchenko chan->remote_flush_to = 343642dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 343742dceae2SAndrei Emeltchenko chan->remote_acc_lat = 343842dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 343942dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 344042dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 344142dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 34422d792818SGustavo Padovan sizeof(efs), 34432d792818SGustavo Padovan (unsigned long) &efs); 344442dceae2SAndrei Emeltchenko } 34450a708f8fSGustavo F. Padovan break; 34460a708f8fSGustavo F. Padovan 34470a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3448c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 34492d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 34502d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3451c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3452c8f79162SAndrei Emeltchenko chan->remote_mps = size; 34530a708f8fSGustavo F. Padovan 3454c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 34550a708f8fSGustavo F. Padovan 34562d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 34572d792818SGustavo Padovan (unsigned long) &rfc); 34580a708f8fSGustavo F. Padovan 34590a708f8fSGustavo F. Padovan break; 34600a708f8fSGustavo F. Padovan 34610a708f8fSGustavo F. Padovan default: 34620a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 34630a708f8fSGustavo F. Padovan 34640a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 34650c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 34660a708f8fSGustavo F. Padovan } 34670a708f8fSGustavo F. Padovan 34680a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3469c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 34700a708f8fSGustavo F. Padovan } 3471fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 34720a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 347359e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 34740a708f8fSGustavo F. Padovan 34750a708f8fSGustavo F. Padovan return ptr - data; 34760a708f8fSGustavo F. Padovan } 34770a708f8fSGustavo F. Padovan 34782d792818SGustavo Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, 34792d792818SGustavo Padovan void *data, u16 *result) 34800a708f8fSGustavo F. Padovan { 34810a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 34820a708f8fSGustavo F. Padovan void *ptr = req->data; 34830a708f8fSGustavo F. Padovan int type, olen; 34840a708f8fSGustavo F. Padovan unsigned long val; 348536e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 348666af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 34870a708f8fSGustavo F. Padovan 3488fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 34890a708f8fSGustavo F. Padovan 34900a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 34910a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 34920a708f8fSGustavo F. Padovan 34930a708f8fSGustavo F. Padovan switch (type) { 34940a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 34950a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 34960a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 34970c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 34980a708f8fSGustavo F. Padovan } else 34990c1bc5c6SGustavo F. Padovan chan->imtu = val; 35000c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 35010a708f8fSGustavo F. Padovan break; 35020a708f8fSGustavo F. Padovan 35030a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 35040c1bc5c6SGustavo F. Padovan chan->flush_to = val; 35050a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 35060c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 35070a708f8fSGustavo F. Padovan break; 35080a708f8fSGustavo F. Padovan 35090a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 35100a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 35110a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 35120a708f8fSGustavo F. Padovan 3513c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 35140c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 35150a708f8fSGustavo F. Padovan return -ECONNREFUSED; 35160a708f8fSGustavo F. Padovan 351747d1ec61SGustavo F. Padovan chan->fcs = 0; 35180a708f8fSGustavo F. Padovan 35190a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 35200a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 35210a708f8fSGustavo F. Padovan break; 35226327eb98SAndrei Emeltchenko 35236327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 3524c20f8e35SMat Martineau chan->ack_win = min_t(u16, val, chan->ack_win); 35253e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 35263e6b3b95SGustavo F. Padovan chan->tx_win); 35276327eb98SAndrei Emeltchenko break; 352866af7aafSAndrei Emeltchenko 352966af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 353066af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 353166af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 353266af7aafSAndrei Emeltchenko 353366af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 353466af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 353566af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 353666af7aafSAndrei Emeltchenko return -ECONNREFUSED; 353766af7aafSAndrei Emeltchenko 35382d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, sizeof(efs), 35392d792818SGustavo Padovan (unsigned long) &efs); 354066af7aafSAndrei Emeltchenko break; 3541cbabee78SAndrei Emeltchenko 3542cbabee78SAndrei Emeltchenko case L2CAP_CONF_FCS: 3543cbabee78SAndrei Emeltchenko if (*result == L2CAP_CONF_PENDING) 3544cbabee78SAndrei Emeltchenko if (val == L2CAP_FCS_NONE) 3545f2592d3eSAndrei Emeltchenko set_bit(CONF_RECV_NO_FCS, 3546cbabee78SAndrei Emeltchenko &chan->conf_state); 3547cbabee78SAndrei Emeltchenko break; 35480a708f8fSGustavo F. Padovan } 35490a708f8fSGustavo F. Padovan } 35500a708f8fSGustavo F. Padovan 35510c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 35520a708f8fSGustavo F. Padovan return -ECONNREFUSED; 35530a708f8fSGustavo F. Padovan 35540c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 35550a708f8fSGustavo F. Padovan 35560e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 35570a708f8fSGustavo F. Padovan switch (rfc.mode) { 35580a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 355947d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 356047d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 356147d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3562c20f8e35SMat Martineau if (!test_bit(FLAG_EXT_CTRL, &chan->flags)) 3563c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3564c20f8e35SMat Martineau rfc.txwin_size); 356566af7aafSAndrei Emeltchenko 356666af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 356766af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 356866af7aafSAndrei Emeltchenko chan->local_sdu_itime = 356966af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 357066af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 357166af7aafSAndrei Emeltchenko chan->local_flush_to = 357266af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 357366af7aafSAndrei Emeltchenko } 35740a708f8fSGustavo F. Padovan break; 357566af7aafSAndrei Emeltchenko 35760a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 357747d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 35780a708f8fSGustavo F. Padovan } 35790a708f8fSGustavo F. Padovan } 35800a708f8fSGustavo F. Padovan 3581fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 358259e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 35830a708f8fSGustavo F. Padovan 35840a708f8fSGustavo F. Padovan return ptr - data; 35850a708f8fSGustavo F. Padovan } 35860a708f8fSGustavo F. Padovan 35872d792818SGustavo Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, 35882d792818SGustavo Padovan u16 result, u16 flags) 35890a708f8fSGustavo F. Padovan { 35900a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 35910a708f8fSGustavo F. Padovan void *ptr = rsp->data; 35920a708f8fSGustavo F. Padovan 3593fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 35940a708f8fSGustavo F. Padovan 3595fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 35960a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 35970a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 35980a708f8fSGustavo F. Padovan 35990a708f8fSGustavo F. Padovan return ptr - data; 36000a708f8fSGustavo F. Padovan } 36010a708f8fSGustavo F. Padovan 36028c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3603710f9b0aSGustavo F. Padovan { 3604710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 36058c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3606710f9b0aSGustavo F. Padovan u8 buf[128]; 3607439f34acSAndrei Emeltchenko u8 rsp_code; 3608710f9b0aSGustavo F. Padovan 3609fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3610fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3611ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3612ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3613439f34acSAndrei Emeltchenko 3614439f34acSAndrei Emeltchenko if (chan->hs_hcon) 3615439f34acSAndrei Emeltchenko rsp_code = L2CAP_CREATE_CHAN_RSP; 3616439f34acSAndrei Emeltchenko else 3617439f34acSAndrei Emeltchenko rsp_code = L2CAP_CONN_RSP; 3618439f34acSAndrei Emeltchenko 3619439f34acSAndrei Emeltchenko BT_DBG("chan %p rsp_code %u", chan, rsp_code); 3620439f34acSAndrei Emeltchenko 3621439f34acSAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, rsp_code, sizeof(rsp), &rsp); 3622710f9b0aSGustavo F. Padovan 3623c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3624710f9b0aSGustavo F. Padovan return; 3625710f9b0aSGustavo F. Padovan 3626710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3627710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3628710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3629710f9b0aSGustavo F. Padovan } 3630710f9b0aSGustavo F. Padovan 363147d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 36320a708f8fSGustavo F. Padovan { 36330a708f8fSGustavo F. Padovan int type, olen; 36340a708f8fSGustavo F. Padovan unsigned long val; 3635c20f8e35SMat Martineau /* Use sane default values in case a misbehaving remote device 3636c20f8e35SMat Martineau * did not send an RFC or extended window size option. 3637c20f8e35SMat Martineau */ 3638c20f8e35SMat Martineau u16 txwin_ext = chan->ack_win; 3639c20f8e35SMat Martineau struct l2cap_conf_rfc rfc = { 3640c20f8e35SMat Martineau .mode = chan->mode, 3641c20f8e35SMat Martineau .retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO), 3642c20f8e35SMat Martineau .monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO), 3643c20f8e35SMat Martineau .max_pdu_size = cpu_to_le16(chan->imtu), 3644c20f8e35SMat Martineau .txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW), 3645c20f8e35SMat Martineau }; 36460a708f8fSGustavo F. Padovan 364747d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 36480a708f8fSGustavo F. Padovan 36490c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 36500a708f8fSGustavo F. Padovan return; 36510a708f8fSGustavo F. Padovan 36520a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 36530a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 36540a708f8fSGustavo F. Padovan 3655c20f8e35SMat Martineau switch (type) { 3656c20f8e35SMat Martineau case L2CAP_CONF_RFC: 3657c20f8e35SMat Martineau if (olen == sizeof(rfc)) 36580a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 3659c20f8e35SMat Martineau break; 3660c20f8e35SMat Martineau case L2CAP_CONF_EWS: 3661c20f8e35SMat Martineau txwin_ext = val; 3662c20f8e35SMat Martineau break; 3663c20f8e35SMat Martineau } 36640a708f8fSGustavo F. Padovan } 36650a708f8fSGustavo F. Padovan 36660a708f8fSGustavo F. Padovan switch (rfc.mode) { 36670a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 366847d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 366947d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 367047d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3671c20f8e35SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 3672c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, txwin_ext); 3673c20f8e35SMat Martineau else 3674c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3675c20f8e35SMat Martineau rfc.txwin_size); 36760a708f8fSGustavo F. Padovan break; 36770a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 367847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 36790a708f8fSGustavo F. Padovan } 36800a708f8fSGustavo F. Padovan } 36810a708f8fSGustavo F. Padovan 36822d792818SGustavo Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, 3683cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3684cb3b3152SJohan Hedberg u8 *data) 36850a708f8fSGustavo F. Padovan { 3686e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 36870a708f8fSGustavo F. Padovan 3688cb3b3152SJohan Hedberg if (cmd_len < sizeof(*rej)) 3689cb3b3152SJohan Hedberg return -EPROTO; 3690cb3b3152SJohan Hedberg 3691e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 36920a708f8fSGustavo F. Padovan return 0; 36930a708f8fSGustavo F. Padovan 36940a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 36950a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 369617cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 36970a708f8fSGustavo F. Padovan 36980a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 36990a708f8fSGustavo F. Padovan conn->info_ident = 0; 37000a708f8fSGustavo F. Padovan 37010a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 37020a708f8fSGustavo F. Padovan } 37030a708f8fSGustavo F. Padovan 37040a708f8fSGustavo F. Padovan return 0; 37050a708f8fSGustavo F. Padovan } 37060a708f8fSGustavo F. Padovan 37071700915fSMat Martineau static struct l2cap_chan *l2cap_connect(struct l2cap_conn *conn, 37081700915fSMat Martineau struct l2cap_cmd_hdr *cmd, 37094c89b6aaSMat Martineau u8 *data, u8 rsp_code, u8 amp_id) 37100a708f8fSGustavo F. Padovan { 37110a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 37120a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 371323691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 37140a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 37150a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 37160a708f8fSGustavo F. Padovan 37170a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 37180a708f8fSGustavo F. Padovan __le16 psm = req->psm; 37190a708f8fSGustavo F. Padovan 3720097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 37210a708f8fSGustavo F. Padovan 37220a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3723c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 372423691d75SGustavo F. Padovan if (!pchan) { 37250a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 37260a708f8fSGustavo F. Padovan goto sendresp; 37270a708f8fSGustavo F. Padovan } 37280a708f8fSGustavo F. Padovan 372923691d75SGustavo F. Padovan parent = pchan->sk; 373023691d75SGustavo F. Padovan 37313df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3732aa2ac881SGustavo F. Padovan lock_sock(parent); 37330a708f8fSGustavo F. Padovan 37340a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 37352983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 37360a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 37379f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 37380a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 37390a708f8fSGustavo F. Padovan goto response; 37400a708f8fSGustavo F. Padovan } 37410a708f8fSGustavo F. Padovan 37420a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 37430a708f8fSGustavo F. Padovan 37442dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 37452dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 37462dfa1003SGustavo Padovan goto response; 37472dfa1003SGustavo Padovan 374880b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 374980808e43SGustavo F. Padovan if (!chan) 37500a708f8fSGustavo F. Padovan goto response; 37510a708f8fSGustavo F. Padovan 375280808e43SGustavo F. Padovan sk = chan->sk; 375380808e43SGustavo F. Padovan 37540a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 37550a708f8fSGustavo F. Padovan 37560a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 37570a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3758fe4128e0SGustavo F. Padovan chan->psm = psm; 3759fe4128e0SGustavo F. Padovan chan->dcid = scid; 37601700915fSMat Martineau chan->local_amp_id = amp_id; 37610a708f8fSGustavo F. Padovan 37626be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 376348454079SGustavo F. Padovan 3764fe4128e0SGustavo F. Padovan dcid = chan->scid; 37650a708f8fSGustavo F. Padovan 3766c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 37670a708f8fSGustavo F. Padovan 3768fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 37690a708f8fSGustavo F. Padovan 37700a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3771d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3772c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 37730e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 37740a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 37750a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 37762dc4e510SGustavo Padovan chan->ops->defer(chan); 37770a708f8fSGustavo F. Padovan } else { 37781700915fSMat Martineau /* Force pending result for AMP controllers. 37791700915fSMat Martineau * The connection will succeed after the 37801700915fSMat Martineau * physical link is up. 37811700915fSMat Martineau */ 37821700915fSMat Martineau if (amp_id) { 37831700915fSMat Martineau __l2cap_state_change(chan, BT_CONNECT2); 37841700915fSMat Martineau result = L2CAP_CR_PEND; 37851700915fSMat Martineau } else { 37860e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 37870a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 37881700915fSMat Martineau } 37890a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 37900a708f8fSGustavo F. Padovan } 37910a708f8fSGustavo F. Padovan } else { 37920e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 37930a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 37940a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 37950a708f8fSGustavo F. Padovan } 37960a708f8fSGustavo F. Padovan } else { 37970e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 37980a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 37990a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 38000a708f8fSGustavo F. Padovan } 38010a708f8fSGustavo F. Padovan 38020a708f8fSGustavo F. Padovan response: 3803aa2ac881SGustavo F. Padovan release_sock(parent); 38043df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38050a708f8fSGustavo F. Padovan 38060a708f8fSGustavo F. Padovan sendresp: 38070a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 38080a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 38090a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 38100a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 38114c89b6aaSMat Martineau l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp); 38120a708f8fSGustavo F. Padovan 38130a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 38140a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3815ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 38160a708f8fSGustavo F. Padovan 38170a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 38180a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 38190a708f8fSGustavo F. Padovan 3820ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 38210a708f8fSGustavo F. Padovan 38222d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 38232d792818SGustavo Padovan sizeof(info), &info); 38240a708f8fSGustavo F. Padovan } 38250a708f8fSGustavo F. Padovan 3826c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 38270a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 38280a708f8fSGustavo F. Padovan u8 buf[128]; 3829c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 38300a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 383173ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 383273ffa904SGustavo F. Padovan chan->num_conf_req++; 38330a708f8fSGustavo F. Padovan } 38341700915fSMat Martineau 38351700915fSMat Martineau return chan; 38364c89b6aaSMat Martineau } 38370a708f8fSGustavo F. Padovan 38384c89b6aaSMat Martineau static int l2cap_connect_req(struct l2cap_conn *conn, 3839cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 38404c89b6aaSMat Martineau { 38417b064edaSJaganath Kanakkassery struct hci_dev *hdev = conn->hcon->hdev; 38427b064edaSJaganath Kanakkassery struct hci_conn *hcon = conn->hcon; 38437b064edaSJaganath Kanakkassery 3844cb3b3152SJohan Hedberg if (cmd_len < sizeof(struct l2cap_conn_req)) 3845cb3b3152SJohan Hedberg return -EPROTO; 3846cb3b3152SJohan Hedberg 38477b064edaSJaganath Kanakkassery hci_dev_lock(hdev); 38487b064edaSJaganath Kanakkassery if (test_bit(HCI_MGMT, &hdev->dev_flags) && 38497b064edaSJaganath Kanakkassery !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &hcon->flags)) 38507b064edaSJaganath Kanakkassery mgmt_device_connected(hdev, &hcon->dst, hcon->type, 38517b064edaSJaganath Kanakkassery hcon->dst_type, 0, NULL, 0, 38527b064edaSJaganath Kanakkassery hcon->dev_class); 38537b064edaSJaganath Kanakkassery hci_dev_unlock(hdev); 38547b064edaSJaganath Kanakkassery 3855300229f9SGustavo Padovan l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP, 0); 38560a708f8fSGustavo F. Padovan return 0; 38570a708f8fSGustavo F. Padovan } 38580a708f8fSGustavo F. Padovan 38595909cf30SMat Martineau static int l2cap_connect_create_rsp(struct l2cap_conn *conn, 3860cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3861cb3b3152SJohan Hedberg u8 *data) 38620a708f8fSGustavo F. Padovan { 38630a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 38640a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 386548454079SGustavo F. Padovan struct l2cap_chan *chan; 38660a708f8fSGustavo F. Padovan u8 req[128]; 38673df91ea2SAndrei Emeltchenko int err; 38680a708f8fSGustavo F. Padovan 3869cb3b3152SJohan Hedberg if (cmd_len < sizeof(*rsp)) 3870cb3b3152SJohan Hedberg return -EPROTO; 3871cb3b3152SJohan Hedberg 38720a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 38730a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 38740a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 38750a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 38760a708f8fSGustavo F. Padovan 38771b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 38781b009c98SAndrei Emeltchenko dcid, scid, result, status); 38790a708f8fSGustavo F. Padovan 38803df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 38813df91ea2SAndrei Emeltchenko 38820a708f8fSGustavo F. Padovan if (scid) { 38833df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 38843df91ea2SAndrei Emeltchenko if (!chan) { 38853df91ea2SAndrei Emeltchenko err = -EFAULT; 38863df91ea2SAndrei Emeltchenko goto unlock; 38873df91ea2SAndrei Emeltchenko } 38880a708f8fSGustavo F. Padovan } else { 38893df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 38903df91ea2SAndrei Emeltchenko if (!chan) { 38913df91ea2SAndrei Emeltchenko err = -EFAULT; 38923df91ea2SAndrei Emeltchenko goto unlock; 38933df91ea2SAndrei Emeltchenko } 38940a708f8fSGustavo F. Padovan } 38950a708f8fSGustavo F. Padovan 38963df91ea2SAndrei Emeltchenko err = 0; 38973df91ea2SAndrei Emeltchenko 38986be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 389948454079SGustavo F. Padovan 39000a708f8fSGustavo F. Padovan switch (result) { 39010a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 390289bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3903fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3904fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3905c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 39060a708f8fSGustavo F. Padovan 3907c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 39080a708f8fSGustavo F. Padovan break; 39090a708f8fSGustavo F. Padovan 39100a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 391173ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 391273ffa904SGustavo F. Padovan chan->num_conf_req++; 39130a708f8fSGustavo F. Padovan break; 39140a708f8fSGustavo F. Padovan 39150a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3916c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 39170a708f8fSGustavo F. Padovan break; 39180a708f8fSGustavo F. Padovan 39190a708f8fSGustavo F. Padovan default: 392048454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 39210a708f8fSGustavo F. Padovan break; 39220a708f8fSGustavo F. Padovan } 39230a708f8fSGustavo F. Padovan 39246be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39253df91ea2SAndrei Emeltchenko 39263df91ea2SAndrei Emeltchenko unlock: 39273df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39283df91ea2SAndrei Emeltchenko 39293df91ea2SAndrei Emeltchenko return err; 39300a708f8fSGustavo F. Padovan } 39310a708f8fSGustavo F. Padovan 393247d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 39330a708f8fSGustavo F. Padovan { 39340a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 39350a708f8fSGustavo F. Padovan * sides request it. 39360a708f8fSGustavo F. Padovan */ 39370c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 393847d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3939f2592d3eSAndrei Emeltchenko else if (!test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) 394047d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 39410a708f8fSGustavo F. Padovan } 39420a708f8fSGustavo F. Padovan 394329d8a590SAndrei Emeltchenko static void l2cap_send_efs_conf_rsp(struct l2cap_chan *chan, void *data, 394429d8a590SAndrei Emeltchenko u8 ident, u16 flags) 394529d8a590SAndrei Emeltchenko { 394629d8a590SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 394729d8a590SAndrei Emeltchenko 394829d8a590SAndrei Emeltchenko BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident, 394929d8a590SAndrei Emeltchenko flags); 395029d8a590SAndrei Emeltchenko 395129d8a590SAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 395229d8a590SAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 395329d8a590SAndrei Emeltchenko 395429d8a590SAndrei Emeltchenko l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP, 395529d8a590SAndrei Emeltchenko l2cap_build_conf_rsp(chan, data, 395629d8a590SAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), data); 395729d8a590SAndrei Emeltchenko } 395829d8a590SAndrei Emeltchenko 39592d792818SGustavo Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, 39602d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 39612d792818SGustavo Padovan u8 *data) 39620a708f8fSGustavo F. Padovan { 39630a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 39640a708f8fSGustavo F. Padovan u16 dcid, flags; 39650a708f8fSGustavo F. Padovan u8 rsp[64]; 396648454079SGustavo F. Padovan struct l2cap_chan *chan; 39673c588192SMat Martineau int len, err = 0; 39680a708f8fSGustavo F. Padovan 3969cb3b3152SJohan Hedberg if (cmd_len < sizeof(*req)) 3970cb3b3152SJohan Hedberg return -EPROTO; 3971cb3b3152SJohan Hedberg 39720a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 39730a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 39740a708f8fSGustavo F. Padovan 39750a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 39760a708f8fSGustavo F. Padovan 3977baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 397848454079SGustavo F. Padovan if (!chan) 39790a708f8fSGustavo F. Padovan return -ENOENT; 39800a708f8fSGustavo F. Padovan 3981033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3982e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 39830a708f8fSGustavo F. Padovan 3984ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3985e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3986e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3987e2fd318eSIlia Kolomisnky 39880a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 39890a708f8fSGustavo F. Padovan sizeof(rej), &rej); 39900a708f8fSGustavo F. Padovan goto unlock; 39910a708f8fSGustavo F. Padovan } 39920a708f8fSGustavo F. Padovan 39930a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 39940a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 3995cb3b3152SJohan Hedberg if (chan->conf_len + len > sizeof(chan->conf_req)) { 39960a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3997fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 39980a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 39990a708f8fSGustavo F. Padovan goto unlock; 40000a708f8fSGustavo F. Padovan } 40010a708f8fSGustavo F. Padovan 40020a708f8fSGustavo F. Padovan /* Store config. */ 400373ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 400473ffa904SGustavo F. Padovan chan->conf_len += len; 40050a708f8fSGustavo F. Padovan 400659e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 40070a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 40080a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 4009fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 40105325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 40110a708f8fSGustavo F. Padovan goto unlock; 40120a708f8fSGustavo F. Padovan } 40130a708f8fSGustavo F. Padovan 40140a708f8fSGustavo F. Padovan /* Complete config. */ 401573ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 40160a708f8fSGustavo F. Padovan if (len < 0) { 40175e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 40180a708f8fSGustavo F. Padovan goto unlock; 40190a708f8fSGustavo F. Padovan } 40200a708f8fSGustavo F. Padovan 40211500109bSMat Martineau chan->ident = cmd->ident; 40220a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 402373ffa904SGustavo F. Padovan chan->num_conf_rsp++; 40240a708f8fSGustavo F. Padovan 40250a708f8fSGustavo F. Padovan /* Reset config buffer. */ 402673ffa904SGustavo F. Padovan chan->conf_len = 0; 40270a708f8fSGustavo F. Padovan 4028c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 40290a708f8fSGustavo F. Padovan goto unlock; 40300a708f8fSGustavo F. Padovan 4031c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 403247d1ec61SGustavo F. Padovan set_default_fcs(chan); 40330a708f8fSGustavo F. Padovan 4034105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 4035105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 40363c588192SMat Martineau err = l2cap_ertm_init(chan); 40370a708f8fSGustavo F. Padovan 40383c588192SMat Martineau if (err < 0) 40395e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 40403c588192SMat Martineau else 4041cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 40423c588192SMat Martineau 40430a708f8fSGustavo F. Padovan goto unlock; 40440a708f8fSGustavo F. Padovan } 40450a708f8fSGustavo F. Padovan 4046c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 40470a708f8fSGustavo F. Padovan u8 buf[64]; 40480a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 404973ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 405073ffa904SGustavo F. Padovan chan->num_conf_req++; 40510a708f8fSGustavo F. Padovan } 40520a708f8fSGustavo F. Padovan 40530e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 40540e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 40550e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 40560e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 40570e8b207eSAndrei Emeltchenko 40580e8b207eSAndrei Emeltchenko /* check compatibility */ 40590e8b207eSAndrei Emeltchenko 406079de886dSAndrei Emeltchenko /* Send rsp for BR/EDR channel */ 4061f351bc72SAndrei Emeltchenko if (!chan->hs_hcon) 406229d8a590SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, rsp, cmd->ident, flags); 406379de886dSAndrei Emeltchenko else 406479de886dSAndrei Emeltchenko chan->ident = cmd->ident; 40650e8b207eSAndrei Emeltchenko } 40660e8b207eSAndrei Emeltchenko 40670a708f8fSGustavo F. Padovan unlock: 40686be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 40693c588192SMat Martineau return err; 40700a708f8fSGustavo F. Padovan } 40710a708f8fSGustavo F. Padovan 40722d792818SGustavo Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, 4073cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4074cb3b3152SJohan Hedberg u8 *data) 40750a708f8fSGustavo F. Padovan { 40760a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 40770a708f8fSGustavo F. Padovan u16 scid, flags, result; 407848454079SGustavo F. Padovan struct l2cap_chan *chan; 4079cb3b3152SJohan Hedberg int len = cmd_len - sizeof(*rsp); 40803c588192SMat Martineau int err = 0; 40810a708f8fSGustavo F. Padovan 4082cb3b3152SJohan Hedberg if (cmd_len < sizeof(*rsp)) 4083cb3b3152SJohan Hedberg return -EPROTO; 4084cb3b3152SJohan Hedberg 40850a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 40860a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 40870a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 40880a708f8fSGustavo F. Padovan 408961386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 409061386cbaSAndrei Emeltchenko result, len); 40910a708f8fSGustavo F. Padovan 4092baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 409348454079SGustavo F. Padovan if (!chan) 40940a708f8fSGustavo F. Padovan return 0; 40950a708f8fSGustavo F. Padovan 40960a708f8fSGustavo F. Padovan switch (result) { 40970a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 409847d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 40990e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 41000a708f8fSGustavo F. Padovan break; 41010a708f8fSGustavo F. Padovan 41020e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 41030e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 41040e8b207eSAndrei Emeltchenko 41050e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 41060e8b207eSAndrei Emeltchenko char buf[64]; 41070e8b207eSAndrei Emeltchenko 41080e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 41090e8b207eSAndrei Emeltchenko buf, &result); 41100e8b207eSAndrei Emeltchenko if (len < 0) { 41115e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41120e8b207eSAndrei Emeltchenko goto done; 41130e8b207eSAndrei Emeltchenko } 41140e8b207eSAndrei Emeltchenko 4115f351bc72SAndrei Emeltchenko if (!chan->hs_hcon) { 411679de886dSAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, buf, cmd->ident, 411779de886dSAndrei Emeltchenko 0); 41185ce66b59SAndrei Emeltchenko } else { 41195ce66b59SAndrei Emeltchenko if (l2cap_check_efs(chan)) { 41205ce66b59SAndrei Emeltchenko amp_create_logical_link(chan); 412179de886dSAndrei Emeltchenko chan->ident = cmd->ident; 41220e8b207eSAndrei Emeltchenko } 41235ce66b59SAndrei Emeltchenko } 41245ce66b59SAndrei Emeltchenko } 41250e8b207eSAndrei Emeltchenko goto done; 41260e8b207eSAndrei Emeltchenko 41270a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 412873ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 41290a708f8fSGustavo F. Padovan char req[64]; 41300a708f8fSGustavo F. Padovan 41310a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 41325e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41330a708f8fSGustavo F. Padovan goto done; 41340a708f8fSGustavo F. Padovan } 41350a708f8fSGustavo F. Padovan 41360a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 41370a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 4138b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 4139b4450035SGustavo F. Padovan req, &result); 41400a708f8fSGustavo F. Padovan if (len < 0) { 41415e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41420a708f8fSGustavo F. Padovan goto done; 41430a708f8fSGustavo F. Padovan } 41440a708f8fSGustavo F. Padovan 41450a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 41460a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 414773ffa904SGustavo F. Padovan chan->num_conf_req++; 41480a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 41490a708f8fSGustavo F. Padovan goto done; 41500a708f8fSGustavo F. Padovan break; 41510a708f8fSGustavo F. Padovan } 41520a708f8fSGustavo F. Padovan 41530a708f8fSGustavo F. Padovan default: 41546be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 41552e0052e4SAndrei Emeltchenko 4156ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 41575e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41580a708f8fSGustavo F. Padovan goto done; 41590a708f8fSGustavo F. Padovan } 41600a708f8fSGustavo F. Padovan 416159e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 41620a708f8fSGustavo F. Padovan goto done; 41630a708f8fSGustavo F. Padovan 4164c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 41650a708f8fSGustavo F. Padovan 4166c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 416747d1ec61SGustavo F. Padovan set_default_fcs(chan); 41680a708f8fSGustavo F. Padovan 4169105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 4170105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 41713c588192SMat Martineau err = l2cap_ertm_init(chan); 41720a708f8fSGustavo F. Padovan 41733c588192SMat Martineau if (err < 0) 41745e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 41753c588192SMat Martineau else 4176cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 41770a708f8fSGustavo F. Padovan } 41780a708f8fSGustavo F. Padovan 41790a708f8fSGustavo F. Padovan done: 41806be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 41813c588192SMat Martineau return err; 41820a708f8fSGustavo F. Padovan } 41830a708f8fSGustavo F. Padovan 41842d792818SGustavo Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, 4185cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4186cb3b3152SJohan Hedberg u8 *data) 41870a708f8fSGustavo F. Padovan { 41880a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 41890a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 41900a708f8fSGustavo F. Padovan u16 dcid, scid; 419148454079SGustavo F. Padovan struct l2cap_chan *chan; 41920a708f8fSGustavo F. Padovan struct sock *sk; 41930a708f8fSGustavo F. Padovan 4194cb3b3152SJohan Hedberg if (cmd_len != sizeof(*req)) 4195cb3b3152SJohan Hedberg return -EPROTO; 4196cb3b3152SJohan Hedberg 41970a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 41980a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 41990a708f8fSGustavo F. Padovan 42000a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 42010a708f8fSGustavo F. Padovan 42023df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 42033df91ea2SAndrei Emeltchenko 42043df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 42053df91ea2SAndrei Emeltchenko if (!chan) { 42063df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 42070a708f8fSGustavo F. Padovan return 0; 42083df91ea2SAndrei Emeltchenko } 42090a708f8fSGustavo F. Padovan 42106be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 42116be36555SAndrei Emeltchenko 421248454079SGustavo F. Padovan sk = chan->sk; 421348454079SGustavo F. Padovan 4214fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 4215fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 42160a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 42170a708f8fSGustavo F. Padovan 42186be36555SAndrei Emeltchenko lock_sock(sk); 42190a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 42206be36555SAndrei Emeltchenko release_sock(sk); 42210a708f8fSGustavo F. Padovan 422261d6ef3eSMat Martineau l2cap_chan_hold(chan); 422348454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 42246be36555SAndrei Emeltchenko 42256be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 42260a708f8fSGustavo F. Padovan 422780b98027SGustavo Padovan chan->ops->close(chan); 422861d6ef3eSMat Martineau l2cap_chan_put(chan); 42293df91ea2SAndrei Emeltchenko 42303df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 42313df91ea2SAndrei Emeltchenko 42320a708f8fSGustavo F. Padovan return 0; 42330a708f8fSGustavo F. Padovan } 42340a708f8fSGustavo F. Padovan 42352d792818SGustavo Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, 4236cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4237cb3b3152SJohan Hedberg u8 *data) 42380a708f8fSGustavo F. Padovan { 42390a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 42400a708f8fSGustavo F. Padovan u16 dcid, scid; 424148454079SGustavo F. Padovan struct l2cap_chan *chan; 42420a708f8fSGustavo F. Padovan 4243cb3b3152SJohan Hedberg if (cmd_len != sizeof(*rsp)) 4244cb3b3152SJohan Hedberg return -EPROTO; 4245cb3b3152SJohan Hedberg 42460a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 42470a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 42480a708f8fSGustavo F. Padovan 42490a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 42500a708f8fSGustavo F. Padovan 42513df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 42523df91ea2SAndrei Emeltchenko 42533df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 42543df91ea2SAndrei Emeltchenko if (!chan) { 42553df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 42560a708f8fSGustavo F. Padovan return 0; 42573df91ea2SAndrei Emeltchenko } 42580a708f8fSGustavo F. Padovan 42596be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 426048454079SGustavo F. Padovan 426161d6ef3eSMat Martineau l2cap_chan_hold(chan); 426248454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 42636be36555SAndrei Emeltchenko 42646be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 42650a708f8fSGustavo F. Padovan 426680b98027SGustavo Padovan chan->ops->close(chan); 426761d6ef3eSMat Martineau l2cap_chan_put(chan); 42683df91ea2SAndrei Emeltchenko 42693df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 42703df91ea2SAndrei Emeltchenko 42710a708f8fSGustavo F. Padovan return 0; 42720a708f8fSGustavo F. Padovan } 42730a708f8fSGustavo F. Padovan 42742d792818SGustavo Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, 4275cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4276cb3b3152SJohan Hedberg u8 *data) 42770a708f8fSGustavo F. Padovan { 42780a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 42790a708f8fSGustavo F. Padovan u16 type; 42800a708f8fSGustavo F. Padovan 4281cb3b3152SJohan Hedberg if (cmd_len != sizeof(*req)) 4282cb3b3152SJohan Hedberg return -EPROTO; 4283cb3b3152SJohan Hedberg 42840a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 42850a708f8fSGustavo F. Padovan 42860a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 42870a708f8fSGustavo F. Padovan 42880a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 42890a708f8fSGustavo F. Padovan u8 buf[8]; 42900a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 42910a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 4292ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 4293ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 42940a708f8fSGustavo F. Padovan if (!disable_ertm) 42950a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 42960a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 4297a5fd6f30SAndrei Emeltchenko if (enable_hs) 42986327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 42996327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 4300a5fd6f30SAndrei Emeltchenko 43010a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 43022d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 43032d792818SGustavo Padovan buf); 43040a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 43050a708f8fSGustavo F. Padovan u8 buf[12]; 43060a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 430750a147cdSMat Martineau 430850a147cdSMat Martineau if (enable_hs) 430950a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 431050a147cdSMat Martineau else 431150a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 431250a147cdSMat Martineau 4313ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 4314ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 4315c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 43162d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 43172d792818SGustavo Padovan buf); 43180a708f8fSGustavo F. Padovan } else { 43190a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 43200a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 4321ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 43222d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), 43232d792818SGustavo Padovan &rsp); 43240a708f8fSGustavo F. Padovan } 43250a708f8fSGustavo F. Padovan 43260a708f8fSGustavo F. Padovan return 0; 43270a708f8fSGustavo F. Padovan } 43280a708f8fSGustavo F. Padovan 43292d792818SGustavo Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, 4330cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4331cb3b3152SJohan Hedberg u8 *data) 43320a708f8fSGustavo F. Padovan { 43330a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 43340a708f8fSGustavo F. Padovan u16 type, result; 43350a708f8fSGustavo F. Padovan 4336cb3b3152SJohan Hedberg if (cmd_len != sizeof(*rsp)) 4337cb3b3152SJohan Hedberg return -EPROTO; 4338cb3b3152SJohan Hedberg 43390a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 43400a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 43410a708f8fSGustavo F. Padovan 43420a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 43430a708f8fSGustavo F. Padovan 4344e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 4345e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 4346e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 4347e90165beSAndrei Emeltchenko return 0; 4348e90165beSAndrei Emeltchenko 434917cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 43500a708f8fSGustavo F. Padovan 43510a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 43520a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 43530a708f8fSGustavo F. Padovan conn->info_ident = 0; 43540a708f8fSGustavo F. Padovan 43550a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 43560a708f8fSGustavo F. Padovan 43570a708f8fSGustavo F. Padovan return 0; 43580a708f8fSGustavo F. Padovan } 43590a708f8fSGustavo F. Padovan 4360978c93b9SAndrei Emeltchenko switch (type) { 4361978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 43620a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 43630a708f8fSGustavo F. Padovan 43640a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 43650a708f8fSGustavo F. Padovan struct l2cap_info_req req; 4366ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 43670a708f8fSGustavo F. Padovan 43680a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 43690a708f8fSGustavo F. Padovan 43700a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 43710a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 43720a708f8fSGustavo F. Padovan } else { 43730a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 43740a708f8fSGustavo F. Padovan conn->info_ident = 0; 43750a708f8fSGustavo F. Padovan 43760a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 43770a708f8fSGustavo F. Padovan } 4378978c93b9SAndrei Emeltchenko break; 4379978c93b9SAndrei Emeltchenko 4380978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 4381978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 43820a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 43830a708f8fSGustavo F. Padovan conn->info_ident = 0; 43840a708f8fSGustavo F. Padovan 43850a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 4386978c93b9SAndrei Emeltchenko break; 43870a708f8fSGustavo F. Padovan } 43880a708f8fSGustavo F. Padovan 43890a708f8fSGustavo F. Padovan return 0; 43900a708f8fSGustavo F. Padovan } 43910a708f8fSGustavo F. Padovan 43921700915fSMat Martineau static int l2cap_create_channel_req(struct l2cap_conn *conn, 43932d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 43942d792818SGustavo Padovan u16 cmd_len, void *data) 4395f94ff6ffSMat Martineau { 4396f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 43976e1df6a6SAndrei Emeltchenko struct l2cap_create_chan_rsp rsp; 43981700915fSMat Martineau struct l2cap_chan *chan; 43996e1df6a6SAndrei Emeltchenko struct hci_dev *hdev; 4400f94ff6ffSMat Martineau u16 psm, scid; 4401f94ff6ffSMat Martineau 4402f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 4403f94ff6ffSMat Martineau return -EPROTO; 4404f94ff6ffSMat Martineau 4405f94ff6ffSMat Martineau if (!enable_hs) 4406f94ff6ffSMat Martineau return -EINVAL; 4407f94ff6ffSMat Martineau 4408f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 4409f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 4410f94ff6ffSMat Martineau 4411ad0ac6caSAndrei Emeltchenko BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id); 4412f94ff6ffSMat Martineau 44136e1df6a6SAndrei Emeltchenko /* For controller id 0 make BR/EDR connection */ 44146e1df6a6SAndrei Emeltchenko if (req->amp_id == HCI_BREDR_ID) { 44156e1df6a6SAndrei Emeltchenko l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 44166e1df6a6SAndrei Emeltchenko req->amp_id); 44176e1df6a6SAndrei Emeltchenko return 0; 44186e1df6a6SAndrei Emeltchenko } 44191700915fSMat Martineau 44201700915fSMat Martineau /* Validate AMP controller id */ 44211700915fSMat Martineau hdev = hci_dev_get(req->amp_id); 44226e1df6a6SAndrei Emeltchenko if (!hdev) 44236e1df6a6SAndrei Emeltchenko goto error; 44241700915fSMat Martineau 44256e1df6a6SAndrei Emeltchenko if (hdev->dev_type != HCI_AMP || !test_bit(HCI_UP, &hdev->flags)) { 44266e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 44276e1df6a6SAndrei Emeltchenko goto error; 44286e1df6a6SAndrei Emeltchenko } 44296e1df6a6SAndrei Emeltchenko 44306e1df6a6SAndrei Emeltchenko chan = l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 44316e1df6a6SAndrei Emeltchenko req->amp_id); 44326e1df6a6SAndrei Emeltchenko if (chan) { 44336e1df6a6SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 44346e1df6a6SAndrei Emeltchenko struct hci_conn *hs_hcon; 44356e1df6a6SAndrei Emeltchenko 44366e1df6a6SAndrei Emeltchenko hs_hcon = hci_conn_hash_lookup_ba(hdev, AMP_LINK, conn->dst); 44376e1df6a6SAndrei Emeltchenko if (!hs_hcon) { 44386e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 44396e1df6a6SAndrei Emeltchenko return -EFAULT; 44406e1df6a6SAndrei Emeltchenko } 44416e1df6a6SAndrei Emeltchenko 44426e1df6a6SAndrei Emeltchenko BT_DBG("mgr %p bredr_chan %p hs_hcon %p", mgr, chan, hs_hcon); 44436e1df6a6SAndrei Emeltchenko 44446e1df6a6SAndrei Emeltchenko mgr->bredr_chan = chan; 44456e1df6a6SAndrei Emeltchenko chan->hs_hcon = hs_hcon; 4446fd45bf4cSAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 44476e1df6a6SAndrei Emeltchenko conn->mtu = hdev->block_mtu; 44486e1df6a6SAndrei Emeltchenko } 44496e1df6a6SAndrei Emeltchenko 44506e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 44516e1df6a6SAndrei Emeltchenko 44526e1df6a6SAndrei Emeltchenko return 0; 44536e1df6a6SAndrei Emeltchenko 44546e1df6a6SAndrei Emeltchenko error: 4455f94ff6ffSMat Martineau rsp.dcid = 0; 4456f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 44571700915fSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_CR_BAD_AMP); 44588ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 4459f94ff6ffSMat Martineau 4460f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 4461f94ff6ffSMat Martineau sizeof(rsp), &rsp); 4462f94ff6ffSMat Martineau 44636e1df6a6SAndrei Emeltchenko return -EFAULT; 4464f94ff6ffSMat Martineau } 4465f94ff6ffSMat Martineau 44668eb200bdSMat Martineau static void l2cap_send_move_chan_req(struct l2cap_chan *chan, u8 dest_amp_id) 44678eb200bdSMat Martineau { 44688eb200bdSMat Martineau struct l2cap_move_chan_req req; 44698eb200bdSMat Martineau u8 ident; 44708eb200bdSMat Martineau 44718eb200bdSMat Martineau BT_DBG("chan %p, dest_amp_id %d", chan, dest_amp_id); 44728eb200bdSMat Martineau 44738eb200bdSMat Martineau ident = l2cap_get_ident(chan->conn); 44748eb200bdSMat Martineau chan->ident = ident; 44758eb200bdSMat Martineau 44768eb200bdSMat Martineau req.icid = cpu_to_le16(chan->scid); 44778eb200bdSMat Martineau req.dest_amp_id = dest_amp_id; 44788eb200bdSMat Martineau 44798eb200bdSMat Martineau l2cap_send_cmd(chan->conn, ident, L2CAP_MOVE_CHAN_REQ, sizeof(req), 44808eb200bdSMat Martineau &req); 44818eb200bdSMat Martineau 44828eb200bdSMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 44838eb200bdSMat Martineau } 44848eb200bdSMat Martineau 44851500109bSMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_chan *chan, u16 result) 44868d5a04a1SMat Martineau { 44878d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 44888d5a04a1SMat Martineau 44891500109bSMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 44908d5a04a1SMat Martineau 44911500109bSMat Martineau rsp.icid = cpu_to_le16(chan->dcid); 44928d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 44938d5a04a1SMat Martineau 44941500109bSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_RSP, 44951500109bSMat Martineau sizeof(rsp), &rsp); 44968d5a04a1SMat Martineau } 44978d5a04a1SMat Martineau 44985b155ef9SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_chan *chan, u16 result) 44998d5a04a1SMat Martineau { 45008d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 45018d5a04a1SMat Martineau 45025b155ef9SMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 45038d5a04a1SMat Martineau 45045b155ef9SMat Martineau chan->ident = l2cap_get_ident(chan->conn); 45058d5a04a1SMat Martineau 45065b155ef9SMat Martineau cfm.icid = cpu_to_le16(chan->scid); 45078d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 45088d5a04a1SMat Martineau 45095b155ef9SMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_CFM, 45105b155ef9SMat Martineau sizeof(cfm), &cfm); 45115b155ef9SMat Martineau 45125b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 45135b155ef9SMat Martineau } 45145b155ef9SMat Martineau 45155b155ef9SMat Martineau static void l2cap_send_move_chan_cfm_icid(struct l2cap_conn *conn, u16 icid) 45165b155ef9SMat Martineau { 45175b155ef9SMat Martineau struct l2cap_move_chan_cfm cfm; 45185b155ef9SMat Martineau 45195b155ef9SMat Martineau BT_DBG("conn %p, icid 0x%4.4x", conn, icid); 45205b155ef9SMat Martineau 45215b155ef9SMat Martineau cfm.icid = cpu_to_le16(icid); 45225b155ef9SMat Martineau cfm.result = __constant_cpu_to_le16(L2CAP_MC_UNCONFIRMED); 45235b155ef9SMat Martineau 45245b155ef9SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_MOVE_CHAN_CFM, 45255b155ef9SMat Martineau sizeof(cfm), &cfm); 45268d5a04a1SMat Martineau } 45278d5a04a1SMat Martineau 45288d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 45298d5a04a1SMat Martineau u16 icid) 45308d5a04a1SMat Martineau { 45318d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 45328d5a04a1SMat Martineau 4533ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 45348d5a04a1SMat Martineau 45358d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 45368d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 45378d5a04a1SMat Martineau } 45388d5a04a1SMat Martineau 45395f3847a4SMat Martineau static void __release_logical_link(struct l2cap_chan *chan) 45405f3847a4SMat Martineau { 45415f3847a4SMat Martineau chan->hs_hchan = NULL; 45425f3847a4SMat Martineau chan->hs_hcon = NULL; 45435f3847a4SMat Martineau 45445f3847a4SMat Martineau /* Placeholder - release the logical link */ 45455f3847a4SMat Martineau } 45465f3847a4SMat Martineau 45471500109bSMat Martineau static void l2cap_logical_fail(struct l2cap_chan *chan) 45481500109bSMat Martineau { 45491500109bSMat Martineau /* Logical link setup failed */ 45501500109bSMat Martineau if (chan->state != BT_CONNECTED) { 45511500109bSMat Martineau /* Create channel failure, disconnect */ 45525e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 45531500109bSMat Martineau return; 45541500109bSMat Martineau } 45551500109bSMat Martineau 45561500109bSMat Martineau switch (chan->move_role) { 45571500109bSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 45581500109bSMat Martineau l2cap_move_done(chan); 45591500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_SUPP); 45601500109bSMat Martineau break; 45611500109bSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 45621500109bSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_COMP || 45631500109bSMat Martineau chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_CFM) { 45641500109bSMat Martineau /* Remote has only sent pending or 45651500109bSMat Martineau * success responses, clean up 45661500109bSMat Martineau */ 45671500109bSMat Martineau l2cap_move_done(chan); 45681500109bSMat Martineau } 45691500109bSMat Martineau 45701500109bSMat Martineau /* Other amp move states imply that the move 45711500109bSMat Martineau * has already aborted 45721500109bSMat Martineau */ 45731500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 45741500109bSMat Martineau break; 45751500109bSMat Martineau } 45761500109bSMat Martineau } 45771500109bSMat Martineau 45781500109bSMat Martineau static void l2cap_logical_finish_create(struct l2cap_chan *chan, 45791500109bSMat Martineau struct hci_chan *hchan) 45801500109bSMat Martineau { 45811500109bSMat Martineau struct l2cap_conf_rsp rsp; 45821500109bSMat Martineau 4583336178a3SAndrei Emeltchenko chan->hs_hchan = hchan; 45841500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 45851500109bSMat Martineau 458635ba9561SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, &rsp, chan->ident, 0); 45871500109bSMat Martineau 45881500109bSMat Martineau if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 4589fe79c6feSAndrei Emeltchenko int err; 45901500109bSMat Martineau 45911500109bSMat Martineau set_default_fcs(chan); 45921500109bSMat Martineau 45931500109bSMat Martineau err = l2cap_ertm_init(chan); 45941500109bSMat Martineau if (err < 0) 45955e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 45961500109bSMat Martineau else 45971500109bSMat Martineau l2cap_chan_ready(chan); 45981500109bSMat Martineau } 45991500109bSMat Martineau } 46001500109bSMat Martineau 46011500109bSMat Martineau static void l2cap_logical_finish_move(struct l2cap_chan *chan, 46021500109bSMat Martineau struct hci_chan *hchan) 46031500109bSMat Martineau { 46041500109bSMat Martineau chan->hs_hcon = hchan->conn; 46051500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 46061500109bSMat Martineau 46071500109bSMat Martineau BT_DBG("move_state %d", chan->move_state); 46081500109bSMat Martineau 46091500109bSMat Martineau switch (chan->move_state) { 46101500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 46111500109bSMat Martineau /* Move confirm will be sent after a success 46121500109bSMat Martineau * response is received 46131500109bSMat Martineau */ 46141500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 46151500109bSMat Martineau break; 46161500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_CFM: 46171500109bSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 46181500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 46191500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 46201500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 46211500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 46221500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 46231500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 46241500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 46251500109bSMat Martineau } 46261500109bSMat Martineau break; 46271500109bSMat Martineau default: 46281500109bSMat Martineau /* Move was not in expected state, free the channel */ 46291500109bSMat Martineau __release_logical_link(chan); 46301500109bSMat Martineau 46311500109bSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 46321500109bSMat Martineau } 46331500109bSMat Martineau } 46341500109bSMat Martineau 46351500109bSMat Martineau /* Call with chan locked */ 463627695fb4SAndrei Emeltchenko void l2cap_logical_cfm(struct l2cap_chan *chan, struct hci_chan *hchan, 46375b155ef9SMat Martineau u8 status) 46385b155ef9SMat Martineau { 46391500109bSMat Martineau BT_DBG("chan %p, hchan %p, status %d", chan, hchan, status); 46401500109bSMat Martineau 46411500109bSMat Martineau if (status) { 46421500109bSMat Martineau l2cap_logical_fail(chan); 46431500109bSMat Martineau __release_logical_link(chan); 46445b155ef9SMat Martineau return; 46455b155ef9SMat Martineau } 46465b155ef9SMat Martineau 46471500109bSMat Martineau if (chan->state != BT_CONNECTED) { 46481500109bSMat Martineau /* Ignore logical link if channel is on BR/EDR */ 46491500109bSMat Martineau if (chan->local_amp_id) 46501500109bSMat Martineau l2cap_logical_finish_create(chan, hchan); 46511500109bSMat Martineau } else { 46521500109bSMat Martineau l2cap_logical_finish_move(chan, hchan); 46531500109bSMat Martineau } 46541500109bSMat Martineau } 46551500109bSMat Martineau 46563f7a56c4SMat Martineau void l2cap_move_start(struct l2cap_chan *chan) 46573f7a56c4SMat Martineau { 46583f7a56c4SMat Martineau BT_DBG("chan %p", chan); 46593f7a56c4SMat Martineau 46603f7a56c4SMat Martineau if (chan->local_amp_id == HCI_BREDR_ID) { 46613f7a56c4SMat Martineau if (chan->chan_policy != BT_CHANNEL_POLICY_AMP_PREFERRED) 46623f7a56c4SMat Martineau return; 46633f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 46643f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 46653f7a56c4SMat Martineau /* Placeholder - start physical link setup */ 46663f7a56c4SMat Martineau } else { 46673f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 46683f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 46693f7a56c4SMat Martineau chan->move_id = 0; 46703f7a56c4SMat Martineau l2cap_move_setup(chan); 46713f7a56c4SMat Martineau l2cap_send_move_chan_req(chan, 0); 46723f7a56c4SMat Martineau } 46733f7a56c4SMat Martineau } 46743f7a56c4SMat Martineau 46758eb200bdSMat Martineau static void l2cap_do_create(struct l2cap_chan *chan, int result, 46768eb200bdSMat Martineau u8 local_amp_id, u8 remote_amp_id) 46778eb200bdSMat Martineau { 467862748ca1SAndrei Emeltchenko BT_DBG("chan %p state %s %u -> %u", chan, state_to_string(chan->state), 467962748ca1SAndrei Emeltchenko local_amp_id, remote_amp_id); 468062748ca1SAndrei Emeltchenko 468112d6cc60SAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 468212d6cc60SAndrei Emeltchenko 468362748ca1SAndrei Emeltchenko /* Outgoing channel on AMP */ 468462748ca1SAndrei Emeltchenko if (chan->state == BT_CONNECT) { 468562748ca1SAndrei Emeltchenko if (result == L2CAP_CR_SUCCESS) { 468662748ca1SAndrei Emeltchenko chan->local_amp_id = local_amp_id; 468762748ca1SAndrei Emeltchenko l2cap_send_create_chan_req(chan, remote_amp_id); 468862748ca1SAndrei Emeltchenko } else { 468962748ca1SAndrei Emeltchenko /* Revert to BR/EDR connect */ 469062748ca1SAndrei Emeltchenko l2cap_send_conn_req(chan); 469162748ca1SAndrei Emeltchenko } 469262748ca1SAndrei Emeltchenko 469362748ca1SAndrei Emeltchenko return; 469462748ca1SAndrei Emeltchenko } 469562748ca1SAndrei Emeltchenko 469662748ca1SAndrei Emeltchenko /* Incoming channel on AMP */ 469762748ca1SAndrei Emeltchenko if (__l2cap_no_conn_pending(chan)) { 46988eb200bdSMat Martineau struct l2cap_conn_rsp rsp; 46998eb200bdSMat Martineau char buf[128]; 47008eb200bdSMat Martineau rsp.scid = cpu_to_le16(chan->dcid); 47018eb200bdSMat Martineau rsp.dcid = cpu_to_le16(chan->scid); 47028eb200bdSMat Martineau 47038eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 47048eb200bdSMat Martineau /* Send successful response */ 470562cd50e2SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 470662cd50e2SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 47078eb200bdSMat Martineau } else { 47088eb200bdSMat Martineau /* Send negative response */ 470962cd50e2SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_NO_MEM); 471062cd50e2SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 47118eb200bdSMat Martineau } 47128eb200bdSMat Martineau 47138eb200bdSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_RSP, 47148eb200bdSMat Martineau sizeof(rsp), &rsp); 47158eb200bdSMat Martineau 47168eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 47178eb200bdSMat Martineau __l2cap_state_change(chan, BT_CONFIG); 47188eb200bdSMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 47198eb200bdSMat Martineau l2cap_send_cmd(chan->conn, l2cap_get_ident(chan->conn), 47208eb200bdSMat Martineau L2CAP_CONF_REQ, 47218eb200bdSMat Martineau l2cap_build_conf_req(chan, buf), buf); 47228eb200bdSMat Martineau chan->num_conf_req++; 47238eb200bdSMat Martineau } 47248eb200bdSMat Martineau } 47258eb200bdSMat Martineau } 47268eb200bdSMat Martineau 47278eb200bdSMat Martineau static void l2cap_do_move_initiate(struct l2cap_chan *chan, u8 local_amp_id, 47288eb200bdSMat Martineau u8 remote_amp_id) 47298eb200bdSMat Martineau { 47308eb200bdSMat Martineau l2cap_move_setup(chan); 47318eb200bdSMat Martineau chan->move_id = local_amp_id; 47328eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP; 47338eb200bdSMat Martineau 47348eb200bdSMat Martineau l2cap_send_move_chan_req(chan, remote_amp_id); 47358eb200bdSMat Martineau } 47368eb200bdSMat Martineau 47378eb200bdSMat Martineau static void l2cap_do_move_respond(struct l2cap_chan *chan, int result) 47388eb200bdSMat Martineau { 47398eb200bdSMat Martineau struct hci_chan *hchan = NULL; 47408eb200bdSMat Martineau 47418eb200bdSMat Martineau /* Placeholder - get hci_chan for logical link */ 47428eb200bdSMat Martineau 47438eb200bdSMat Martineau if (hchan) { 47448eb200bdSMat Martineau if (hchan->state == BT_CONNECTED) { 47458eb200bdSMat Martineau /* Logical link is ready to go */ 47468eb200bdSMat Martineau chan->hs_hcon = hchan->conn; 47478eb200bdSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 47488eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 47498eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 47508eb200bdSMat Martineau 47518eb200bdSMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 47528eb200bdSMat Martineau } else { 47538eb200bdSMat Martineau /* Wait for logical link to be ready */ 47548eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 47558eb200bdSMat Martineau } 47568eb200bdSMat Martineau } else { 47578eb200bdSMat Martineau /* Logical link not available */ 47588eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_ALLOWED); 47598eb200bdSMat Martineau } 47608eb200bdSMat Martineau } 47618eb200bdSMat Martineau 47628eb200bdSMat Martineau static void l2cap_do_move_cancel(struct l2cap_chan *chan, int result) 47638eb200bdSMat Martineau { 47648eb200bdSMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 47658eb200bdSMat Martineau u8 rsp_result; 47668eb200bdSMat Martineau if (result == -EINVAL) 47678eb200bdSMat Martineau rsp_result = L2CAP_MR_BAD_ID; 47688eb200bdSMat Martineau else 47698eb200bdSMat Martineau rsp_result = L2CAP_MR_NOT_ALLOWED; 47708eb200bdSMat Martineau 47718eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, rsp_result); 47728eb200bdSMat Martineau } 47738eb200bdSMat Martineau 47748eb200bdSMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 47758eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 47768eb200bdSMat Martineau 47778eb200bdSMat Martineau /* Restart data transmission */ 47788eb200bdSMat Martineau l2cap_ertm_send(chan); 47798eb200bdSMat Martineau } 47808eb200bdSMat Martineau 4781a514b17fSAndrei Emeltchenko /* Invoke with locked chan */ 4782a514b17fSAndrei Emeltchenko void __l2cap_physical_cfm(struct l2cap_chan *chan, int result) 47838eb200bdSMat Martineau { 4784770bfefaSAndrei Emeltchenko u8 local_amp_id = chan->local_amp_id; 4785fffadc08SAndrei Emeltchenko u8 remote_amp_id = chan->remote_amp_id; 4786770bfefaSAndrei Emeltchenko 47878eb200bdSMat Martineau BT_DBG("chan %p, result %d, local_amp_id %d, remote_amp_id %d", 47888eb200bdSMat Martineau chan, result, local_amp_id, remote_amp_id); 47898eb200bdSMat Martineau 47908eb200bdSMat Martineau if (chan->state == BT_DISCONN || chan->state == BT_CLOSED) { 47918eb200bdSMat Martineau l2cap_chan_unlock(chan); 47928eb200bdSMat Martineau return; 47938eb200bdSMat Martineau } 47948eb200bdSMat Martineau 47958eb200bdSMat Martineau if (chan->state != BT_CONNECTED) { 47968eb200bdSMat Martineau l2cap_do_create(chan, result, local_amp_id, remote_amp_id); 47978eb200bdSMat Martineau } else if (result != L2CAP_MR_SUCCESS) { 47988eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 47998eb200bdSMat Martineau } else { 48008eb200bdSMat Martineau switch (chan->move_role) { 48018eb200bdSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 48028eb200bdSMat Martineau l2cap_do_move_initiate(chan, local_amp_id, 48038eb200bdSMat Martineau remote_amp_id); 48048eb200bdSMat Martineau break; 48058eb200bdSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 48068eb200bdSMat Martineau l2cap_do_move_respond(chan, result); 48078eb200bdSMat Martineau break; 48088eb200bdSMat Martineau default: 48098eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 48108eb200bdSMat Martineau break; 48118eb200bdSMat Martineau } 48128eb200bdSMat Martineau } 48138eb200bdSMat Martineau } 48148eb200bdSMat Martineau 48158d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 4816ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4817ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 48188d5a04a1SMat Martineau { 48198d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 48201500109bSMat Martineau struct l2cap_move_chan_rsp rsp; 482102b0fbb9SMat Martineau struct l2cap_chan *chan; 48228d5a04a1SMat Martineau u16 icid = 0; 48238d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 48248d5a04a1SMat Martineau 48258d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 48268d5a04a1SMat Martineau return -EPROTO; 48278d5a04a1SMat Martineau 48288d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 48298d5a04a1SMat Martineau 4830ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id); 48318d5a04a1SMat Martineau 48328d5a04a1SMat Martineau if (!enable_hs) 48338d5a04a1SMat Martineau return -EINVAL; 48348d5a04a1SMat Martineau 483502b0fbb9SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 483602b0fbb9SMat Martineau if (!chan) { 48371500109bSMat Martineau rsp.icid = cpu_to_le16(icid); 48381500109bSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_MR_NOT_ALLOWED); 48391500109bSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_MOVE_CHAN_RSP, 48401500109bSMat Martineau sizeof(rsp), &rsp); 484102b0fbb9SMat Martineau return 0; 484202b0fbb9SMat Martineau } 484302b0fbb9SMat Martineau 48441500109bSMat Martineau chan->ident = cmd->ident; 48451500109bSMat Martineau 484602b0fbb9SMat Martineau if (chan->scid < L2CAP_CID_DYN_START || 484702b0fbb9SMat Martineau chan->chan_policy == BT_CHANNEL_POLICY_BREDR_ONLY || 484802b0fbb9SMat Martineau (chan->mode != L2CAP_MODE_ERTM && 484902b0fbb9SMat Martineau chan->mode != L2CAP_MODE_STREAMING)) { 485002b0fbb9SMat Martineau result = L2CAP_MR_NOT_ALLOWED; 485102b0fbb9SMat Martineau goto send_move_response; 485202b0fbb9SMat Martineau } 485302b0fbb9SMat Martineau 485402b0fbb9SMat Martineau if (chan->local_amp_id == req->dest_amp_id) { 485502b0fbb9SMat Martineau result = L2CAP_MR_SAME_ID; 485602b0fbb9SMat Martineau goto send_move_response; 485702b0fbb9SMat Martineau } 485802b0fbb9SMat Martineau 485902b0fbb9SMat Martineau if (req->dest_amp_id) { 486002b0fbb9SMat Martineau struct hci_dev *hdev; 486102b0fbb9SMat Martineau hdev = hci_dev_get(req->dest_amp_id); 486202b0fbb9SMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 486302b0fbb9SMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 486402b0fbb9SMat Martineau if (hdev) 486502b0fbb9SMat Martineau hci_dev_put(hdev); 486602b0fbb9SMat Martineau 486702b0fbb9SMat Martineau result = L2CAP_MR_BAD_ID; 486802b0fbb9SMat Martineau goto send_move_response; 486902b0fbb9SMat Martineau } 487002b0fbb9SMat Martineau hci_dev_put(hdev); 487102b0fbb9SMat Martineau } 487202b0fbb9SMat Martineau 487302b0fbb9SMat Martineau /* Detect a move collision. Only send a collision response 487402b0fbb9SMat Martineau * if this side has "lost", otherwise proceed with the move. 487502b0fbb9SMat Martineau * The winner has the larger bd_addr. 487602b0fbb9SMat Martineau */ 487702b0fbb9SMat Martineau if ((__chan_is_moving(chan) || 487802b0fbb9SMat Martineau chan->move_role != L2CAP_MOVE_ROLE_NONE) && 487902b0fbb9SMat Martineau bacmp(conn->src, conn->dst) > 0) { 488002b0fbb9SMat Martineau result = L2CAP_MR_COLLISION; 488102b0fbb9SMat Martineau goto send_move_response; 488202b0fbb9SMat Martineau } 488302b0fbb9SMat Martineau 488402b0fbb9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 488502b0fbb9SMat Martineau l2cap_move_setup(chan); 488602b0fbb9SMat Martineau chan->move_id = req->dest_amp_id; 488702b0fbb9SMat Martineau icid = chan->dcid; 488802b0fbb9SMat Martineau 488902b0fbb9SMat Martineau if (!req->dest_amp_id) { 489002b0fbb9SMat Martineau /* Moving to BR/EDR */ 489102b0fbb9SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 489202b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 489302b0fbb9SMat Martineau result = L2CAP_MR_PEND; 489402b0fbb9SMat Martineau } else { 489502b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 489602b0fbb9SMat Martineau result = L2CAP_MR_SUCCESS; 489702b0fbb9SMat Martineau } 489802b0fbb9SMat Martineau } else { 489902b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 490002b0fbb9SMat Martineau /* Placeholder - uncomment when amp functions are available */ 490102b0fbb9SMat Martineau /*amp_accept_physical(chan, req->dest_amp_id);*/ 490202b0fbb9SMat Martineau result = L2CAP_MR_PEND; 490302b0fbb9SMat Martineau } 490402b0fbb9SMat Martineau 490502b0fbb9SMat Martineau send_move_response: 49061500109bSMat Martineau l2cap_send_move_chan_rsp(chan, result); 49078d5a04a1SMat Martineau 490802b0fbb9SMat Martineau l2cap_chan_unlock(chan); 490902b0fbb9SMat Martineau 49108d5a04a1SMat Martineau return 0; 49118d5a04a1SMat Martineau } 49128d5a04a1SMat Martineau 49135b155ef9SMat Martineau static void l2cap_move_continue(struct l2cap_conn *conn, u16 icid, u16 result) 49145b155ef9SMat Martineau { 49155b155ef9SMat Martineau struct l2cap_chan *chan; 49165b155ef9SMat Martineau struct hci_chan *hchan = NULL; 49175b155ef9SMat Martineau 49185b155ef9SMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 49195b155ef9SMat Martineau if (!chan) { 49205b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 49215b155ef9SMat Martineau return; 49225b155ef9SMat Martineau } 49235b155ef9SMat Martineau 49245b155ef9SMat Martineau __clear_chan_timer(chan); 49255b155ef9SMat Martineau if (result == L2CAP_MR_PEND) 49265b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_ERTX_TIMEOUT); 49275b155ef9SMat Martineau 49285b155ef9SMat Martineau switch (chan->move_state) { 49295b155ef9SMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 49305b155ef9SMat Martineau /* Move confirm will be sent when logical link 49315b155ef9SMat Martineau * is complete. 49325b155ef9SMat Martineau */ 49335b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 49345b155ef9SMat Martineau break; 49355b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP_SUCCESS: 49365b155ef9SMat Martineau if (result == L2CAP_MR_PEND) { 49375b155ef9SMat Martineau break; 49385b155ef9SMat Martineau } else if (test_bit(CONN_LOCAL_BUSY, 49395b155ef9SMat Martineau &chan->conn_state)) { 49405b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 49415b155ef9SMat Martineau } else { 49425b155ef9SMat Martineau /* Logical link is up or moving to BR/EDR, 49435b155ef9SMat Martineau * proceed with move 49445b155ef9SMat Martineau */ 49455b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 49465b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 49475b155ef9SMat Martineau } 49485b155ef9SMat Martineau break; 49495b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP: 49505b155ef9SMat Martineau /* Moving to AMP */ 49515b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 49525b155ef9SMat Martineau /* Remote is ready, send confirm immediately 49535b155ef9SMat Martineau * after logical link is ready 49545b155ef9SMat Martineau */ 49555b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 49565b155ef9SMat Martineau } else { 49575b155ef9SMat Martineau /* Both logical link and move success 49585b155ef9SMat Martineau * are required to confirm 49595b155ef9SMat Martineau */ 49605b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_COMP; 49615b155ef9SMat Martineau } 49625b155ef9SMat Martineau 49635b155ef9SMat Martineau /* Placeholder - get hci_chan for logical link */ 49645b155ef9SMat Martineau if (!hchan) { 49655b155ef9SMat Martineau /* Logical link not available */ 49665b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 49675b155ef9SMat Martineau break; 49685b155ef9SMat Martineau } 49695b155ef9SMat Martineau 49705b155ef9SMat Martineau /* If the logical link is not yet connected, do not 49715b155ef9SMat Martineau * send confirmation. 49725b155ef9SMat Martineau */ 49735b155ef9SMat Martineau if (hchan->state != BT_CONNECTED) 49745b155ef9SMat Martineau break; 49755b155ef9SMat Martineau 49765b155ef9SMat Martineau /* Logical link is already ready to go */ 49775b155ef9SMat Martineau 49785b155ef9SMat Martineau chan->hs_hcon = hchan->conn; 49795b155ef9SMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 49805b155ef9SMat Martineau 49815b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 49825b155ef9SMat Martineau /* Can confirm now */ 49835b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 49845b155ef9SMat Martineau } else { 49855b155ef9SMat Martineau /* Now only need move success 49865b155ef9SMat Martineau * to confirm 49875b155ef9SMat Martineau */ 49885b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 49895b155ef9SMat Martineau } 49905b155ef9SMat Martineau 49915b155ef9SMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 49925b155ef9SMat Martineau break; 49935b155ef9SMat Martineau default: 49945b155ef9SMat Martineau /* Any other amp move state means the move failed. */ 49955b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 49965b155ef9SMat Martineau l2cap_move_done(chan); 49975b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 49985b155ef9SMat Martineau } 49995b155ef9SMat Martineau 50005b155ef9SMat Martineau l2cap_chan_unlock(chan); 50015b155ef9SMat Martineau } 50025b155ef9SMat Martineau 50035b155ef9SMat Martineau static void l2cap_move_fail(struct l2cap_conn *conn, u8 ident, u16 icid, 50045b155ef9SMat Martineau u16 result) 50055b155ef9SMat Martineau { 50065b155ef9SMat Martineau struct l2cap_chan *chan; 50075b155ef9SMat Martineau 50085b155ef9SMat Martineau chan = l2cap_get_chan_by_ident(conn, ident); 50095b155ef9SMat Martineau if (!chan) { 50105b155ef9SMat Martineau /* Could not locate channel, icid is best guess */ 50115b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 50125b155ef9SMat Martineau return; 50135b155ef9SMat Martineau } 50145b155ef9SMat Martineau 50155b155ef9SMat Martineau __clear_chan_timer(chan); 50165b155ef9SMat Martineau 50175b155ef9SMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 50185b155ef9SMat Martineau if (result == L2CAP_MR_COLLISION) { 50195b155ef9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 50205b155ef9SMat Martineau } else { 50215b155ef9SMat Martineau /* Cleanup - cancel move */ 50225b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 50235b155ef9SMat Martineau l2cap_move_done(chan); 50245b155ef9SMat Martineau } 50255b155ef9SMat Martineau } 50265b155ef9SMat Martineau 50275b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 50285b155ef9SMat Martineau 50295b155ef9SMat Martineau l2cap_chan_unlock(chan); 50305b155ef9SMat Martineau } 50315b155ef9SMat Martineau 50325b155ef9SMat Martineau static int l2cap_move_channel_rsp(struct l2cap_conn *conn, 5033ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 5034ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 50358d5a04a1SMat Martineau { 50368d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 50378d5a04a1SMat Martineau u16 icid, result; 50388d5a04a1SMat Martineau 50398d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 50408d5a04a1SMat Martineau return -EPROTO; 50418d5a04a1SMat Martineau 50428d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 50438d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 50448d5a04a1SMat Martineau 5045ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 50468d5a04a1SMat Martineau 50475b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS || result == L2CAP_MR_PEND) 50485b155ef9SMat Martineau l2cap_move_continue(conn, icid, result); 50495b155ef9SMat Martineau else 50505b155ef9SMat Martineau l2cap_move_fail(conn, cmd->ident, icid, result); 50518d5a04a1SMat Martineau 50528d5a04a1SMat Martineau return 0; 50538d5a04a1SMat Martineau } 50548d5a04a1SMat Martineau 50555f3847a4SMat Martineau static int l2cap_move_channel_confirm(struct l2cap_conn *conn, 5056ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 5057ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 50588d5a04a1SMat Martineau { 50598d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 50605f3847a4SMat Martineau struct l2cap_chan *chan; 50618d5a04a1SMat Martineau u16 icid, result; 50628d5a04a1SMat Martineau 50638d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 50648d5a04a1SMat Martineau return -EPROTO; 50658d5a04a1SMat Martineau 50668d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 50678d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 50688d5a04a1SMat Martineau 5069ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 50708d5a04a1SMat Martineau 50715f3847a4SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 50725f3847a4SMat Martineau if (!chan) { 50735f3847a4SMat Martineau /* Spec requires a response even if the icid was not found */ 50748d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 50755f3847a4SMat Martineau return 0; 50765f3847a4SMat Martineau } 50775f3847a4SMat Martineau 50785f3847a4SMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM) { 50795f3847a4SMat Martineau if (result == L2CAP_MC_CONFIRMED) { 50805f3847a4SMat Martineau chan->local_amp_id = chan->move_id; 50815f3847a4SMat Martineau if (!chan->local_amp_id) 50825f3847a4SMat Martineau __release_logical_link(chan); 50835f3847a4SMat Martineau } else { 50845f3847a4SMat Martineau chan->move_id = chan->local_amp_id; 50855f3847a4SMat Martineau } 50865f3847a4SMat Martineau 50875f3847a4SMat Martineau l2cap_move_done(chan); 50885f3847a4SMat Martineau } 50895f3847a4SMat Martineau 50905f3847a4SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 50915f3847a4SMat Martineau 50925f3847a4SMat Martineau l2cap_chan_unlock(chan); 50938d5a04a1SMat Martineau 50948d5a04a1SMat Martineau return 0; 50958d5a04a1SMat Martineau } 50968d5a04a1SMat Martineau 50978d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 5098ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 5099ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 51008d5a04a1SMat Martineau { 51018d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 51023fd71a0aSMat Martineau struct l2cap_chan *chan; 51038d5a04a1SMat Martineau u16 icid; 51048d5a04a1SMat Martineau 51058d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 51068d5a04a1SMat Martineau return -EPROTO; 51078d5a04a1SMat Martineau 51088d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 51098d5a04a1SMat Martineau 5110ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 51118d5a04a1SMat Martineau 51123fd71a0aSMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 51133fd71a0aSMat Martineau if (!chan) 51143fd71a0aSMat Martineau return 0; 51153fd71a0aSMat Martineau 51163fd71a0aSMat Martineau __clear_chan_timer(chan); 51173fd71a0aSMat Martineau 51183fd71a0aSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM_RSP) { 51193fd71a0aSMat Martineau chan->local_amp_id = chan->move_id; 51203fd71a0aSMat Martineau 51213fd71a0aSMat Martineau if (!chan->local_amp_id && chan->hs_hchan) 51223fd71a0aSMat Martineau __release_logical_link(chan); 51233fd71a0aSMat Martineau 51243fd71a0aSMat Martineau l2cap_move_done(chan); 51253fd71a0aSMat Martineau } 51263fd71a0aSMat Martineau 51273fd71a0aSMat Martineau l2cap_chan_unlock(chan); 51283fd71a0aSMat Martineau 51298d5a04a1SMat Martineau return 0; 51308d5a04a1SMat Martineau } 51318d5a04a1SMat Martineau 5132e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 5133de73115aSClaudio Takahasi u16 to_multiplier) 5134de73115aSClaudio Takahasi { 5135de73115aSClaudio Takahasi u16 max_latency; 5136de73115aSClaudio Takahasi 5137de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 5138de73115aSClaudio Takahasi return -EINVAL; 5139de73115aSClaudio Takahasi 5140de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 5141de73115aSClaudio Takahasi return -EINVAL; 5142de73115aSClaudio Takahasi 5143de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 5144de73115aSClaudio Takahasi return -EINVAL; 5145de73115aSClaudio Takahasi 5146de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 5147de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 5148de73115aSClaudio Takahasi return -EINVAL; 5149de73115aSClaudio Takahasi 5150de73115aSClaudio Takahasi return 0; 5151de73115aSClaudio Takahasi } 5152de73115aSClaudio Takahasi 5153de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 51542d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 51552d792818SGustavo Padovan u8 *data) 5156de73115aSClaudio Takahasi { 5157de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 5158de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 5159de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 5160de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 51612ce603ebSClaudio Takahasi int err; 5162de73115aSClaudio Takahasi 5163de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 5164de73115aSClaudio Takahasi return -EINVAL; 5165de73115aSClaudio Takahasi 5166de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 5167de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 5168de73115aSClaudio Takahasi return -EPROTO; 5169de73115aSClaudio Takahasi 5170de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 5171de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 5172de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 5173de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 5174de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 5175de73115aSClaudio Takahasi 5176de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 5177de73115aSClaudio Takahasi min, max, latency, to_multiplier); 5178de73115aSClaudio Takahasi 5179de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 51802ce603ebSClaudio Takahasi 51812ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 51822ce603ebSClaudio Takahasi if (err) 5183ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 5184de73115aSClaudio Takahasi else 5185ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 5186de73115aSClaudio Takahasi 5187de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 5188de73115aSClaudio Takahasi sizeof(rsp), &rsp); 5189de73115aSClaudio Takahasi 51902ce603ebSClaudio Takahasi if (!err) 51912ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 51922ce603ebSClaudio Takahasi 5193de73115aSClaudio Takahasi return 0; 5194de73115aSClaudio Takahasi } 5195de73115aSClaudio Takahasi 51963300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 51972d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 51982d792818SGustavo Padovan u8 *data) 51993300d9a9SClaudio Takahasi { 52003300d9a9SClaudio Takahasi int err = 0; 52013300d9a9SClaudio Takahasi 52023300d9a9SClaudio Takahasi switch (cmd->code) { 52033300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 5204cb3b3152SJohan Hedberg l2cap_command_rej(conn, cmd, cmd_len, data); 52053300d9a9SClaudio Takahasi break; 52063300d9a9SClaudio Takahasi 52073300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 5208cb3b3152SJohan Hedberg err = l2cap_connect_req(conn, cmd, cmd_len, data); 52093300d9a9SClaudio Takahasi break; 52103300d9a9SClaudio Takahasi 52113300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 5212f5a2598dSMat Martineau case L2CAP_CREATE_CHAN_RSP: 5213cb3b3152SJohan Hedberg err = l2cap_connect_create_rsp(conn, cmd, cmd_len, data); 52143300d9a9SClaudio Takahasi break; 52153300d9a9SClaudio Takahasi 52163300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 52173300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 52183300d9a9SClaudio Takahasi break; 52193300d9a9SClaudio Takahasi 52203300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 5221cb3b3152SJohan Hedberg err = l2cap_config_rsp(conn, cmd, cmd_len, data); 52223300d9a9SClaudio Takahasi break; 52233300d9a9SClaudio Takahasi 52243300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 5225cb3b3152SJohan Hedberg err = l2cap_disconnect_req(conn, cmd, cmd_len, data); 52263300d9a9SClaudio Takahasi break; 52273300d9a9SClaudio Takahasi 52283300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 5229cb3b3152SJohan Hedberg err = l2cap_disconnect_rsp(conn, cmd, cmd_len, data); 52303300d9a9SClaudio Takahasi break; 52313300d9a9SClaudio Takahasi 52323300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 52333300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 52343300d9a9SClaudio Takahasi break; 52353300d9a9SClaudio Takahasi 52363300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 52373300d9a9SClaudio Takahasi break; 52383300d9a9SClaudio Takahasi 52393300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 5240cb3b3152SJohan Hedberg err = l2cap_information_req(conn, cmd, cmd_len, data); 52413300d9a9SClaudio Takahasi break; 52423300d9a9SClaudio Takahasi 52433300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 5244cb3b3152SJohan Hedberg err = l2cap_information_rsp(conn, cmd, cmd_len, data); 52453300d9a9SClaudio Takahasi break; 52463300d9a9SClaudio Takahasi 5247f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 5248f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 5249f94ff6ffSMat Martineau break; 5250f94ff6ffSMat Martineau 52518d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 52528d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 52538d5a04a1SMat Martineau break; 52548d5a04a1SMat Martineau 52558d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 52568d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 52578d5a04a1SMat Martineau break; 52588d5a04a1SMat Martineau 52598d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 52608d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 52618d5a04a1SMat Martineau break; 52628d5a04a1SMat Martineau 52638d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 52648d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 52658d5a04a1SMat Martineau break; 52668d5a04a1SMat Martineau 52673300d9a9SClaudio Takahasi default: 52683300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 52693300d9a9SClaudio Takahasi err = -EINVAL; 52703300d9a9SClaudio Takahasi break; 52713300d9a9SClaudio Takahasi } 52723300d9a9SClaudio Takahasi 52733300d9a9SClaudio Takahasi return err; 52743300d9a9SClaudio Takahasi } 52753300d9a9SClaudio Takahasi 52763300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 52773300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 52783300d9a9SClaudio Takahasi { 52793300d9a9SClaudio Takahasi switch (cmd->code) { 52803300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 52813300d9a9SClaudio Takahasi return 0; 52823300d9a9SClaudio Takahasi 52833300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 5284de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 52853300d9a9SClaudio Takahasi 52863300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 52873300d9a9SClaudio Takahasi return 0; 52883300d9a9SClaudio Takahasi 52893300d9a9SClaudio Takahasi default: 52903300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 52913300d9a9SClaudio Takahasi return -EINVAL; 52923300d9a9SClaudio Takahasi } 52933300d9a9SClaudio Takahasi } 52943300d9a9SClaudio Takahasi 5295c5623556SJohan Hedberg static inline void l2cap_le_sig_channel(struct l2cap_conn *conn, 5296c5623556SJohan Hedberg struct sk_buff *skb) 5297c5623556SJohan Hedberg { 5298c5623556SJohan Hedberg u8 *data = skb->data; 5299c5623556SJohan Hedberg int len = skb->len; 5300c5623556SJohan Hedberg struct l2cap_cmd_hdr cmd; 5301c5623556SJohan Hedberg int err; 5302c5623556SJohan Hedberg 5303c5623556SJohan Hedberg l2cap_raw_recv(conn, skb); 5304c5623556SJohan Hedberg 5305c5623556SJohan Hedberg while (len >= L2CAP_CMD_HDR_SIZE) { 5306c5623556SJohan Hedberg u16 cmd_len; 5307c5623556SJohan Hedberg memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 5308c5623556SJohan Hedberg data += L2CAP_CMD_HDR_SIZE; 5309c5623556SJohan Hedberg len -= L2CAP_CMD_HDR_SIZE; 5310c5623556SJohan Hedberg 5311c5623556SJohan Hedberg cmd_len = le16_to_cpu(cmd.len); 5312c5623556SJohan Hedberg 5313c5623556SJohan Hedberg BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 5314c5623556SJohan Hedberg cmd.ident); 5315c5623556SJohan Hedberg 5316c5623556SJohan Hedberg if (cmd_len > len || !cmd.ident) { 5317c5623556SJohan Hedberg BT_DBG("corrupted command"); 5318c5623556SJohan Hedberg break; 5319c5623556SJohan Hedberg } 5320c5623556SJohan Hedberg 5321c5623556SJohan Hedberg err = l2cap_le_sig_cmd(conn, &cmd, data); 5322c5623556SJohan Hedberg if (err) { 5323c5623556SJohan Hedberg struct l2cap_cmd_rej_unk rej; 5324c5623556SJohan Hedberg 5325c5623556SJohan Hedberg BT_ERR("Wrong link type (%d)", err); 5326c5623556SJohan Hedberg 5327c5623556SJohan Hedberg /* FIXME: Map err to a valid reason */ 5328c5623556SJohan Hedberg rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 5329c5623556SJohan Hedberg l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 5330c5623556SJohan Hedberg sizeof(rej), &rej); 5331c5623556SJohan Hedberg } 5332c5623556SJohan Hedberg 5333c5623556SJohan Hedberg data += cmd_len; 5334c5623556SJohan Hedberg len -= cmd_len; 5335c5623556SJohan Hedberg } 5336c5623556SJohan Hedberg 5337c5623556SJohan Hedberg kfree_skb(skb); 5338c5623556SJohan Hedberg } 5339c5623556SJohan Hedberg 53403300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 53413300d9a9SClaudio Takahasi struct sk_buff *skb) 53420a708f8fSGustavo F. Padovan { 53430a708f8fSGustavo F. Padovan u8 *data = skb->data; 53440a708f8fSGustavo F. Padovan int len = skb->len; 53450a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 53463300d9a9SClaudio Takahasi int err; 53470a708f8fSGustavo F. Padovan 53480a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 53490a708f8fSGustavo F. Padovan 53500a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 53510a708f8fSGustavo F. Padovan u16 cmd_len; 53520a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 53530a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 53540a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 53550a708f8fSGustavo F. Padovan 53560a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 53570a708f8fSGustavo F. Padovan 53582d792818SGustavo Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 53592d792818SGustavo Padovan cmd.ident); 53600a708f8fSGustavo F. Padovan 53610a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 53620a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 53630a708f8fSGustavo F. Padovan break; 53640a708f8fSGustavo F. Padovan } 53650a708f8fSGustavo F. Padovan 53663300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 53670a708f8fSGustavo F. Padovan if (err) { 5368e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 53692c6d1a2eSGustavo F. Padovan 53702c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 53710a708f8fSGustavo F. Padovan 53720a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 5373ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 53742d792818SGustavo Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 53752d792818SGustavo Padovan sizeof(rej), &rej); 53760a708f8fSGustavo F. Padovan } 53770a708f8fSGustavo F. Padovan 53780a708f8fSGustavo F. Padovan data += cmd_len; 53790a708f8fSGustavo F. Padovan len -= cmd_len; 53800a708f8fSGustavo F. Padovan } 53810a708f8fSGustavo F. Padovan 53820a708f8fSGustavo F. Padovan kfree_skb(skb); 53830a708f8fSGustavo F. Padovan } 53840a708f8fSGustavo F. Padovan 538547d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 53860a708f8fSGustavo F. Padovan { 53870a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 5388e4ca6d98SAndrei Emeltchenko int hdr_size; 5389e4ca6d98SAndrei Emeltchenko 5390e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 5391e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 5392e4ca6d98SAndrei Emeltchenko else 5393e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 53940a708f8fSGustavo F. Padovan 539547d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 539603a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 53970a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 53980a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 53990a708f8fSGustavo F. Padovan 54000a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 54010a708f8fSGustavo F. Padovan return -EBADMSG; 54020a708f8fSGustavo F. Padovan } 54030a708f8fSGustavo F. Padovan return 0; 54040a708f8fSGustavo F. Padovan } 54050a708f8fSGustavo F. Padovan 54066ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 54070a708f8fSGustavo F. Padovan { 5408e31f7633SMat Martineau struct l2cap_ctrl control; 54090a708f8fSGustavo F. Padovan 5410e31f7633SMat Martineau BT_DBG("chan %p", chan); 54110a708f8fSGustavo F. Padovan 5412e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 5413e31f7633SMat Martineau control.sframe = 1; 5414e31f7633SMat Martineau control.final = 1; 5415e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 5416e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 54170a708f8fSGustavo F. Padovan 5418e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5419e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 5420e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 54210a708f8fSGustavo F. Padovan } 54220a708f8fSGustavo F. Padovan 5423e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 5424e31f7633SMat Martineau chan->unacked_frames > 0) 5425e31f7633SMat Martineau __set_retrans_timer(chan); 54260a708f8fSGustavo F. Padovan 5427e31f7633SMat Martineau /* Send pending iframes */ 5428525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 54290a708f8fSGustavo F. Padovan 5430e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 5431e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 5432e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 5433e31f7633SMat Martineau * send it now. 5434e31f7633SMat Martineau */ 5435e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 5436e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 54370a708f8fSGustavo F. Padovan } 54380a708f8fSGustavo F. Padovan } 54390a708f8fSGustavo F. Padovan 54402d792818SGustavo Padovan static void append_skb_frag(struct sk_buff *skb, struct sk_buff *new_frag, 54412d792818SGustavo Padovan struct sk_buff **last_frag) 54420a708f8fSGustavo F. Padovan { 544384084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 544484084a31SMat Martineau * skb->data_len reflects only data in fragments 544584084a31SMat Martineau */ 544684084a31SMat Martineau if (!skb_has_frag_list(skb)) 544784084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 544884084a31SMat Martineau 544984084a31SMat Martineau new_frag->next = NULL; 545084084a31SMat Martineau 545184084a31SMat Martineau (*last_frag)->next = new_frag; 545284084a31SMat Martineau *last_frag = new_frag; 545384084a31SMat Martineau 545484084a31SMat Martineau skb->len += new_frag->len; 545584084a31SMat Martineau skb->data_len += new_frag->len; 545684084a31SMat Martineau skb->truesize += new_frag->truesize; 545784084a31SMat Martineau } 545884084a31SMat Martineau 54594b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 54604b51dae9SMat Martineau struct l2cap_ctrl *control) 546184084a31SMat Martineau { 546284084a31SMat Martineau int err = -EINVAL; 54630a708f8fSGustavo F. Padovan 54644b51dae9SMat Martineau switch (control->sar) { 54657e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 546684084a31SMat Martineau if (chan->sdu) 546784084a31SMat Martineau break; 54680a708f8fSGustavo F. Padovan 546980b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 547084084a31SMat Martineau break; 54710a708f8fSGustavo F. Padovan 54727e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 547384084a31SMat Martineau if (chan->sdu) 547484084a31SMat Martineau break; 54750a708f8fSGustavo F. Padovan 54766f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 547703a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 54780a708f8fSGustavo F. Padovan 547984084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 548084084a31SMat Martineau err = -EMSGSIZE; 548184084a31SMat Martineau break; 548284084a31SMat Martineau } 54830a708f8fSGustavo F. Padovan 548484084a31SMat Martineau if (skb->len >= chan->sdu_len) 548584084a31SMat Martineau break; 548684084a31SMat Martineau 548784084a31SMat Martineau chan->sdu = skb; 548884084a31SMat Martineau chan->sdu_last_frag = skb; 548984084a31SMat Martineau 549084084a31SMat Martineau skb = NULL; 549184084a31SMat Martineau err = 0; 54920a708f8fSGustavo F. Padovan break; 54930a708f8fSGustavo F. Padovan 54947e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 54956f61fd47SGustavo F. Padovan if (!chan->sdu) 549684084a31SMat Martineau break; 54970a708f8fSGustavo F. Padovan 549884084a31SMat Martineau append_skb_frag(chan->sdu, skb, 549984084a31SMat Martineau &chan->sdu_last_frag); 550084084a31SMat Martineau skb = NULL; 55010a708f8fSGustavo F. Padovan 550284084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 550384084a31SMat Martineau break; 55040a708f8fSGustavo F. Padovan 550584084a31SMat Martineau err = 0; 55060a708f8fSGustavo F. Padovan break; 55070a708f8fSGustavo F. Padovan 55087e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 55096f61fd47SGustavo F. Padovan if (!chan->sdu) 551084084a31SMat Martineau break; 55110a708f8fSGustavo F. Padovan 551284084a31SMat Martineau append_skb_frag(chan->sdu, skb, 551384084a31SMat Martineau &chan->sdu_last_frag); 551484084a31SMat Martineau skb = NULL; 55150a708f8fSGustavo F. Padovan 551684084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 551784084a31SMat Martineau break; 55180a708f8fSGustavo F. Padovan 551980b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 55200a708f8fSGustavo F. Padovan 552184084a31SMat Martineau if (!err) { 552284084a31SMat Martineau /* Reassembly complete */ 552384084a31SMat Martineau chan->sdu = NULL; 552484084a31SMat Martineau chan->sdu_last_frag = NULL; 552584084a31SMat Martineau chan->sdu_len = 0; 55260a708f8fSGustavo F. Padovan } 55270a708f8fSGustavo F. Padovan break; 55280a708f8fSGustavo F. Padovan } 55290a708f8fSGustavo F. Padovan 553084084a31SMat Martineau if (err) { 55310a708f8fSGustavo F. Padovan kfree_skb(skb); 55326f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 55336f61fd47SGustavo F. Padovan chan->sdu = NULL; 553484084a31SMat Martineau chan->sdu_last_frag = NULL; 553584084a31SMat Martineau chan->sdu_len = 0; 553684084a31SMat Martineau } 55370a708f8fSGustavo F. Padovan 553884084a31SMat Martineau return err; 55390a708f8fSGustavo F. Padovan } 55400a708f8fSGustavo F. Padovan 554132b32735SMat Martineau static int l2cap_resegment(struct l2cap_chan *chan) 554232b32735SMat Martineau { 554332b32735SMat Martineau /* Placeholder */ 554432b32735SMat Martineau return 0; 554532b32735SMat Martineau } 554632b32735SMat Martineau 5547e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 55480a708f8fSGustavo F. Padovan { 554961aa4f5bSMat Martineau u8 event; 555061aa4f5bSMat Martineau 555161aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 555261aa4f5bSMat Martineau return; 555361aa4f5bSMat Martineau 555461aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 5555401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 55560a708f8fSGustavo F. Padovan } 55570a708f8fSGustavo F. Padovan 5558d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 5559d2a7ac5dSMat Martineau { 556063838725SMat Martineau int err = 0; 556163838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 556263838725SMat Martineau * until a gap is encountered. 556363838725SMat Martineau */ 556463838725SMat Martineau 556563838725SMat Martineau BT_DBG("chan %p", chan); 556663838725SMat Martineau 556763838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 556863838725SMat Martineau struct sk_buff *skb; 556963838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 557063838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 557163838725SMat Martineau 557263838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 557363838725SMat Martineau 557463838725SMat Martineau if (!skb) 557563838725SMat Martineau break; 557663838725SMat Martineau 557763838725SMat Martineau skb_unlink(skb, &chan->srej_q); 557863838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 557963838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 558063838725SMat Martineau if (err) 558163838725SMat Martineau break; 558263838725SMat Martineau } 558363838725SMat Martineau 558463838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 558563838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 558663838725SMat Martineau l2cap_send_ack(chan); 558763838725SMat Martineau } 558863838725SMat Martineau 558963838725SMat Martineau return err; 5590d2a7ac5dSMat Martineau } 5591d2a7ac5dSMat Martineau 5592d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 5593d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5594d2a7ac5dSMat Martineau { 5595f80842a8SMat Martineau struct sk_buff *skb; 5596f80842a8SMat Martineau 5597f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 5598f80842a8SMat Martineau 5599f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 5600f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 56015e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5602f80842a8SMat Martineau return; 5603f80842a8SMat Martineau } 5604f80842a8SMat Martineau 5605f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5606f80842a8SMat Martineau 5607f80842a8SMat Martineau if (skb == NULL) { 5608f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 5609f80842a8SMat Martineau control->reqseq); 5610f80842a8SMat Martineau return; 5611f80842a8SMat Martineau } 5612f80842a8SMat Martineau 5613f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 5614f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 56155e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5616f80842a8SMat Martineau return; 5617f80842a8SMat Martineau } 5618f80842a8SMat Martineau 5619f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5620f80842a8SMat Martineau 5621f80842a8SMat Martineau if (control->poll) { 5622f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 5623f80842a8SMat Martineau 5624f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5625f80842a8SMat Martineau l2cap_retransmit(chan, control); 5626f80842a8SMat Martineau l2cap_ertm_send(chan); 5627f80842a8SMat Martineau 5628f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 5629f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 5630f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 5631f80842a8SMat Martineau } 5632f80842a8SMat Martineau } else { 5633f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 5634f80842a8SMat Martineau 5635f80842a8SMat Martineau if (control->final) { 5636f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 5637f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 5638f80842a8SMat Martineau &chan->conn_state)) 5639f80842a8SMat Martineau l2cap_retransmit(chan, control); 5640f80842a8SMat Martineau } else { 5641f80842a8SMat Martineau l2cap_retransmit(chan, control); 5642f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 5643f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 5644f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 5645f80842a8SMat Martineau } 5646f80842a8SMat Martineau } 5647f80842a8SMat Martineau } 5648d2a7ac5dSMat Martineau } 5649d2a7ac5dSMat Martineau 5650d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 5651d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5652d2a7ac5dSMat Martineau { 5653fcd289dfSMat Martineau struct sk_buff *skb; 5654fcd289dfSMat Martineau 5655fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 5656fcd289dfSMat Martineau 5657fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 5658fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 56595e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5660fcd289dfSMat Martineau return; 5661fcd289dfSMat Martineau } 5662fcd289dfSMat Martineau 5663fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5664fcd289dfSMat Martineau 5665fcd289dfSMat Martineau if (chan->max_tx && skb && 5666fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 5667fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 56685e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5669fcd289dfSMat Martineau return; 5670fcd289dfSMat Martineau } 5671fcd289dfSMat Martineau 5672fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5673fcd289dfSMat Martineau 5674fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 5675fcd289dfSMat Martineau 5676fcd289dfSMat Martineau if (control->final) { 5677fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 5678fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5679fcd289dfSMat Martineau } else { 5680fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5681fcd289dfSMat Martineau l2cap_ertm_send(chan); 5682fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 5683fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 5684fcd289dfSMat Martineau } 5685d2a7ac5dSMat Martineau } 5686d2a7ac5dSMat Martineau 56874b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 56884b51dae9SMat Martineau { 56894b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 56904b51dae9SMat Martineau 56914b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 56924b51dae9SMat Martineau chan->expected_tx_seq); 56934b51dae9SMat Martineau 56944b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 56954b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 56964b51dae9SMat Martineau chan->tx_win) { 56974b51dae9SMat Martineau /* See notes below regarding "double poll" and 56984b51dae9SMat Martineau * invalid packets. 56994b51dae9SMat Martineau */ 57004b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 57014b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 57024b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 57034b51dae9SMat Martineau } else { 57044b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 57054b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 57064b51dae9SMat Martineau } 57074b51dae9SMat Martineau } 57084b51dae9SMat Martineau 57094b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 57104b51dae9SMat Martineau BT_DBG("Expected SREJ"); 57114b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 57124b51dae9SMat Martineau } 57134b51dae9SMat Martineau 57144b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 57154b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 57164b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 57174b51dae9SMat Martineau } 57184b51dae9SMat Martineau 57194b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 57204b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 57214b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 57224b51dae9SMat Martineau } 57234b51dae9SMat Martineau } 57244b51dae9SMat Martineau 57254b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 57264b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 57274b51dae9SMat Martineau chan->tx_win) { 57284b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 57294b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 57304b51dae9SMat Martineau } else { 57314b51dae9SMat Martineau BT_DBG("Expected"); 57324b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 57334b51dae9SMat Martineau } 57344b51dae9SMat Martineau } 57354b51dae9SMat Martineau 57364b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 57372d792818SGustavo Padovan __seq_offset(chan, chan->expected_tx_seq, chan->last_acked_seq)) { 57384b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 57394b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 57404b51dae9SMat Martineau } 57414b51dae9SMat Martineau 57424b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 57434b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 57444b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 57454b51dae9SMat Martineau * the remote stack receives and processes both polls, 57464b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 57474b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 57484b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 57494b51dae9SMat Martineau * request. 57504b51dae9SMat Martineau * 57514b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 57524b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 57534b51dae9SMat Martineau * invalid frames to be safely ignored. 57544b51dae9SMat Martineau * 57554b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 57564b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 57574b51dae9SMat Martineau * causes a disconnect. 57584b51dae9SMat Martineau */ 57594b51dae9SMat Martineau 57604b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 57614b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 57624b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 57634b51dae9SMat Martineau } else { 57644b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 57654b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 57664b51dae9SMat Martineau } 57674b51dae9SMat Martineau } else { 57684b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 57694b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 57704b51dae9SMat Martineau } 57714b51dae9SMat Martineau } 57724b51dae9SMat Martineau 5773d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 5774d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5775d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5776d2a7ac5dSMat Martineau { 5777d2a7ac5dSMat Martineau int err = 0; 5778d2a7ac5dSMat Martineau bool skb_in_use = 0; 5779d2a7ac5dSMat Martineau 5780d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5781d2a7ac5dSMat Martineau event); 5782d2a7ac5dSMat Martineau 5783d2a7ac5dSMat Martineau switch (event) { 5784d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5785d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 5786d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5787d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5788d2a7ac5dSMat Martineau 5789d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5790d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 5791d2a7ac5dSMat Martineau control->txseq); 5792d2a7ac5dSMat Martineau break; 5793d2a7ac5dSMat Martineau } 5794d2a7ac5dSMat Martineau 5795d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 5796d2a7ac5dSMat Martineau control->txseq); 5797d2a7ac5dSMat Martineau 5798d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 5799d2a7ac5dSMat Martineau skb_in_use = 1; 5800d2a7ac5dSMat Martineau 5801d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 5802d2a7ac5dSMat Martineau if (err) 5803d2a7ac5dSMat Martineau break; 5804d2a7ac5dSMat Martineau 5805d2a7ac5dSMat Martineau if (control->final) { 5806d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5807d2a7ac5dSMat Martineau &chan->conn_state)) { 5808d2a7ac5dSMat Martineau control->final = 0; 5809d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5810d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5811d2a7ac5dSMat Martineau } 5812d2a7ac5dSMat Martineau } 5813d2a7ac5dSMat Martineau 5814d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 5815d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5816d2a7ac5dSMat Martineau break; 5817d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5818d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5819d2a7ac5dSMat Martineau 5820d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 5821d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 5822d2a7ac5dSMat Martineau * when local busy is exited. 5823d2a7ac5dSMat Martineau */ 5824d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5825d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 5826d2a7ac5dSMat Martineau control->txseq); 5827d2a7ac5dSMat Martineau break; 5828d2a7ac5dSMat Martineau } 5829d2a7ac5dSMat Martineau 5830d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 5831d2a7ac5dSMat Martineau * must be sent for each missing frame. The 5832d2a7ac5dSMat Martineau * current frame is stored for later use. 5833d2a7ac5dSMat Martineau */ 5834d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5835d2a7ac5dSMat Martineau skb_in_use = 1; 5836d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5837d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5838d2a7ac5dSMat Martineau 5839d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 5840d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 5841d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5842d2a7ac5dSMat Martineau 5843d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 5844d2a7ac5dSMat Martineau break; 5845d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5846d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5847d2a7ac5dSMat Martineau break; 5848d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5849d2a7ac5dSMat Martineau break; 5850d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5851d2a7ac5dSMat Martineau default: 58525e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5853d2a7ac5dSMat Martineau break; 5854d2a7ac5dSMat Martineau } 5855d2a7ac5dSMat Martineau break; 5856d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5857d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5858d2a7ac5dSMat Martineau if (control->final) { 5859d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5860d2a7ac5dSMat Martineau 5861e6a3ee6eSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state) && 5862e6a3ee6eSMat Martineau !__chan_is_moving(chan)) { 5863d2a7ac5dSMat Martineau control->final = 0; 5864d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5865d2a7ac5dSMat Martineau } 5866d2a7ac5dSMat Martineau 5867d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5868d2a7ac5dSMat Martineau } else if (control->poll) { 5869d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 5870d2a7ac5dSMat Martineau } else { 5871d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5872d2a7ac5dSMat Martineau &chan->conn_state) && 5873d2a7ac5dSMat Martineau chan->unacked_frames) 5874d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5875d2a7ac5dSMat Martineau 5876d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5877d2a7ac5dSMat Martineau } 5878d2a7ac5dSMat Martineau break; 5879d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5880d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5881d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5882d2a7ac5dSMat Martineau if (control && control->poll) { 5883d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5884d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 5885d2a7ac5dSMat Martineau } 5886d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 5887d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 5888d2a7ac5dSMat Martineau break; 5889d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5890d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5891d2a7ac5dSMat Martineau break; 5892d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5893d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5894d2a7ac5dSMat Martineau break; 5895d2a7ac5dSMat Martineau default: 5896d2a7ac5dSMat Martineau break; 5897d2a7ac5dSMat Martineau } 5898d2a7ac5dSMat Martineau 5899d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5900d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5901d2a7ac5dSMat Martineau kfree_skb(skb); 5902d2a7ac5dSMat Martineau } 5903d2a7ac5dSMat Martineau 5904d2a7ac5dSMat Martineau return err; 5905d2a7ac5dSMat Martineau } 5906d2a7ac5dSMat Martineau 5907d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 5908d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5909d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5910d2a7ac5dSMat Martineau { 5911d2a7ac5dSMat Martineau int err = 0; 5912d2a7ac5dSMat Martineau u16 txseq = control->txseq; 5913d2a7ac5dSMat Martineau bool skb_in_use = 0; 5914d2a7ac5dSMat Martineau 5915d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5916d2a7ac5dSMat Martineau event); 5917d2a7ac5dSMat Martineau 5918d2a7ac5dSMat Martineau switch (event) { 5919d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5920d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 5921d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5922d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 5923d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5924d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5925d2a7ac5dSMat Martineau skb_in_use = 1; 5926d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5927d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5928d2a7ac5dSMat Martineau 5929d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 5930d2a7ac5dSMat Martineau break; 5931d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 5932d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 5933d2a7ac5dSMat Martineau 5934d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5935d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5936d2a7ac5dSMat Martineau skb_in_use = 1; 5937d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5938d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5939d2a7ac5dSMat Martineau 5940d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 5941d2a7ac5dSMat Martineau if (err) 5942d2a7ac5dSMat Martineau break; 5943d2a7ac5dSMat Martineau 5944d2a7ac5dSMat Martineau break; 5945d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5946d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 5947d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 5948d2a7ac5dSMat Martineau * the missing frames. 5949d2a7ac5dSMat Martineau */ 5950d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5951d2a7ac5dSMat Martineau skb_in_use = 1; 5952d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5953d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5954d2a7ac5dSMat Martineau 5955d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5956d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5957d2a7ac5dSMat Martineau break; 5958d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 5959d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 5960d2a7ac5dSMat Martineau * some expected retransmitted frames are 5961d2a7ac5dSMat Martineau * missing. Request retransmission of missing 5962d2a7ac5dSMat Martineau * SREJ'd frames. 5963d2a7ac5dSMat Martineau */ 5964d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5965d2a7ac5dSMat Martineau skb_in_use = 1; 5966d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5967d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5968d2a7ac5dSMat Martineau 5969d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5970d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 5971d2a7ac5dSMat Martineau break; 5972d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 5973d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 5974d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5975d2a7ac5dSMat Martineau break; 5976d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5977d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 5978d2a7ac5dSMat Martineau * was already received. Ignore it completely. 5979d2a7ac5dSMat Martineau */ 5980d2a7ac5dSMat Martineau break; 5981d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5982d2a7ac5dSMat Martineau break; 5983d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5984d2a7ac5dSMat Martineau default: 59855e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5986d2a7ac5dSMat Martineau break; 5987d2a7ac5dSMat Martineau } 5988d2a7ac5dSMat Martineau break; 5989d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5990d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5991d2a7ac5dSMat Martineau if (control->final) { 5992d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5993d2a7ac5dSMat Martineau 5994d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5995d2a7ac5dSMat Martineau &chan->conn_state)) { 5996d2a7ac5dSMat Martineau control->final = 0; 5997d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5998d2a7ac5dSMat Martineau } 5999d2a7ac5dSMat Martineau 6000d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 6001d2a7ac5dSMat Martineau } else if (control->poll) { 6002d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 6003d2a7ac5dSMat Martineau &chan->conn_state) && 6004d2a7ac5dSMat Martineau chan->unacked_frames) { 6005d2a7ac5dSMat Martineau __set_retrans_timer(chan); 6006d2a7ac5dSMat Martineau } 6007d2a7ac5dSMat Martineau 6008d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 6009d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 6010d2a7ac5dSMat Martineau } else { 6011d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 6012d2a7ac5dSMat Martineau &chan->conn_state) && 6013d2a7ac5dSMat Martineau chan->unacked_frames) 6014d2a7ac5dSMat Martineau __set_retrans_timer(chan); 6015d2a7ac5dSMat Martineau 6016d2a7ac5dSMat Martineau l2cap_send_ack(chan); 6017d2a7ac5dSMat Martineau } 6018d2a7ac5dSMat Martineau break; 6019d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 6020d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 6021d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 6022d2a7ac5dSMat Martineau if (control->poll) { 6023d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 6024d2a7ac5dSMat Martineau } else { 6025d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 6026d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 6027d2a7ac5dSMat Martineau rr_control.sframe = 1; 6028d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 6029d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 6030d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 6031d2a7ac5dSMat Martineau } 6032d2a7ac5dSMat Martineau 6033d2a7ac5dSMat Martineau break; 6034d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 6035d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 6036d2a7ac5dSMat Martineau break; 6037d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 6038d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 6039d2a7ac5dSMat Martineau break; 6040d2a7ac5dSMat Martineau } 6041d2a7ac5dSMat Martineau 6042d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 6043d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 6044d2a7ac5dSMat Martineau kfree_skb(skb); 6045d2a7ac5dSMat Martineau } 6046d2a7ac5dSMat Martineau 6047d2a7ac5dSMat Martineau return err; 6048d2a7ac5dSMat Martineau } 6049d2a7ac5dSMat Martineau 605032b32735SMat Martineau static int l2cap_finish_move(struct l2cap_chan *chan) 605132b32735SMat Martineau { 605232b32735SMat Martineau BT_DBG("chan %p", chan); 605332b32735SMat Martineau 605432b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 605532b32735SMat Martineau 605632b32735SMat Martineau if (chan->hs_hcon) 605732b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 605832b32735SMat Martineau else 605932b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 606032b32735SMat Martineau 606132b32735SMat Martineau return l2cap_resegment(chan); 606232b32735SMat Martineau } 606332b32735SMat Martineau 606432b32735SMat Martineau static int l2cap_rx_state_wait_p(struct l2cap_chan *chan, 606532b32735SMat Martineau struct l2cap_ctrl *control, 606632b32735SMat Martineau struct sk_buff *skb, u8 event) 606732b32735SMat Martineau { 606832b32735SMat Martineau int err; 606932b32735SMat Martineau 607032b32735SMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 607132b32735SMat Martineau event); 607232b32735SMat Martineau 607332b32735SMat Martineau if (!control->poll) 607432b32735SMat Martineau return -EPROTO; 607532b32735SMat Martineau 607632b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 607732b32735SMat Martineau 607832b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 607932b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 608032b32735SMat Martineau else 608132b32735SMat Martineau chan->tx_send_head = NULL; 608232b32735SMat Martineau 608332b32735SMat Martineau /* Rewind next_tx_seq to the point expected 608432b32735SMat Martineau * by the receiver. 608532b32735SMat Martineau */ 608632b32735SMat Martineau chan->next_tx_seq = control->reqseq; 608732b32735SMat Martineau chan->unacked_frames = 0; 608832b32735SMat Martineau 608932b32735SMat Martineau err = l2cap_finish_move(chan); 609032b32735SMat Martineau if (err) 609132b32735SMat Martineau return err; 609232b32735SMat Martineau 609332b32735SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 609432b32735SMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 609532b32735SMat Martineau 609632b32735SMat Martineau if (event == L2CAP_EV_RECV_IFRAME) 609732b32735SMat Martineau return -EPROTO; 609832b32735SMat Martineau 609932b32735SMat Martineau return l2cap_rx_state_recv(chan, control, NULL, event); 610032b32735SMat Martineau } 610132b32735SMat Martineau 610232b32735SMat Martineau static int l2cap_rx_state_wait_f(struct l2cap_chan *chan, 610332b32735SMat Martineau struct l2cap_ctrl *control, 610432b32735SMat Martineau struct sk_buff *skb, u8 event) 610532b32735SMat Martineau { 610632b32735SMat Martineau int err; 610732b32735SMat Martineau 610832b32735SMat Martineau if (!control->final) 610932b32735SMat Martineau return -EPROTO; 611032b32735SMat Martineau 611132b32735SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 611232b32735SMat Martineau 611332b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 611432b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 611532b32735SMat Martineau 611632b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 611732b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 611832b32735SMat Martineau else 611932b32735SMat Martineau chan->tx_send_head = NULL; 612032b32735SMat Martineau 612132b32735SMat Martineau /* Rewind next_tx_seq to the point expected 612232b32735SMat Martineau * by the receiver. 612332b32735SMat Martineau */ 612432b32735SMat Martineau chan->next_tx_seq = control->reqseq; 612532b32735SMat Martineau chan->unacked_frames = 0; 612632b32735SMat Martineau 612732b32735SMat Martineau if (chan->hs_hcon) 612832b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 612932b32735SMat Martineau else 613032b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 613132b32735SMat Martineau 613232b32735SMat Martineau err = l2cap_resegment(chan); 613332b32735SMat Martineau 613432b32735SMat Martineau if (!err) 613532b32735SMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 613632b32735SMat Martineau 613732b32735SMat Martineau return err; 613832b32735SMat Martineau } 613932b32735SMat Martineau 6140d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 6141d2a7ac5dSMat Martineau { 6142d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 6143d2a7ac5dSMat Martineau u16 unacked; 6144d2a7ac5dSMat Martineau 6145d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 6146d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 6147d2a7ac5dSMat Martineau } 6148d2a7ac5dSMat Martineau 6149cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 6150cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 61510a708f8fSGustavo F. Padovan { 6152d2a7ac5dSMat Martineau int err = 0; 6153d2a7ac5dSMat Martineau 6154d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 6155d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 6156d2a7ac5dSMat Martineau 6157d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 6158d2a7ac5dSMat Martineau switch (chan->rx_state) { 6159d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 6160d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 6161d2a7ac5dSMat Martineau break; 6162d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 6163d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 6164d2a7ac5dSMat Martineau event); 6165d2a7ac5dSMat Martineau break; 616632b32735SMat Martineau case L2CAP_RX_STATE_WAIT_P: 616732b32735SMat Martineau err = l2cap_rx_state_wait_p(chan, control, skb, event); 616832b32735SMat Martineau break; 616932b32735SMat Martineau case L2CAP_RX_STATE_WAIT_F: 617032b32735SMat Martineau err = l2cap_rx_state_wait_f(chan, control, skb, event); 617132b32735SMat Martineau break; 6172d2a7ac5dSMat Martineau default: 6173d2a7ac5dSMat Martineau /* shut it down */ 6174d2a7ac5dSMat Martineau break; 6175d2a7ac5dSMat Martineau } 6176d2a7ac5dSMat Martineau } else { 6177d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 6178d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 6179d2a7ac5dSMat Martineau chan->expected_ack_seq); 61805e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 6181d2a7ac5dSMat Martineau } 6182d2a7ac5dSMat Martineau 6183d2a7ac5dSMat Martineau return err; 6184cec8ab6eSMat Martineau } 6185cec8ab6eSMat Martineau 6186cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 6187cec8ab6eSMat Martineau struct sk_buff *skb) 6188cec8ab6eSMat Martineau { 61894b51dae9SMat Martineau int err = 0; 61904b51dae9SMat Martineau 61914b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 61924b51dae9SMat Martineau chan->rx_state); 61934b51dae9SMat Martineau 61944b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 61954b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 61964b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 61974b51dae9SMat Martineau 61984b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 61994b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 62004b51dae9SMat Martineau 62014b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 62024b51dae9SMat Martineau 62034b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 62044b51dae9SMat Martineau } else { 62054b51dae9SMat Martineau if (chan->sdu) { 62064b51dae9SMat Martineau kfree_skb(chan->sdu); 62074b51dae9SMat Martineau chan->sdu = NULL; 62084b51dae9SMat Martineau } 62094b51dae9SMat Martineau chan->sdu_last_frag = NULL; 62104b51dae9SMat Martineau chan->sdu_len = 0; 62114b51dae9SMat Martineau 62124b51dae9SMat Martineau if (skb) { 62134b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 62144b51dae9SMat Martineau kfree_skb(skb); 62154b51dae9SMat Martineau } 62164b51dae9SMat Martineau } 62174b51dae9SMat Martineau 62184b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 62194b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 62204b51dae9SMat Martineau 62214b51dae9SMat Martineau return err; 6222cec8ab6eSMat Martineau } 6223cec8ab6eSMat Martineau 6224cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 6225cec8ab6eSMat Martineau { 6226cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 6227cec8ab6eSMat Martineau u16 len; 6228cec8ab6eSMat Martineau u8 event; 62290a708f8fSGustavo F. Padovan 6230b76bbd66SMat Martineau __unpack_control(chan, skb); 6231b76bbd66SMat Martineau 62320a708f8fSGustavo F. Padovan len = skb->len; 62330a708f8fSGustavo F. Padovan 62340a708f8fSGustavo F. Padovan /* 62350a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 62360a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 6237cec8ab6eSMat Martineau * procedures and ask for retransmission. 62380a708f8fSGustavo F. Padovan */ 623947d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 62400a708f8fSGustavo F. Padovan goto drop; 62410a708f8fSGustavo F. Padovan 6242cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 624303a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 62440a708f8fSGustavo F. Padovan 624547d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 624603a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 62470a708f8fSGustavo F. Padovan 624847d1ec61SGustavo F. Padovan if (len > chan->mps) { 62495e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 62500a708f8fSGustavo F. Padovan goto drop; 62510a708f8fSGustavo F. Padovan } 62520a708f8fSGustavo F. Padovan 6253cec8ab6eSMat Martineau if (!control->sframe) { 6254cec8ab6eSMat Martineau int err; 62550a708f8fSGustavo F. Padovan 6256cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 6257cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 6258cec8ab6eSMat Martineau control->txseq); 6259836be934SAndrei Emeltchenko 6260cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 6261cec8ab6eSMat Martineau * valid in TX WAIT_F 6262cec8ab6eSMat Martineau */ 6263cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 62640a708f8fSGustavo F. Padovan goto drop; 62650a708f8fSGustavo F. Padovan 6266cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 6267cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 6268cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 62690a708f8fSGustavo F. Padovan } else { 6270cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 6271cec8ab6eSMat Martineau } 6272cec8ab6eSMat Martineau 6273cec8ab6eSMat Martineau if (err) 62745e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 6275cec8ab6eSMat Martineau } else { 6276cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 6277cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 6278cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 6279cec8ab6eSMat Martineau }; 6280cec8ab6eSMat Martineau 6281cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 6282cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 6283cec8ab6eSMat Martineau goto drop; 6284cec8ab6eSMat Martineau 6285cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 6286cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 6287cec8ab6eSMat Martineau control->super); 6288cec8ab6eSMat Martineau 62890a708f8fSGustavo F. Padovan if (len != 0) { 62901bb166e6SAndrei Emeltchenko BT_ERR("Trailing bytes: %d in sframe", len); 62915e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 62920a708f8fSGustavo F. Padovan goto drop; 62930a708f8fSGustavo F. Padovan } 62940a708f8fSGustavo F. Padovan 6295cec8ab6eSMat Martineau /* Validate F and P bits */ 6296cec8ab6eSMat Martineau if (control->final && (control->poll || 6297cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 6298cec8ab6eSMat Martineau goto drop; 6299cec8ab6eSMat Martineau 6300cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 6301cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 63025e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 63030a708f8fSGustavo F. Padovan } 63040a708f8fSGustavo F. Padovan 63050a708f8fSGustavo F. Padovan return 0; 63060a708f8fSGustavo F. Padovan 63070a708f8fSGustavo F. Padovan drop: 63080a708f8fSGustavo F. Padovan kfree_skb(skb); 63090a708f8fSGustavo F. Padovan return 0; 63100a708f8fSGustavo F. Padovan } 63110a708f8fSGustavo F. Padovan 631213ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 631313ca56e0SAndrei Emeltchenko struct sk_buff *skb) 63140a708f8fSGustavo F. Padovan { 631548454079SGustavo F. Padovan struct l2cap_chan *chan; 63160a708f8fSGustavo F. Padovan 6317baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 631848454079SGustavo F. Padovan if (!chan) { 631997e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 632097e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 632197e8e89dSAndrei Emeltchenko if (!chan) { 632297e8e89dSAndrei Emeltchenko kfree_skb(skb); 632313ca56e0SAndrei Emeltchenko return; 632497e8e89dSAndrei Emeltchenko } 632597e8e89dSAndrei Emeltchenko 632697e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 632797e8e89dSAndrei Emeltchenko } else { 63280a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 63296be36555SAndrei Emeltchenko /* Drop packet and return */ 63303379013bSDan Carpenter kfree_skb(skb); 633113ca56e0SAndrei Emeltchenko return; 63320a708f8fSGustavo F. Padovan } 633397e8e89dSAndrei Emeltchenko } 63340a708f8fSGustavo F. Padovan 633549208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 63360a708f8fSGustavo F. Padovan 633789bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 63380a708f8fSGustavo F. Padovan goto drop; 63390a708f8fSGustavo F. Padovan 63400c1bc5c6SGustavo F. Padovan switch (chan->mode) { 63410a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 63420a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 63430a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 63440a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 63450a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 63460a708f8fSGustavo F. Padovan 63470c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 63480a708f8fSGustavo F. Padovan goto drop; 63490a708f8fSGustavo F. Padovan 635080b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 63510a708f8fSGustavo F. Padovan goto done; 63520a708f8fSGustavo F. Padovan break; 63530a708f8fSGustavo F. Padovan 63540a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 63550a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 6356cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 63570a708f8fSGustavo F. Padovan goto done; 63580a708f8fSGustavo F. Padovan 63590a708f8fSGustavo F. Padovan default: 63600c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 63610a708f8fSGustavo F. Padovan break; 63620a708f8fSGustavo F. Padovan } 63630a708f8fSGustavo F. Padovan 63640a708f8fSGustavo F. Padovan drop: 63650a708f8fSGustavo F. Padovan kfree_skb(skb); 63660a708f8fSGustavo F. Padovan 63670a708f8fSGustavo F. Padovan done: 63686be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 63690a708f8fSGustavo F. Padovan } 63700a708f8fSGustavo F. Padovan 637184104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 637284104b24SAndrei Emeltchenko struct sk_buff *skb) 63730a708f8fSGustavo F. Padovan { 637423691d75SGustavo F. Padovan struct l2cap_chan *chan; 63750a708f8fSGustavo F. Padovan 6376c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 637723691d75SGustavo F. Padovan if (!chan) 63780a708f8fSGustavo F. Padovan goto drop; 63790a708f8fSGustavo F. Padovan 63805b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 63810a708f8fSGustavo F. Padovan 638289bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 63830a708f8fSGustavo F. Padovan goto drop; 63840a708f8fSGustavo F. Padovan 6385e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 63860a708f8fSGustavo F. Padovan goto drop; 63870a708f8fSGustavo F. Padovan 638880b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 638984104b24SAndrei Emeltchenko return; 63900a708f8fSGustavo F. Padovan 63910a708f8fSGustavo F. Padovan drop: 63920a708f8fSGustavo F. Padovan kfree_skb(skb); 63930a708f8fSGustavo F. Padovan } 63940a708f8fSGustavo F. Padovan 639572f78356SMarcel Holtmann static void l2cap_att_channel(struct l2cap_conn *conn, 6396d9b88702SAndrei Emeltchenko struct sk_buff *skb) 63979f69bda6SGustavo F. Padovan { 639823691d75SGustavo F. Padovan struct l2cap_chan *chan; 63999f69bda6SGustavo F. Padovan 6400073d1cf3SJohan Hedberg chan = l2cap_global_chan_by_scid(0, L2CAP_CID_ATT, 640172f78356SMarcel Holtmann conn->src, conn->dst); 640223691d75SGustavo F. Padovan if (!chan) 64039f69bda6SGustavo F. Padovan goto drop; 64049f69bda6SGustavo F. Padovan 64055b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 64069f69bda6SGustavo F. Padovan 640789bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 64089f69bda6SGustavo F. Padovan goto drop; 64099f69bda6SGustavo F. Padovan 6410e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 64119f69bda6SGustavo F. Padovan goto drop; 64129f69bda6SGustavo F. Padovan 641380b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 64146810fca7SAndrei Emeltchenko return; 64159f69bda6SGustavo F. Padovan 64169f69bda6SGustavo F. Padovan drop: 64179f69bda6SGustavo F. Padovan kfree_skb(skb); 64189f69bda6SGustavo F. Padovan } 64199f69bda6SGustavo F. Padovan 64200a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 64210a708f8fSGustavo F. Padovan { 64220a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 64230a708f8fSGustavo F. Padovan u16 cid, len; 64240a708f8fSGustavo F. Padovan __le16 psm; 64250a708f8fSGustavo F. Padovan 64260a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 64270a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 64280a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 64290a708f8fSGustavo F. Padovan 64300a708f8fSGustavo F. Padovan if (len != skb->len) { 64310a708f8fSGustavo F. Padovan kfree_skb(skb); 64320a708f8fSGustavo F. Padovan return; 64330a708f8fSGustavo F. Padovan } 64340a708f8fSGustavo F. Padovan 64350a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 64360a708f8fSGustavo F. Padovan 64370a708f8fSGustavo F. Padovan switch (cid) { 64383300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 6439c5623556SJohan Hedberg l2cap_le_sig_channel(conn, skb); 6440c5623556SJohan Hedberg break; 64410a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 64420a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 64430a708f8fSGustavo F. Padovan break; 64440a708f8fSGustavo F. Padovan 64450a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 6446097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 64470181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 64480a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 64490a708f8fSGustavo F. Padovan break; 64500a708f8fSGustavo F. Padovan 6451073d1cf3SJohan Hedberg case L2CAP_CID_ATT: 645272f78356SMarcel Holtmann l2cap_att_channel(conn, skb); 64539f69bda6SGustavo F. Padovan break; 64549f69bda6SGustavo F. Padovan 6455b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 6456b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 6457b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 6458b501d6a1SAnderson Briglia break; 6459b501d6a1SAnderson Briglia 64600a708f8fSGustavo F. Padovan default: 64610a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 64620a708f8fSGustavo F. Padovan break; 64630a708f8fSGustavo F. Padovan } 64640a708f8fSGustavo F. Padovan } 64650a708f8fSGustavo F. Padovan 64660a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 64670a708f8fSGustavo F. Padovan 6468686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 64690a708f8fSGustavo F. Padovan { 64700a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 647123691d75SGustavo F. Padovan struct l2cap_chan *c; 64720a708f8fSGustavo F. Padovan 64736ed93dc6SAndrei Emeltchenko BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 64740a708f8fSGustavo F. Padovan 64750a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 647623691d75SGustavo F. Padovan read_lock(&chan_list_lock); 647723691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 647823691d75SGustavo F. Padovan struct sock *sk = c->sk; 64794343478fSGustavo F. Padovan 648089bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 64810a708f8fSGustavo F. Padovan continue; 64820a708f8fSGustavo F. Padovan 64830a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 64840a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 648543bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 64860a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 64870a708f8fSGustavo F. Padovan exact++; 64880a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 64890a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 649043bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 64910a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 64920a708f8fSGustavo F. Padovan } 64930a708f8fSGustavo F. Padovan } 649423691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 64950a708f8fSGustavo F. Padovan 64960a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 64970a708f8fSGustavo F. Padovan } 64980a708f8fSGustavo F. Padovan 64999e664631SAndrei Emeltchenko void l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 65000a708f8fSGustavo F. Padovan { 65010a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 65020a708f8fSGustavo F. Padovan 65036ed93dc6SAndrei Emeltchenko BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status); 65040a708f8fSGustavo F. Padovan 65050a708f8fSGustavo F. Padovan if (!status) { 6506baf43251SClaudio Takahasi conn = l2cap_conn_add(hcon); 65070a708f8fSGustavo F. Padovan if (conn) 65080a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 6509ba6fc317SAndrei Emeltchenko } else { 6510e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 6511ba6fc317SAndrei Emeltchenko } 65120a708f8fSGustavo F. Padovan } 65130a708f8fSGustavo F. Padovan 6514686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 65150a708f8fSGustavo F. Padovan { 65160a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 65170a708f8fSGustavo F. Padovan 65180a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 65190a708f8fSGustavo F. Padovan 6520686ebf28SUlisses Furquim if (!conn) 65219f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 65220a708f8fSGustavo F. Padovan return conn->disc_reason; 65230a708f8fSGustavo F. Padovan } 65240a708f8fSGustavo F. Padovan 65259e664631SAndrei Emeltchenko void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 65260a708f8fSGustavo F. Padovan { 65270a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 65280a708f8fSGustavo F. Padovan 6529e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 65300a708f8fSGustavo F. Padovan } 65310a708f8fSGustavo F. Padovan 65324343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 65330a708f8fSGustavo F. Padovan { 6534715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 65350a708f8fSGustavo F. Padovan return; 65360a708f8fSGustavo F. Padovan 65370a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 65384343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 6539ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 65404343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 65410f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 65420a708f8fSGustavo F. Padovan } else { 65434343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 6544c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 65450a708f8fSGustavo F. Padovan } 65460a708f8fSGustavo F. Padovan } 65470a708f8fSGustavo F. Padovan 6548686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 65490a708f8fSGustavo F. Padovan { 65500a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 655148454079SGustavo F. Padovan struct l2cap_chan *chan; 65520a708f8fSGustavo F. Padovan 65530a708f8fSGustavo F. Padovan if (!conn) 65540a708f8fSGustavo F. Padovan return 0; 65550a708f8fSGustavo F. Padovan 655689d8b407SAndrei Emeltchenko BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt); 65570a708f8fSGustavo F. Padovan 6558160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 655935d4adccSHemant Gupta if (!status && encrypt) 6560160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 656117cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 6562160dc6acSVinicius Costa Gomes } 6563160dc6acSVinicius Costa Gomes 65643df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 65650a708f8fSGustavo F. Padovan 65663df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 65676be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 65680a708f8fSGustavo F. Padovan 656989d8b407SAndrei Emeltchenko BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid, 657089d8b407SAndrei Emeltchenko state_to_string(chan->state)); 6571f1cb9af5SVinicius Costa Gomes 657278eb2f98SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 657378eb2f98SAndrei Emeltchenko l2cap_chan_unlock(chan); 657478eb2f98SAndrei Emeltchenko continue; 657578eb2f98SAndrei Emeltchenko } 657678eb2f98SAndrei Emeltchenko 6577073d1cf3SJohan Hedberg if (chan->scid == L2CAP_CID_ATT) { 6578f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 6579f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 6580cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 6581f1cb9af5SVinicius Costa Gomes } 6582f1cb9af5SVinicius Costa Gomes 65836be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 6584f1cb9af5SVinicius Costa Gomes continue; 6585f1cb9af5SVinicius Costa Gomes } 6586f1cb9af5SVinicius Costa Gomes 658796eff46eSAndrei Emeltchenko if (!__l2cap_no_conn_pending(chan)) { 65886be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 65890a708f8fSGustavo F. Padovan continue; 65900a708f8fSGustavo F. Padovan } 65910a708f8fSGustavo F. Padovan 659289bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 659389bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 6594a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 6595a7d7723aSGustavo Padovan 6596c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 6597a7d7723aSGustavo Padovan sk->sk_state_change(sk); 6598a7d7723aSGustavo Padovan 65994343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 66006be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 66010a708f8fSGustavo F. Padovan continue; 66020a708f8fSGustavo F. Padovan } 66030a708f8fSGustavo F. Padovan 660489bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 66050a708f8fSGustavo F. Padovan if (!status) { 660693c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 66070a708f8fSGustavo F. Padovan } else { 6608ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 66090a708f8fSGustavo F. Padovan } 661089bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 66116be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 66120a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6613df3c3931SJohan Hedberg __u16 res, stat; 66140a708f8fSGustavo F. Padovan 66156be36555SAndrei Emeltchenko lock_sock(sk); 66166be36555SAndrei Emeltchenko 66170a708f8fSGustavo F. Padovan if (!status) { 6618c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 6619c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 6620df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 6621df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 66222dc4e510SGustavo Padovan chan->ops->defer(chan); 6623df3c3931SJohan Hedberg } else { 66240e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 6625df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 6626df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 6627df3c3931SJohan Hedberg } 66280a708f8fSGustavo F. Padovan } else { 66290e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 6630ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 6631df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 6632df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 66330a708f8fSGustavo F. Padovan } 66340a708f8fSGustavo F. Padovan 66356be36555SAndrei Emeltchenko release_sock(sk); 66366be36555SAndrei Emeltchenko 6637fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6638fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6639df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 6640df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 6641fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6642fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 66432d369359SMat Martineau 66442d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 66452d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 66462d369359SMat Martineau char buf[128]; 66472d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 66482d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 66492d369359SMat Martineau L2CAP_CONF_REQ, 66502d369359SMat Martineau l2cap_build_conf_req(chan, buf), 66512d369359SMat Martineau buf); 66522d369359SMat Martineau chan->num_conf_req++; 66532d369359SMat Martineau } 66540a708f8fSGustavo F. Padovan } 66550a708f8fSGustavo F. Padovan 66566be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 66570a708f8fSGustavo F. Padovan } 66580a708f8fSGustavo F. Padovan 66593df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 66600a708f8fSGustavo F. Padovan 66610a708f8fSGustavo F. Padovan return 0; 66620a708f8fSGustavo F. Padovan } 66630a708f8fSGustavo F. Padovan 6664686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 66650a708f8fSGustavo F. Padovan { 66660a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 6667d73a0988SAndrei Emeltchenko struct l2cap_hdr *hdr; 6668d73a0988SAndrei Emeltchenko int len; 66690a708f8fSGustavo F. Padovan 66701d13a254SAndrei Emeltchenko /* For AMP controller do not create l2cap conn */ 66711d13a254SAndrei Emeltchenko if (!conn && hcon->hdev->dev_type != HCI_BREDR) 66721d13a254SAndrei Emeltchenko goto drop; 66730a708f8fSGustavo F. Padovan 66740a708f8fSGustavo F. Padovan if (!conn) 6675baf43251SClaudio Takahasi conn = l2cap_conn_add(hcon); 66760a708f8fSGustavo F. Padovan 66770a708f8fSGustavo F. Padovan if (!conn) 66780a708f8fSGustavo F. Padovan goto drop; 66790a708f8fSGustavo F. Padovan 66800a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 66810a708f8fSGustavo F. Padovan 6682d73a0988SAndrei Emeltchenko switch (flags) { 6683d73a0988SAndrei Emeltchenko case ACL_START: 6684d73a0988SAndrei Emeltchenko case ACL_START_NO_FLUSH: 6685d73a0988SAndrei Emeltchenko case ACL_COMPLETE: 66860a708f8fSGustavo F. Padovan if (conn->rx_len) { 66870a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 66880a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 66890a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 66900a708f8fSGustavo F. Padovan conn->rx_len = 0; 66910a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 66920a708f8fSGustavo F. Padovan } 66930a708f8fSGustavo F. Padovan 66940a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 66950a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 66960a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 66970a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 66980a708f8fSGustavo F. Padovan goto drop; 66990a708f8fSGustavo F. Padovan } 67000a708f8fSGustavo F. Padovan 67010a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 67020a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 67030a708f8fSGustavo F. Padovan 67040a708f8fSGustavo F. Padovan if (len == skb->len) { 67050a708f8fSGustavo F. Padovan /* Complete frame received */ 67060a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 67070a708f8fSGustavo F. Padovan return 0; 67080a708f8fSGustavo F. Padovan } 67090a708f8fSGustavo F. Padovan 67100a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 67110a708f8fSGustavo F. Padovan 67120a708f8fSGustavo F. Padovan if (skb->len > len) { 67130a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 67140a708f8fSGustavo F. Padovan skb->len, len); 67150a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67160a708f8fSGustavo F. Padovan goto drop; 67170a708f8fSGustavo F. Padovan } 67180a708f8fSGustavo F. Padovan 67190a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 67208bcde1f2SGustavo Padovan conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL); 67210a708f8fSGustavo F. Padovan if (!conn->rx_skb) 67220a708f8fSGustavo F. Padovan goto drop; 67230a708f8fSGustavo F. Padovan 67240a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 67250a708f8fSGustavo F. Padovan skb->len); 67260a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 6727d73a0988SAndrei Emeltchenko break; 6728d73a0988SAndrei Emeltchenko 6729d73a0988SAndrei Emeltchenko case ACL_CONT: 67300a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 67310a708f8fSGustavo F. Padovan 67320a708f8fSGustavo F. Padovan if (!conn->rx_len) { 67330a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 67340a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67350a708f8fSGustavo F. Padovan goto drop; 67360a708f8fSGustavo F. Padovan } 67370a708f8fSGustavo F. Padovan 67380a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 67390a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 67400a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 67410a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 67420a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 67430a708f8fSGustavo F. Padovan conn->rx_len = 0; 67440a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67450a708f8fSGustavo F. Padovan goto drop; 67460a708f8fSGustavo F. Padovan } 67470a708f8fSGustavo F. Padovan 67480a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 67490a708f8fSGustavo F. Padovan skb->len); 67500a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 67510a708f8fSGustavo F. Padovan 67520a708f8fSGustavo F. Padovan if (!conn->rx_len) { 67530a708f8fSGustavo F. Padovan /* Complete frame received */ 67540a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 67550a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 67560a708f8fSGustavo F. Padovan } 6757d73a0988SAndrei Emeltchenko break; 67580a708f8fSGustavo F. Padovan } 67590a708f8fSGustavo F. Padovan 67600a708f8fSGustavo F. Padovan drop: 67610a708f8fSGustavo F. Padovan kfree_skb(skb); 67620a708f8fSGustavo F. Padovan return 0; 67630a708f8fSGustavo F. Padovan } 67640a708f8fSGustavo F. Padovan 67650a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 67660a708f8fSGustavo F. Padovan { 676723691d75SGustavo F. Padovan struct l2cap_chan *c; 67680a708f8fSGustavo F. Padovan 6769333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 67700a708f8fSGustavo F. Padovan 677123691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 677223691d75SGustavo F. Padovan struct sock *sk = c->sk; 67730a708f8fSGustavo F. Padovan 6774fcb73338SAndrei Emeltchenko seq_printf(f, "%pMR %pMR %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 6775fcb73338SAndrei Emeltchenko &bt_sk(sk)->src, &bt_sk(sk)->dst, 677689bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 677723691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 677823691d75SGustavo F. Padovan c->sec_level, c->mode); 67790a708f8fSGustavo F. Padovan } 67800a708f8fSGustavo F. Padovan 6781333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 67820a708f8fSGustavo F. Padovan 67830a708f8fSGustavo F. Padovan return 0; 67840a708f8fSGustavo F. Padovan } 67850a708f8fSGustavo F. Padovan 67860a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 67870a708f8fSGustavo F. Padovan { 67880a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 67890a708f8fSGustavo F. Padovan } 67900a708f8fSGustavo F. Padovan 67910a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 67920a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 67930a708f8fSGustavo F. Padovan .read = seq_read, 67940a708f8fSGustavo F. Padovan .llseek = seq_lseek, 67950a708f8fSGustavo F. Padovan .release = single_release, 67960a708f8fSGustavo F. Padovan }; 67970a708f8fSGustavo F. Padovan 67980a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 67990a708f8fSGustavo F. Padovan 680064274518SGustavo F. Padovan int __init l2cap_init(void) 68010a708f8fSGustavo F. Padovan { 68020a708f8fSGustavo F. Padovan int err; 68030a708f8fSGustavo F. Padovan 6804bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 68050a708f8fSGustavo F. Padovan if (err < 0) 68060a708f8fSGustavo F. Padovan return err; 68070a708f8fSGustavo F. Padovan 68080a708f8fSGustavo F. Padovan if (bt_debugfs) { 68092d792818SGustavo Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, bt_debugfs, 68102d792818SGustavo Padovan NULL, &l2cap_debugfs_fops); 68110a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 68120a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 68130a708f8fSGustavo F. Padovan } 68140a708f8fSGustavo F. Padovan 68150a708f8fSGustavo F. Padovan return 0; 68160a708f8fSGustavo F. Padovan } 68170a708f8fSGustavo F. Padovan 681864274518SGustavo F. Padovan void l2cap_exit(void) 68190a708f8fSGustavo F. Padovan { 68200a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 6821bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 68220a708f8fSGustavo F. Padovan } 68230a708f8fSGustavo F. Padovan 68240a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 68250a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 6826