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; 5079f22398cSJohan Hedberg if (chan->dcid == L2CAP_CID_ATT) 508073d1cf3SJohan Hedberg chan->scid = L2CAP_CID_ATT; 5099f22398cSJohan Hedberg else 5109f22398cSJohan Hedberg chan->scid = l2cap_alloc_cid(conn); 511b62f328bSVille Tervo } else { 5120a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 513fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 5140c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 515b62f328bSVille Tervo } 5165491120eSAndrei Emeltchenko break; 5175491120eSAndrei Emeltchenko 5185491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 5190a708f8fSGustavo F. Padovan /* Connectionless socket */ 520fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 521fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 5220c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5235491120eSAndrei Emeltchenko break; 5245491120eSAndrei Emeltchenko 525416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 526416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 527416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 528416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 529416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 530416fa752SAndrei Emeltchenko break; 531416fa752SAndrei Emeltchenko 5325491120eSAndrei Emeltchenko default: 5330a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 534fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 535fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 5360c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5370a708f8fSGustavo F. Padovan } 5380a708f8fSGustavo F. Padovan 5398f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 5408f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 5418f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 5428f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 5438f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 5448936fa6dSAndrei Emeltchenko chan->local_flush_to = L2CAP_EFS_DEFAULT_FLUSH_TO; 5458f7975b1SAndrei Emeltchenko 546371fd835SUlisses Furquim l2cap_chan_hold(chan); 547baa7e1faSGustavo F. Padovan 5485ee9891dSJohan Hedberg hci_conn_hold(conn->hcon); 5495ee9891dSJohan Hedberg 5503df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 551643162a8SAndrei Emeltchenko } 552643162a8SAndrei Emeltchenko 553466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 554643162a8SAndrei Emeltchenko { 555643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 556643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 5573df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5580a708f8fSGustavo F. Padovan } 5590a708f8fSGustavo F. Padovan 560466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5610a708f8fSGustavo F. Padovan { 5628c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5630a708f8fSGustavo F. Padovan 564c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5650a708f8fSGustavo F. Padovan 56649208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5670a708f8fSGustavo F. Padovan 5680a708f8fSGustavo F. Padovan if (conn) { 56956f60984SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 570baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5713df91ea2SAndrei Emeltchenko list_del(&chan->list); 5723d57dc68SGustavo F. Padovan 573371fd835SUlisses Furquim l2cap_chan_put(chan); 574baa7e1faSGustavo F. Padovan 5758c1d787bSGustavo F. Padovan chan->conn = NULL; 5763cabbfdaSAndrei Emeltchenko 5773cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 57876a68ba0SDavid Herrmann hci_conn_drop(conn->hcon); 57956f60984SAndrei Emeltchenko 58056f60984SAndrei Emeltchenko if (mgr && mgr->bredr_chan == chan) 58156f60984SAndrei Emeltchenko mgr->bredr_chan = NULL; 5820a708f8fSGustavo F. Padovan } 5830a708f8fSGustavo F. Padovan 584419e08c1SAndrei Emeltchenko if (chan->hs_hchan) { 585419e08c1SAndrei Emeltchenko struct hci_chan *hs_hchan = chan->hs_hchan; 586419e08c1SAndrei Emeltchenko 587419e08c1SAndrei Emeltchenko BT_DBG("chan %p disconnect hs_hchan %p", chan, hs_hchan); 588419e08c1SAndrei Emeltchenko amp_disconnect_logical_link(hs_hchan); 589419e08c1SAndrei Emeltchenko } 590419e08c1SAndrei Emeltchenko 591c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5926be36555SAndrei Emeltchenko 5932827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5946ff5abbfSGustavo F. Padovan return; 5952ead70b8SGustavo F. Padovan 596ee556f66SGustavo Padovan switch(chan->mode) { 597ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 598ee556f66SGustavo Padovan break; 5990a708f8fSGustavo F. Padovan 600ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 6011a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 6021a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 6031a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 6040a708f8fSGustavo F. Padovan 605f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 6060a708f8fSGustavo F. Padovan 6073c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 6083c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 609ee556f66SGustavo Padovan 610ee556f66SGustavo Padovan /* fall through */ 611ee556f66SGustavo Padovan 612ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 613ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 614ee556f66SGustavo Padovan break; 6150a708f8fSGustavo F. Padovan } 616ee556f66SGustavo Padovan 617ee556f66SGustavo Padovan return; 6180a708f8fSGustavo F. Padovan } 6190a708f8fSGustavo F. Padovan 6200f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 6214519de9aSGustavo F. Padovan { 6224519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6234519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 6244519de9aSGustavo F. Padovan 6252d792818SGustavo Padovan BT_DBG("chan %p state %s sk %p", chan, state_to_string(chan->state), 6262d792818SGustavo Padovan sk); 6274519de9aSGustavo F. Padovan 62889bc500eSGustavo F. Padovan switch (chan->state) { 6294519de9aSGustavo F. Padovan case BT_LISTEN: 630c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6314519de9aSGustavo F. Padovan break; 6324519de9aSGustavo F. Padovan 6334519de9aSGustavo F. Padovan case BT_CONNECTED: 6344519de9aSGustavo F. Padovan case BT_CONFIG: 635715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6364519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 637c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 6385e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, reason); 6394519de9aSGustavo F. Padovan } else 6404519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6414519de9aSGustavo F. Padovan break; 6424519de9aSGustavo F. Padovan 6434519de9aSGustavo F. Padovan case BT_CONNECT2: 644715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6454519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 6464519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6474519de9aSGustavo F. Padovan __u16 result; 6484519de9aSGustavo F. Padovan 649c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 6504519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 6514519de9aSGustavo F. Padovan else 6524519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 65389bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 6544519de9aSGustavo F. Padovan 6554519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6564519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6574519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 658ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 6594519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6604519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 6614519de9aSGustavo F. Padovan } 6624519de9aSGustavo F. Padovan 6634519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6644519de9aSGustavo F. Padovan break; 6654519de9aSGustavo F. Padovan 6664519de9aSGustavo F. Padovan case BT_CONNECT: 6674519de9aSGustavo F. Padovan case BT_DISCONN: 6684519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6694519de9aSGustavo F. Padovan break; 6704519de9aSGustavo F. Padovan 6714519de9aSGustavo F. Padovan default: 672c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6734519de9aSGustavo F. Padovan break; 6744519de9aSGustavo F. Padovan } 6754519de9aSGustavo F. Padovan } 6764519de9aSGustavo F. Padovan 6774343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6780a708f8fSGustavo F. Padovan { 679715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6804343478fSGustavo F. Padovan switch (chan->sec_level) { 6810a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6820a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6830a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6840a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6850a708f8fSGustavo F. Padovan default: 6860a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6870a708f8fSGustavo F. Padovan } 6882983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6894343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6904343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6910a708f8fSGustavo F. Padovan 6924343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6930a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6940a708f8fSGustavo F. Padovan else 6950a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6960a708f8fSGustavo F. Padovan } else { 6974343478fSGustavo F. Padovan switch (chan->sec_level) { 6980a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6990a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 7000a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 7010a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 7020a708f8fSGustavo F. Padovan default: 7030a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 7040a708f8fSGustavo F. Padovan } 7050a708f8fSGustavo F. Padovan } 7060a708f8fSGustavo F. Padovan } 7070a708f8fSGustavo F. Padovan 7080a708f8fSGustavo F. Padovan /* Service level security */ 709d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 7100a708f8fSGustavo F. Padovan { 7118c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 7120a708f8fSGustavo F. Padovan __u8 auth_type; 7130a708f8fSGustavo F. Padovan 7144343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 7150a708f8fSGustavo F. Padovan 7164343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 7170a708f8fSGustavo F. Padovan } 7180a708f8fSGustavo F. Padovan 719b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 7200a708f8fSGustavo F. Padovan { 7210a708f8fSGustavo F. Padovan u8 id; 7220a708f8fSGustavo F. Padovan 7230a708f8fSGustavo F. Padovan /* Get next available identificator. 7240a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 7250a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 7260a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 7270a708f8fSGustavo F. Padovan */ 7280a708f8fSGustavo F. Padovan 729333055f2SGustavo F. Padovan spin_lock(&conn->lock); 7300a708f8fSGustavo F. Padovan 7310a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 7320a708f8fSGustavo F. Padovan conn->tx_ident = 1; 7330a708f8fSGustavo F. Padovan 7340a708f8fSGustavo F. Padovan id = conn->tx_ident; 7350a708f8fSGustavo F. Padovan 736333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 7370a708f8fSGustavo F. Padovan 7380a708f8fSGustavo F. Padovan return id; 7390a708f8fSGustavo F. Padovan } 7400a708f8fSGustavo F. Padovan 7412d792818SGustavo Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 7422d792818SGustavo Padovan void *data) 7430a708f8fSGustavo F. Padovan { 7440a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 7450a708f8fSGustavo F. Padovan u8 flags; 7460a708f8fSGustavo F. Padovan 7470a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 7480a708f8fSGustavo F. Padovan 7490a708f8fSGustavo F. Padovan if (!skb) 7500a708f8fSGustavo F. Padovan return; 7510a708f8fSGustavo F. Padovan 7520a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 7530a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 7540a708f8fSGustavo F. Padovan else 7550a708f8fSGustavo F. Padovan flags = ACL_START; 7560a708f8fSGustavo F. Padovan 75714b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 7585e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 75914b12d0bSJaikumar Ganesh 76073d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 7610a708f8fSGustavo F. Padovan } 7620a708f8fSGustavo F. Padovan 76302b0fbb9SMat Martineau static bool __chan_is_moving(struct l2cap_chan *chan) 76402b0fbb9SMat Martineau { 76502b0fbb9SMat Martineau return chan->move_state != L2CAP_MOVE_STABLE && 76602b0fbb9SMat Martineau chan->move_state != L2CAP_MOVE_WAIT_PREPARE; 76702b0fbb9SMat Martineau } 76802b0fbb9SMat Martineau 76973d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 77073d80debSLuiz Augusto von Dentz { 77173d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 77273d80debSLuiz Augusto von Dentz u16 flags; 77373d80debSLuiz Augusto von Dentz 77473d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 77573d80debSLuiz Augusto von Dentz skb->priority); 77673d80debSLuiz Augusto von Dentz 777d5f8a75dSMat Martineau if (chan->hs_hcon && !__chan_is_moving(chan)) { 778d5f8a75dSMat Martineau if (chan->hs_hchan) 779d5f8a75dSMat Martineau hci_send_acl(chan->hs_hchan, skb, ACL_COMPLETE); 780d5f8a75dSMat Martineau else 781d5f8a75dSMat Martineau kfree_skb(skb); 782d5f8a75dSMat Martineau 783d5f8a75dSMat Martineau return; 784d5f8a75dSMat Martineau } 785d5f8a75dSMat Martineau 78673d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 78773d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 78873d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 78973d80debSLuiz Augusto von Dentz else 79073d80debSLuiz Augusto von Dentz flags = ACL_START; 79173d80debSLuiz Augusto von Dentz 79273d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 79373d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7940a708f8fSGustavo F. Padovan } 7950a708f8fSGustavo F. Padovan 796b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 797b5c6aaedSMat Martineau { 798b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 799b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 800b5c6aaedSMat Martineau 801b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 802b5c6aaedSMat Martineau /* S-Frame */ 803b5c6aaedSMat Martineau control->sframe = 1; 804b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 805b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 806b5c6aaedSMat Martineau 807b5c6aaedSMat Martineau control->sar = 0; 808b5c6aaedSMat Martineau control->txseq = 0; 809b5c6aaedSMat Martineau } else { 810b5c6aaedSMat Martineau /* I-Frame */ 811b5c6aaedSMat Martineau control->sframe = 0; 812b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 813b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 814b5c6aaedSMat Martineau 815b5c6aaedSMat Martineau control->poll = 0; 816b5c6aaedSMat Martineau control->super = 0; 817b5c6aaedSMat Martineau } 818b5c6aaedSMat Martineau } 819b5c6aaedSMat Martineau 820b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 821b5c6aaedSMat Martineau { 822b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 823b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 824b5c6aaedSMat Martineau 825b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 826b5c6aaedSMat Martineau /* S-Frame */ 827b5c6aaedSMat Martineau control->sframe = 1; 828b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 829b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 830b5c6aaedSMat Martineau 831b5c6aaedSMat Martineau control->sar = 0; 832b5c6aaedSMat Martineau control->txseq = 0; 833b5c6aaedSMat Martineau } else { 834b5c6aaedSMat Martineau /* I-Frame */ 835b5c6aaedSMat Martineau control->sframe = 0; 836b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 837b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 838b5c6aaedSMat Martineau 839b5c6aaedSMat Martineau control->poll = 0; 840b5c6aaedSMat Martineau control->super = 0; 841b5c6aaedSMat Martineau } 842b5c6aaedSMat Martineau } 843b5c6aaedSMat Martineau 844b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 845b5c6aaedSMat Martineau struct sk_buff *skb) 846b5c6aaedSMat Martineau { 847b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 848b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 849b5c6aaedSMat Martineau &bt_cb(skb)->control); 850cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 851b5c6aaedSMat Martineau } else { 852b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 853b5c6aaedSMat Martineau &bt_cb(skb)->control); 854cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 855b5c6aaedSMat Martineau } 856b5c6aaedSMat Martineau } 857b5c6aaedSMat Martineau 858b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 859b5c6aaedSMat Martineau { 860b5c6aaedSMat Martineau u32 packed; 861b5c6aaedSMat Martineau 862b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 863b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 864b5c6aaedSMat Martineau 865b5c6aaedSMat Martineau if (control->sframe) { 866b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 867b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 868b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 869b5c6aaedSMat Martineau } else { 870b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 871b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 872b5c6aaedSMat Martineau } 873b5c6aaedSMat Martineau 874b5c6aaedSMat Martineau return packed; 875b5c6aaedSMat Martineau } 876b5c6aaedSMat Martineau 877b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 878b5c6aaedSMat Martineau { 879b5c6aaedSMat Martineau u16 packed; 880b5c6aaedSMat Martineau 881b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 882b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 883b5c6aaedSMat Martineau 884b5c6aaedSMat Martineau if (control->sframe) { 885b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 886b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 887b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 888b5c6aaedSMat Martineau } else { 889b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 890b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 891b5c6aaedSMat Martineau } 892b5c6aaedSMat Martineau 893b5c6aaedSMat Martineau return packed; 894b5c6aaedSMat Martineau } 895b5c6aaedSMat Martineau 896b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 897b5c6aaedSMat Martineau struct l2cap_ctrl *control, 898b5c6aaedSMat Martineau struct sk_buff *skb) 899b5c6aaedSMat Martineau { 900b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 901b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 902b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 903b5c6aaedSMat Martineau } else { 904b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 905b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 906b5c6aaedSMat Martineau } 907b5c6aaedSMat Martineau } 908b5c6aaedSMat Martineau 909ba7aa64fSGustavo Padovan static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan) 910ba7aa64fSGustavo Padovan { 911ba7aa64fSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 912ba7aa64fSGustavo Padovan return L2CAP_EXT_HDR_SIZE; 913ba7aa64fSGustavo Padovan else 914ba7aa64fSGustavo Padovan return L2CAP_ENH_HDR_SIZE; 915ba7aa64fSGustavo Padovan } 916ba7aa64fSGustavo Padovan 917a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 918a67d7f6fSMat Martineau u32 control) 9190a708f8fSGustavo F. Padovan { 9200a708f8fSGustavo F. Padovan struct sk_buff *skb; 9210a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 922ba7aa64fSGustavo Padovan int hlen = __ertm_hdr_size(chan); 9230a708f8fSGustavo F. Padovan 9240a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 92503a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 9260a708f8fSGustavo F. Padovan 927a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 9280a708f8fSGustavo F. Padovan 9290a708f8fSGustavo F. Padovan if (!skb) 930a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 9310a708f8fSGustavo F. Padovan 9320a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 9330a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 934fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 93588843ab0SAndrei Emeltchenko 936a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 937a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 938a67d7f6fSMat Martineau else 939a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 9400a708f8fSGustavo F. Padovan 94147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 942a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 94303a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 9440a708f8fSGustavo F. Padovan } 9450a708f8fSGustavo F. Padovan 94673d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 947a67d7f6fSMat Martineau return skb; 948a67d7f6fSMat Martineau } 949a67d7f6fSMat Martineau 950a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 951a67d7f6fSMat Martineau struct l2cap_ctrl *control) 952a67d7f6fSMat Martineau { 953a67d7f6fSMat Martineau struct sk_buff *skb; 954a67d7f6fSMat Martineau u32 control_field; 955a67d7f6fSMat Martineau 956a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 957a67d7f6fSMat Martineau 958a67d7f6fSMat Martineau if (!control->sframe) 959a67d7f6fSMat Martineau return; 960a67d7f6fSMat Martineau 961b99e13adSMat Martineau if (__chan_is_moving(chan)) 962b99e13adSMat Martineau return; 963b99e13adSMat Martineau 964a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 965a67d7f6fSMat Martineau !control->poll) 966a67d7f6fSMat Martineau control->final = 1; 967a67d7f6fSMat Martineau 968a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 969a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 970a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 971a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 972a67d7f6fSMat Martineau 973a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 974a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 975a67d7f6fSMat Martineau __clear_ack_timer(chan); 976a67d7f6fSMat Martineau } 977a67d7f6fSMat Martineau 978a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 979a67d7f6fSMat Martineau control->final, control->poll, control->super); 980a67d7f6fSMat Martineau 981a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 982a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 983a67d7f6fSMat Martineau else 984a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 985a67d7f6fSMat Martineau 986a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 987a67d7f6fSMat Martineau if (!IS_ERR(skb)) 98873d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9890a708f8fSGustavo F. Padovan } 9900a708f8fSGustavo F. Padovan 991c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9920a708f8fSGustavo F. Padovan { 993c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9940a708f8fSGustavo F. Padovan 995c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 996c9e3d5e0SMat Martineau 997c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 998c9e3d5e0SMat Martineau control.sframe = 1; 999c9e3d5e0SMat Martineau control.poll = poll; 1000c9e3d5e0SMat Martineau 1001c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 1002c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 1003c9e3d5e0SMat Martineau else 1004c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 1005c9e3d5e0SMat Martineau 1006c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 1007c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 10080a708f8fSGustavo F. Padovan } 10090a708f8fSGustavo F. Padovan 1010b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 10110a708f8fSGustavo F. Padovan { 1012c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 10130a708f8fSGustavo F. Padovan } 10140a708f8fSGustavo F. Padovan 101593c3e8f5SAndrei Emeltchenko static bool __amp_capable(struct l2cap_chan *chan) 101693c3e8f5SAndrei Emeltchenko { 101793c3e8f5SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 101893c3e8f5SAndrei Emeltchenko 101993c3e8f5SAndrei Emeltchenko if (enable_hs && 10205d05416eSAndrei Emeltchenko hci_amp_capable() && 102193c3e8f5SAndrei Emeltchenko chan->chan_policy == BT_CHANNEL_POLICY_AMP_PREFERRED && 102293c3e8f5SAndrei Emeltchenko conn->fixed_chan_mask & L2CAP_FC_A2MP) 102393c3e8f5SAndrei Emeltchenko return true; 102493c3e8f5SAndrei Emeltchenko else 102593c3e8f5SAndrei Emeltchenko return false; 102693c3e8f5SAndrei Emeltchenko } 102793c3e8f5SAndrei Emeltchenko 10285ce66b59SAndrei Emeltchenko static bool l2cap_check_efs(struct l2cap_chan *chan) 10295ce66b59SAndrei Emeltchenko { 10305ce66b59SAndrei Emeltchenko /* Check EFS parameters */ 10315ce66b59SAndrei Emeltchenko return true; 10325ce66b59SAndrei Emeltchenko } 10335ce66b59SAndrei Emeltchenko 10342766be48SAndrei Emeltchenko void l2cap_send_conn_req(struct l2cap_chan *chan) 10359b27f350SAndrei Emeltchenko { 10369b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 10379b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 10389b27f350SAndrei Emeltchenko 10399b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 10409b27f350SAndrei Emeltchenko req.psm = chan->psm; 10419b27f350SAndrei Emeltchenko 10429b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 10439b27f350SAndrei Emeltchenko 10449b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 10459b27f350SAndrei Emeltchenko 10469b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 10479b27f350SAndrei Emeltchenko } 10489b27f350SAndrei Emeltchenko 10498eb200bdSMat Martineau static void l2cap_send_create_chan_req(struct l2cap_chan *chan, u8 amp_id) 10508eb200bdSMat Martineau { 10518eb200bdSMat Martineau struct l2cap_create_chan_req req; 10528eb200bdSMat Martineau req.scid = cpu_to_le16(chan->scid); 10538eb200bdSMat Martineau req.psm = chan->psm; 10548eb200bdSMat Martineau req.amp_id = amp_id; 10558eb200bdSMat Martineau 10568eb200bdSMat Martineau chan->ident = l2cap_get_ident(chan->conn); 10578eb200bdSMat Martineau 10588eb200bdSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_REQ, 10598eb200bdSMat Martineau sizeof(req), &req); 10608eb200bdSMat Martineau } 10618eb200bdSMat Martineau 106202b0fbb9SMat Martineau static void l2cap_move_setup(struct l2cap_chan *chan) 106302b0fbb9SMat Martineau { 106402b0fbb9SMat Martineau struct sk_buff *skb; 106502b0fbb9SMat Martineau 106602b0fbb9SMat Martineau BT_DBG("chan %p", chan); 106702b0fbb9SMat Martineau 106802b0fbb9SMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 106902b0fbb9SMat Martineau return; 107002b0fbb9SMat Martineau 107102b0fbb9SMat Martineau __clear_retrans_timer(chan); 107202b0fbb9SMat Martineau __clear_monitor_timer(chan); 107302b0fbb9SMat Martineau __clear_ack_timer(chan); 107402b0fbb9SMat Martineau 107502b0fbb9SMat Martineau chan->retry_count = 0; 107602b0fbb9SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 107702b0fbb9SMat Martineau if (bt_cb(skb)->control.retries) 107802b0fbb9SMat Martineau bt_cb(skb)->control.retries = 1; 107902b0fbb9SMat Martineau else 108002b0fbb9SMat Martineau break; 108102b0fbb9SMat Martineau } 108202b0fbb9SMat Martineau 108302b0fbb9SMat Martineau chan->expected_tx_seq = chan->buffer_seq; 108402b0fbb9SMat Martineau 108502b0fbb9SMat Martineau clear_bit(CONN_REJ_ACT, &chan->conn_state); 108602b0fbb9SMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 108702b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 108802b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->srej_list); 108902b0fbb9SMat Martineau skb_queue_purge(&chan->srej_q); 109002b0fbb9SMat Martineau 109102b0fbb9SMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 109202b0fbb9SMat Martineau chan->rx_state = L2CAP_RX_STATE_MOVE; 109302b0fbb9SMat Martineau 109402b0fbb9SMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 109502b0fbb9SMat Martineau } 109602b0fbb9SMat Martineau 10975f3847a4SMat Martineau static void l2cap_move_done(struct l2cap_chan *chan) 10985f3847a4SMat Martineau { 10995f3847a4SMat Martineau u8 move_role = chan->move_role; 11005f3847a4SMat Martineau BT_DBG("chan %p", chan); 11015f3847a4SMat Martineau 11025f3847a4SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 11035f3847a4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 11045f3847a4SMat Martineau 11055f3847a4SMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 11065f3847a4SMat Martineau return; 11075f3847a4SMat Martineau 11085f3847a4SMat Martineau switch (move_role) { 11095f3847a4SMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 11105f3847a4SMat Martineau l2cap_tx(chan, NULL, NULL, L2CAP_EV_EXPLICIT_POLL); 11115f3847a4SMat Martineau chan->rx_state = L2CAP_RX_STATE_WAIT_F; 11125f3847a4SMat Martineau break; 11135f3847a4SMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 11145f3847a4SMat Martineau chan->rx_state = L2CAP_RX_STATE_WAIT_P; 11155f3847a4SMat Martineau break; 11165f3847a4SMat Martineau } 11175f3847a4SMat Martineau } 11185f3847a4SMat Martineau 11199f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 11209f0caeb1SVinicius Costa Gomes { 11212827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 11229f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 11239f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 11249f0caeb1SVinicius Costa Gomes 112554a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 11269f0caeb1SVinicius Costa Gomes 112754a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 11289f0caeb1SVinicius Costa Gomes } 11299f0caeb1SVinicius Costa Gomes 113093c3e8f5SAndrei Emeltchenko static void l2cap_start_connection(struct l2cap_chan *chan) 113193c3e8f5SAndrei Emeltchenko { 113293c3e8f5SAndrei Emeltchenko if (__amp_capable(chan)) { 113393c3e8f5SAndrei Emeltchenko BT_DBG("chan %p AMP capable: discover AMPs", chan); 113493c3e8f5SAndrei Emeltchenko a2mp_discover_amp(chan); 113593c3e8f5SAndrei Emeltchenko } else { 113693c3e8f5SAndrei Emeltchenko l2cap_send_conn_req(chan); 113793c3e8f5SAndrei Emeltchenko } 113893c3e8f5SAndrei Emeltchenko } 113993c3e8f5SAndrei Emeltchenko 1140fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 11410a708f8fSGustavo F. Padovan { 11428c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 11430a708f8fSGustavo F. Padovan 11449f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 11459f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 11469f0caeb1SVinicius Costa Gomes return; 11479f0caeb1SVinicius Costa Gomes } 11489f0caeb1SVinicius Costa Gomes 11490a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 11500a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 11510a708f8fSGustavo F. Padovan return; 11520a708f8fSGustavo F. Padovan 1153d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 115493c3e8f5SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) { 115593c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 115693c3e8f5SAndrei Emeltchenko } 11570a708f8fSGustavo F. Padovan } else { 11580a708f8fSGustavo F. Padovan struct l2cap_info_req req; 1159ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 11600a708f8fSGustavo F. Padovan 11610a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 11620a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 11630a708f8fSGustavo F. Padovan 1164ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 11650a708f8fSGustavo F. Padovan 11662d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 11672d792818SGustavo Padovan sizeof(req), &req); 11680a708f8fSGustavo F. Padovan } 11690a708f8fSGustavo F. Padovan } 11700a708f8fSGustavo F. Padovan 11710a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 11720a708f8fSGustavo F. Padovan { 11730a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 11740a708f8fSGustavo F. Padovan if (!disable_ertm) 11750a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 11760a708f8fSGustavo F. Padovan 11770a708f8fSGustavo F. Padovan switch (mode) { 11780a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 11790a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 11800a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 11810a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 11820a708f8fSGustavo F. Padovan default: 11830a708f8fSGustavo F. Padovan return 0x00; 11840a708f8fSGustavo F. Padovan } 11850a708f8fSGustavo F. Padovan } 11860a708f8fSGustavo F. Padovan 11875e4e3972SAndrei Emeltchenko static void l2cap_send_disconn_req(struct l2cap_chan *chan, int err) 11880a708f8fSGustavo F. Padovan { 11896be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 11905e4e3972SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 11910a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 11920a708f8fSGustavo F. Padovan 11930a708f8fSGustavo F. Padovan if (!conn) 11940a708f8fSGustavo F. Padovan return; 11950a708f8fSGustavo F. Padovan 1196aad3d0e3SAndrei Emeltchenko if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) { 11971a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 11981a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 11991a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 12000a708f8fSGustavo F. Padovan } 12010a708f8fSGustavo F. Padovan 1202416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1203d117773cSGustavo Padovan l2cap_state_change(chan, BT_DISCONN); 1204416fa752SAndrei Emeltchenko return; 1205416fa752SAndrei Emeltchenko } 1206416fa752SAndrei Emeltchenko 1207fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1208fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 12092d792818SGustavo Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_DISCONN_REQ, 12102d792818SGustavo Padovan sizeof(req), &req); 12110a708f8fSGustavo F. Padovan 12126be36555SAndrei Emeltchenko lock_sock(sk); 12130e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 12142e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 12156be36555SAndrei Emeltchenko release_sock(sk); 12160a708f8fSGustavo F. Padovan } 12170a708f8fSGustavo F. Padovan 12180a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 12190a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 12200a708f8fSGustavo F. Padovan { 12213df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 12220a708f8fSGustavo F. Padovan 12230a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12240a708f8fSGustavo F. Padovan 12253df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12260a708f8fSGustavo F. Padovan 12273df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 122848454079SGustavo F. Padovan struct sock *sk = chan->sk; 1229baa7e1faSGustavo F. Padovan 12306be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12310a708f8fSGustavo F. Padovan 1232715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12336be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12340a708f8fSGustavo F. Padovan continue; 12350a708f8fSGustavo F. Padovan } 12360a708f8fSGustavo F. Padovan 123789bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1238d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1239b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 12406be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12410a708f8fSGustavo F. Padovan continue; 12420a708f8fSGustavo F. Padovan } 12430a708f8fSGustavo F. Padovan 1244c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1245c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1246c1360a1cSGustavo F. Padovan &chan->conf_state)) { 12470f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 12486be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12490a708f8fSGustavo F. Padovan continue; 12500a708f8fSGustavo F. Padovan } 12510a708f8fSGustavo F. Padovan 125293c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 12530a708f8fSGustavo F. Padovan 125489bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 12550a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 12560a708f8fSGustavo F. Padovan char buf[128]; 1257fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1258fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 12590a708f8fSGustavo F. Padovan 1260d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 12616be36555SAndrei Emeltchenko lock_sock(sk); 1262c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1263c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 1264ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1265ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 12662dc4e510SGustavo Padovan chan->ops->defer(chan); 12670a708f8fSGustavo F. Padovan 12680a708f8fSGustavo F. Padovan } else { 12690e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1270ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1271ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 12720a708f8fSGustavo F. Padovan } 12736be36555SAndrei Emeltchenko release_sock(sk); 12740a708f8fSGustavo F. Padovan } else { 1275ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1276ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 12770a708f8fSGustavo F. Padovan } 12780a708f8fSGustavo F. Padovan 1279fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1280fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 12810a708f8fSGustavo F. Padovan 1282c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 12830a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 12846be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12850a708f8fSGustavo F. Padovan continue; 12860a708f8fSGustavo F. Padovan } 12870a708f8fSGustavo F. Padovan 1288c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 12890a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 129073ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 129173ffa904SGustavo F. Padovan chan->num_conf_req++; 12920a708f8fSGustavo F. Padovan } 12930a708f8fSGustavo F. Padovan 12946be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12950a708f8fSGustavo F. Padovan } 12960a708f8fSGustavo F. Padovan 12973df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12980a708f8fSGustavo F. Padovan } 12990a708f8fSGustavo F. Padovan 1300c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1301b62f328bSVille Tervo * Returns closest match, locked. 1302b62f328bSVille Tervo */ 1303d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1304c2287681SIdo Yariv bdaddr_t *src, 1305c2287681SIdo Yariv bdaddr_t *dst) 1306b62f328bSVille Tervo { 130723691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1308b62f328bSVille Tervo 130923691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1310b62f328bSVille Tervo 131123691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 131223691d75SGustavo F. Padovan struct sock *sk = c->sk; 1313fe4128e0SGustavo F. Padovan 131489bc500eSGustavo F. Padovan if (state && c->state != state) 1315b62f328bSVille Tervo continue; 1316b62f328bSVille Tervo 131723691d75SGustavo F. Padovan if (c->scid == cid) { 1318c2287681SIdo Yariv int src_match, dst_match; 1319c2287681SIdo Yariv int src_any, dst_any; 1320c2287681SIdo Yariv 1321b62f328bSVille Tervo /* Exact match. */ 1322c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1323c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1324c2287681SIdo Yariv if (src_match && dst_match) { 132523691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 132623691d75SGustavo F. Padovan return c; 132723691d75SGustavo F. Padovan } 1328b62f328bSVille Tervo 1329b62f328bSVille Tervo /* Closest match */ 1330c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1331c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1332c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1333c2287681SIdo Yariv (src_any && dst_any)) 133423691d75SGustavo F. Padovan c1 = c; 1335b62f328bSVille Tervo } 1336b62f328bSVille Tervo } 1337280f294fSGustavo F. Padovan 133823691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1339b62f328bSVille Tervo 134023691d75SGustavo F. Padovan return c1; 1341b62f328bSVille Tervo } 1342b62f328bSVille Tervo 1343b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1344b62f328bSVille Tervo { 134560bac184SJohan Hedberg struct sock *parent; 134623691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1347b62f328bSVille Tervo 1348b62f328bSVille Tervo BT_DBG(""); 1349b62f328bSVille Tervo 1350b62f328bSVille Tervo /* Check if we have socket listening on cid */ 1351073d1cf3SJohan Hedberg pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_ATT, 1352c2287681SIdo Yariv conn->src, conn->dst); 135323691d75SGustavo F. Padovan if (!pchan) 1354b62f328bSVille Tervo return; 1355b62f328bSVille Tervo 135644f3b0fbSJohan Hedberg /* Client ATT sockets should override the server one */ 135744f3b0fbSJohan Hedberg if (__l2cap_get_chan_by_dcid(conn, L2CAP_CID_ATT)) 135844f3b0fbSJohan Hedberg return; 135944f3b0fbSJohan Hedberg 136023691d75SGustavo F. Padovan parent = pchan->sk; 136123691d75SGustavo F. Padovan 1362aa2ac881SGustavo F. Padovan lock_sock(parent); 136362f3a2cfSGustavo F. Padovan 136480b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 136580808e43SGustavo F. Padovan if (!chan) 1366b62f328bSVille Tervo goto clean; 1367b62f328bSVille Tervo 13689f22398cSJohan Hedberg chan->dcid = L2CAP_CID_ATT; 13699f22398cSJohan Hedberg 137060bac184SJohan Hedberg bacpy(&bt_sk(chan->sk)->src, conn->src); 137160bac184SJohan Hedberg bacpy(&bt_sk(chan->sk)->dst, conn->dst); 1372b62f328bSVille Tervo 137344f3b0fbSJohan Hedberg __l2cap_chan_add(conn, chan); 137448454079SGustavo F. Padovan 1375b62f328bSVille Tervo clean: 1376aa2ac881SGustavo F. Padovan release_sock(parent); 1377b62f328bSVille Tervo } 1378b62f328bSVille Tervo 13790a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 13800a708f8fSGustavo F. Padovan { 138148454079SGustavo F. Padovan struct l2cap_chan *chan; 1382cc110922SVinicius Costa Gomes struct hci_conn *hcon = conn->hcon; 13830a708f8fSGustavo F. Padovan 13840a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 13850a708f8fSGustavo F. Padovan 1386d8729922SJohan Hedberg /* For outgoing pairing which doesn't necessarily have an 1387d8729922SJohan Hedberg * associated socket (e.g. mgmt_pair_device). 1388d8729922SJohan Hedberg */ 1389cc110922SVinicius Costa Gomes if (hcon->out && hcon->type == LE_LINK) 1390cc110922SVinicius Costa Gomes smp_conn_security(hcon, hcon->pending_sec_level); 1391160dc6acSVinicius Costa Gomes 13923df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 13930a708f8fSGustavo F. Padovan 139444f3b0fbSJohan Hedberg if (hcon->type == LE_LINK) 139544f3b0fbSJohan Hedberg l2cap_le_conn_ready(conn); 139644f3b0fbSJohan Hedberg 13973df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1398baa7e1faSGustavo F. Padovan 13996be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 14000a708f8fSGustavo F. Padovan 1401416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1402416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1403416fa752SAndrei Emeltchenko continue; 1404416fa752SAndrei Emeltchenko } 1405416fa752SAndrei Emeltchenko 1406cc110922SVinicius Costa Gomes if (hcon->type == LE_LINK) { 1407cc110922SVinicius Costa Gomes if (smp_conn_security(hcon, chan->sec_level)) 1408cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1409acd7d370SVille Tervo 141063128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 14116be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1412c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 14136be36555SAndrei Emeltchenko lock_sock(sk); 14140e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 14150a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 14166be36555SAndrei Emeltchenko release_sock(sk); 1417b501d6a1SAnderson Briglia 14181c244f79SGustavo Padovan } else if (chan->state == BT_CONNECT) { 1419fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 14201c244f79SGustavo Padovan } 14210a708f8fSGustavo F. Padovan 14226be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 14230a708f8fSGustavo F. Padovan } 14240a708f8fSGustavo F. Padovan 14253df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14260a708f8fSGustavo F. Padovan } 14270a708f8fSGustavo F. Padovan 14280a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 14290a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 14300a708f8fSGustavo F. Padovan { 143148454079SGustavo F. Padovan struct l2cap_chan *chan; 14320a708f8fSGustavo F. Padovan 14330a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 14340a708f8fSGustavo F. Padovan 14353df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 14360a708f8fSGustavo F. Padovan 14373df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1438ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 14391d8b1fd5SGustavo Padovan l2cap_chan_set_err(chan, err); 14400a708f8fSGustavo F. Padovan } 14410a708f8fSGustavo F. Padovan 14423df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14430a708f8fSGustavo F. Padovan } 14440a708f8fSGustavo F. Padovan 1445f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 14460a708f8fSGustavo F. Padovan { 1447f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1448030013d8SGustavo F. Padovan info_timer.work); 14490a708f8fSGustavo F. Padovan 14500a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 14510a708f8fSGustavo F. Padovan conn->info_ident = 0; 14520a708f8fSGustavo F. Padovan 14530a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 14540a708f8fSGustavo F. Padovan } 14550a708f8fSGustavo F. Padovan 14562c8e1411SDavid Herrmann /* 14572c8e1411SDavid Herrmann * l2cap_user 14582c8e1411SDavid Herrmann * External modules can register l2cap_user objects on l2cap_conn. The ->probe 14592c8e1411SDavid Herrmann * callback is called during registration. The ->remove callback is called 14602c8e1411SDavid Herrmann * during unregistration. 14612c8e1411SDavid Herrmann * An l2cap_user object can either be explicitly unregistered or when the 14622c8e1411SDavid Herrmann * underlying l2cap_conn object is deleted. This guarantees that l2cap->hcon, 14632c8e1411SDavid Herrmann * l2cap->hchan, .. are valid as long as the remove callback hasn't been called. 14642c8e1411SDavid Herrmann * External modules must own a reference to the l2cap_conn object if they intend 14652c8e1411SDavid Herrmann * to call l2cap_unregister_user(). The l2cap_conn object might get destroyed at 14662c8e1411SDavid Herrmann * any time if they don't. 14672c8e1411SDavid Herrmann */ 14682c8e1411SDavid Herrmann 14692c8e1411SDavid Herrmann int l2cap_register_user(struct l2cap_conn *conn, struct l2cap_user *user) 14702c8e1411SDavid Herrmann { 14712c8e1411SDavid Herrmann struct hci_dev *hdev = conn->hcon->hdev; 14722c8e1411SDavid Herrmann int ret; 14732c8e1411SDavid Herrmann 14742c8e1411SDavid Herrmann /* We need to check whether l2cap_conn is registered. If it is not, we 14752c8e1411SDavid Herrmann * must not register the l2cap_user. l2cap_conn_del() is unregisters 14762c8e1411SDavid Herrmann * l2cap_conn objects, but doesn't provide its own locking. Instead, it 14772c8e1411SDavid Herrmann * relies on the parent hci_conn object to be locked. This itself relies 14782c8e1411SDavid Herrmann * on the hci_dev object to be locked. So we must lock the hci device 14792c8e1411SDavid Herrmann * here, too. */ 14802c8e1411SDavid Herrmann 14812c8e1411SDavid Herrmann hci_dev_lock(hdev); 14822c8e1411SDavid Herrmann 14832c8e1411SDavid Herrmann if (user->list.next || user->list.prev) { 14842c8e1411SDavid Herrmann ret = -EINVAL; 14852c8e1411SDavid Herrmann goto out_unlock; 14862c8e1411SDavid Herrmann } 14872c8e1411SDavid Herrmann 14882c8e1411SDavid Herrmann /* conn->hchan is NULL after l2cap_conn_del() was called */ 14892c8e1411SDavid Herrmann if (!conn->hchan) { 14902c8e1411SDavid Herrmann ret = -ENODEV; 14912c8e1411SDavid Herrmann goto out_unlock; 14922c8e1411SDavid Herrmann } 14932c8e1411SDavid Herrmann 14942c8e1411SDavid Herrmann ret = user->probe(conn, user); 14952c8e1411SDavid Herrmann if (ret) 14962c8e1411SDavid Herrmann goto out_unlock; 14972c8e1411SDavid Herrmann 14982c8e1411SDavid Herrmann list_add(&user->list, &conn->users); 14992c8e1411SDavid Herrmann ret = 0; 15002c8e1411SDavid Herrmann 15012c8e1411SDavid Herrmann out_unlock: 15022c8e1411SDavid Herrmann hci_dev_unlock(hdev); 15032c8e1411SDavid Herrmann return ret; 15042c8e1411SDavid Herrmann } 15052c8e1411SDavid Herrmann EXPORT_SYMBOL(l2cap_register_user); 15062c8e1411SDavid Herrmann 15072c8e1411SDavid Herrmann void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user) 15082c8e1411SDavid Herrmann { 15092c8e1411SDavid Herrmann struct hci_dev *hdev = conn->hcon->hdev; 15102c8e1411SDavid Herrmann 15112c8e1411SDavid Herrmann hci_dev_lock(hdev); 15122c8e1411SDavid Herrmann 15132c8e1411SDavid Herrmann if (!user->list.next || !user->list.prev) 15142c8e1411SDavid Herrmann goto out_unlock; 15152c8e1411SDavid Herrmann 15162c8e1411SDavid Herrmann list_del(&user->list); 15172c8e1411SDavid Herrmann user->list.next = NULL; 15182c8e1411SDavid Herrmann user->list.prev = NULL; 15192c8e1411SDavid Herrmann user->remove(conn, user); 15202c8e1411SDavid Herrmann 15212c8e1411SDavid Herrmann out_unlock: 15222c8e1411SDavid Herrmann hci_dev_unlock(hdev); 15232c8e1411SDavid Herrmann } 15242c8e1411SDavid Herrmann EXPORT_SYMBOL(l2cap_unregister_user); 15252c8e1411SDavid Herrmann 15262c8e1411SDavid Herrmann static void l2cap_unregister_all_users(struct l2cap_conn *conn) 15272c8e1411SDavid Herrmann { 15282c8e1411SDavid Herrmann struct l2cap_user *user; 15292c8e1411SDavid Herrmann 15302c8e1411SDavid Herrmann while (!list_empty(&conn->users)) { 15312c8e1411SDavid Herrmann user = list_first_entry(&conn->users, struct l2cap_user, list); 15322c8e1411SDavid Herrmann list_del(&user->list); 15332c8e1411SDavid Herrmann user->list.next = NULL; 15342c8e1411SDavid Herrmann user->list.prev = NULL; 15352c8e1411SDavid Herrmann user->remove(conn, user); 15362c8e1411SDavid Herrmann } 15372c8e1411SDavid Herrmann } 15382c8e1411SDavid Herrmann 15395d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 15405d3de7dfSVinicius Costa Gomes { 15415d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 15425d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 15435d3de7dfSVinicius Costa Gomes 15445d3de7dfSVinicius Costa Gomes if (!conn) 15455d3de7dfSVinicius Costa Gomes return; 15465d3de7dfSVinicius Costa Gomes 15475d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 15485d3de7dfSVinicius Costa Gomes 15495d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 15505d3de7dfSVinicius Costa Gomes 15512c8e1411SDavid Herrmann l2cap_unregister_all_users(conn); 15522c8e1411SDavid Herrmann 15533df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 15543df91ea2SAndrei Emeltchenko 15555d3de7dfSVinicius Costa Gomes /* Kill channels */ 15565d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 155761d6ef3eSMat Martineau l2cap_chan_hold(chan); 15586be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 15596be36555SAndrei Emeltchenko 15605d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 15616be36555SAndrei Emeltchenko 15626be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 15636be36555SAndrei Emeltchenko 156480b98027SGustavo Padovan chan->ops->close(chan); 156561d6ef3eSMat Martineau l2cap_chan_put(chan); 15665d3de7dfSVinicius Costa Gomes } 15675d3de7dfSVinicius Costa Gomes 15683df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 15693df91ea2SAndrei Emeltchenko 157073d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 157173d80debSLuiz Augusto von Dentz 15725d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1573127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 15745d3de7dfSVinicius Costa Gomes 157551a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1576127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 15778aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1578d26a2345SVinicius Costa Gomes } 15795d3de7dfSVinicius Costa Gomes 15805d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 15819c903e37SDavid Herrmann conn->hchan = NULL; 15829c903e37SDavid Herrmann l2cap_conn_put(conn); 15835d3de7dfSVinicius Costa Gomes } 15845d3de7dfSVinicius Costa Gomes 15856c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 15865d3de7dfSVinicius Costa Gomes { 15876c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 15886c9d42a1SGustavo F. Padovan security_timer.work); 15895d3de7dfSVinicius Costa Gomes 1590d06cc416SJohan Hedberg BT_DBG("conn %p", conn); 1591d06cc416SJohan Hedberg 1592d06cc416SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 1593d06cc416SJohan Hedberg smp_chan_destroy(conn); 15945d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 15955d3de7dfSVinicius Costa Gomes } 1596d06cc416SJohan Hedberg } 15975d3de7dfSVinicius Costa Gomes 1598baf43251SClaudio Takahasi static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon) 15990a708f8fSGustavo F. Padovan { 16000a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 160173d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 16020a708f8fSGustavo F. Padovan 1603baf43251SClaudio Takahasi if (conn) 16040a708f8fSGustavo F. Padovan return conn; 16050a708f8fSGustavo F. Padovan 160673d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 160773d80debSLuiz Augusto von Dentz if (!hchan) 16080a708f8fSGustavo F. Padovan return NULL; 16090a708f8fSGustavo F. Padovan 16108bcde1f2SGustavo Padovan conn = kzalloc(sizeof(struct l2cap_conn), GFP_KERNEL); 161173d80debSLuiz Augusto von Dentz if (!conn) { 161273d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 161373d80debSLuiz Augusto von Dentz return NULL; 161473d80debSLuiz Augusto von Dentz } 161573d80debSLuiz Augusto von Dentz 16169c903e37SDavid Herrmann kref_init(&conn->ref); 16170a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 16180a708f8fSGustavo F. Padovan conn->hcon = hcon; 16199c903e37SDavid Herrmann hci_conn_get(conn->hcon); 162073d80debSLuiz Augusto von Dentz conn->hchan = hchan; 16210a708f8fSGustavo F. Padovan 162273d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 16230a708f8fSGustavo F. Padovan 1624dcc042d5SAndrei Emeltchenko switch (hcon->type) { 1625dcc042d5SAndrei Emeltchenko case LE_LINK: 1626dcc042d5SAndrei Emeltchenko if (hcon->hdev->le_mtu) { 1627acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1628dcc042d5SAndrei Emeltchenko break; 1629dcc042d5SAndrei Emeltchenko } 1630dcc042d5SAndrei Emeltchenko /* fall through */ 1631dcc042d5SAndrei Emeltchenko default: 16320a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1633dcc042d5SAndrei Emeltchenko break; 1634dcc042d5SAndrei Emeltchenko } 1635acd7d370SVille Tervo 16360a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 16370a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 16380a708f8fSGustavo F. Padovan 16390a708f8fSGustavo F. Padovan conn->feat_mask = 0; 16400a708f8fSGustavo F. Padovan 16410a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 16423df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1643baa7e1faSGustavo F. Padovan 1644baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 16452c8e1411SDavid Herrmann INIT_LIST_HEAD(&conn->users); 16460a708f8fSGustavo F. Padovan 16475d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 16486c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 16495d3de7dfSVinicius Costa Gomes else 1650030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 16510a708f8fSGustavo F. Padovan 16529f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 16530a708f8fSGustavo F. Padovan 16540a708f8fSGustavo F. Padovan return conn; 16550a708f8fSGustavo F. Padovan } 16560a708f8fSGustavo F. Padovan 16579c903e37SDavid Herrmann static void l2cap_conn_free(struct kref *ref) 16589c903e37SDavid Herrmann { 16599c903e37SDavid Herrmann struct l2cap_conn *conn = container_of(ref, struct l2cap_conn, ref); 16609c903e37SDavid Herrmann 16619c903e37SDavid Herrmann hci_conn_put(conn->hcon); 16629c903e37SDavid Herrmann kfree(conn); 16639c903e37SDavid Herrmann } 16649c903e37SDavid Herrmann 16659c903e37SDavid Herrmann void l2cap_conn_get(struct l2cap_conn *conn) 16669c903e37SDavid Herrmann { 16679c903e37SDavid Herrmann kref_get(&conn->ref); 16689c903e37SDavid Herrmann } 16699c903e37SDavid Herrmann EXPORT_SYMBOL(l2cap_conn_get); 16709c903e37SDavid Herrmann 16719c903e37SDavid Herrmann void l2cap_conn_put(struct l2cap_conn *conn) 16729c903e37SDavid Herrmann { 16739c903e37SDavid Herrmann kref_put(&conn->ref, l2cap_conn_free); 16749c903e37SDavid Herrmann } 16759c903e37SDavid Herrmann EXPORT_SYMBOL(l2cap_conn_put); 16769c903e37SDavid Herrmann 16770a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 16780a708f8fSGustavo F. Padovan 1679c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 16800a708f8fSGustavo F. Padovan * Returns closest match. 16810a708f8fSGustavo F. Padovan */ 1682c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1683c2287681SIdo Yariv bdaddr_t *src, 1684c2287681SIdo Yariv bdaddr_t *dst) 16850a708f8fSGustavo F. Padovan { 168623691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 16870a708f8fSGustavo F. Padovan 168823691d75SGustavo F. Padovan read_lock(&chan_list_lock); 16890a708f8fSGustavo F. Padovan 169023691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 169123691d75SGustavo F. Padovan struct sock *sk = c->sk; 1692fe4128e0SGustavo F. Padovan 169389bc500eSGustavo F. Padovan if (state && c->state != state) 16940a708f8fSGustavo F. Padovan continue; 16950a708f8fSGustavo F. Padovan 169623691d75SGustavo F. Padovan if (c->psm == psm) { 1697c2287681SIdo Yariv int src_match, dst_match; 1698c2287681SIdo Yariv int src_any, dst_any; 1699c2287681SIdo Yariv 17000a708f8fSGustavo F. Padovan /* Exact match. */ 1701c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1702c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1703c2287681SIdo Yariv if (src_match && dst_match) { 1704a7567b20SJohannes Berg read_unlock(&chan_list_lock); 170523691d75SGustavo F. Padovan return c; 170623691d75SGustavo F. Padovan } 17070a708f8fSGustavo F. Padovan 17080a708f8fSGustavo F. Padovan /* Closest match */ 1709c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1710c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1711c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1712c2287681SIdo Yariv (src_any && dst_any)) 171323691d75SGustavo F. Padovan c1 = c; 17140a708f8fSGustavo F. Padovan } 17150a708f8fSGustavo F. Padovan } 17160a708f8fSGustavo F. Padovan 171723691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 17180a708f8fSGustavo F. Padovan 171923691d75SGustavo F. Padovan return c1; 17200a708f8fSGustavo F. Padovan } 17210a708f8fSGustavo F. Padovan 17228e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 17238e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 17240a708f8fSGustavo F. Padovan { 17255d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 17260a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 17270a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 17280a708f8fSGustavo F. Padovan struct hci_conn *hcon; 17290a708f8fSGustavo F. Padovan struct hci_dev *hdev; 17300a708f8fSGustavo F. Padovan __u8 auth_type; 17310a708f8fSGustavo F. Padovan int err; 17320a708f8fSGustavo F. Padovan 17336ed93dc6SAndrei Emeltchenko BT_DBG("%pMR -> %pMR (type %u) psm 0x%2.2x", src, dst, 1734ab19516aSSyam Sidhardhan dst_type, __le16_to_cpu(psm)); 17350a708f8fSGustavo F. Padovan 17360a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 17370a708f8fSGustavo F. Padovan if (!hdev) 17380a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 17390a708f8fSGustavo F. Padovan 174009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17410a708f8fSGustavo F. Padovan 17426be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 174303a00194SGustavo F. Padovan 174403a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 174503a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 174603a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 174703a00194SGustavo F. Padovan err = -EINVAL; 174803a00194SGustavo F. Padovan goto done; 174903a00194SGustavo F. Padovan } 175003a00194SGustavo F. Padovan 175103a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 175203a00194SGustavo F. Padovan err = -EINVAL; 175303a00194SGustavo F. Padovan goto done; 175403a00194SGustavo F. Padovan } 175503a00194SGustavo F. Padovan 175603a00194SGustavo F. Padovan switch (chan->mode) { 175703a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 175803a00194SGustavo F. Padovan break; 175903a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 176003a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 176103a00194SGustavo F. Padovan if (!disable_ertm) 176203a00194SGustavo F. Padovan break; 176303a00194SGustavo F. Padovan /* fall through */ 176403a00194SGustavo F. Padovan default: 176503a00194SGustavo F. Padovan err = -ENOTSUPP; 176603a00194SGustavo F. Padovan goto done; 176703a00194SGustavo F. Padovan } 176803a00194SGustavo F. Padovan 17690797e01dSGustavo Padovan switch (chan->state) { 177003a00194SGustavo F. Padovan case BT_CONNECT: 177103a00194SGustavo F. Padovan case BT_CONNECT2: 177203a00194SGustavo F. Padovan case BT_CONFIG: 177303a00194SGustavo F. Padovan /* Already connecting */ 177403a00194SGustavo F. Padovan err = 0; 177503a00194SGustavo F. Padovan goto done; 177603a00194SGustavo F. Padovan 177703a00194SGustavo F. Padovan case BT_CONNECTED: 177803a00194SGustavo F. Padovan /* Already connected */ 177903a00194SGustavo F. Padovan err = -EISCONN; 178003a00194SGustavo F. Padovan goto done; 178103a00194SGustavo F. Padovan 178203a00194SGustavo F. Padovan case BT_OPEN: 178303a00194SGustavo F. Padovan case BT_BOUND: 178403a00194SGustavo F. Padovan /* Can connect */ 178503a00194SGustavo F. Padovan break; 178603a00194SGustavo F. Padovan 178703a00194SGustavo F. Padovan default: 178803a00194SGustavo F. Padovan err = -EBADFD; 178903a00194SGustavo F. Padovan goto done; 179003a00194SGustavo F. Padovan } 179103a00194SGustavo F. Padovan 179203a00194SGustavo F. Padovan /* Set destination address and psm */ 17930797e01dSGustavo Padovan lock_sock(sk); 17949219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 17956be36555SAndrei Emeltchenko release_sock(sk); 17966be36555SAndrei Emeltchenko 179703a00194SGustavo F. Padovan chan->psm = psm; 179803a00194SGustavo F. Padovan chan->dcid = cid; 17990a708f8fSGustavo F. Padovan 18004343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 18010a708f8fSGustavo F. Padovan 1802f224ca5fSJohan Hedberg if (bdaddr_type_is_le(dst_type)) 18038e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 18044343478fSGustavo F. Padovan chan->sec_level, auth_type); 1805acd7d370SVille Tervo else 18068e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 18074343478fSGustavo F. Padovan chan->sec_level, auth_type); 1808acd7d370SVille Tervo 180930e76272SVille Tervo if (IS_ERR(hcon)) { 181030e76272SVille Tervo err = PTR_ERR(hcon); 18110a708f8fSGustavo F. Padovan goto done; 181230e76272SVille Tervo } 18130a708f8fSGustavo F. Padovan 1814baf43251SClaudio Takahasi conn = l2cap_conn_add(hcon); 18150a708f8fSGustavo F. Padovan if (!conn) { 181676a68ba0SDavid Herrmann hci_conn_drop(hcon); 181730e76272SVille Tervo err = -ENOMEM; 18180a708f8fSGustavo F. Padovan goto done; 18190a708f8fSGustavo F. Padovan } 18200a708f8fSGustavo F. Padovan 1821141d5706SJohan Hedberg if (cid && __l2cap_get_chan_by_dcid(conn, cid)) { 182276a68ba0SDavid Herrmann hci_conn_drop(hcon); 1823141d5706SJohan Hedberg err = -EBUSY; 18249f0caeb1SVinicius Costa Gomes goto done; 18259f0caeb1SVinicius Costa Gomes } 18269f0caeb1SVinicius Costa Gomes 18270a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 18280a708f8fSGustavo F. Padovan bacpy(src, conn->src); 18290a708f8fSGustavo F. Padovan 18306be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 183148454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 18326be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 183348454079SGustavo F. Padovan 18345ee9891dSJohan Hedberg /* l2cap_chan_add takes its own ref so we can drop this one */ 18355ee9891dSJohan Hedberg hci_conn_drop(hcon); 18365ee9891dSJohan Hedberg 18376be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1838c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 18390a708f8fSGustavo F. Padovan 18400a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1841715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1842c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1843d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 18446be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 18450a708f8fSGustavo F. Padovan } else 1846fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 18470a708f8fSGustavo F. Padovan } 18480a708f8fSGustavo F. Padovan 184930e76272SVille Tervo err = 0; 185030e76272SVille Tervo 18510a708f8fSGustavo F. Padovan done: 18526be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 185309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18540a708f8fSGustavo F. Padovan hci_dev_put(hdev); 18550a708f8fSGustavo F. Padovan return err; 18560a708f8fSGustavo F. Padovan } 18570a708f8fSGustavo F. Padovan 1858dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 18590a708f8fSGustavo F. Padovan { 18608c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 18610a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 18620a708f8fSGustavo F. Padovan int err = 0; 18630a708f8fSGustavo F. Padovan int timeo = HZ/5; 18640a708f8fSGustavo F. Padovan 18650a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 18660a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1867a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 18680a708f8fSGustavo F. Padovan if (!timeo) 18690a708f8fSGustavo F. Padovan timeo = HZ/5; 18700a708f8fSGustavo F. Padovan 18710a708f8fSGustavo F. Padovan if (signal_pending(current)) { 18720a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 18730a708f8fSGustavo F. Padovan break; 18740a708f8fSGustavo F. Padovan } 18750a708f8fSGustavo F. Padovan 18760a708f8fSGustavo F. Padovan release_sock(sk); 18770a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 18780a708f8fSGustavo F. Padovan lock_sock(sk); 1879a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 18800a708f8fSGustavo F. Padovan 18810a708f8fSGustavo F. Padovan err = sock_error(sk); 18820a708f8fSGustavo F. Padovan if (err) 18830a708f8fSGustavo F. Padovan break; 18840a708f8fSGustavo F. Padovan } 18850a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 18860a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 18870a708f8fSGustavo F. Padovan return err; 18880a708f8fSGustavo F. Padovan } 18890a708f8fSGustavo F. Padovan 1890721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 18910a708f8fSGustavo F. Padovan { 1892721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1893721c4181SGustavo F. Padovan monitor_timer.work); 18940a708f8fSGustavo F. Padovan 1895525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 18960a708f8fSGustavo F. Padovan 18976be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 18986be36555SAndrei Emeltchenko 189980909e04SMat Martineau if (!chan->conn) { 19006be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 19018d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 19020a708f8fSGustavo F. Padovan return; 19030a708f8fSGustavo F. Padovan } 19040a708f8fSGustavo F. Padovan 1905401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 19060a708f8fSGustavo F. Padovan 19076be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 19088d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 19090a708f8fSGustavo F. Padovan } 19100a708f8fSGustavo F. Padovan 1911721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 19120a708f8fSGustavo F. Padovan { 1913721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1914721c4181SGustavo F. Padovan retrans_timer.work); 19150a708f8fSGustavo F. Padovan 191649208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 19170a708f8fSGustavo F. Padovan 19186be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 19196be36555SAndrei Emeltchenko 192080909e04SMat Martineau if (!chan->conn) { 192180909e04SMat Martineau l2cap_chan_unlock(chan); 192280909e04SMat Martineau l2cap_chan_put(chan); 192380909e04SMat Martineau return; 192480909e04SMat Martineau } 19250a708f8fSGustavo F. Padovan 1926401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 19276be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 19288d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 19290a708f8fSGustavo F. Padovan } 19300a708f8fSGustavo F. Padovan 1931d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 19323733937dSMat Martineau struct sk_buff_head *skbs) 19330a708f8fSGustavo F. Padovan { 19340a708f8fSGustavo F. Padovan struct sk_buff *skb; 19353733937dSMat Martineau struct l2cap_ctrl *control; 19360a708f8fSGustavo F. Padovan 19373733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 19383733937dSMat Martineau 1939b99e13adSMat Martineau if (__chan_is_moving(chan)) 1940b99e13adSMat Martineau return; 1941b99e13adSMat Martineau 19423733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 19433733937dSMat Martineau 19443733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 19453733937dSMat Martineau 19463733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 19473733937dSMat Martineau 19483733937dSMat Martineau bt_cb(skb)->control.retries = 1; 19493733937dSMat Martineau control = &bt_cb(skb)->control; 19503733937dSMat Martineau 19513733937dSMat Martineau control->reqseq = 0; 19523733937dSMat Martineau control->txseq = chan->next_tx_seq; 19533733937dSMat Martineau 19543733937dSMat Martineau __pack_control(chan, control, skb); 19550a708f8fSGustavo F. Padovan 195647d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 19573733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 19583733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 19590a708f8fSGustavo F. Padovan } 19600a708f8fSGustavo F. Padovan 19614343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 19620a708f8fSGustavo F. Padovan 1963b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 19643733937dSMat Martineau 1965836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 19663733937dSMat Martineau chan->frames_sent++; 19670a708f8fSGustavo F. Padovan } 19680a708f8fSGustavo F. Padovan } 19690a708f8fSGustavo F. Padovan 197067c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 19710a708f8fSGustavo F. Padovan { 19720a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 197318a48e76SMat Martineau struct l2cap_ctrl *control; 197418a48e76SMat Martineau int sent = 0; 197518a48e76SMat Martineau 197618a48e76SMat Martineau BT_DBG("chan %p", chan); 19770a708f8fSGustavo F. Padovan 197889bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 19790a708f8fSGustavo F. Padovan return -ENOTCONN; 19800a708f8fSGustavo F. Padovan 198194122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 198294122bbeSMat Martineau return 0; 198394122bbeSMat Martineau 1984b99e13adSMat Martineau if (__chan_is_moving(chan)) 1985b99e13adSMat Martineau return 0; 1986b99e13adSMat Martineau 198718a48e76SMat Martineau while (chan->tx_send_head && 198818a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 198918a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 19900a708f8fSGustavo F. Padovan 199118a48e76SMat Martineau skb = chan->tx_send_head; 19920a708f8fSGustavo F. Padovan 199318a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 199418a48e76SMat Martineau control = &bt_cb(skb)->control; 19950a708f8fSGustavo F. Padovan 1996e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 199718a48e76SMat Martineau control->final = 1; 1998e2ab4353SGustavo F. Padovan 199918a48e76SMat Martineau control->reqseq = chan->buffer_seq; 200018a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 200118a48e76SMat Martineau control->txseq = chan->next_tx_seq; 20020a708f8fSGustavo F. Padovan 200318a48e76SMat Martineau __pack_control(chan, control, skb); 20040a708f8fSGustavo F. Padovan 200547d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 200618a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 200718a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 20080a708f8fSGustavo F. Padovan } 20090a708f8fSGustavo F. Padovan 201018a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 201118a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 201218a48e76SMat Martineau */ 201318a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 201418a48e76SMat Martineau 201518a48e76SMat Martineau if (!tx_skb) 201618a48e76SMat Martineau break; 20170a708f8fSGustavo F. Padovan 20181a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 20190a708f8fSGustavo F. Padovan 2020836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 20216a026610SGustavo F. Padovan chan->unacked_frames++; 20226a026610SGustavo F. Padovan chan->frames_sent++; 202318a48e76SMat Martineau sent++; 20240a708f8fSGustavo F. Padovan 202558d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 202658d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 20270a708f8fSGustavo F. Padovan else 202858d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 202918a48e76SMat Martineau 203018a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 2031b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 20320a708f8fSGustavo F. Padovan } 20330a708f8fSGustavo F. Padovan 2034b4400672SAndrei Emeltchenko BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent, 2035b4400672SAndrei Emeltchenko chan->unacked_frames, skb_queue_len(&chan->tx_q)); 203618a48e76SMat Martineau 203718a48e76SMat Martineau return sent; 20380a708f8fSGustavo F. Padovan } 20390a708f8fSGustavo F. Padovan 2040e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 2041e1fbd4c1SMat Martineau { 2042e1fbd4c1SMat Martineau struct l2cap_ctrl control; 2043e1fbd4c1SMat Martineau struct sk_buff *skb; 2044e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 2045e1fbd4c1SMat Martineau u16 seq; 2046e1fbd4c1SMat Martineau 2047e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 2048e1fbd4c1SMat Martineau 2049e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 2050e1fbd4c1SMat Martineau return; 2051e1fbd4c1SMat Martineau 2052b99e13adSMat Martineau if (__chan_is_moving(chan)) 2053b99e13adSMat Martineau return; 2054b99e13adSMat Martineau 2055e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 2056e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 2057e1fbd4c1SMat Martineau 2058e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 2059e1fbd4c1SMat Martineau if (!skb) { 2060e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 2061e1fbd4c1SMat Martineau seq); 2062e1fbd4c1SMat Martineau continue; 2063e1fbd4c1SMat Martineau } 2064e1fbd4c1SMat Martineau 2065e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 2066e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 2067e1fbd4c1SMat Martineau 2068e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 2069e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 2070e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 20715e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 2072e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2073e1fbd4c1SMat Martineau break; 2074e1fbd4c1SMat Martineau } 2075e1fbd4c1SMat Martineau 2076e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 2077e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 2078e1fbd4c1SMat Martineau control.final = 1; 2079e1fbd4c1SMat Martineau else 2080e1fbd4c1SMat Martineau control.final = 0; 2081e1fbd4c1SMat Martineau 2082e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 2083e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 2084e1fbd4c1SMat Martineau * writeable copy 2085e1fbd4c1SMat Martineau */ 20868bcde1f2SGustavo Padovan tx_skb = skb_copy(skb, GFP_KERNEL); 2087e1fbd4c1SMat Martineau } else { 20888bcde1f2SGustavo Padovan tx_skb = skb_clone(skb, GFP_KERNEL); 2089e1fbd4c1SMat Martineau } 2090e1fbd4c1SMat Martineau 2091e1fbd4c1SMat Martineau if (!tx_skb) { 2092e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2093e1fbd4c1SMat Martineau break; 2094e1fbd4c1SMat Martineau } 2095e1fbd4c1SMat Martineau 2096e1fbd4c1SMat Martineau /* Update skb contents */ 2097e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 2098e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 2099e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 2100e1fbd4c1SMat Martineau } else { 2101e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 2102e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 2103e1fbd4c1SMat Martineau } 2104e1fbd4c1SMat Martineau 2105e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 2106e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 2107e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 2108e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 2109e1fbd4c1SMat Martineau } 2110e1fbd4c1SMat Martineau 2111e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 2112e1fbd4c1SMat Martineau 2113e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 2114e1fbd4c1SMat Martineau 2115e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 2116e1fbd4c1SMat Martineau } 2117e1fbd4c1SMat Martineau } 2118e1fbd4c1SMat Martineau 2119f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 2120f80842a8SMat Martineau struct l2cap_ctrl *control) 2121f80842a8SMat Martineau { 2122f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2123f80842a8SMat Martineau 2124f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 2125f80842a8SMat Martineau l2cap_ertm_resend(chan); 2126f80842a8SMat Martineau } 2127f80842a8SMat Martineau 2128d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 2129d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 2130d2a7ac5dSMat Martineau { 2131e1fbd4c1SMat Martineau struct sk_buff *skb; 2132e1fbd4c1SMat Martineau 2133e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2134e1fbd4c1SMat Martineau 2135e1fbd4c1SMat Martineau if (control->poll) 2136e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 2137e1fbd4c1SMat Martineau 2138e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2139e1fbd4c1SMat Martineau 2140e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 2141e1fbd4c1SMat Martineau return; 2142e1fbd4c1SMat Martineau 2143e1fbd4c1SMat Martineau if (chan->unacked_frames) { 2144e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 2145e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 2146e1fbd4c1SMat Martineau skb == chan->tx_send_head) 2147e1fbd4c1SMat Martineau break; 2148e1fbd4c1SMat Martineau } 2149e1fbd4c1SMat Martineau 2150e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 2151e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 2152e1fbd4c1SMat Martineau break; 2153e1fbd4c1SMat Martineau 2154e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 2155e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 2156e1fbd4c1SMat Martineau } 2157e1fbd4c1SMat Martineau 2158e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 2159e1fbd4c1SMat Martineau } 2160d2a7ac5dSMat Martineau } 2161d2a7ac5dSMat Martineau 2162b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 2163b17e73bbSSzymon Janc { 21640a0aba42SMat Martineau struct l2cap_ctrl control; 21650a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 21660a0aba42SMat Martineau chan->last_acked_seq); 21670a0aba42SMat Martineau int threshold; 21680a0aba42SMat Martineau 21690a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 21700a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 21710a0aba42SMat Martineau 21720a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 21730a0aba42SMat Martineau control.sframe = 1; 21740a0aba42SMat Martineau 21750a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 21760a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 2177b17e73bbSSzymon Janc __clear_ack_timer(chan); 21780a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 21790a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 21800a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 21810a0aba42SMat Martineau } else { 21820a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 21830a0aba42SMat Martineau l2cap_ertm_send(chan); 21840a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 21850a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 21860a0aba42SMat Martineau frames_to_ack = 0; 21870a0aba42SMat Martineau } 21880a0aba42SMat Martineau 2189c20f8e35SMat Martineau /* Ack now if the window is 3/4ths full. 21900a0aba42SMat Martineau * Calculate without mul or div 21910a0aba42SMat Martineau */ 2192c20f8e35SMat Martineau threshold = chan->ack_win; 21930a0aba42SMat Martineau threshold += threshold << 1; 21940a0aba42SMat Martineau threshold >>= 2; 21950a0aba42SMat Martineau 2196b4400672SAndrei Emeltchenko BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack, 21970a0aba42SMat Martineau threshold); 21980a0aba42SMat Martineau 21990a0aba42SMat Martineau if (frames_to_ack >= threshold) { 22000a0aba42SMat Martineau __clear_ack_timer(chan); 22010a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 22020a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 22030a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 22040a0aba42SMat Martineau frames_to_ack = 0; 22050a0aba42SMat Martineau } 22060a0aba42SMat Martineau 22070a0aba42SMat Martineau if (frames_to_ack) 22080a0aba42SMat Martineau __set_ack_timer(chan); 22090a0aba42SMat Martineau } 2210b17e73bbSSzymon Janc } 2211b17e73bbSSzymon Janc 221204124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 221304124681SGustavo F. Padovan struct msghdr *msg, int len, 221404124681SGustavo F. Padovan int count, struct sk_buff *skb) 22150a708f8fSGustavo F. Padovan { 22160952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 22170a708f8fSGustavo F. Padovan struct sk_buff **frag; 221890338947SGustavo Padovan int sent = 0; 22190a708f8fSGustavo F. Padovan 22200a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 22210a708f8fSGustavo F. Padovan return -EFAULT; 22220a708f8fSGustavo F. Padovan 22230a708f8fSGustavo F. Padovan sent += count; 22240a708f8fSGustavo F. Padovan len -= count; 22250a708f8fSGustavo F. Padovan 22260a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 22270a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 22280a708f8fSGustavo F. Padovan while (len) { 2229fbe00700SGustavo Padovan struct sk_buff *tmp; 2230fbe00700SGustavo Padovan 22310a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 22320a708f8fSGustavo F. Padovan 2233fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 223490338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 2235fbe00700SGustavo Padovan if (IS_ERR(tmp)) 2236fbe00700SGustavo Padovan return PTR_ERR(tmp); 22372f7719ceSAndrei Emeltchenko 2238fbe00700SGustavo Padovan *frag = tmp; 2239fbe00700SGustavo Padovan 22400a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 22410a708f8fSGustavo F. Padovan return -EFAULT; 22420a708f8fSGustavo F. Padovan 22435e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 22445e59b791SLuiz Augusto von Dentz 22450a708f8fSGustavo F. Padovan sent += count; 22460a708f8fSGustavo F. Padovan len -= count; 22470a708f8fSGustavo F. Padovan 22482d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 22492d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 22502d0ed3d5SGustavo Padovan 22510a708f8fSGustavo F. Padovan frag = &(*frag)->next; 22520a708f8fSGustavo F. Padovan } 22530a708f8fSGustavo F. Padovan 22540a708f8fSGustavo F. Padovan return sent; 22550a708f8fSGustavo F. Padovan } 22560a708f8fSGustavo F. Padovan 22575e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 22585e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 22595e59b791SLuiz Augusto von Dentz u32 priority) 22600a708f8fSGustavo F. Padovan { 22618c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 22620a708f8fSGustavo F. Padovan struct sk_buff *skb; 226303a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 22640a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 22650a708f8fSGustavo F. Padovan 2266b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu priority %u", chan, len, priority); 22670a708f8fSGustavo F. Padovan 22680a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 22692f7719ceSAndrei Emeltchenko 22702f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 227190338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 227290338947SGustavo Padovan if (IS_ERR(skb)) 227390338947SGustavo Padovan return skb; 22740a708f8fSGustavo F. Padovan 22755e59b791SLuiz Augusto von Dentz skb->priority = priority; 22765e59b791SLuiz Augusto von Dentz 22770a708f8fSGustavo F. Padovan /* Create L2CAP header */ 22780a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2279fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 2280daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 2281daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 22820a708f8fSGustavo F. Padovan 22830952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 22840a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 22850a708f8fSGustavo F. Padovan kfree_skb(skb); 22860a708f8fSGustavo F. Padovan return ERR_PTR(err); 22870a708f8fSGustavo F. Padovan } 22880a708f8fSGustavo F. Padovan return skb; 22890a708f8fSGustavo F. Padovan } 22900a708f8fSGustavo F. Padovan 22915e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 22925e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 22935e59b791SLuiz Augusto von Dentz u32 priority) 22940a708f8fSGustavo F. Padovan { 22958c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 22960a708f8fSGustavo F. Padovan struct sk_buff *skb; 2297f2ba7faeSGustavo Padovan int err, count; 22980a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 22990a708f8fSGustavo F. Padovan 2300b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 23010a708f8fSGustavo F. Padovan 2302f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 23032f7719ceSAndrei Emeltchenko 2304f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 230590338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 230690338947SGustavo Padovan if (IS_ERR(skb)) 230790338947SGustavo Padovan return skb; 23080a708f8fSGustavo F. Padovan 23095e59b791SLuiz Augusto von Dentz skb->priority = priority; 23105e59b791SLuiz Augusto von Dentz 23110a708f8fSGustavo F. Padovan /* Create L2CAP header */ 23120a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2313fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 23146ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 23150a708f8fSGustavo F. Padovan 23160952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 23170a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 23180a708f8fSGustavo F. Padovan kfree_skb(skb); 23190a708f8fSGustavo F. Padovan return ERR_PTR(err); 23200a708f8fSGustavo F. Padovan } 23210a708f8fSGustavo F. Padovan return skb; 23220a708f8fSGustavo F. Padovan } 23230a708f8fSGustavo F. Padovan 2324ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2325ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 232694122bbeSMat Martineau u16 sdulen) 23270a708f8fSGustavo F. Padovan { 23288c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 23290a708f8fSGustavo F. Padovan struct sk_buff *skb; 2330e4ca6d98SAndrei Emeltchenko int err, count, hlen; 23310a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 23320a708f8fSGustavo F. Padovan 2333b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 23340a708f8fSGustavo F. Padovan 23350a708f8fSGustavo F. Padovan if (!conn) 23360a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 23370a708f8fSGustavo F. Padovan 2338ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2339e4ca6d98SAndrei Emeltchenko 23400a708f8fSGustavo F. Padovan if (sdulen) 234103a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 23420a708f8fSGustavo F. Padovan 234347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 234403a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 23450a708f8fSGustavo F. Padovan 23460a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 23472f7719ceSAndrei Emeltchenko 23482f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 234990338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 235090338947SGustavo Padovan if (IS_ERR(skb)) 235190338947SGustavo Padovan return skb; 23520a708f8fSGustavo F. Padovan 23530a708f8fSGustavo F. Padovan /* Create L2CAP header */ 23540a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2355fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 23560a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 235788843ab0SAndrei Emeltchenko 235818a48e76SMat Martineau /* Control header is populated later */ 235918a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 236018a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 236118a48e76SMat Martineau else 236218a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 236388843ab0SAndrei Emeltchenko 23640a708f8fSGustavo F. Padovan if (sdulen) 236503a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 23660a708f8fSGustavo F. Padovan 23670952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 23680a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 23690a708f8fSGustavo F. Padovan kfree_skb(skb); 23700a708f8fSGustavo F. Padovan return ERR_PTR(err); 23710a708f8fSGustavo F. Padovan } 23720a708f8fSGustavo F. Padovan 237318a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 23743ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 23750a708f8fSGustavo F. Padovan return skb; 23760a708f8fSGustavo F. Padovan } 23770a708f8fSGustavo F. Padovan 237894122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 237994122bbeSMat Martineau struct sk_buff_head *seg_queue, 238094122bbeSMat Martineau struct msghdr *msg, size_t len) 23810a708f8fSGustavo F. Padovan { 23820a708f8fSGustavo F. Padovan struct sk_buff *skb; 238394122bbeSMat Martineau u16 sdu_len; 238494122bbeSMat Martineau size_t pdu_len; 238594122bbeSMat Martineau u8 sar; 23860a708f8fSGustavo F. Padovan 2387b4400672SAndrei Emeltchenko BT_DBG("chan %p, msg %p, len %zu", chan, msg, len); 23880a708f8fSGustavo F. Padovan 238994122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 239094122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 239194122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 239294122bbeSMat Martineau */ 239394122bbeSMat Martineau 239494122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 239594122bbeSMat Martineau pdu_len = chan->conn->mtu; 239694122bbeSMat Martineau 2397a549574dSMat Martineau /* Constrain PDU size for BR/EDR connections */ 2398a549574dSMat Martineau if (!chan->hs_hcon) 239994122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 240094122bbeSMat Martineau 240194122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 240235d401dfSGustavo Padovan if (chan->fcs) 240335d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 240435d401dfSGustavo Padovan 2405ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 240694122bbeSMat Martineau 240794122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 240894122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 240994122bbeSMat Martineau 241094122bbeSMat Martineau if (len <= pdu_len) { 241194122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 241294122bbeSMat Martineau sdu_len = 0; 241394122bbeSMat Martineau pdu_len = len; 241494122bbeSMat Martineau } else { 241594122bbeSMat Martineau sar = L2CAP_SAR_START; 241694122bbeSMat Martineau sdu_len = len; 241794122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 241894122bbeSMat Martineau } 24190a708f8fSGustavo F. Padovan 24200a708f8fSGustavo F. Padovan while (len > 0) { 242194122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 24220a708f8fSGustavo F. Padovan 24230a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 242494122bbeSMat Martineau __skb_queue_purge(seg_queue); 24250a708f8fSGustavo F. Padovan return PTR_ERR(skb); 24260a708f8fSGustavo F. Padovan } 24270a708f8fSGustavo F. Padovan 242894122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 242994122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 24300a708f8fSGustavo F. Padovan 243194122bbeSMat Martineau len -= pdu_len; 243294122bbeSMat Martineau if (sdu_len) { 243394122bbeSMat Martineau sdu_len = 0; 243494122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 243594122bbeSMat Martineau } 243694122bbeSMat Martineau 243794122bbeSMat Martineau if (len <= pdu_len) { 243894122bbeSMat Martineau sar = L2CAP_SAR_END; 243994122bbeSMat Martineau pdu_len = len; 244094122bbeSMat Martineau } else { 244194122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 244294122bbeSMat Martineau } 244394122bbeSMat Martineau } 244494122bbeSMat Martineau 2445f0f62799SGustavo Padovan return 0; 24460a708f8fSGustavo F. Padovan } 24470a708f8fSGustavo F. Padovan 24485e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 24495e59b791SLuiz Augusto von Dentz u32 priority) 24509a91a04aSGustavo F. Padovan { 24519a91a04aSGustavo F. Padovan struct sk_buff *skb; 24529a91a04aSGustavo F. Padovan int err; 245394122bbeSMat Martineau struct sk_buff_head seg_queue; 24549a91a04aSGustavo F. Padovan 24559a91a04aSGustavo F. Padovan /* Connectionless channel */ 2456715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 24575e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 24589a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 24599a91a04aSGustavo F. Padovan return PTR_ERR(skb); 24609a91a04aSGustavo F. Padovan 24619a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 24629a91a04aSGustavo F. Padovan return len; 24639a91a04aSGustavo F. Padovan } 24649a91a04aSGustavo F. Padovan 24659a91a04aSGustavo F. Padovan switch (chan->mode) { 24669a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 24679a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 24689a91a04aSGustavo F. Padovan if (len > chan->omtu) 24699a91a04aSGustavo F. Padovan return -EMSGSIZE; 24709a91a04aSGustavo F. Padovan 24719a91a04aSGustavo F. Padovan /* Create a basic PDU */ 24725e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 24739a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 24749a91a04aSGustavo F. Padovan return PTR_ERR(skb); 24759a91a04aSGustavo F. Padovan 24769a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 24779a91a04aSGustavo F. Padovan err = len; 24789a91a04aSGustavo F. Padovan break; 24799a91a04aSGustavo F. Padovan 24809a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 24819a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 248294122bbeSMat Martineau /* Check outgoing MTU */ 248394122bbeSMat Martineau if (len > chan->omtu) { 248494122bbeSMat Martineau err = -EMSGSIZE; 24859a91a04aSGustavo F. Padovan break; 24869a91a04aSGustavo F. Padovan } 24879a91a04aSGustavo F. Padovan 248894122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 248994122bbeSMat Martineau 249094122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 249194122bbeSMat Martineau * since it's possible to block while waiting for memory 249294122bbeSMat Martineau * allocation. 249394122bbeSMat Martineau */ 249494122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 249594122bbeSMat Martineau 249694122bbeSMat Martineau /* The channel could have been closed while segmenting, 249794122bbeSMat Martineau * check that it is still connected. 249894122bbeSMat Martineau */ 249994122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 250094122bbeSMat Martineau __skb_queue_purge(&seg_queue); 250194122bbeSMat Martineau err = -ENOTCONN; 25029a91a04aSGustavo F. Padovan } 25039a91a04aSGustavo F. Padovan 250494122bbeSMat Martineau if (err) 250594122bbeSMat Martineau break; 250694122bbeSMat Martineau 25073733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2508d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 25093733937dSMat Martineau else 2510d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 251194122bbeSMat Martineau 25129a91a04aSGustavo F. Padovan err = len; 25139a91a04aSGustavo F. Padovan 251494122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 251594122bbeSMat Martineau * seg_queue and need to be purged. 251694122bbeSMat Martineau */ 251794122bbeSMat Martineau __skb_queue_purge(&seg_queue); 25189a91a04aSGustavo F. Padovan break; 25199a91a04aSGustavo F. Padovan 25209a91a04aSGustavo F. Padovan default: 25219a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 25229a91a04aSGustavo F. Padovan err = -EBADFD; 25239a91a04aSGustavo F. Padovan } 25249a91a04aSGustavo F. Padovan 25259a91a04aSGustavo F. Padovan return err; 25269a91a04aSGustavo F. Padovan } 25279a91a04aSGustavo F. Padovan 2528d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2529d2a7ac5dSMat Martineau { 2530bed68bdeSMat Martineau struct l2cap_ctrl control; 2531bed68bdeSMat Martineau u16 seq; 2532bed68bdeSMat Martineau 2533b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2534bed68bdeSMat Martineau 2535bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2536bed68bdeSMat Martineau control.sframe = 1; 2537bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2538bed68bdeSMat Martineau 2539bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2540bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2541bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2542bed68bdeSMat Martineau control.reqseq = seq; 2543bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2544bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2545bed68bdeSMat Martineau } 2546bed68bdeSMat Martineau } 2547bed68bdeSMat Martineau 2548bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2549d2a7ac5dSMat Martineau } 2550d2a7ac5dSMat Martineau 2551d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2552d2a7ac5dSMat Martineau { 2553bed68bdeSMat Martineau struct l2cap_ctrl control; 2554bed68bdeSMat Martineau 2555bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2556bed68bdeSMat Martineau 2557bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2558bed68bdeSMat Martineau return; 2559bed68bdeSMat Martineau 2560bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2561bed68bdeSMat Martineau control.sframe = 1; 2562bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2563bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2564bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2565d2a7ac5dSMat Martineau } 2566d2a7ac5dSMat Martineau 2567d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2568d2a7ac5dSMat Martineau { 2569bed68bdeSMat Martineau struct l2cap_ctrl control; 2570bed68bdeSMat Martineau u16 initial_head; 2571bed68bdeSMat Martineau u16 seq; 2572bed68bdeSMat Martineau 2573b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2574bed68bdeSMat Martineau 2575bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2576bed68bdeSMat Martineau control.sframe = 1; 2577bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2578bed68bdeSMat Martineau 2579bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2580bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2581bed68bdeSMat Martineau 2582bed68bdeSMat Martineau do { 2583bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2584bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2585bed68bdeSMat Martineau break; 2586bed68bdeSMat Martineau 2587bed68bdeSMat Martineau control.reqseq = seq; 2588bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2589bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2590bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2591d2a7ac5dSMat Martineau } 2592d2a7ac5dSMat Martineau 2593608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2594608bcc6dSMat Martineau { 2595608bcc6dSMat Martineau struct sk_buff *acked_skb; 2596608bcc6dSMat Martineau u16 ackseq; 2597608bcc6dSMat Martineau 2598b4400672SAndrei Emeltchenko BT_DBG("chan %p, reqseq %u", chan, reqseq); 2599608bcc6dSMat Martineau 2600608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2601608bcc6dSMat Martineau return; 2602608bcc6dSMat Martineau 2603b4400672SAndrei Emeltchenko BT_DBG("expected_ack_seq %u, unacked_frames %u", 2604608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2605608bcc6dSMat Martineau 2606608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2607608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2608608bcc6dSMat Martineau 2609608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2610608bcc6dSMat Martineau if (acked_skb) { 2611608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2612608bcc6dSMat Martineau kfree_skb(acked_skb); 2613608bcc6dSMat Martineau chan->unacked_frames--; 2614608bcc6dSMat Martineau } 2615608bcc6dSMat Martineau } 2616608bcc6dSMat Martineau 2617608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2618608bcc6dSMat Martineau 2619608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2620608bcc6dSMat Martineau __clear_retrans_timer(chan); 2621608bcc6dSMat Martineau 2622b4400672SAndrei Emeltchenko BT_DBG("unacked_frames %u", chan->unacked_frames); 2623608bcc6dSMat Martineau } 2624608bcc6dSMat Martineau 2625608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2626608bcc6dSMat Martineau { 2627608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2628608bcc6dSMat Martineau 2629608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2630608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2631608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2632608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2633608bcc6dSMat Martineau } 2634608bcc6dSMat Martineau 2635d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2636608bcc6dSMat Martineau struct l2cap_ctrl *control, 2637608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2638608bcc6dSMat Martineau { 2639608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2640608bcc6dSMat Martineau event); 2641608bcc6dSMat Martineau 2642608bcc6dSMat Martineau switch (event) { 2643608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2644608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2645608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2646608bcc6dSMat Martineau 2647608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2648608bcc6dSMat Martineau l2cap_ertm_send(chan); 2649608bcc6dSMat Martineau break; 2650608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2651608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2652608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2653608bcc6dSMat Martineau 2654608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2655608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2656608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2657608bcc6dSMat Martineau */ 2658608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2659608bcc6dSMat Martineau } 2660608bcc6dSMat Martineau 2661608bcc6dSMat Martineau l2cap_send_ack(chan); 2662608bcc6dSMat Martineau 2663608bcc6dSMat Martineau break; 2664608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2665608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2666608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2667608bcc6dSMat Martineau 2668608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2669608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2670608bcc6dSMat Martineau 2671608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2672608bcc6dSMat Martineau local_control.sframe = 1; 2673608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2674608bcc6dSMat Martineau local_control.poll = 1; 2675608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2676a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2677608bcc6dSMat Martineau 2678608bcc6dSMat Martineau chan->retry_count = 1; 2679608bcc6dSMat Martineau __set_monitor_timer(chan); 2680608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2681608bcc6dSMat Martineau } 2682608bcc6dSMat Martineau break; 2683608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2684608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2685608bcc6dSMat Martineau break; 2686608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2687608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2688608bcc6dSMat Martineau chan->retry_count = 1; 2689608bcc6dSMat Martineau __set_monitor_timer(chan); 2690608bcc6dSMat Martineau __clear_ack_timer(chan); 2691608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2692608bcc6dSMat Martineau break; 2693608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2694608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2695608bcc6dSMat Martineau chan->retry_count = 1; 2696608bcc6dSMat Martineau __set_monitor_timer(chan); 2697608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2698608bcc6dSMat Martineau break; 2699608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2700608bcc6dSMat Martineau /* Nothing to process */ 2701608bcc6dSMat Martineau break; 2702608bcc6dSMat Martineau default: 2703608bcc6dSMat Martineau break; 2704608bcc6dSMat Martineau } 2705608bcc6dSMat Martineau } 2706608bcc6dSMat Martineau 2707d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2708608bcc6dSMat Martineau struct l2cap_ctrl *control, 2709608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2710608bcc6dSMat Martineau { 2711608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2712608bcc6dSMat Martineau event); 2713608bcc6dSMat Martineau 2714608bcc6dSMat Martineau switch (event) { 2715608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2716608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2717608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2718608bcc6dSMat Martineau /* Queue data, but don't send. */ 2719608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2720608bcc6dSMat Martineau break; 2721608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2722608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2723608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2724608bcc6dSMat Martineau 2725608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2726608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2727608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2728608bcc6dSMat Martineau */ 2729608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2730608bcc6dSMat Martineau } 2731608bcc6dSMat Martineau 2732608bcc6dSMat Martineau l2cap_send_ack(chan); 2733608bcc6dSMat Martineau 2734608bcc6dSMat Martineau break; 2735608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2736608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2737608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2738608bcc6dSMat Martineau 2739608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2740608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2741608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2742608bcc6dSMat Martineau local_control.sframe = 1; 2743608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2744608bcc6dSMat Martineau local_control.poll = 1; 2745608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2746a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2747608bcc6dSMat Martineau 2748608bcc6dSMat Martineau chan->retry_count = 1; 2749608bcc6dSMat Martineau __set_monitor_timer(chan); 2750608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2751608bcc6dSMat Martineau } 2752608bcc6dSMat Martineau break; 2753608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2754608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2755608bcc6dSMat Martineau 2756608bcc6dSMat Martineau /* Fall through */ 2757608bcc6dSMat Martineau 2758608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2759608bcc6dSMat Martineau if (control && control->final) { 2760608bcc6dSMat Martineau __clear_monitor_timer(chan); 2761608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2762608bcc6dSMat Martineau __set_retrans_timer(chan); 2763608bcc6dSMat Martineau chan->retry_count = 0; 2764608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2765608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2766608bcc6dSMat Martineau } 2767608bcc6dSMat Martineau break; 2768608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2769608bcc6dSMat Martineau /* Ignore */ 2770608bcc6dSMat Martineau break; 2771608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2772608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2773608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2774608bcc6dSMat Martineau __set_monitor_timer(chan); 2775608bcc6dSMat Martineau chan->retry_count++; 2776608bcc6dSMat Martineau } else { 27775e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNABORTED); 2778608bcc6dSMat Martineau } 2779608bcc6dSMat Martineau break; 2780608bcc6dSMat Martineau default: 2781608bcc6dSMat Martineau break; 2782608bcc6dSMat Martineau } 2783608bcc6dSMat Martineau } 2784608bcc6dSMat Martineau 2785d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2786608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2787608bcc6dSMat Martineau { 2788608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2789608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2790608bcc6dSMat Martineau 2791608bcc6dSMat Martineau switch (chan->tx_state) { 2792608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2793d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2794608bcc6dSMat Martineau break; 2795608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2796d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2797608bcc6dSMat Martineau break; 2798608bcc6dSMat Martineau default: 2799608bcc6dSMat Martineau /* Ignore event */ 2800608bcc6dSMat Martineau break; 2801608bcc6dSMat Martineau } 2802608bcc6dSMat Martineau } 2803608bcc6dSMat Martineau 28044b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 28054b51dae9SMat Martineau struct l2cap_ctrl *control) 28064b51dae9SMat Martineau { 28074b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2808401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 28094b51dae9SMat Martineau } 28104b51dae9SMat Martineau 2811f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2812f80842a8SMat Martineau struct l2cap_ctrl *control) 2813f80842a8SMat Martineau { 2814f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2815401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2816f80842a8SMat Martineau } 2817f80842a8SMat Martineau 28180a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 28190a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 28200a708f8fSGustavo F. Padovan { 28210a708f8fSGustavo F. Padovan struct sk_buff *nskb; 282248454079SGustavo F. Padovan struct l2cap_chan *chan; 28230a708f8fSGustavo F. Padovan 28240a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 28250a708f8fSGustavo F. Padovan 28263df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 28273d57dc68SGustavo F. Padovan 28283df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 282948454079SGustavo F. Padovan struct sock *sk = chan->sk; 2830715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 28310a708f8fSGustavo F. Padovan continue; 28320a708f8fSGustavo F. Padovan 28330a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 28340a708f8fSGustavo F. Padovan if (skb->sk == sk) 28350a708f8fSGustavo F. Padovan continue; 28368bcde1f2SGustavo Padovan nskb = skb_clone(skb, GFP_KERNEL); 28370a708f8fSGustavo F. Padovan if (!nskb) 28380a708f8fSGustavo F. Padovan continue; 28390a708f8fSGustavo F. Padovan 284080b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 28410a708f8fSGustavo F. Padovan kfree_skb(nskb); 28420a708f8fSGustavo F. Padovan } 28433d57dc68SGustavo F. Padovan 28443df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 28450a708f8fSGustavo F. Padovan } 28460a708f8fSGustavo F. Padovan 28470a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 2848b4400672SAndrei Emeltchenko static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code, 2849b4400672SAndrei Emeltchenko u8 ident, u16 dlen, void *data) 28500a708f8fSGustavo F. Padovan { 28510a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 28520a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 28530a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 28540a708f8fSGustavo F. Padovan int len, count; 28550a708f8fSGustavo F. Padovan 2856b4400672SAndrei Emeltchenko BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u", 28570a708f8fSGustavo F. Padovan conn, code, ident, dlen); 28580a708f8fSGustavo F. Padovan 2859300b962eSAnderson Lizardo if (conn->mtu < L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE) 2860300b962eSAnderson Lizardo return NULL; 2861300b962eSAnderson Lizardo 28620a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 28630a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 28640a708f8fSGustavo F. Padovan 28658bcde1f2SGustavo Padovan skb = bt_skb_alloc(count, GFP_KERNEL); 28660a708f8fSGustavo F. Padovan if (!skb) 28670a708f8fSGustavo F. Padovan return NULL; 28680a708f8fSGustavo F. Padovan 28690a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 28700a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 28713300d9a9SClaudio Takahasi 28723300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2873ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 28743300d9a9SClaudio Takahasi else 2875ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 28760a708f8fSGustavo F. Padovan 28770a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 28780a708f8fSGustavo F. Padovan cmd->code = code; 28790a708f8fSGustavo F. Padovan cmd->ident = ident; 28800a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 28810a708f8fSGustavo F. Padovan 28820a708f8fSGustavo F. Padovan if (dlen) { 28830a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 28840a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 28850a708f8fSGustavo F. Padovan data += count; 28860a708f8fSGustavo F. Padovan } 28870a708f8fSGustavo F. Padovan 28880a708f8fSGustavo F. Padovan len -= skb->len; 28890a708f8fSGustavo F. Padovan 28900a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 28910a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 28920a708f8fSGustavo F. Padovan while (len) { 28930a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 28940a708f8fSGustavo F. Padovan 28958bcde1f2SGustavo Padovan *frag = bt_skb_alloc(count, GFP_KERNEL); 28960a708f8fSGustavo F. Padovan if (!*frag) 28970a708f8fSGustavo F. Padovan goto fail; 28980a708f8fSGustavo F. Padovan 28990a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 29000a708f8fSGustavo F. Padovan 29010a708f8fSGustavo F. Padovan len -= count; 29020a708f8fSGustavo F. Padovan data += count; 29030a708f8fSGustavo F. Padovan 29040a708f8fSGustavo F. Padovan frag = &(*frag)->next; 29050a708f8fSGustavo F. Padovan } 29060a708f8fSGustavo F. Padovan 29070a708f8fSGustavo F. Padovan return skb; 29080a708f8fSGustavo F. Padovan 29090a708f8fSGustavo F. Padovan fail: 29100a708f8fSGustavo F. Padovan kfree_skb(skb); 29110a708f8fSGustavo F. Padovan return NULL; 29120a708f8fSGustavo F. Padovan } 29130a708f8fSGustavo F. Padovan 29142d792818SGustavo Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, 29152d792818SGustavo Padovan unsigned long *val) 29160a708f8fSGustavo F. Padovan { 29170a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 29180a708f8fSGustavo F. Padovan int len; 29190a708f8fSGustavo F. Padovan 29200a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 29210a708f8fSGustavo F. Padovan *ptr += len; 29220a708f8fSGustavo F. Padovan 29230a708f8fSGustavo F. Padovan *type = opt->type; 29240a708f8fSGustavo F. Padovan *olen = opt->len; 29250a708f8fSGustavo F. Padovan 29260a708f8fSGustavo F. Padovan switch (opt->len) { 29270a708f8fSGustavo F. Padovan case 1: 29280a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 29290a708f8fSGustavo F. Padovan break; 29300a708f8fSGustavo F. Padovan 29310a708f8fSGustavo F. Padovan case 2: 29320a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 29330a708f8fSGustavo F. Padovan break; 29340a708f8fSGustavo F. Padovan 29350a708f8fSGustavo F. Padovan case 4: 29360a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 29370a708f8fSGustavo F. Padovan break; 29380a708f8fSGustavo F. Padovan 29390a708f8fSGustavo F. Padovan default: 29400a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 29410a708f8fSGustavo F. Padovan break; 29420a708f8fSGustavo F. Padovan } 29430a708f8fSGustavo F. Padovan 2944b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val); 29450a708f8fSGustavo F. Padovan return len; 29460a708f8fSGustavo F. Padovan } 29470a708f8fSGustavo F. Padovan 29480a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 29490a708f8fSGustavo F. Padovan { 29500a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 29510a708f8fSGustavo F. Padovan 2952b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val); 29530a708f8fSGustavo F. Padovan 29540a708f8fSGustavo F. Padovan opt->type = type; 29550a708f8fSGustavo F. Padovan opt->len = len; 29560a708f8fSGustavo F. Padovan 29570a708f8fSGustavo F. Padovan switch (len) { 29580a708f8fSGustavo F. Padovan case 1: 29590a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 29600a708f8fSGustavo F. Padovan break; 29610a708f8fSGustavo F. Padovan 29620a708f8fSGustavo F. Padovan case 2: 29630a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 29640a708f8fSGustavo F. Padovan break; 29650a708f8fSGustavo F. Padovan 29660a708f8fSGustavo F. Padovan case 4: 29670a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 29680a708f8fSGustavo F. Padovan break; 29690a708f8fSGustavo F. Padovan 29700a708f8fSGustavo F. Padovan default: 29710a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 29720a708f8fSGustavo F. Padovan break; 29730a708f8fSGustavo F. Padovan } 29740a708f8fSGustavo F. Padovan 29750a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 29760a708f8fSGustavo F. Padovan } 29770a708f8fSGustavo F. Padovan 2978f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2979f89cef09SAndrei Emeltchenko { 2980f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2981f89cef09SAndrei Emeltchenko 2982f89cef09SAndrei Emeltchenko switch (chan->mode) { 2983f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2984f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2985f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2986f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2987f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2988ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 29898936fa6dSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_EFS_DEFAULT_FLUSH_TO); 2990f89cef09SAndrei Emeltchenko break; 2991f89cef09SAndrei Emeltchenko 2992f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2993f89cef09SAndrei Emeltchenko efs.id = 1; 2994f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2995f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2996f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2997f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2998f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2999f89cef09SAndrei Emeltchenko break; 3000f89cef09SAndrei Emeltchenko 3001f89cef09SAndrei Emeltchenko default: 3002f89cef09SAndrei Emeltchenko return; 3003f89cef09SAndrei Emeltchenko } 3004f89cef09SAndrei Emeltchenko 3005f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 3006f89cef09SAndrei Emeltchenko (unsigned long) &efs); 3007f89cef09SAndrei Emeltchenko } 3008f89cef09SAndrei Emeltchenko 3009721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 30100a708f8fSGustavo F. Padovan { 3011721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 3012721c4181SGustavo F. Padovan ack_timer.work); 30130362520bSMat Martineau u16 frames_to_ack; 30140a708f8fSGustavo F. Padovan 30152fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 30162fb9b3d4SGustavo F. Padovan 30176be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 30186be36555SAndrei Emeltchenko 30190362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 30200362520bSMat Martineau chan->last_acked_seq); 30210362520bSMat Martineau 30220362520bSMat Martineau if (frames_to_ack) 30230362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 30246be36555SAndrei Emeltchenko 30256be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 302609bfb2eeSSzymon Janc l2cap_chan_put(chan); 30270a708f8fSGustavo F. Padovan } 30280a708f8fSGustavo F. Padovan 3029466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 30300a708f8fSGustavo F. Padovan { 30313c588192SMat Martineau int err; 30323c588192SMat Martineau 3033105bdf9eSMat Martineau chan->next_tx_seq = 0; 3034105bdf9eSMat Martineau chan->expected_tx_seq = 0; 303542e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 30366a026610SGustavo F. Padovan chan->unacked_frames = 0; 303742e5c802SGustavo F. Padovan chan->buffer_seq = 0; 30386a026610SGustavo F. Padovan chan->frames_sent = 0; 3039105bdf9eSMat Martineau chan->last_acked_seq = 0; 3040105bdf9eSMat Martineau chan->sdu = NULL; 3041105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 3042105bdf9eSMat Martineau chan->sdu_len = 0; 3043105bdf9eSMat Martineau 3044d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 3045d34c34fbSMat Martineau 304608333283SMat Martineau chan->local_amp_id = 0; 304708333283SMat Martineau chan->move_id = 0; 304808333283SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 304908333283SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 305008333283SMat Martineau 3051105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 3052105bdf9eSMat Martineau return 0; 3053105bdf9eSMat Martineau 3054105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 3055105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 30560a708f8fSGustavo F. Padovan 3057721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 3058721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 3059721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 30600a708f8fSGustavo F. Padovan 3061f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 30620a708f8fSGustavo F. Padovan 30633c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 30643c588192SMat Martineau if (err < 0) 30653c588192SMat Martineau return err; 30663c588192SMat Martineau 30679dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 30689dc9affcSMat Martineau if (err < 0) 30699dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 30709dc9affcSMat Martineau 30719dc9affcSMat Martineau return err; 30720a708f8fSGustavo F. Padovan } 30730a708f8fSGustavo F. Padovan 30740a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 30750a708f8fSGustavo F. Padovan { 30760a708f8fSGustavo F. Padovan switch (mode) { 30770a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 30780a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30790a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 30800a708f8fSGustavo F. Padovan return mode; 30810a708f8fSGustavo F. Padovan /* fall through */ 30820a708f8fSGustavo F. Padovan default: 30830a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 30840a708f8fSGustavo F. Padovan } 30850a708f8fSGustavo F. Padovan } 30860a708f8fSGustavo F. Padovan 30876327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 30886327eb98SAndrei Emeltchenko { 30896327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 30906327eb98SAndrei Emeltchenko } 30916327eb98SAndrei Emeltchenko 3092f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 3093f89cef09SAndrei Emeltchenko { 3094f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 3095f89cef09SAndrei Emeltchenko } 3096f89cef09SAndrei Emeltchenko 309736c86c85SMat Martineau static void __l2cap_set_ertm_timeouts(struct l2cap_chan *chan, 309836c86c85SMat Martineau struct l2cap_conf_rfc *rfc) 309936c86c85SMat Martineau { 310036c86c85SMat Martineau if (chan->local_amp_id && chan->hs_hcon) { 310136c86c85SMat Martineau u64 ertm_to = chan->hs_hcon->hdev->amp_be_flush_to; 310236c86c85SMat Martineau 310336c86c85SMat Martineau /* Class 1 devices have must have ERTM timeouts 310436c86c85SMat Martineau * exceeding the Link Supervision Timeout. The 310536c86c85SMat Martineau * default Link Supervision Timeout for AMP 310636c86c85SMat Martineau * controllers is 10 seconds. 310736c86c85SMat Martineau * 310836c86c85SMat Martineau * Class 1 devices use 0xffffffff for their 310936c86c85SMat Martineau * best-effort flush timeout, so the clamping logic 311036c86c85SMat Martineau * will result in a timeout that meets the above 311136c86c85SMat Martineau * requirement. ERTM timeouts are 16-bit values, so 311236c86c85SMat Martineau * the maximum timeout is 65.535 seconds. 311336c86c85SMat Martineau */ 311436c86c85SMat Martineau 311536c86c85SMat Martineau /* Convert timeout to milliseconds and round */ 311636c86c85SMat Martineau ertm_to = DIV_ROUND_UP_ULL(ertm_to, 1000); 311736c86c85SMat Martineau 311836c86c85SMat Martineau /* This is the recommended formula for class 2 devices 311936c86c85SMat Martineau * that start ERTM timers when packets are sent to the 312036c86c85SMat Martineau * controller. 312136c86c85SMat Martineau */ 312236c86c85SMat Martineau ertm_to = 3 * ertm_to + 500; 312336c86c85SMat Martineau 312436c86c85SMat Martineau if (ertm_to > 0xffff) 312536c86c85SMat Martineau ertm_to = 0xffff; 312636c86c85SMat Martineau 312736c86c85SMat Martineau rfc->retrans_timeout = cpu_to_le16((u16) ertm_to); 312836c86c85SMat Martineau rfc->monitor_timeout = rfc->retrans_timeout; 312936c86c85SMat Martineau } else { 313036c86c85SMat Martineau rfc->retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 313136c86c85SMat Martineau rfc->monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 313236c86c85SMat Martineau } 313336c86c85SMat Martineau } 313436c86c85SMat Martineau 31356327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 31366327eb98SAndrei Emeltchenko { 31376327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 3138836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 31396327eb98SAndrei Emeltchenko /* use extended control field */ 31406327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 3141836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 3142836be934SAndrei Emeltchenko } else { 31436327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 31446327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 3145836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 3146836be934SAndrei Emeltchenko } 3147c20f8e35SMat Martineau chan->ack_win = chan->tx_win; 31486327eb98SAndrei Emeltchenko } 31496327eb98SAndrei Emeltchenko 3150710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 31510a708f8fSGustavo F. Padovan { 31520a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 31530c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 31540a708f8fSGustavo F. Padovan void *ptr = req->data; 3155c8f79162SAndrei Emeltchenko u16 size; 31560a708f8fSGustavo F. Padovan 315749208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 31580a708f8fSGustavo F. Padovan 315973ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 31600a708f8fSGustavo F. Padovan goto done; 31610a708f8fSGustavo F. Padovan 31620c1bc5c6SGustavo F. Padovan switch (chan->mode) { 31630a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 31640a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3165c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 31660a708f8fSGustavo F. Padovan break; 31670a708f8fSGustavo F. Padovan 3168f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 3169f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 3170f89cef09SAndrei Emeltchenko 31710a708f8fSGustavo F. Padovan /* fall through */ 31720a708f8fSGustavo F. Padovan default: 31738c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 31740a708f8fSGustavo F. Padovan break; 31750a708f8fSGustavo F. Padovan } 31760a708f8fSGustavo F. Padovan 31770a708f8fSGustavo F. Padovan done: 31780c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 31790c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 31800a708f8fSGustavo F. Padovan 31810c1bc5c6SGustavo F. Padovan switch (chan->mode) { 31820a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 31838c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 31848c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 31850a708f8fSGustavo F. Padovan break; 31860a708f8fSGustavo F. Padovan 31870a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 31880a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 31890a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 31900a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 31910a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 31920a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 31930a708f8fSGustavo F. Padovan 31940a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 31950a708f8fSGustavo F. Padovan (unsigned long) &rfc); 31960a708f8fSGustavo F. Padovan break; 31970a708f8fSGustavo F. Padovan 31980a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 31990a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 320047d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 320136c86c85SMat Martineau 320236c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 3203c8f79162SAndrei Emeltchenko 3204c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 32052d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3206c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3207c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 32080a708f8fSGustavo F. Padovan 32096327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 32106327eb98SAndrei Emeltchenko 32116327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 32126327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 32130a708f8fSGustavo F. Padovan 32140a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 32150a708f8fSGustavo F. Padovan (unsigned long) &rfc); 32160a708f8fSGustavo F. Padovan 3217f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3218f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3219f89cef09SAndrei Emeltchenko 32206327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 32216327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 32226327eb98SAndrei Emeltchenko chan->tx_win); 322360918918SAndrei Emeltchenko 322460918918SAndrei Emeltchenko if (chan->conn->feat_mask & L2CAP_FEAT_FCS) 322560918918SAndrei Emeltchenko if (chan->fcs == L2CAP_FCS_NONE || 3226f2592d3eSAndrei Emeltchenko test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) { 322760918918SAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 322860918918SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, 322960918918SAndrei Emeltchenko chan->fcs); 323060918918SAndrei Emeltchenko } 32310a708f8fSGustavo F. Padovan break; 32320a708f8fSGustavo F. Padovan 32330a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3234273759e2SMat Martineau l2cap_txwin_setup(chan); 32350a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 32360a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 32370a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 32380a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 32390a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 3240c8f79162SAndrei Emeltchenko 3241c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 32422d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3243c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3244c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 32450a708f8fSGustavo F. Padovan 32460a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 32470a708f8fSGustavo F. Padovan (unsigned long) &rfc); 32480a708f8fSGustavo F. Padovan 3249f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3250f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3251f89cef09SAndrei Emeltchenko 325260918918SAndrei Emeltchenko if (chan->conn->feat_mask & L2CAP_FEAT_FCS) 325347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 3254f2592d3eSAndrei Emeltchenko test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) { 325547d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 325660918918SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, 325760918918SAndrei Emeltchenko chan->fcs); 32580a708f8fSGustavo F. Padovan } 32590a708f8fSGustavo F. Padovan break; 32600a708f8fSGustavo F. Padovan } 32610a708f8fSGustavo F. Padovan 3262fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 326359e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 32640a708f8fSGustavo F. Padovan 32650a708f8fSGustavo F. Padovan return ptr - data; 32660a708f8fSGustavo F. Padovan } 32670a708f8fSGustavo F. Padovan 326873ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 32690a708f8fSGustavo F. Padovan { 32700a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 32710a708f8fSGustavo F. Padovan void *ptr = rsp->data; 327273ffa904SGustavo F. Padovan void *req = chan->conf_req; 327373ffa904SGustavo F. Padovan int len = chan->conf_len; 32740a708f8fSGustavo F. Padovan int type, hint, olen; 32750a708f8fSGustavo F. Padovan unsigned long val; 32760a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 327742dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 327842dceae2SAndrei Emeltchenko u8 remote_efs = 0; 32790a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 32800a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 3281c8f79162SAndrei Emeltchenko u16 size; 32820a708f8fSGustavo F. Padovan 328373ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 32840a708f8fSGustavo F. Padovan 32850a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32860a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 32870a708f8fSGustavo F. Padovan 32880a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 32890a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 32900a708f8fSGustavo F. Padovan 32910a708f8fSGustavo F. Padovan switch (type) { 32920a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 32930a708f8fSGustavo F. Padovan mtu = val; 32940a708f8fSGustavo F. Padovan break; 32950a708f8fSGustavo F. Padovan 32960a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 32970c1bc5c6SGustavo F. Padovan chan->flush_to = val; 32980a708f8fSGustavo F. Padovan break; 32990a708f8fSGustavo F. Padovan 33000a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 33010a708f8fSGustavo F. Padovan break; 33020a708f8fSGustavo F. Padovan 33030a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 33040a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 33050a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 33060a708f8fSGustavo F. Padovan break; 33070a708f8fSGustavo F. Padovan 33080a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 33090a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 3310f2592d3eSAndrei Emeltchenko set_bit(CONF_RECV_NO_FCS, &chan->conf_state); 331142dceae2SAndrei Emeltchenko break; 33120a708f8fSGustavo F. Padovan 331342dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 331442dceae2SAndrei Emeltchenko remote_efs = 1; 331542dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 331642dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 33170a708f8fSGustavo F. Padovan break; 33180a708f8fSGustavo F. Padovan 33196327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 33206327eb98SAndrei Emeltchenko if (!enable_hs) 33216327eb98SAndrei Emeltchenko return -ECONNREFUSED; 33226327eb98SAndrei Emeltchenko 33236327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 33246327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 3325836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 33266327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 33270a708f8fSGustavo F. Padovan break; 33280a708f8fSGustavo F. Padovan 33290a708f8fSGustavo F. Padovan default: 33300a708f8fSGustavo F. Padovan if (hint) 33310a708f8fSGustavo F. Padovan break; 33320a708f8fSGustavo F. Padovan 33330a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 33340a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 33350a708f8fSGustavo F. Padovan break; 33360a708f8fSGustavo F. Padovan } 33370a708f8fSGustavo F. Padovan } 33380a708f8fSGustavo F. Padovan 333973ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 33400a708f8fSGustavo F. Padovan goto done; 33410a708f8fSGustavo F. Padovan 33420c1bc5c6SGustavo F. Padovan switch (chan->mode) { 33430a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 33440a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3345c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 33460c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 33478c1d787bSGustavo F. Padovan chan->conn->feat_mask); 33480a708f8fSGustavo F. Padovan break; 33490a708f8fSGustavo F. Padovan } 33500a708f8fSGustavo F. Padovan 335142dceae2SAndrei Emeltchenko if (remote_efs) { 335242dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 335342dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 335442dceae2SAndrei Emeltchenko else 335542dceae2SAndrei Emeltchenko return -ECONNREFUSED; 335642dceae2SAndrei Emeltchenko } 335742dceae2SAndrei Emeltchenko 33580c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 33590a708f8fSGustavo F. Padovan return -ECONNREFUSED; 33600a708f8fSGustavo F. Padovan 33610a708f8fSGustavo F. Padovan break; 33620a708f8fSGustavo F. Padovan } 33630a708f8fSGustavo F. Padovan 33640a708f8fSGustavo F. Padovan done: 33650c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 33660a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 33670c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 33680a708f8fSGustavo F. Padovan 336973ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 33700a708f8fSGustavo F. Padovan return -ECONNREFUSED; 33710a708f8fSGustavo F. Padovan 33722d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 33732d792818SGustavo Padovan (unsigned long) &rfc); 33740a708f8fSGustavo F. Padovan } 33750a708f8fSGustavo F. Padovan 33760a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 33770a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 33780a708f8fSGustavo F. Padovan * which ones we don't like. */ 33790a708f8fSGustavo F. Padovan 33800a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 33810a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 33820a708f8fSGustavo F. Padovan else { 33830c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3384c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 33850a708f8fSGustavo F. Padovan } 33860c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 33870a708f8fSGustavo F. Padovan 338842dceae2SAndrei Emeltchenko if (remote_efs) { 338942dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 339042dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 339142dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 339242dceae2SAndrei Emeltchenko 339342dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 339442dceae2SAndrei Emeltchenko 339542dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 339642dceae2SAndrei Emeltchenko return -ECONNREFUSED; 339742dceae2SAndrei Emeltchenko 339842dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 339942dceae2SAndrei Emeltchenko sizeof(efs), 340042dceae2SAndrei Emeltchenko (unsigned long) &efs); 34010e8b207eSAndrei Emeltchenko } else { 34023e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 34030e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 34040e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 340542dceae2SAndrei Emeltchenko } 340642dceae2SAndrei Emeltchenko } 340742dceae2SAndrei Emeltchenko 34080a708f8fSGustavo F. Padovan switch (rfc.mode) { 34090a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 341047d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3411c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 34120a708f8fSGustavo F. Padovan break; 34130a708f8fSGustavo F. Padovan 34140a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 34156327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 34162c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 34176327eb98SAndrei Emeltchenko else 34186327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 34196327eb98SAndrei Emeltchenko 34202c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 34210a708f8fSGustavo F. Padovan 3422c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 34232d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 34242d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3425c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3426c8f79162SAndrei Emeltchenko chan->remote_mps = size; 34270a708f8fSGustavo F. Padovan 342836c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 34290a708f8fSGustavo F. Padovan 3430c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 34310a708f8fSGustavo F. Padovan 34320a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 34330a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 34340a708f8fSGustavo F. Padovan 343542dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 343642dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 343742dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 343842dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 343942dceae2SAndrei Emeltchenko chan->remote_flush_to = 344042dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 344142dceae2SAndrei Emeltchenko chan->remote_acc_lat = 344242dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 344342dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 344442dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 344542dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 34462d792818SGustavo Padovan sizeof(efs), 34472d792818SGustavo Padovan (unsigned long) &efs); 344842dceae2SAndrei Emeltchenko } 34490a708f8fSGustavo F. Padovan break; 34500a708f8fSGustavo F. Padovan 34510a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3452c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 34532d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 34542d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3455c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3456c8f79162SAndrei Emeltchenko chan->remote_mps = size; 34570a708f8fSGustavo F. Padovan 3458c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 34590a708f8fSGustavo F. Padovan 34602d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 34612d792818SGustavo Padovan (unsigned long) &rfc); 34620a708f8fSGustavo F. Padovan 34630a708f8fSGustavo F. Padovan break; 34640a708f8fSGustavo F. Padovan 34650a708f8fSGustavo F. Padovan default: 34660a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 34670a708f8fSGustavo F. Padovan 34680a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 34690c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 34700a708f8fSGustavo F. Padovan } 34710a708f8fSGustavo F. Padovan 34720a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3473c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 34740a708f8fSGustavo F. Padovan } 3475fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 34760a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 347759e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 34780a708f8fSGustavo F. Padovan 34790a708f8fSGustavo F. Padovan return ptr - data; 34800a708f8fSGustavo F. Padovan } 34810a708f8fSGustavo F. Padovan 34822d792818SGustavo Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, 34832d792818SGustavo Padovan void *data, u16 *result) 34840a708f8fSGustavo F. Padovan { 34850a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 34860a708f8fSGustavo F. Padovan void *ptr = req->data; 34870a708f8fSGustavo F. Padovan int type, olen; 34880a708f8fSGustavo F. Padovan unsigned long val; 348936e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 349066af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 34910a708f8fSGustavo F. Padovan 3492fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 34930a708f8fSGustavo F. Padovan 34940a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 34950a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 34960a708f8fSGustavo F. Padovan 34970a708f8fSGustavo F. Padovan switch (type) { 34980a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 34990a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 35000a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 35010c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 35020a708f8fSGustavo F. Padovan } else 35030c1bc5c6SGustavo F. Padovan chan->imtu = val; 35040c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 35050a708f8fSGustavo F. Padovan break; 35060a708f8fSGustavo F. Padovan 35070a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 35080c1bc5c6SGustavo F. Padovan chan->flush_to = val; 35090a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 35100c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 35110a708f8fSGustavo F. Padovan break; 35120a708f8fSGustavo F. Padovan 35130a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 35140a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 35150a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 35160a708f8fSGustavo F. Padovan 3517c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 35180c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 35190a708f8fSGustavo F. Padovan return -ECONNREFUSED; 35200a708f8fSGustavo F. Padovan 352147d1ec61SGustavo F. Padovan chan->fcs = 0; 35220a708f8fSGustavo F. Padovan 35230a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 35240a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 35250a708f8fSGustavo F. Padovan break; 35266327eb98SAndrei Emeltchenko 35276327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 3528c20f8e35SMat Martineau chan->ack_win = min_t(u16, val, chan->ack_win); 35293e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 35303e6b3b95SGustavo F. Padovan chan->tx_win); 35316327eb98SAndrei Emeltchenko break; 353266af7aafSAndrei Emeltchenko 353366af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 353466af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 353566af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 353666af7aafSAndrei Emeltchenko 353766af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 353866af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 353966af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 354066af7aafSAndrei Emeltchenko return -ECONNREFUSED; 354166af7aafSAndrei Emeltchenko 35422d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, sizeof(efs), 35432d792818SGustavo Padovan (unsigned long) &efs); 354466af7aafSAndrei Emeltchenko break; 3545cbabee78SAndrei Emeltchenko 3546cbabee78SAndrei Emeltchenko case L2CAP_CONF_FCS: 3547cbabee78SAndrei Emeltchenko if (*result == L2CAP_CONF_PENDING) 3548cbabee78SAndrei Emeltchenko if (val == L2CAP_FCS_NONE) 3549f2592d3eSAndrei Emeltchenko set_bit(CONF_RECV_NO_FCS, 3550cbabee78SAndrei Emeltchenko &chan->conf_state); 3551cbabee78SAndrei Emeltchenko break; 35520a708f8fSGustavo F. Padovan } 35530a708f8fSGustavo F. Padovan } 35540a708f8fSGustavo F. Padovan 35550c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 35560a708f8fSGustavo F. Padovan return -ECONNREFUSED; 35570a708f8fSGustavo F. Padovan 35580c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 35590a708f8fSGustavo F. Padovan 35600e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 35610a708f8fSGustavo F. Padovan switch (rfc.mode) { 35620a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 356347d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 356447d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 356547d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3566c20f8e35SMat Martineau if (!test_bit(FLAG_EXT_CTRL, &chan->flags)) 3567c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3568c20f8e35SMat Martineau rfc.txwin_size); 356966af7aafSAndrei Emeltchenko 357066af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 357166af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 357266af7aafSAndrei Emeltchenko chan->local_sdu_itime = 357366af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 357466af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 357566af7aafSAndrei Emeltchenko chan->local_flush_to = 357666af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 357766af7aafSAndrei Emeltchenko } 35780a708f8fSGustavo F. Padovan break; 357966af7aafSAndrei Emeltchenko 35800a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 358147d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 35820a708f8fSGustavo F. Padovan } 35830a708f8fSGustavo F. Padovan } 35840a708f8fSGustavo F. Padovan 3585fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 358659e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 35870a708f8fSGustavo F. Padovan 35880a708f8fSGustavo F. Padovan return ptr - data; 35890a708f8fSGustavo F. Padovan } 35900a708f8fSGustavo F. Padovan 35912d792818SGustavo Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, 35922d792818SGustavo Padovan u16 result, u16 flags) 35930a708f8fSGustavo F. Padovan { 35940a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 35950a708f8fSGustavo F. Padovan void *ptr = rsp->data; 35960a708f8fSGustavo F. Padovan 3597fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 35980a708f8fSGustavo F. Padovan 3599fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 36000a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 36010a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 36020a708f8fSGustavo F. Padovan 36030a708f8fSGustavo F. Padovan return ptr - data; 36040a708f8fSGustavo F. Padovan } 36050a708f8fSGustavo F. Padovan 36068c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3607710f9b0aSGustavo F. Padovan { 3608710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 36098c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3610710f9b0aSGustavo F. Padovan u8 buf[128]; 3611439f34acSAndrei Emeltchenko u8 rsp_code; 3612710f9b0aSGustavo F. Padovan 3613fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3614fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3615ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3616ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3617439f34acSAndrei Emeltchenko 3618439f34acSAndrei Emeltchenko if (chan->hs_hcon) 3619439f34acSAndrei Emeltchenko rsp_code = L2CAP_CREATE_CHAN_RSP; 3620439f34acSAndrei Emeltchenko else 3621439f34acSAndrei Emeltchenko rsp_code = L2CAP_CONN_RSP; 3622439f34acSAndrei Emeltchenko 3623439f34acSAndrei Emeltchenko BT_DBG("chan %p rsp_code %u", chan, rsp_code); 3624439f34acSAndrei Emeltchenko 3625439f34acSAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, rsp_code, sizeof(rsp), &rsp); 3626710f9b0aSGustavo F. Padovan 3627c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3628710f9b0aSGustavo F. Padovan return; 3629710f9b0aSGustavo F. Padovan 3630710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3631710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3632710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3633710f9b0aSGustavo F. Padovan } 3634710f9b0aSGustavo F. Padovan 363547d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 36360a708f8fSGustavo F. Padovan { 36370a708f8fSGustavo F. Padovan int type, olen; 36380a708f8fSGustavo F. Padovan unsigned long val; 3639c20f8e35SMat Martineau /* Use sane default values in case a misbehaving remote device 3640c20f8e35SMat Martineau * did not send an RFC or extended window size option. 3641c20f8e35SMat Martineau */ 3642c20f8e35SMat Martineau u16 txwin_ext = chan->ack_win; 3643c20f8e35SMat Martineau struct l2cap_conf_rfc rfc = { 3644c20f8e35SMat Martineau .mode = chan->mode, 3645c20f8e35SMat Martineau .retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO), 3646c20f8e35SMat Martineau .monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO), 3647c20f8e35SMat Martineau .max_pdu_size = cpu_to_le16(chan->imtu), 3648c20f8e35SMat Martineau .txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW), 3649c20f8e35SMat Martineau }; 36500a708f8fSGustavo F. Padovan 365147d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 36520a708f8fSGustavo F. Padovan 36530c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 36540a708f8fSGustavo F. Padovan return; 36550a708f8fSGustavo F. Padovan 36560a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 36570a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 36580a708f8fSGustavo F. Padovan 3659c20f8e35SMat Martineau switch (type) { 3660c20f8e35SMat Martineau case L2CAP_CONF_RFC: 3661c20f8e35SMat Martineau if (olen == sizeof(rfc)) 36620a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 3663c20f8e35SMat Martineau break; 3664c20f8e35SMat Martineau case L2CAP_CONF_EWS: 3665c20f8e35SMat Martineau txwin_ext = val; 3666c20f8e35SMat Martineau break; 3667c20f8e35SMat Martineau } 36680a708f8fSGustavo F. Padovan } 36690a708f8fSGustavo F. Padovan 36700a708f8fSGustavo F. Padovan switch (rfc.mode) { 36710a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 367247d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 367347d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 367447d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3675c20f8e35SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 3676c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, txwin_ext); 3677c20f8e35SMat Martineau else 3678c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3679c20f8e35SMat Martineau rfc.txwin_size); 36800a708f8fSGustavo F. Padovan break; 36810a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 368247d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 36830a708f8fSGustavo F. Padovan } 36840a708f8fSGustavo F. Padovan } 36850a708f8fSGustavo F. Padovan 36862d792818SGustavo Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, 3687cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3688cb3b3152SJohan Hedberg u8 *data) 36890a708f8fSGustavo F. Padovan { 3690e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 36910a708f8fSGustavo F. Padovan 3692cb3b3152SJohan Hedberg if (cmd_len < sizeof(*rej)) 3693cb3b3152SJohan Hedberg return -EPROTO; 3694cb3b3152SJohan Hedberg 3695e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 36960a708f8fSGustavo F. Padovan return 0; 36970a708f8fSGustavo F. Padovan 36980a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 36990a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 370017cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 37010a708f8fSGustavo F. Padovan 37020a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 37030a708f8fSGustavo F. Padovan conn->info_ident = 0; 37040a708f8fSGustavo F. Padovan 37050a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 37060a708f8fSGustavo F. Padovan } 37070a708f8fSGustavo F. Padovan 37080a708f8fSGustavo F. Padovan return 0; 37090a708f8fSGustavo F. Padovan } 37100a708f8fSGustavo F. Padovan 37111700915fSMat Martineau static struct l2cap_chan *l2cap_connect(struct l2cap_conn *conn, 37121700915fSMat Martineau struct l2cap_cmd_hdr *cmd, 37134c89b6aaSMat Martineau u8 *data, u8 rsp_code, u8 amp_id) 37140a708f8fSGustavo F. Padovan { 37150a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 37160a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 371723691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 37180a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 37190a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 37200a708f8fSGustavo F. Padovan 37210a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 37220a708f8fSGustavo F. Padovan __le16 psm = req->psm; 37230a708f8fSGustavo F. Padovan 3724097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 37250a708f8fSGustavo F. Padovan 37260a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3727c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 372823691d75SGustavo F. Padovan if (!pchan) { 37290a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 37300a708f8fSGustavo F. Padovan goto sendresp; 37310a708f8fSGustavo F. Padovan } 37320a708f8fSGustavo F. Padovan 373323691d75SGustavo F. Padovan parent = pchan->sk; 373423691d75SGustavo F. Padovan 37353df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3736aa2ac881SGustavo F. Padovan lock_sock(parent); 37370a708f8fSGustavo F. Padovan 37380a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 37392983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 37400a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 37419f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 37420a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 37430a708f8fSGustavo F. Padovan goto response; 37440a708f8fSGustavo F. Padovan } 37450a708f8fSGustavo F. Padovan 37460a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 37470a708f8fSGustavo F. Padovan 37482dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 37492dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 37502dfa1003SGustavo Padovan goto response; 37512dfa1003SGustavo Padovan 375280b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 375380808e43SGustavo F. Padovan if (!chan) 37540a708f8fSGustavo F. Padovan goto response; 37550a708f8fSGustavo F. Padovan 375680808e43SGustavo F. Padovan sk = chan->sk; 375780808e43SGustavo F. Padovan 37580a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 37590a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3760fe4128e0SGustavo F. Padovan chan->psm = psm; 3761fe4128e0SGustavo F. Padovan chan->dcid = scid; 37621700915fSMat Martineau chan->local_amp_id = amp_id; 37630a708f8fSGustavo F. Padovan 37646be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 376548454079SGustavo F. Padovan 3766fe4128e0SGustavo F. Padovan dcid = chan->scid; 37670a708f8fSGustavo F. Padovan 3768c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 37690a708f8fSGustavo F. Padovan 3770fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 37710a708f8fSGustavo F. Padovan 37720a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3773d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3774c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 37750e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 37760a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 37770a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 37782dc4e510SGustavo Padovan chan->ops->defer(chan); 37790a708f8fSGustavo F. Padovan } else { 37801700915fSMat Martineau /* Force pending result for AMP controllers. 37811700915fSMat Martineau * The connection will succeed after the 37821700915fSMat Martineau * physical link is up. 37831700915fSMat Martineau */ 37841700915fSMat Martineau if (amp_id) { 37851700915fSMat Martineau __l2cap_state_change(chan, BT_CONNECT2); 37861700915fSMat Martineau result = L2CAP_CR_PEND; 37871700915fSMat Martineau } else { 37880e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 37890a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 37901700915fSMat Martineau } 37910a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 37920a708f8fSGustavo F. Padovan } 37930a708f8fSGustavo F. Padovan } else { 37940e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 37950a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 37960a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 37970a708f8fSGustavo F. Padovan } 37980a708f8fSGustavo F. Padovan } else { 37990e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 38000a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 38010a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 38020a708f8fSGustavo F. Padovan } 38030a708f8fSGustavo F. Padovan 38040a708f8fSGustavo F. Padovan response: 3805aa2ac881SGustavo F. Padovan release_sock(parent); 38063df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38070a708f8fSGustavo F. Padovan 38080a708f8fSGustavo F. Padovan sendresp: 38090a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 38100a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 38110a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 38120a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 38134c89b6aaSMat Martineau l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp); 38140a708f8fSGustavo F. Padovan 38150a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 38160a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3817ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 38180a708f8fSGustavo F. Padovan 38190a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 38200a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 38210a708f8fSGustavo F. Padovan 3822ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 38230a708f8fSGustavo F. Padovan 38242d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 38252d792818SGustavo Padovan sizeof(info), &info); 38260a708f8fSGustavo F. Padovan } 38270a708f8fSGustavo F. Padovan 3828c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 38290a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 38300a708f8fSGustavo F. Padovan u8 buf[128]; 3831c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 38320a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 383373ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 383473ffa904SGustavo F. Padovan chan->num_conf_req++; 38350a708f8fSGustavo F. Padovan } 38361700915fSMat Martineau 38371700915fSMat Martineau return chan; 38384c89b6aaSMat Martineau } 38390a708f8fSGustavo F. Padovan 38404c89b6aaSMat Martineau static int l2cap_connect_req(struct l2cap_conn *conn, 3841cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 38424c89b6aaSMat Martineau { 38437b064edaSJaganath Kanakkassery struct hci_dev *hdev = conn->hcon->hdev; 38447b064edaSJaganath Kanakkassery struct hci_conn *hcon = conn->hcon; 38457b064edaSJaganath Kanakkassery 3846cb3b3152SJohan Hedberg if (cmd_len < sizeof(struct l2cap_conn_req)) 3847cb3b3152SJohan Hedberg return -EPROTO; 3848cb3b3152SJohan Hedberg 38497b064edaSJaganath Kanakkassery hci_dev_lock(hdev); 38507b064edaSJaganath Kanakkassery if (test_bit(HCI_MGMT, &hdev->dev_flags) && 38517b064edaSJaganath Kanakkassery !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &hcon->flags)) 38527b064edaSJaganath Kanakkassery mgmt_device_connected(hdev, &hcon->dst, hcon->type, 38537b064edaSJaganath Kanakkassery hcon->dst_type, 0, NULL, 0, 38547b064edaSJaganath Kanakkassery hcon->dev_class); 38557b064edaSJaganath Kanakkassery hci_dev_unlock(hdev); 38567b064edaSJaganath Kanakkassery 3857300229f9SGustavo Padovan l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP, 0); 38580a708f8fSGustavo F. Padovan return 0; 38590a708f8fSGustavo F. Padovan } 38600a708f8fSGustavo F. Padovan 38615909cf30SMat Martineau static int l2cap_connect_create_rsp(struct l2cap_conn *conn, 3862cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3863cb3b3152SJohan Hedberg u8 *data) 38640a708f8fSGustavo F. Padovan { 38650a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 38660a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 386748454079SGustavo F. Padovan struct l2cap_chan *chan; 38680a708f8fSGustavo F. Padovan u8 req[128]; 38693df91ea2SAndrei Emeltchenko int err; 38700a708f8fSGustavo F. Padovan 3871cb3b3152SJohan Hedberg if (cmd_len < sizeof(*rsp)) 3872cb3b3152SJohan Hedberg return -EPROTO; 3873cb3b3152SJohan Hedberg 38740a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 38750a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 38760a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 38770a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 38780a708f8fSGustavo F. Padovan 38791b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 38801b009c98SAndrei Emeltchenko dcid, scid, result, status); 38810a708f8fSGustavo F. Padovan 38823df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 38833df91ea2SAndrei Emeltchenko 38840a708f8fSGustavo F. Padovan if (scid) { 38853df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 38863df91ea2SAndrei Emeltchenko if (!chan) { 388721870b52SJohan Hedberg err = -EBADSLT; 38883df91ea2SAndrei Emeltchenko goto unlock; 38893df91ea2SAndrei Emeltchenko } 38900a708f8fSGustavo F. Padovan } else { 38913df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 38923df91ea2SAndrei Emeltchenko if (!chan) { 389321870b52SJohan Hedberg err = -EBADSLT; 38943df91ea2SAndrei Emeltchenko goto unlock; 38953df91ea2SAndrei Emeltchenko } 38960a708f8fSGustavo F. Padovan } 38970a708f8fSGustavo F. Padovan 38983df91ea2SAndrei Emeltchenko err = 0; 38993df91ea2SAndrei Emeltchenko 39006be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 390148454079SGustavo F. Padovan 39020a708f8fSGustavo F. Padovan switch (result) { 39030a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 390489bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3905fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3906fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3907c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 39080a708f8fSGustavo F. Padovan 3909c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 39100a708f8fSGustavo F. Padovan break; 39110a708f8fSGustavo F. Padovan 39120a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 391373ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 391473ffa904SGustavo F. Padovan chan->num_conf_req++; 39150a708f8fSGustavo F. Padovan break; 39160a708f8fSGustavo F. Padovan 39170a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3918c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 39190a708f8fSGustavo F. Padovan break; 39200a708f8fSGustavo F. Padovan 39210a708f8fSGustavo F. Padovan default: 392248454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 39230a708f8fSGustavo F. Padovan break; 39240a708f8fSGustavo F. Padovan } 39250a708f8fSGustavo F. Padovan 39266be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39273df91ea2SAndrei Emeltchenko 39283df91ea2SAndrei Emeltchenko unlock: 39293df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 39303df91ea2SAndrei Emeltchenko 39313df91ea2SAndrei Emeltchenko return err; 39320a708f8fSGustavo F. Padovan } 39330a708f8fSGustavo F. Padovan 393447d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 39350a708f8fSGustavo F. Padovan { 39360a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 39370a708f8fSGustavo F. Padovan * sides request it. 39380a708f8fSGustavo F. Padovan */ 39390c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 394047d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3941f2592d3eSAndrei Emeltchenko else if (!test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) 394247d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 39430a708f8fSGustavo F. Padovan } 39440a708f8fSGustavo F. Padovan 394529d8a590SAndrei Emeltchenko static void l2cap_send_efs_conf_rsp(struct l2cap_chan *chan, void *data, 394629d8a590SAndrei Emeltchenko u8 ident, u16 flags) 394729d8a590SAndrei Emeltchenko { 394829d8a590SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 394929d8a590SAndrei Emeltchenko 395029d8a590SAndrei Emeltchenko BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident, 395129d8a590SAndrei Emeltchenko flags); 395229d8a590SAndrei Emeltchenko 395329d8a590SAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 395429d8a590SAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 395529d8a590SAndrei Emeltchenko 395629d8a590SAndrei Emeltchenko l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP, 395729d8a590SAndrei Emeltchenko l2cap_build_conf_rsp(chan, data, 395829d8a590SAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), data); 395929d8a590SAndrei Emeltchenko } 396029d8a590SAndrei Emeltchenko 39612d792818SGustavo Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, 39622d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 39632d792818SGustavo Padovan u8 *data) 39640a708f8fSGustavo F. Padovan { 39650a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 39660a708f8fSGustavo F. Padovan u16 dcid, flags; 39670a708f8fSGustavo F. Padovan u8 rsp[64]; 396848454079SGustavo F. Padovan struct l2cap_chan *chan; 39693c588192SMat Martineau int len, err = 0; 39700a708f8fSGustavo F. Padovan 3971cb3b3152SJohan Hedberg if (cmd_len < sizeof(*req)) 3972cb3b3152SJohan Hedberg return -EPROTO; 3973cb3b3152SJohan Hedberg 39740a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 39750a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 39760a708f8fSGustavo F. Padovan 39770a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 39780a708f8fSGustavo F. Padovan 3979baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 398048454079SGustavo F. Padovan if (!chan) 398121870b52SJohan Hedberg return -EBADSLT; 39820a708f8fSGustavo F. Padovan 3983033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3984e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 39850a708f8fSGustavo F. Padovan 3986ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3987e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3988e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3989e2fd318eSIlia Kolomisnky 39900a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 39910a708f8fSGustavo F. Padovan sizeof(rej), &rej); 39920a708f8fSGustavo F. Padovan goto unlock; 39930a708f8fSGustavo F. Padovan } 39940a708f8fSGustavo F. Padovan 39950a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 39960a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 3997cb3b3152SJohan Hedberg if (chan->conf_len + len > sizeof(chan->conf_req)) { 39980a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3999fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 40000a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 40010a708f8fSGustavo F. Padovan goto unlock; 40020a708f8fSGustavo F. Padovan } 40030a708f8fSGustavo F. Padovan 40040a708f8fSGustavo F. Padovan /* Store config. */ 400573ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 400673ffa904SGustavo F. Padovan chan->conf_len += len; 40070a708f8fSGustavo F. Padovan 400859e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 40090a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 40100a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 4011fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 40125325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 40130a708f8fSGustavo F. Padovan goto unlock; 40140a708f8fSGustavo F. Padovan } 40150a708f8fSGustavo F. Padovan 40160a708f8fSGustavo F. Padovan /* Complete config. */ 401773ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 40180a708f8fSGustavo F. Padovan if (len < 0) { 40195e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 40200a708f8fSGustavo F. Padovan goto unlock; 40210a708f8fSGustavo F. Padovan } 40220a708f8fSGustavo F. Padovan 40231500109bSMat Martineau chan->ident = cmd->ident; 40240a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 402573ffa904SGustavo F. Padovan chan->num_conf_rsp++; 40260a708f8fSGustavo F. Padovan 40270a708f8fSGustavo F. Padovan /* Reset config buffer. */ 402873ffa904SGustavo F. Padovan chan->conf_len = 0; 40290a708f8fSGustavo F. Padovan 4030c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 40310a708f8fSGustavo F. Padovan goto unlock; 40320a708f8fSGustavo F. Padovan 4033c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 403447d1ec61SGustavo F. Padovan set_default_fcs(chan); 40350a708f8fSGustavo F. Padovan 4036105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 4037105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 40383c588192SMat Martineau err = l2cap_ertm_init(chan); 40390a708f8fSGustavo F. Padovan 40403c588192SMat Martineau if (err < 0) 40415e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 40423c588192SMat Martineau else 4043cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 40443c588192SMat Martineau 40450a708f8fSGustavo F. Padovan goto unlock; 40460a708f8fSGustavo F. Padovan } 40470a708f8fSGustavo F. Padovan 4048c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 40490a708f8fSGustavo F. Padovan u8 buf[64]; 40500a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 405173ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 405273ffa904SGustavo F. Padovan chan->num_conf_req++; 40530a708f8fSGustavo F. Padovan } 40540a708f8fSGustavo F. Padovan 40550e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 40560e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 40570e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 40580e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 40590e8b207eSAndrei Emeltchenko 40600e8b207eSAndrei Emeltchenko /* check compatibility */ 40610e8b207eSAndrei Emeltchenko 406279de886dSAndrei Emeltchenko /* Send rsp for BR/EDR channel */ 4063f351bc72SAndrei Emeltchenko if (!chan->hs_hcon) 406429d8a590SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, rsp, cmd->ident, flags); 406579de886dSAndrei Emeltchenko else 406679de886dSAndrei Emeltchenko chan->ident = cmd->ident; 40670e8b207eSAndrei Emeltchenko } 40680e8b207eSAndrei Emeltchenko 40690a708f8fSGustavo F. Padovan unlock: 40706be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 40713c588192SMat Martineau return err; 40720a708f8fSGustavo F. Padovan } 40730a708f8fSGustavo F. Padovan 40742d792818SGustavo Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, 4075cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4076cb3b3152SJohan Hedberg u8 *data) 40770a708f8fSGustavo F. Padovan { 40780a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 40790a708f8fSGustavo F. Padovan u16 scid, flags, result; 408048454079SGustavo F. Padovan struct l2cap_chan *chan; 4081cb3b3152SJohan Hedberg int len = cmd_len - sizeof(*rsp); 40823c588192SMat Martineau int err = 0; 40830a708f8fSGustavo F. Padovan 4084cb3b3152SJohan Hedberg if (cmd_len < sizeof(*rsp)) 4085cb3b3152SJohan Hedberg return -EPROTO; 4086cb3b3152SJohan Hedberg 40870a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 40880a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 40890a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 40900a708f8fSGustavo F. Padovan 409161386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 409261386cbaSAndrei Emeltchenko result, len); 40930a708f8fSGustavo F. Padovan 4094baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 409548454079SGustavo F. Padovan if (!chan) 40960a708f8fSGustavo F. Padovan return 0; 40970a708f8fSGustavo F. Padovan 40980a708f8fSGustavo F. Padovan switch (result) { 40990a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 410047d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 41010e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 41020a708f8fSGustavo F. Padovan break; 41030a708f8fSGustavo F. Padovan 41040e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 41050e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 41060e8b207eSAndrei Emeltchenko 41070e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 41080e8b207eSAndrei Emeltchenko char buf[64]; 41090e8b207eSAndrei Emeltchenko 41100e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 41110e8b207eSAndrei Emeltchenko buf, &result); 41120e8b207eSAndrei Emeltchenko if (len < 0) { 41135e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41140e8b207eSAndrei Emeltchenko goto done; 41150e8b207eSAndrei Emeltchenko } 41160e8b207eSAndrei Emeltchenko 4117f351bc72SAndrei Emeltchenko if (!chan->hs_hcon) { 411879de886dSAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, buf, cmd->ident, 411979de886dSAndrei Emeltchenko 0); 41205ce66b59SAndrei Emeltchenko } else { 41215ce66b59SAndrei Emeltchenko if (l2cap_check_efs(chan)) { 41225ce66b59SAndrei Emeltchenko amp_create_logical_link(chan); 412379de886dSAndrei Emeltchenko chan->ident = cmd->ident; 41240e8b207eSAndrei Emeltchenko } 41255ce66b59SAndrei Emeltchenko } 41265ce66b59SAndrei Emeltchenko } 41270e8b207eSAndrei Emeltchenko goto done; 41280e8b207eSAndrei Emeltchenko 41290a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 413073ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 41310a708f8fSGustavo F. Padovan char req[64]; 41320a708f8fSGustavo F. Padovan 41330a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 41345e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41350a708f8fSGustavo F. Padovan goto done; 41360a708f8fSGustavo F. Padovan } 41370a708f8fSGustavo F. Padovan 41380a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 41390a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 4140b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 4141b4450035SGustavo F. Padovan req, &result); 41420a708f8fSGustavo F. Padovan if (len < 0) { 41435e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41440a708f8fSGustavo F. Padovan goto done; 41450a708f8fSGustavo F. Padovan } 41460a708f8fSGustavo F. Padovan 41470a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 41480a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 414973ffa904SGustavo F. Padovan chan->num_conf_req++; 41500a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 41510a708f8fSGustavo F. Padovan goto done; 41520a708f8fSGustavo F. Padovan break; 41530a708f8fSGustavo F. Padovan } 41540a708f8fSGustavo F. Padovan 41550a708f8fSGustavo F. Padovan default: 41566be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 41572e0052e4SAndrei Emeltchenko 4158ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 41595e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 41600a708f8fSGustavo F. Padovan goto done; 41610a708f8fSGustavo F. Padovan } 41620a708f8fSGustavo F. Padovan 416359e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 41640a708f8fSGustavo F. Padovan goto done; 41650a708f8fSGustavo F. Padovan 4166c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 41670a708f8fSGustavo F. Padovan 4168c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 416947d1ec61SGustavo F. Padovan set_default_fcs(chan); 41700a708f8fSGustavo F. Padovan 4171105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 4172105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 41733c588192SMat Martineau err = l2cap_ertm_init(chan); 41740a708f8fSGustavo F. Padovan 41753c588192SMat Martineau if (err < 0) 41765e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 41773c588192SMat Martineau else 4178cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 41790a708f8fSGustavo F. Padovan } 41800a708f8fSGustavo F. Padovan 41810a708f8fSGustavo F. Padovan done: 41826be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 41833c588192SMat Martineau return err; 41840a708f8fSGustavo F. Padovan } 41850a708f8fSGustavo F. Padovan 41862d792818SGustavo Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, 4187cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4188cb3b3152SJohan Hedberg u8 *data) 41890a708f8fSGustavo F. Padovan { 41900a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 41910a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 41920a708f8fSGustavo F. Padovan u16 dcid, scid; 419348454079SGustavo F. Padovan struct l2cap_chan *chan; 41940a708f8fSGustavo F. Padovan struct sock *sk; 41950a708f8fSGustavo F. Padovan 4196cb3b3152SJohan Hedberg if (cmd_len != sizeof(*req)) 4197cb3b3152SJohan Hedberg return -EPROTO; 4198cb3b3152SJohan Hedberg 41990a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 42000a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 42010a708f8fSGustavo F. Padovan 42020a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 42030a708f8fSGustavo F. Padovan 42043df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 42053df91ea2SAndrei Emeltchenko 42063df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 42073df91ea2SAndrei Emeltchenko if (!chan) { 42083df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 4209c4ea249fSJohan Hedberg return -EBADSLT; 42103df91ea2SAndrei Emeltchenko } 42110a708f8fSGustavo F. Padovan 42126be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 42136be36555SAndrei Emeltchenko 421448454079SGustavo F. Padovan sk = chan->sk; 421548454079SGustavo F. Padovan 4216fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 4217fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 42180a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 42190a708f8fSGustavo F. Padovan 42206be36555SAndrei Emeltchenko lock_sock(sk); 42210a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 42226be36555SAndrei Emeltchenko release_sock(sk); 42230a708f8fSGustavo F. Padovan 422461d6ef3eSMat Martineau l2cap_chan_hold(chan); 422548454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 42266be36555SAndrei Emeltchenko 42276be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 42280a708f8fSGustavo F. Padovan 422980b98027SGustavo Padovan chan->ops->close(chan); 423061d6ef3eSMat Martineau l2cap_chan_put(chan); 42313df91ea2SAndrei Emeltchenko 42323df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 42333df91ea2SAndrei Emeltchenko 42340a708f8fSGustavo F. Padovan return 0; 42350a708f8fSGustavo F. Padovan } 42360a708f8fSGustavo F. Padovan 42372d792818SGustavo Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, 4238cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4239cb3b3152SJohan Hedberg u8 *data) 42400a708f8fSGustavo F. Padovan { 42410a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 42420a708f8fSGustavo F. Padovan u16 dcid, scid; 424348454079SGustavo F. Padovan struct l2cap_chan *chan; 42440a708f8fSGustavo F. Padovan 4245cb3b3152SJohan Hedberg if (cmd_len != sizeof(*rsp)) 4246cb3b3152SJohan Hedberg return -EPROTO; 4247cb3b3152SJohan Hedberg 42480a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 42490a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 42500a708f8fSGustavo F. Padovan 42510a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 42520a708f8fSGustavo F. Padovan 42533df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 42543df91ea2SAndrei Emeltchenko 42553df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 42563df91ea2SAndrei Emeltchenko if (!chan) { 42573df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 42580a708f8fSGustavo F. Padovan return 0; 42593df91ea2SAndrei Emeltchenko } 42600a708f8fSGustavo F. Padovan 42616be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 426248454079SGustavo F. Padovan 426361d6ef3eSMat Martineau l2cap_chan_hold(chan); 426448454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 42656be36555SAndrei Emeltchenko 42666be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 42670a708f8fSGustavo F. Padovan 426880b98027SGustavo Padovan chan->ops->close(chan); 426961d6ef3eSMat Martineau l2cap_chan_put(chan); 42703df91ea2SAndrei Emeltchenko 42713df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 42723df91ea2SAndrei Emeltchenko 42730a708f8fSGustavo F. Padovan return 0; 42740a708f8fSGustavo F. Padovan } 42750a708f8fSGustavo F. Padovan 42762d792818SGustavo Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, 4277cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4278cb3b3152SJohan Hedberg u8 *data) 42790a708f8fSGustavo F. Padovan { 42800a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 42810a708f8fSGustavo F. Padovan u16 type; 42820a708f8fSGustavo F. Padovan 4283cb3b3152SJohan Hedberg if (cmd_len != sizeof(*req)) 4284cb3b3152SJohan Hedberg return -EPROTO; 4285cb3b3152SJohan Hedberg 42860a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 42870a708f8fSGustavo F. Padovan 42880a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 42890a708f8fSGustavo F. Padovan 42900a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 42910a708f8fSGustavo F. Padovan u8 buf[8]; 42920a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 42930a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 4294ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 4295ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 42960a708f8fSGustavo F. Padovan if (!disable_ertm) 42970a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 42980a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 4299a5fd6f30SAndrei Emeltchenko if (enable_hs) 43006327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 43016327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 4302a5fd6f30SAndrei Emeltchenko 43030a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 43042d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 43052d792818SGustavo Padovan buf); 43060a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 43070a708f8fSGustavo F. Padovan u8 buf[12]; 43080a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 430950a147cdSMat Martineau 431050a147cdSMat Martineau if (enable_hs) 431150a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 431250a147cdSMat Martineau else 431350a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 431450a147cdSMat Martineau 4315ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 4316ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 4317c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 43182d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 43192d792818SGustavo Padovan buf); 43200a708f8fSGustavo F. Padovan } else { 43210a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 43220a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 4323ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 43242d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), 43252d792818SGustavo Padovan &rsp); 43260a708f8fSGustavo F. Padovan } 43270a708f8fSGustavo F. Padovan 43280a708f8fSGustavo F. Padovan return 0; 43290a708f8fSGustavo F. Padovan } 43300a708f8fSGustavo F. Padovan 43312d792818SGustavo Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, 4332cb3b3152SJohan Hedberg struct l2cap_cmd_hdr *cmd, u16 cmd_len, 4333cb3b3152SJohan Hedberg u8 *data) 43340a708f8fSGustavo F. Padovan { 43350a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 43360a708f8fSGustavo F. Padovan u16 type, result; 43370a708f8fSGustavo F. Padovan 43383f6fa3d4SJaganath Kanakkassery if (cmd_len < sizeof(*rsp)) 4339cb3b3152SJohan Hedberg return -EPROTO; 4340cb3b3152SJohan Hedberg 43410a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 43420a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 43430a708f8fSGustavo F. Padovan 43440a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 43450a708f8fSGustavo F. Padovan 4346e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 4347e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 4348e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 4349e90165beSAndrei Emeltchenko return 0; 4350e90165beSAndrei Emeltchenko 435117cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 43520a708f8fSGustavo F. Padovan 43530a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 43540a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 43550a708f8fSGustavo F. Padovan conn->info_ident = 0; 43560a708f8fSGustavo F. Padovan 43570a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 43580a708f8fSGustavo F. Padovan 43590a708f8fSGustavo F. Padovan return 0; 43600a708f8fSGustavo F. Padovan } 43610a708f8fSGustavo F. Padovan 4362978c93b9SAndrei Emeltchenko switch (type) { 4363978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 43640a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 43650a708f8fSGustavo F. Padovan 43660a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 43670a708f8fSGustavo F. Padovan struct l2cap_info_req req; 4368ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 43690a708f8fSGustavo F. Padovan 43700a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 43710a708f8fSGustavo F. Padovan 43720a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 43730a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 43740a708f8fSGustavo F. Padovan } else { 43750a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 43760a708f8fSGustavo F. Padovan conn->info_ident = 0; 43770a708f8fSGustavo F. Padovan 43780a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 43790a708f8fSGustavo F. Padovan } 4380978c93b9SAndrei Emeltchenko break; 4381978c93b9SAndrei Emeltchenko 4382978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 4383978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 43840a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 43850a708f8fSGustavo F. Padovan conn->info_ident = 0; 43860a708f8fSGustavo F. Padovan 43870a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 4388978c93b9SAndrei Emeltchenko break; 43890a708f8fSGustavo F. Padovan } 43900a708f8fSGustavo F. Padovan 43910a708f8fSGustavo F. Padovan return 0; 43920a708f8fSGustavo F. Padovan } 43930a708f8fSGustavo F. Padovan 43941700915fSMat Martineau static int l2cap_create_channel_req(struct l2cap_conn *conn, 43952d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 43962d792818SGustavo Padovan u16 cmd_len, void *data) 4397f94ff6ffSMat Martineau { 4398f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 43996e1df6a6SAndrei Emeltchenko struct l2cap_create_chan_rsp rsp; 44001700915fSMat Martineau struct l2cap_chan *chan; 44016e1df6a6SAndrei Emeltchenko struct hci_dev *hdev; 4402f94ff6ffSMat Martineau u16 psm, scid; 4403f94ff6ffSMat Martineau 4404f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 4405f94ff6ffSMat Martineau return -EPROTO; 4406f94ff6ffSMat Martineau 4407f94ff6ffSMat Martineau if (!enable_hs) 4408f94ff6ffSMat Martineau return -EINVAL; 4409f94ff6ffSMat Martineau 4410f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 4411f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 4412f94ff6ffSMat Martineau 4413ad0ac6caSAndrei Emeltchenko BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id); 4414f94ff6ffSMat Martineau 44156e1df6a6SAndrei Emeltchenko /* For controller id 0 make BR/EDR connection */ 44166e1df6a6SAndrei Emeltchenko if (req->amp_id == HCI_BREDR_ID) { 44176e1df6a6SAndrei Emeltchenko l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 44186e1df6a6SAndrei Emeltchenko req->amp_id); 44196e1df6a6SAndrei Emeltchenko return 0; 44206e1df6a6SAndrei Emeltchenko } 44211700915fSMat Martineau 44221700915fSMat Martineau /* Validate AMP controller id */ 44231700915fSMat Martineau hdev = hci_dev_get(req->amp_id); 44246e1df6a6SAndrei Emeltchenko if (!hdev) 44256e1df6a6SAndrei Emeltchenko goto error; 44261700915fSMat Martineau 44276e1df6a6SAndrei Emeltchenko if (hdev->dev_type != HCI_AMP || !test_bit(HCI_UP, &hdev->flags)) { 44286e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 44296e1df6a6SAndrei Emeltchenko goto error; 44306e1df6a6SAndrei Emeltchenko } 44316e1df6a6SAndrei Emeltchenko 44326e1df6a6SAndrei Emeltchenko chan = l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 44336e1df6a6SAndrei Emeltchenko req->amp_id); 44346e1df6a6SAndrei Emeltchenko if (chan) { 44356e1df6a6SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 44366e1df6a6SAndrei Emeltchenko struct hci_conn *hs_hcon; 44376e1df6a6SAndrei Emeltchenko 44386e1df6a6SAndrei Emeltchenko hs_hcon = hci_conn_hash_lookup_ba(hdev, AMP_LINK, conn->dst); 44396e1df6a6SAndrei Emeltchenko if (!hs_hcon) { 44406e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 444121870b52SJohan Hedberg return -EBADSLT; 44426e1df6a6SAndrei Emeltchenko } 44436e1df6a6SAndrei Emeltchenko 44446e1df6a6SAndrei Emeltchenko BT_DBG("mgr %p bredr_chan %p hs_hcon %p", mgr, chan, hs_hcon); 44456e1df6a6SAndrei Emeltchenko 44466e1df6a6SAndrei Emeltchenko mgr->bredr_chan = chan; 44476e1df6a6SAndrei Emeltchenko chan->hs_hcon = hs_hcon; 4448fd45bf4cSAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 44496e1df6a6SAndrei Emeltchenko conn->mtu = hdev->block_mtu; 44506e1df6a6SAndrei Emeltchenko } 44516e1df6a6SAndrei Emeltchenko 44526e1df6a6SAndrei Emeltchenko hci_dev_put(hdev); 44536e1df6a6SAndrei Emeltchenko 44546e1df6a6SAndrei Emeltchenko return 0; 44556e1df6a6SAndrei Emeltchenko 44566e1df6a6SAndrei Emeltchenko error: 4457f94ff6ffSMat Martineau rsp.dcid = 0; 4458f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 44591700915fSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_CR_BAD_AMP); 44608ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 4461f94ff6ffSMat Martineau 4462f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 4463f94ff6ffSMat Martineau sizeof(rsp), &rsp); 4464f94ff6ffSMat Martineau 4465dc280801SJohan Hedberg return 0; 4466f94ff6ffSMat Martineau } 4467f94ff6ffSMat Martineau 44688eb200bdSMat Martineau static void l2cap_send_move_chan_req(struct l2cap_chan *chan, u8 dest_amp_id) 44698eb200bdSMat Martineau { 44708eb200bdSMat Martineau struct l2cap_move_chan_req req; 44718eb200bdSMat Martineau u8 ident; 44728eb200bdSMat Martineau 44738eb200bdSMat Martineau BT_DBG("chan %p, dest_amp_id %d", chan, dest_amp_id); 44748eb200bdSMat Martineau 44758eb200bdSMat Martineau ident = l2cap_get_ident(chan->conn); 44768eb200bdSMat Martineau chan->ident = ident; 44778eb200bdSMat Martineau 44788eb200bdSMat Martineau req.icid = cpu_to_le16(chan->scid); 44798eb200bdSMat Martineau req.dest_amp_id = dest_amp_id; 44808eb200bdSMat Martineau 44818eb200bdSMat Martineau l2cap_send_cmd(chan->conn, ident, L2CAP_MOVE_CHAN_REQ, sizeof(req), 44828eb200bdSMat Martineau &req); 44838eb200bdSMat Martineau 44848eb200bdSMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 44858eb200bdSMat Martineau } 44868eb200bdSMat Martineau 44871500109bSMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_chan *chan, u16 result) 44888d5a04a1SMat Martineau { 44898d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 44908d5a04a1SMat Martineau 44911500109bSMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 44928d5a04a1SMat Martineau 44931500109bSMat Martineau rsp.icid = cpu_to_le16(chan->dcid); 44948d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 44958d5a04a1SMat Martineau 44961500109bSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_RSP, 44971500109bSMat Martineau sizeof(rsp), &rsp); 44988d5a04a1SMat Martineau } 44998d5a04a1SMat Martineau 45005b155ef9SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_chan *chan, u16 result) 45018d5a04a1SMat Martineau { 45028d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 45038d5a04a1SMat Martineau 45045b155ef9SMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 45058d5a04a1SMat Martineau 45065b155ef9SMat Martineau chan->ident = l2cap_get_ident(chan->conn); 45078d5a04a1SMat Martineau 45085b155ef9SMat Martineau cfm.icid = cpu_to_le16(chan->scid); 45098d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 45108d5a04a1SMat Martineau 45115b155ef9SMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_CFM, 45125b155ef9SMat Martineau sizeof(cfm), &cfm); 45135b155ef9SMat Martineau 45145b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 45155b155ef9SMat Martineau } 45165b155ef9SMat Martineau 45175b155ef9SMat Martineau static void l2cap_send_move_chan_cfm_icid(struct l2cap_conn *conn, u16 icid) 45185b155ef9SMat Martineau { 45195b155ef9SMat Martineau struct l2cap_move_chan_cfm cfm; 45205b155ef9SMat Martineau 45215b155ef9SMat Martineau BT_DBG("conn %p, icid 0x%4.4x", conn, icid); 45225b155ef9SMat Martineau 45235b155ef9SMat Martineau cfm.icid = cpu_to_le16(icid); 45245b155ef9SMat Martineau cfm.result = __constant_cpu_to_le16(L2CAP_MC_UNCONFIRMED); 45255b155ef9SMat Martineau 45265b155ef9SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_MOVE_CHAN_CFM, 45275b155ef9SMat Martineau sizeof(cfm), &cfm); 45288d5a04a1SMat Martineau } 45298d5a04a1SMat Martineau 45308d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 45318d5a04a1SMat Martineau u16 icid) 45328d5a04a1SMat Martineau { 45338d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 45348d5a04a1SMat Martineau 4535ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 45368d5a04a1SMat Martineau 45378d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 45388d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 45398d5a04a1SMat Martineau } 45408d5a04a1SMat Martineau 45415f3847a4SMat Martineau static void __release_logical_link(struct l2cap_chan *chan) 45425f3847a4SMat Martineau { 45435f3847a4SMat Martineau chan->hs_hchan = NULL; 45445f3847a4SMat Martineau chan->hs_hcon = NULL; 45455f3847a4SMat Martineau 45465f3847a4SMat Martineau /* Placeholder - release the logical link */ 45475f3847a4SMat Martineau } 45485f3847a4SMat Martineau 45491500109bSMat Martineau static void l2cap_logical_fail(struct l2cap_chan *chan) 45501500109bSMat Martineau { 45511500109bSMat Martineau /* Logical link setup failed */ 45521500109bSMat Martineau if (chan->state != BT_CONNECTED) { 45531500109bSMat Martineau /* Create channel failure, disconnect */ 45545e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 45551500109bSMat Martineau return; 45561500109bSMat Martineau } 45571500109bSMat Martineau 45581500109bSMat Martineau switch (chan->move_role) { 45591500109bSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 45601500109bSMat Martineau l2cap_move_done(chan); 45611500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_SUPP); 45621500109bSMat Martineau break; 45631500109bSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 45641500109bSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_COMP || 45651500109bSMat Martineau chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_CFM) { 45661500109bSMat Martineau /* Remote has only sent pending or 45671500109bSMat Martineau * success responses, clean up 45681500109bSMat Martineau */ 45691500109bSMat Martineau l2cap_move_done(chan); 45701500109bSMat Martineau } 45711500109bSMat Martineau 45721500109bSMat Martineau /* Other amp move states imply that the move 45731500109bSMat Martineau * has already aborted 45741500109bSMat Martineau */ 45751500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 45761500109bSMat Martineau break; 45771500109bSMat Martineau } 45781500109bSMat Martineau } 45791500109bSMat Martineau 45801500109bSMat Martineau static void l2cap_logical_finish_create(struct l2cap_chan *chan, 45811500109bSMat Martineau struct hci_chan *hchan) 45821500109bSMat Martineau { 45831500109bSMat Martineau struct l2cap_conf_rsp rsp; 45841500109bSMat Martineau 4585336178a3SAndrei Emeltchenko chan->hs_hchan = hchan; 45861500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 45871500109bSMat Martineau 458835ba9561SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, &rsp, chan->ident, 0); 45891500109bSMat Martineau 45901500109bSMat Martineau if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 4591fe79c6feSAndrei Emeltchenko int err; 45921500109bSMat Martineau 45931500109bSMat Martineau set_default_fcs(chan); 45941500109bSMat Martineau 45951500109bSMat Martineau err = l2cap_ertm_init(chan); 45961500109bSMat Martineau if (err < 0) 45975e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, -err); 45981500109bSMat Martineau else 45991500109bSMat Martineau l2cap_chan_ready(chan); 46001500109bSMat Martineau } 46011500109bSMat Martineau } 46021500109bSMat Martineau 46031500109bSMat Martineau static void l2cap_logical_finish_move(struct l2cap_chan *chan, 46041500109bSMat Martineau struct hci_chan *hchan) 46051500109bSMat Martineau { 46061500109bSMat Martineau chan->hs_hcon = hchan->conn; 46071500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 46081500109bSMat Martineau 46091500109bSMat Martineau BT_DBG("move_state %d", chan->move_state); 46101500109bSMat Martineau 46111500109bSMat Martineau switch (chan->move_state) { 46121500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 46131500109bSMat Martineau /* Move confirm will be sent after a success 46141500109bSMat Martineau * response is received 46151500109bSMat Martineau */ 46161500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 46171500109bSMat Martineau break; 46181500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_CFM: 46191500109bSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 46201500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 46211500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 46221500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 46231500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 46241500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 46251500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 46261500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 46271500109bSMat Martineau } 46281500109bSMat Martineau break; 46291500109bSMat Martineau default: 46301500109bSMat Martineau /* Move was not in expected state, free the channel */ 46311500109bSMat Martineau __release_logical_link(chan); 46321500109bSMat Martineau 46331500109bSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 46341500109bSMat Martineau } 46351500109bSMat Martineau } 46361500109bSMat Martineau 46371500109bSMat Martineau /* Call with chan locked */ 463827695fb4SAndrei Emeltchenko void l2cap_logical_cfm(struct l2cap_chan *chan, struct hci_chan *hchan, 46395b155ef9SMat Martineau u8 status) 46405b155ef9SMat Martineau { 46411500109bSMat Martineau BT_DBG("chan %p, hchan %p, status %d", chan, hchan, status); 46421500109bSMat Martineau 46431500109bSMat Martineau if (status) { 46441500109bSMat Martineau l2cap_logical_fail(chan); 46451500109bSMat Martineau __release_logical_link(chan); 46465b155ef9SMat Martineau return; 46475b155ef9SMat Martineau } 46485b155ef9SMat Martineau 46491500109bSMat Martineau if (chan->state != BT_CONNECTED) { 46501500109bSMat Martineau /* Ignore logical link if channel is on BR/EDR */ 46511500109bSMat Martineau if (chan->local_amp_id) 46521500109bSMat Martineau l2cap_logical_finish_create(chan, hchan); 46531500109bSMat Martineau } else { 46541500109bSMat Martineau l2cap_logical_finish_move(chan, hchan); 46551500109bSMat Martineau } 46561500109bSMat Martineau } 46571500109bSMat Martineau 46583f7a56c4SMat Martineau void l2cap_move_start(struct l2cap_chan *chan) 46593f7a56c4SMat Martineau { 46603f7a56c4SMat Martineau BT_DBG("chan %p", chan); 46613f7a56c4SMat Martineau 46623f7a56c4SMat Martineau if (chan->local_amp_id == HCI_BREDR_ID) { 46633f7a56c4SMat Martineau if (chan->chan_policy != BT_CHANNEL_POLICY_AMP_PREFERRED) 46643f7a56c4SMat Martineau return; 46653f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 46663f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 46673f7a56c4SMat Martineau /* Placeholder - start physical link setup */ 46683f7a56c4SMat Martineau } else { 46693f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 46703f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 46713f7a56c4SMat Martineau chan->move_id = 0; 46723f7a56c4SMat Martineau l2cap_move_setup(chan); 46733f7a56c4SMat Martineau l2cap_send_move_chan_req(chan, 0); 46743f7a56c4SMat Martineau } 46753f7a56c4SMat Martineau } 46763f7a56c4SMat Martineau 46778eb200bdSMat Martineau static void l2cap_do_create(struct l2cap_chan *chan, int result, 46788eb200bdSMat Martineau u8 local_amp_id, u8 remote_amp_id) 46798eb200bdSMat Martineau { 468062748ca1SAndrei Emeltchenko BT_DBG("chan %p state %s %u -> %u", chan, state_to_string(chan->state), 468162748ca1SAndrei Emeltchenko local_amp_id, remote_amp_id); 468262748ca1SAndrei Emeltchenko 468312d6cc60SAndrei Emeltchenko chan->fcs = L2CAP_FCS_NONE; 468412d6cc60SAndrei Emeltchenko 468562748ca1SAndrei Emeltchenko /* Outgoing channel on AMP */ 468662748ca1SAndrei Emeltchenko if (chan->state == BT_CONNECT) { 468762748ca1SAndrei Emeltchenko if (result == L2CAP_CR_SUCCESS) { 468862748ca1SAndrei Emeltchenko chan->local_amp_id = local_amp_id; 468962748ca1SAndrei Emeltchenko l2cap_send_create_chan_req(chan, remote_amp_id); 469062748ca1SAndrei Emeltchenko } else { 469162748ca1SAndrei Emeltchenko /* Revert to BR/EDR connect */ 469262748ca1SAndrei Emeltchenko l2cap_send_conn_req(chan); 469362748ca1SAndrei Emeltchenko } 469462748ca1SAndrei Emeltchenko 469562748ca1SAndrei Emeltchenko return; 469662748ca1SAndrei Emeltchenko } 469762748ca1SAndrei Emeltchenko 469862748ca1SAndrei Emeltchenko /* Incoming channel on AMP */ 469962748ca1SAndrei Emeltchenko if (__l2cap_no_conn_pending(chan)) { 47008eb200bdSMat Martineau struct l2cap_conn_rsp rsp; 47018eb200bdSMat Martineau char buf[128]; 47028eb200bdSMat Martineau rsp.scid = cpu_to_le16(chan->dcid); 47038eb200bdSMat Martineau rsp.dcid = cpu_to_le16(chan->scid); 47048eb200bdSMat Martineau 47058eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 47068eb200bdSMat Martineau /* Send successful response */ 470762cd50e2SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 470862cd50e2SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 47098eb200bdSMat Martineau } else { 47108eb200bdSMat Martineau /* Send negative response */ 471162cd50e2SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_NO_MEM); 471262cd50e2SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 47138eb200bdSMat Martineau } 47148eb200bdSMat Martineau 47158eb200bdSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_RSP, 47168eb200bdSMat Martineau sizeof(rsp), &rsp); 47178eb200bdSMat Martineau 47188eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 47198eb200bdSMat Martineau __l2cap_state_change(chan, BT_CONFIG); 47208eb200bdSMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 47218eb200bdSMat Martineau l2cap_send_cmd(chan->conn, l2cap_get_ident(chan->conn), 47228eb200bdSMat Martineau L2CAP_CONF_REQ, 47238eb200bdSMat Martineau l2cap_build_conf_req(chan, buf), buf); 47248eb200bdSMat Martineau chan->num_conf_req++; 47258eb200bdSMat Martineau } 47268eb200bdSMat Martineau } 47278eb200bdSMat Martineau } 47288eb200bdSMat Martineau 47298eb200bdSMat Martineau static void l2cap_do_move_initiate(struct l2cap_chan *chan, u8 local_amp_id, 47308eb200bdSMat Martineau u8 remote_amp_id) 47318eb200bdSMat Martineau { 47328eb200bdSMat Martineau l2cap_move_setup(chan); 47338eb200bdSMat Martineau chan->move_id = local_amp_id; 47348eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP; 47358eb200bdSMat Martineau 47368eb200bdSMat Martineau l2cap_send_move_chan_req(chan, remote_amp_id); 47378eb200bdSMat Martineau } 47388eb200bdSMat Martineau 47398eb200bdSMat Martineau static void l2cap_do_move_respond(struct l2cap_chan *chan, int result) 47408eb200bdSMat Martineau { 47418eb200bdSMat Martineau struct hci_chan *hchan = NULL; 47428eb200bdSMat Martineau 47438eb200bdSMat Martineau /* Placeholder - get hci_chan for logical link */ 47448eb200bdSMat Martineau 47458eb200bdSMat Martineau if (hchan) { 47468eb200bdSMat Martineau if (hchan->state == BT_CONNECTED) { 47478eb200bdSMat Martineau /* Logical link is ready to go */ 47488eb200bdSMat Martineau chan->hs_hcon = hchan->conn; 47498eb200bdSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 47508eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 47518eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 47528eb200bdSMat Martineau 47538eb200bdSMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 47548eb200bdSMat Martineau } else { 47558eb200bdSMat Martineau /* Wait for logical link to be ready */ 47568eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 47578eb200bdSMat Martineau } 47588eb200bdSMat Martineau } else { 47598eb200bdSMat Martineau /* Logical link not available */ 47608eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_ALLOWED); 47618eb200bdSMat Martineau } 47628eb200bdSMat Martineau } 47638eb200bdSMat Martineau 47648eb200bdSMat Martineau static void l2cap_do_move_cancel(struct l2cap_chan *chan, int result) 47658eb200bdSMat Martineau { 47668eb200bdSMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 47678eb200bdSMat Martineau u8 rsp_result; 47688eb200bdSMat Martineau if (result == -EINVAL) 47698eb200bdSMat Martineau rsp_result = L2CAP_MR_BAD_ID; 47708eb200bdSMat Martineau else 47718eb200bdSMat Martineau rsp_result = L2CAP_MR_NOT_ALLOWED; 47728eb200bdSMat Martineau 47738eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, rsp_result); 47748eb200bdSMat Martineau } 47758eb200bdSMat Martineau 47768eb200bdSMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 47778eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 47788eb200bdSMat Martineau 47798eb200bdSMat Martineau /* Restart data transmission */ 47808eb200bdSMat Martineau l2cap_ertm_send(chan); 47818eb200bdSMat Martineau } 47828eb200bdSMat Martineau 4783a514b17fSAndrei Emeltchenko /* Invoke with locked chan */ 4784a514b17fSAndrei Emeltchenko void __l2cap_physical_cfm(struct l2cap_chan *chan, int result) 47858eb200bdSMat Martineau { 4786770bfefaSAndrei Emeltchenko u8 local_amp_id = chan->local_amp_id; 4787fffadc08SAndrei Emeltchenko u8 remote_amp_id = chan->remote_amp_id; 4788770bfefaSAndrei Emeltchenko 47898eb200bdSMat Martineau BT_DBG("chan %p, result %d, local_amp_id %d, remote_amp_id %d", 47908eb200bdSMat Martineau chan, result, local_amp_id, remote_amp_id); 47918eb200bdSMat Martineau 47928eb200bdSMat Martineau if (chan->state == BT_DISCONN || chan->state == BT_CLOSED) { 47938eb200bdSMat Martineau l2cap_chan_unlock(chan); 47948eb200bdSMat Martineau return; 47958eb200bdSMat Martineau } 47968eb200bdSMat Martineau 47978eb200bdSMat Martineau if (chan->state != BT_CONNECTED) { 47988eb200bdSMat Martineau l2cap_do_create(chan, result, local_amp_id, remote_amp_id); 47998eb200bdSMat Martineau } else if (result != L2CAP_MR_SUCCESS) { 48008eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 48018eb200bdSMat Martineau } else { 48028eb200bdSMat Martineau switch (chan->move_role) { 48038eb200bdSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 48048eb200bdSMat Martineau l2cap_do_move_initiate(chan, local_amp_id, 48058eb200bdSMat Martineau remote_amp_id); 48068eb200bdSMat Martineau break; 48078eb200bdSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 48088eb200bdSMat Martineau l2cap_do_move_respond(chan, result); 48098eb200bdSMat Martineau break; 48108eb200bdSMat Martineau default: 48118eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 48128eb200bdSMat Martineau break; 48138eb200bdSMat Martineau } 48148eb200bdSMat Martineau } 48158eb200bdSMat Martineau } 48168eb200bdSMat Martineau 48178d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 4818ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4819ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 48208d5a04a1SMat Martineau { 48218d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 48221500109bSMat Martineau struct l2cap_move_chan_rsp rsp; 482302b0fbb9SMat Martineau struct l2cap_chan *chan; 48248d5a04a1SMat Martineau u16 icid = 0; 48258d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 48268d5a04a1SMat Martineau 48278d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 48288d5a04a1SMat Martineau return -EPROTO; 48298d5a04a1SMat Martineau 48308d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 48318d5a04a1SMat Martineau 4832ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id); 48338d5a04a1SMat Martineau 48348d5a04a1SMat Martineau if (!enable_hs) 48358d5a04a1SMat Martineau return -EINVAL; 48368d5a04a1SMat Martineau 483702b0fbb9SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 483802b0fbb9SMat Martineau if (!chan) { 48391500109bSMat Martineau rsp.icid = cpu_to_le16(icid); 48401500109bSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_MR_NOT_ALLOWED); 48411500109bSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_MOVE_CHAN_RSP, 48421500109bSMat Martineau sizeof(rsp), &rsp); 484302b0fbb9SMat Martineau return 0; 484402b0fbb9SMat Martineau } 484502b0fbb9SMat Martineau 48461500109bSMat Martineau chan->ident = cmd->ident; 48471500109bSMat Martineau 484802b0fbb9SMat Martineau if (chan->scid < L2CAP_CID_DYN_START || 484902b0fbb9SMat Martineau chan->chan_policy == BT_CHANNEL_POLICY_BREDR_ONLY || 485002b0fbb9SMat Martineau (chan->mode != L2CAP_MODE_ERTM && 485102b0fbb9SMat Martineau chan->mode != L2CAP_MODE_STREAMING)) { 485202b0fbb9SMat Martineau result = L2CAP_MR_NOT_ALLOWED; 485302b0fbb9SMat Martineau goto send_move_response; 485402b0fbb9SMat Martineau } 485502b0fbb9SMat Martineau 485602b0fbb9SMat Martineau if (chan->local_amp_id == req->dest_amp_id) { 485702b0fbb9SMat Martineau result = L2CAP_MR_SAME_ID; 485802b0fbb9SMat Martineau goto send_move_response; 485902b0fbb9SMat Martineau } 486002b0fbb9SMat Martineau 486102b0fbb9SMat Martineau if (req->dest_amp_id) { 486202b0fbb9SMat Martineau struct hci_dev *hdev; 486302b0fbb9SMat Martineau hdev = hci_dev_get(req->dest_amp_id); 486402b0fbb9SMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 486502b0fbb9SMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 486602b0fbb9SMat Martineau if (hdev) 486702b0fbb9SMat Martineau hci_dev_put(hdev); 486802b0fbb9SMat Martineau 486902b0fbb9SMat Martineau result = L2CAP_MR_BAD_ID; 487002b0fbb9SMat Martineau goto send_move_response; 487102b0fbb9SMat Martineau } 487202b0fbb9SMat Martineau hci_dev_put(hdev); 487302b0fbb9SMat Martineau } 487402b0fbb9SMat Martineau 487502b0fbb9SMat Martineau /* Detect a move collision. Only send a collision response 487602b0fbb9SMat Martineau * if this side has "lost", otherwise proceed with the move. 487702b0fbb9SMat Martineau * The winner has the larger bd_addr. 487802b0fbb9SMat Martineau */ 487902b0fbb9SMat Martineau if ((__chan_is_moving(chan) || 488002b0fbb9SMat Martineau chan->move_role != L2CAP_MOVE_ROLE_NONE) && 488102b0fbb9SMat Martineau bacmp(conn->src, conn->dst) > 0) { 488202b0fbb9SMat Martineau result = L2CAP_MR_COLLISION; 488302b0fbb9SMat Martineau goto send_move_response; 488402b0fbb9SMat Martineau } 488502b0fbb9SMat Martineau 488602b0fbb9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 488702b0fbb9SMat Martineau l2cap_move_setup(chan); 488802b0fbb9SMat Martineau chan->move_id = req->dest_amp_id; 488902b0fbb9SMat Martineau icid = chan->dcid; 489002b0fbb9SMat Martineau 489102b0fbb9SMat Martineau if (!req->dest_amp_id) { 489202b0fbb9SMat Martineau /* Moving to BR/EDR */ 489302b0fbb9SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 489402b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 489502b0fbb9SMat Martineau result = L2CAP_MR_PEND; 489602b0fbb9SMat Martineau } else { 489702b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 489802b0fbb9SMat Martineau result = L2CAP_MR_SUCCESS; 489902b0fbb9SMat Martineau } 490002b0fbb9SMat Martineau } else { 490102b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 490202b0fbb9SMat Martineau /* Placeholder - uncomment when amp functions are available */ 490302b0fbb9SMat Martineau /*amp_accept_physical(chan, req->dest_amp_id);*/ 490402b0fbb9SMat Martineau result = L2CAP_MR_PEND; 490502b0fbb9SMat Martineau } 490602b0fbb9SMat Martineau 490702b0fbb9SMat Martineau send_move_response: 49081500109bSMat Martineau l2cap_send_move_chan_rsp(chan, result); 49098d5a04a1SMat Martineau 491002b0fbb9SMat Martineau l2cap_chan_unlock(chan); 491102b0fbb9SMat Martineau 49128d5a04a1SMat Martineau return 0; 49138d5a04a1SMat Martineau } 49148d5a04a1SMat Martineau 49155b155ef9SMat Martineau static void l2cap_move_continue(struct l2cap_conn *conn, u16 icid, u16 result) 49165b155ef9SMat Martineau { 49175b155ef9SMat Martineau struct l2cap_chan *chan; 49185b155ef9SMat Martineau struct hci_chan *hchan = NULL; 49195b155ef9SMat Martineau 49205b155ef9SMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 49215b155ef9SMat Martineau if (!chan) { 49225b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 49235b155ef9SMat Martineau return; 49245b155ef9SMat Martineau } 49255b155ef9SMat Martineau 49265b155ef9SMat Martineau __clear_chan_timer(chan); 49275b155ef9SMat Martineau if (result == L2CAP_MR_PEND) 49285b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_ERTX_TIMEOUT); 49295b155ef9SMat Martineau 49305b155ef9SMat Martineau switch (chan->move_state) { 49315b155ef9SMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 49325b155ef9SMat Martineau /* Move confirm will be sent when logical link 49335b155ef9SMat Martineau * is complete. 49345b155ef9SMat Martineau */ 49355b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 49365b155ef9SMat Martineau break; 49375b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP_SUCCESS: 49385b155ef9SMat Martineau if (result == L2CAP_MR_PEND) { 49395b155ef9SMat Martineau break; 49405b155ef9SMat Martineau } else if (test_bit(CONN_LOCAL_BUSY, 49415b155ef9SMat Martineau &chan->conn_state)) { 49425b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 49435b155ef9SMat Martineau } else { 49445b155ef9SMat Martineau /* Logical link is up or moving to BR/EDR, 49455b155ef9SMat Martineau * proceed with move 49465b155ef9SMat Martineau */ 49475b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 49485b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 49495b155ef9SMat Martineau } 49505b155ef9SMat Martineau break; 49515b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP: 49525b155ef9SMat Martineau /* Moving to AMP */ 49535b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 49545b155ef9SMat Martineau /* Remote is ready, send confirm immediately 49555b155ef9SMat Martineau * after logical link is ready 49565b155ef9SMat Martineau */ 49575b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 49585b155ef9SMat Martineau } else { 49595b155ef9SMat Martineau /* Both logical link and move success 49605b155ef9SMat Martineau * are required to confirm 49615b155ef9SMat Martineau */ 49625b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_COMP; 49635b155ef9SMat Martineau } 49645b155ef9SMat Martineau 49655b155ef9SMat Martineau /* Placeholder - get hci_chan for logical link */ 49665b155ef9SMat Martineau if (!hchan) { 49675b155ef9SMat Martineau /* Logical link not available */ 49685b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 49695b155ef9SMat Martineau break; 49705b155ef9SMat Martineau } 49715b155ef9SMat Martineau 49725b155ef9SMat Martineau /* If the logical link is not yet connected, do not 49735b155ef9SMat Martineau * send confirmation. 49745b155ef9SMat Martineau */ 49755b155ef9SMat Martineau if (hchan->state != BT_CONNECTED) 49765b155ef9SMat Martineau break; 49775b155ef9SMat Martineau 49785b155ef9SMat Martineau /* Logical link is already ready to go */ 49795b155ef9SMat Martineau 49805b155ef9SMat Martineau chan->hs_hcon = hchan->conn; 49815b155ef9SMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 49825b155ef9SMat Martineau 49835b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 49845b155ef9SMat Martineau /* Can confirm now */ 49855b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 49865b155ef9SMat Martineau } else { 49875b155ef9SMat Martineau /* Now only need move success 49885b155ef9SMat Martineau * to confirm 49895b155ef9SMat Martineau */ 49905b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 49915b155ef9SMat Martineau } 49925b155ef9SMat Martineau 49935b155ef9SMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 49945b155ef9SMat Martineau break; 49955b155ef9SMat Martineau default: 49965b155ef9SMat Martineau /* Any other amp move state means the move failed. */ 49975b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 49985b155ef9SMat Martineau l2cap_move_done(chan); 49995b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 50005b155ef9SMat Martineau } 50015b155ef9SMat Martineau 50025b155ef9SMat Martineau l2cap_chan_unlock(chan); 50035b155ef9SMat Martineau } 50045b155ef9SMat Martineau 50055b155ef9SMat Martineau static void l2cap_move_fail(struct l2cap_conn *conn, u8 ident, u16 icid, 50065b155ef9SMat Martineau u16 result) 50075b155ef9SMat Martineau { 50085b155ef9SMat Martineau struct l2cap_chan *chan; 50095b155ef9SMat Martineau 50105b155ef9SMat Martineau chan = l2cap_get_chan_by_ident(conn, ident); 50115b155ef9SMat Martineau if (!chan) { 50125b155ef9SMat Martineau /* Could not locate channel, icid is best guess */ 50135b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 50145b155ef9SMat Martineau return; 50155b155ef9SMat Martineau } 50165b155ef9SMat Martineau 50175b155ef9SMat Martineau __clear_chan_timer(chan); 50185b155ef9SMat Martineau 50195b155ef9SMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 50205b155ef9SMat Martineau if (result == L2CAP_MR_COLLISION) { 50215b155ef9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 50225b155ef9SMat Martineau } else { 50235b155ef9SMat Martineau /* Cleanup - cancel move */ 50245b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 50255b155ef9SMat Martineau l2cap_move_done(chan); 50265b155ef9SMat Martineau } 50275b155ef9SMat Martineau } 50285b155ef9SMat Martineau 50295b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 50305b155ef9SMat Martineau 50315b155ef9SMat Martineau l2cap_chan_unlock(chan); 50325b155ef9SMat Martineau } 50335b155ef9SMat Martineau 50345b155ef9SMat Martineau static int l2cap_move_channel_rsp(struct l2cap_conn *conn, 5035ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 5036ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 50378d5a04a1SMat Martineau { 50388d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 50398d5a04a1SMat Martineau u16 icid, result; 50408d5a04a1SMat Martineau 50418d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 50428d5a04a1SMat Martineau return -EPROTO; 50438d5a04a1SMat Martineau 50448d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 50458d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 50468d5a04a1SMat Martineau 5047ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 50488d5a04a1SMat Martineau 50495b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS || result == L2CAP_MR_PEND) 50505b155ef9SMat Martineau l2cap_move_continue(conn, icid, result); 50515b155ef9SMat Martineau else 50525b155ef9SMat Martineau l2cap_move_fail(conn, cmd->ident, icid, result); 50538d5a04a1SMat Martineau 50548d5a04a1SMat Martineau return 0; 50558d5a04a1SMat Martineau } 50568d5a04a1SMat Martineau 50575f3847a4SMat Martineau static int l2cap_move_channel_confirm(struct l2cap_conn *conn, 5058ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 5059ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 50608d5a04a1SMat Martineau { 50618d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 50625f3847a4SMat Martineau struct l2cap_chan *chan; 50638d5a04a1SMat Martineau u16 icid, result; 50648d5a04a1SMat Martineau 50658d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 50668d5a04a1SMat Martineau return -EPROTO; 50678d5a04a1SMat Martineau 50688d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 50698d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 50708d5a04a1SMat Martineau 5071ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 50728d5a04a1SMat Martineau 50735f3847a4SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 50745f3847a4SMat Martineau if (!chan) { 50755f3847a4SMat Martineau /* Spec requires a response even if the icid was not found */ 50768d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 50775f3847a4SMat Martineau return 0; 50785f3847a4SMat Martineau } 50795f3847a4SMat Martineau 50805f3847a4SMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM) { 50815f3847a4SMat Martineau if (result == L2CAP_MC_CONFIRMED) { 50825f3847a4SMat Martineau chan->local_amp_id = chan->move_id; 50835f3847a4SMat Martineau if (!chan->local_amp_id) 50845f3847a4SMat Martineau __release_logical_link(chan); 50855f3847a4SMat Martineau } else { 50865f3847a4SMat Martineau chan->move_id = chan->local_amp_id; 50875f3847a4SMat Martineau } 50885f3847a4SMat Martineau 50895f3847a4SMat Martineau l2cap_move_done(chan); 50905f3847a4SMat Martineau } 50915f3847a4SMat Martineau 50925f3847a4SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 50935f3847a4SMat Martineau 50945f3847a4SMat Martineau l2cap_chan_unlock(chan); 50958d5a04a1SMat Martineau 50968d5a04a1SMat Martineau return 0; 50978d5a04a1SMat Martineau } 50988d5a04a1SMat Martineau 50998d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 5100ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 5101ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 51028d5a04a1SMat Martineau { 51038d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 51043fd71a0aSMat Martineau struct l2cap_chan *chan; 51058d5a04a1SMat Martineau u16 icid; 51068d5a04a1SMat Martineau 51078d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 51088d5a04a1SMat Martineau return -EPROTO; 51098d5a04a1SMat Martineau 51108d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 51118d5a04a1SMat Martineau 5112ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 51138d5a04a1SMat Martineau 51143fd71a0aSMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 51153fd71a0aSMat Martineau if (!chan) 51163fd71a0aSMat Martineau return 0; 51173fd71a0aSMat Martineau 51183fd71a0aSMat Martineau __clear_chan_timer(chan); 51193fd71a0aSMat Martineau 51203fd71a0aSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM_RSP) { 51213fd71a0aSMat Martineau chan->local_amp_id = chan->move_id; 51223fd71a0aSMat Martineau 51233fd71a0aSMat Martineau if (!chan->local_amp_id && chan->hs_hchan) 51243fd71a0aSMat Martineau __release_logical_link(chan); 51253fd71a0aSMat Martineau 51263fd71a0aSMat Martineau l2cap_move_done(chan); 51273fd71a0aSMat Martineau } 51283fd71a0aSMat Martineau 51293fd71a0aSMat Martineau l2cap_chan_unlock(chan); 51303fd71a0aSMat Martineau 51318d5a04a1SMat Martineau return 0; 51328d5a04a1SMat Martineau } 51338d5a04a1SMat Martineau 5134e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 5135de73115aSClaudio Takahasi u16 to_multiplier) 5136de73115aSClaudio Takahasi { 5137de73115aSClaudio Takahasi u16 max_latency; 5138de73115aSClaudio Takahasi 5139de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 5140de73115aSClaudio Takahasi return -EINVAL; 5141de73115aSClaudio Takahasi 5142de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 5143de73115aSClaudio Takahasi return -EINVAL; 5144de73115aSClaudio Takahasi 5145de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 5146de73115aSClaudio Takahasi return -EINVAL; 5147de73115aSClaudio Takahasi 5148de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 5149de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 5150de73115aSClaudio Takahasi return -EINVAL; 5151de73115aSClaudio Takahasi 5152de73115aSClaudio Takahasi return 0; 5153de73115aSClaudio Takahasi } 5154de73115aSClaudio Takahasi 5155de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 51562d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 51572d792818SGustavo Padovan u8 *data) 5158de73115aSClaudio Takahasi { 5159de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 5160de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 5161de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 5162de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 51632ce603ebSClaudio Takahasi int err; 5164de73115aSClaudio Takahasi 5165de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 5166de73115aSClaudio Takahasi return -EINVAL; 5167de73115aSClaudio Takahasi 5168de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 5169de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 5170de73115aSClaudio Takahasi return -EPROTO; 5171de73115aSClaudio Takahasi 5172de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 5173de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 5174de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 5175de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 5176de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 5177de73115aSClaudio Takahasi 5178de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 5179de73115aSClaudio Takahasi min, max, latency, to_multiplier); 5180de73115aSClaudio Takahasi 5181de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 51822ce603ebSClaudio Takahasi 51832ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 51842ce603ebSClaudio Takahasi if (err) 5185ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 5186de73115aSClaudio Takahasi else 5187ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 5188de73115aSClaudio Takahasi 5189de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 5190de73115aSClaudio Takahasi sizeof(rsp), &rsp); 5191de73115aSClaudio Takahasi 51922ce603ebSClaudio Takahasi if (!err) 51932ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 51942ce603ebSClaudio Takahasi 5195de73115aSClaudio Takahasi return 0; 5196de73115aSClaudio Takahasi } 5197de73115aSClaudio Takahasi 51983300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 51992d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 52002d792818SGustavo Padovan u8 *data) 52013300d9a9SClaudio Takahasi { 52023300d9a9SClaudio Takahasi int err = 0; 52033300d9a9SClaudio Takahasi 52043300d9a9SClaudio Takahasi switch (cmd->code) { 52053300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 5206cb3b3152SJohan Hedberg l2cap_command_rej(conn, cmd, cmd_len, data); 52073300d9a9SClaudio Takahasi break; 52083300d9a9SClaudio Takahasi 52093300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 5210cb3b3152SJohan Hedberg err = l2cap_connect_req(conn, cmd, cmd_len, data); 52113300d9a9SClaudio Takahasi break; 52123300d9a9SClaudio Takahasi 52133300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 5214f5a2598dSMat Martineau case L2CAP_CREATE_CHAN_RSP: 5215cb3b3152SJohan Hedberg err = l2cap_connect_create_rsp(conn, cmd, cmd_len, data); 52163300d9a9SClaudio Takahasi break; 52173300d9a9SClaudio Takahasi 52183300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 52193300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 52203300d9a9SClaudio Takahasi break; 52213300d9a9SClaudio Takahasi 52223300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 5223cb3b3152SJohan Hedberg err = l2cap_config_rsp(conn, cmd, cmd_len, data); 52243300d9a9SClaudio Takahasi break; 52253300d9a9SClaudio Takahasi 52263300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 5227cb3b3152SJohan Hedberg err = l2cap_disconnect_req(conn, cmd, cmd_len, data); 52283300d9a9SClaudio Takahasi break; 52293300d9a9SClaudio Takahasi 52303300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 5231cb3b3152SJohan Hedberg err = l2cap_disconnect_rsp(conn, cmd, cmd_len, data); 52323300d9a9SClaudio Takahasi break; 52333300d9a9SClaudio Takahasi 52343300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 52353300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 52363300d9a9SClaudio Takahasi break; 52373300d9a9SClaudio Takahasi 52383300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 52393300d9a9SClaudio Takahasi break; 52403300d9a9SClaudio Takahasi 52413300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 5242cb3b3152SJohan Hedberg err = l2cap_information_req(conn, cmd, cmd_len, data); 52433300d9a9SClaudio Takahasi break; 52443300d9a9SClaudio Takahasi 52453300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 5246cb3b3152SJohan Hedberg err = l2cap_information_rsp(conn, cmd, cmd_len, data); 52473300d9a9SClaudio Takahasi break; 52483300d9a9SClaudio Takahasi 5249f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 5250f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 5251f94ff6ffSMat Martineau break; 5252f94ff6ffSMat Martineau 52538d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 52548d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 52558d5a04a1SMat Martineau break; 52568d5a04a1SMat Martineau 52578d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 52588d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 52598d5a04a1SMat Martineau break; 52608d5a04a1SMat Martineau 52618d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 52628d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 52638d5a04a1SMat Martineau break; 52648d5a04a1SMat Martineau 52658d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 52668d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 52678d5a04a1SMat Martineau break; 52688d5a04a1SMat Martineau 52693300d9a9SClaudio Takahasi default: 52703300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 52713300d9a9SClaudio Takahasi err = -EINVAL; 52723300d9a9SClaudio Takahasi break; 52733300d9a9SClaudio Takahasi } 52743300d9a9SClaudio Takahasi 52753300d9a9SClaudio Takahasi return err; 52763300d9a9SClaudio Takahasi } 52773300d9a9SClaudio Takahasi 52783300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 52793300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 52803300d9a9SClaudio Takahasi { 52813300d9a9SClaudio Takahasi switch (cmd->code) { 52823300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 52833300d9a9SClaudio Takahasi return 0; 52843300d9a9SClaudio Takahasi 52853300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 5286de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 52873300d9a9SClaudio Takahasi 52883300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 52893300d9a9SClaudio Takahasi return 0; 52903300d9a9SClaudio Takahasi 52913300d9a9SClaudio Takahasi default: 52923300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 52933300d9a9SClaudio Takahasi return -EINVAL; 52943300d9a9SClaudio Takahasi } 52953300d9a9SClaudio Takahasi } 52963300d9a9SClaudio Takahasi 52977c2005d6SJohan Hedberg static __le16 l2cap_err_to_reason(int err) 52987c2005d6SJohan Hedberg { 52997c2005d6SJohan Hedberg switch (err) { 53007c2005d6SJohan Hedberg case -EBADSLT: 53017c2005d6SJohan Hedberg return __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 53027c2005d6SJohan Hedberg case -EMSGSIZE: 53037c2005d6SJohan Hedberg return __constant_cpu_to_le16(L2CAP_REJ_MTU_EXCEEDED); 53047c2005d6SJohan Hedberg case -EINVAL: 53057c2005d6SJohan Hedberg case -EPROTO: 53067c2005d6SJohan Hedberg default: 53077c2005d6SJohan Hedberg return __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 53087c2005d6SJohan Hedberg } 53097c2005d6SJohan Hedberg } 53107c2005d6SJohan Hedberg 5311c5623556SJohan Hedberg static inline void l2cap_le_sig_channel(struct l2cap_conn *conn, 5312c5623556SJohan Hedberg struct sk_buff *skb) 5313c5623556SJohan Hedberg { 5314c5623556SJohan Hedberg u8 *data = skb->data; 5315c5623556SJohan Hedberg int len = skb->len; 5316c5623556SJohan Hedberg struct l2cap_cmd_hdr cmd; 5317c5623556SJohan Hedberg int err; 5318c5623556SJohan Hedberg 5319c5623556SJohan Hedberg l2cap_raw_recv(conn, skb); 5320c5623556SJohan Hedberg 5321c5623556SJohan Hedberg while (len >= L2CAP_CMD_HDR_SIZE) { 5322c5623556SJohan Hedberg u16 cmd_len; 5323c5623556SJohan Hedberg memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 5324c5623556SJohan Hedberg data += L2CAP_CMD_HDR_SIZE; 5325c5623556SJohan Hedberg len -= L2CAP_CMD_HDR_SIZE; 5326c5623556SJohan Hedberg 5327c5623556SJohan Hedberg cmd_len = le16_to_cpu(cmd.len); 5328c5623556SJohan Hedberg 5329c5623556SJohan Hedberg BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 5330c5623556SJohan Hedberg cmd.ident); 5331c5623556SJohan Hedberg 5332c5623556SJohan Hedberg if (cmd_len > len || !cmd.ident) { 5333c5623556SJohan Hedberg BT_DBG("corrupted command"); 5334c5623556SJohan Hedberg break; 5335c5623556SJohan Hedberg } 5336c5623556SJohan Hedberg 5337c5623556SJohan Hedberg err = l2cap_le_sig_cmd(conn, &cmd, data); 5338c5623556SJohan Hedberg if (err) { 5339c5623556SJohan Hedberg struct l2cap_cmd_rej_unk rej; 5340c5623556SJohan Hedberg 5341c5623556SJohan Hedberg BT_ERR("Wrong link type (%d)", err); 5342c5623556SJohan Hedberg 53437c2005d6SJohan Hedberg rej.reason = l2cap_err_to_reason(err); 5344c5623556SJohan Hedberg l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 5345c5623556SJohan Hedberg sizeof(rej), &rej); 5346c5623556SJohan Hedberg } 5347c5623556SJohan Hedberg 5348c5623556SJohan Hedberg data += cmd_len; 5349c5623556SJohan Hedberg len -= cmd_len; 5350c5623556SJohan Hedberg } 5351c5623556SJohan Hedberg 5352c5623556SJohan Hedberg kfree_skb(skb); 5353c5623556SJohan Hedberg } 5354c5623556SJohan Hedberg 53553300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 53563300d9a9SClaudio Takahasi struct sk_buff *skb) 53570a708f8fSGustavo F. Padovan { 53580a708f8fSGustavo F. Padovan u8 *data = skb->data; 53590a708f8fSGustavo F. Padovan int len = skb->len; 53600a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 53613300d9a9SClaudio Takahasi int err; 53620a708f8fSGustavo F. Padovan 53630a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 53640a708f8fSGustavo F. Padovan 53650a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 53660a708f8fSGustavo F. Padovan u16 cmd_len; 53670a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 53680a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 53690a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 53700a708f8fSGustavo F. Padovan 53710a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 53720a708f8fSGustavo F. Padovan 53732d792818SGustavo Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 53742d792818SGustavo Padovan cmd.ident); 53750a708f8fSGustavo F. Padovan 53760a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 53770a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 53780a708f8fSGustavo F. Padovan break; 53790a708f8fSGustavo F. Padovan } 53800a708f8fSGustavo F. Padovan 53813300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 53820a708f8fSGustavo F. Padovan if (err) { 5383e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 53842c6d1a2eSGustavo F. Padovan 53852c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 53860a708f8fSGustavo F. Padovan 53877c2005d6SJohan Hedberg rej.reason = l2cap_err_to_reason(err); 53882d792818SGustavo Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 53892d792818SGustavo Padovan sizeof(rej), &rej); 53900a708f8fSGustavo F. Padovan } 53910a708f8fSGustavo F. Padovan 53920a708f8fSGustavo F. Padovan data += cmd_len; 53930a708f8fSGustavo F. Padovan len -= cmd_len; 53940a708f8fSGustavo F. Padovan } 53950a708f8fSGustavo F. Padovan 53960a708f8fSGustavo F. Padovan kfree_skb(skb); 53970a708f8fSGustavo F. Padovan } 53980a708f8fSGustavo F. Padovan 539947d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 54000a708f8fSGustavo F. Padovan { 54010a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 5402e4ca6d98SAndrei Emeltchenko int hdr_size; 5403e4ca6d98SAndrei Emeltchenko 5404e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 5405e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 5406e4ca6d98SAndrei Emeltchenko else 5407e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 54080a708f8fSGustavo F. Padovan 540947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 541003a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 54110a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 54120a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 54130a708f8fSGustavo F. Padovan 54140a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 54150a708f8fSGustavo F. Padovan return -EBADMSG; 54160a708f8fSGustavo F. Padovan } 54170a708f8fSGustavo F. Padovan return 0; 54180a708f8fSGustavo F. Padovan } 54190a708f8fSGustavo F. Padovan 54206ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 54210a708f8fSGustavo F. Padovan { 5422e31f7633SMat Martineau struct l2cap_ctrl control; 54230a708f8fSGustavo F. Padovan 5424e31f7633SMat Martineau BT_DBG("chan %p", chan); 54250a708f8fSGustavo F. Padovan 5426e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 5427e31f7633SMat Martineau control.sframe = 1; 5428e31f7633SMat Martineau control.final = 1; 5429e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 5430e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 54310a708f8fSGustavo F. Padovan 5432e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5433e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 5434e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 54350a708f8fSGustavo F. Padovan } 54360a708f8fSGustavo F. Padovan 5437e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 5438e31f7633SMat Martineau chan->unacked_frames > 0) 5439e31f7633SMat Martineau __set_retrans_timer(chan); 54400a708f8fSGustavo F. Padovan 5441e31f7633SMat Martineau /* Send pending iframes */ 5442525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 54430a708f8fSGustavo F. Padovan 5444e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 5445e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 5446e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 5447e31f7633SMat Martineau * send it now. 5448e31f7633SMat Martineau */ 5449e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 5450e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 54510a708f8fSGustavo F. Padovan } 54520a708f8fSGustavo F. Padovan } 54530a708f8fSGustavo F. Padovan 54542d792818SGustavo Padovan static void append_skb_frag(struct sk_buff *skb, struct sk_buff *new_frag, 54552d792818SGustavo Padovan struct sk_buff **last_frag) 54560a708f8fSGustavo F. Padovan { 545784084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 545884084a31SMat Martineau * skb->data_len reflects only data in fragments 545984084a31SMat Martineau */ 546084084a31SMat Martineau if (!skb_has_frag_list(skb)) 546184084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 546284084a31SMat Martineau 546384084a31SMat Martineau new_frag->next = NULL; 546484084a31SMat Martineau 546584084a31SMat Martineau (*last_frag)->next = new_frag; 546684084a31SMat Martineau *last_frag = new_frag; 546784084a31SMat Martineau 546884084a31SMat Martineau skb->len += new_frag->len; 546984084a31SMat Martineau skb->data_len += new_frag->len; 547084084a31SMat Martineau skb->truesize += new_frag->truesize; 547184084a31SMat Martineau } 547284084a31SMat Martineau 54734b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 54744b51dae9SMat Martineau struct l2cap_ctrl *control) 547584084a31SMat Martineau { 547684084a31SMat Martineau int err = -EINVAL; 54770a708f8fSGustavo F. Padovan 54784b51dae9SMat Martineau switch (control->sar) { 54797e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 548084084a31SMat Martineau if (chan->sdu) 548184084a31SMat Martineau break; 54820a708f8fSGustavo F. Padovan 548380b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 548484084a31SMat Martineau break; 54850a708f8fSGustavo F. Padovan 54867e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 548784084a31SMat Martineau if (chan->sdu) 548884084a31SMat Martineau break; 54890a708f8fSGustavo F. Padovan 54906f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 549103a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 54920a708f8fSGustavo F. Padovan 549384084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 549484084a31SMat Martineau err = -EMSGSIZE; 549584084a31SMat Martineau break; 549684084a31SMat Martineau } 54970a708f8fSGustavo F. Padovan 549884084a31SMat Martineau if (skb->len >= chan->sdu_len) 549984084a31SMat Martineau break; 550084084a31SMat Martineau 550184084a31SMat Martineau chan->sdu = skb; 550284084a31SMat Martineau chan->sdu_last_frag = skb; 550384084a31SMat Martineau 550484084a31SMat Martineau skb = NULL; 550584084a31SMat Martineau err = 0; 55060a708f8fSGustavo F. Padovan break; 55070a708f8fSGustavo F. Padovan 55087e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 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 551984084a31SMat Martineau err = 0; 55200a708f8fSGustavo F. Padovan break; 55210a708f8fSGustavo F. Padovan 55227e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 55236f61fd47SGustavo F. Padovan if (!chan->sdu) 552484084a31SMat Martineau break; 55250a708f8fSGustavo F. Padovan 552684084a31SMat Martineau append_skb_frag(chan->sdu, skb, 552784084a31SMat Martineau &chan->sdu_last_frag); 552884084a31SMat Martineau skb = NULL; 55290a708f8fSGustavo F. Padovan 553084084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 553184084a31SMat Martineau break; 55320a708f8fSGustavo F. Padovan 553380b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 55340a708f8fSGustavo F. Padovan 553584084a31SMat Martineau if (!err) { 553684084a31SMat Martineau /* Reassembly complete */ 553784084a31SMat Martineau chan->sdu = NULL; 553884084a31SMat Martineau chan->sdu_last_frag = NULL; 553984084a31SMat Martineau chan->sdu_len = 0; 55400a708f8fSGustavo F. Padovan } 55410a708f8fSGustavo F. Padovan break; 55420a708f8fSGustavo F. Padovan } 55430a708f8fSGustavo F. Padovan 554484084a31SMat Martineau if (err) { 55450a708f8fSGustavo F. Padovan kfree_skb(skb); 55466f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 55476f61fd47SGustavo F. Padovan chan->sdu = NULL; 554884084a31SMat Martineau chan->sdu_last_frag = NULL; 554984084a31SMat Martineau chan->sdu_len = 0; 555084084a31SMat Martineau } 55510a708f8fSGustavo F. Padovan 555284084a31SMat Martineau return err; 55530a708f8fSGustavo F. Padovan } 55540a708f8fSGustavo F. Padovan 555532b32735SMat Martineau static int l2cap_resegment(struct l2cap_chan *chan) 555632b32735SMat Martineau { 555732b32735SMat Martineau /* Placeholder */ 555832b32735SMat Martineau return 0; 555932b32735SMat Martineau } 556032b32735SMat Martineau 5561e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 55620a708f8fSGustavo F. Padovan { 556361aa4f5bSMat Martineau u8 event; 556461aa4f5bSMat Martineau 556561aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 556661aa4f5bSMat Martineau return; 556761aa4f5bSMat Martineau 556861aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 5569401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 55700a708f8fSGustavo F. Padovan } 55710a708f8fSGustavo F. Padovan 5572d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 5573d2a7ac5dSMat Martineau { 557463838725SMat Martineau int err = 0; 557563838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 557663838725SMat Martineau * until a gap is encountered. 557763838725SMat Martineau */ 557863838725SMat Martineau 557963838725SMat Martineau BT_DBG("chan %p", chan); 558063838725SMat Martineau 558163838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 558263838725SMat Martineau struct sk_buff *skb; 558363838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 558463838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 558563838725SMat Martineau 558663838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 558763838725SMat Martineau 558863838725SMat Martineau if (!skb) 558963838725SMat Martineau break; 559063838725SMat Martineau 559163838725SMat Martineau skb_unlink(skb, &chan->srej_q); 559263838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 559363838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 559463838725SMat Martineau if (err) 559563838725SMat Martineau break; 559663838725SMat Martineau } 559763838725SMat Martineau 559863838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 559963838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 560063838725SMat Martineau l2cap_send_ack(chan); 560163838725SMat Martineau } 560263838725SMat Martineau 560363838725SMat Martineau return err; 5604d2a7ac5dSMat Martineau } 5605d2a7ac5dSMat Martineau 5606d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 5607d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5608d2a7ac5dSMat Martineau { 5609f80842a8SMat Martineau struct sk_buff *skb; 5610f80842a8SMat Martineau 5611f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 5612f80842a8SMat Martineau 5613f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 5614f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 56155e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5616f80842a8SMat Martineau return; 5617f80842a8SMat Martineau } 5618f80842a8SMat Martineau 5619f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5620f80842a8SMat Martineau 5621f80842a8SMat Martineau if (skb == NULL) { 5622f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 5623f80842a8SMat Martineau control->reqseq); 5624f80842a8SMat Martineau return; 5625f80842a8SMat Martineau } 5626f80842a8SMat Martineau 5627f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 5628f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 56295e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5630f80842a8SMat Martineau return; 5631f80842a8SMat Martineau } 5632f80842a8SMat Martineau 5633f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5634f80842a8SMat Martineau 5635f80842a8SMat Martineau if (control->poll) { 5636f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 5637f80842a8SMat Martineau 5638f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5639f80842a8SMat Martineau l2cap_retransmit(chan, control); 5640f80842a8SMat Martineau l2cap_ertm_send(chan); 5641f80842a8SMat Martineau 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 } else { 5647f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 5648f80842a8SMat Martineau 5649f80842a8SMat Martineau if (control->final) { 5650f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 5651f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 5652f80842a8SMat Martineau &chan->conn_state)) 5653f80842a8SMat Martineau l2cap_retransmit(chan, control); 5654f80842a8SMat Martineau } else { 5655f80842a8SMat Martineau l2cap_retransmit(chan, control); 5656f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 5657f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 5658f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 5659f80842a8SMat Martineau } 5660f80842a8SMat Martineau } 5661f80842a8SMat Martineau } 5662d2a7ac5dSMat Martineau } 5663d2a7ac5dSMat Martineau 5664d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 5665d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5666d2a7ac5dSMat Martineau { 5667fcd289dfSMat Martineau struct sk_buff *skb; 5668fcd289dfSMat Martineau 5669fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 5670fcd289dfSMat Martineau 5671fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 5672fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 56735e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5674fcd289dfSMat Martineau return; 5675fcd289dfSMat Martineau } 5676fcd289dfSMat Martineau 5677fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5678fcd289dfSMat Martineau 5679fcd289dfSMat Martineau if (chan->max_tx && skb && 5680fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 5681fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 56825e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5683fcd289dfSMat Martineau return; 5684fcd289dfSMat Martineau } 5685fcd289dfSMat Martineau 5686fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5687fcd289dfSMat Martineau 5688fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 5689fcd289dfSMat Martineau 5690fcd289dfSMat Martineau if (control->final) { 5691fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 5692fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5693fcd289dfSMat Martineau } else { 5694fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5695fcd289dfSMat Martineau l2cap_ertm_send(chan); 5696fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 5697fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 5698fcd289dfSMat Martineau } 5699d2a7ac5dSMat Martineau } 5700d2a7ac5dSMat Martineau 57014b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 57024b51dae9SMat Martineau { 57034b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 57044b51dae9SMat Martineau 57054b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 57064b51dae9SMat Martineau chan->expected_tx_seq); 57074b51dae9SMat Martineau 57084b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 57094b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 57104b51dae9SMat Martineau chan->tx_win) { 57114b51dae9SMat Martineau /* See notes below regarding "double poll" and 57124b51dae9SMat Martineau * invalid packets. 57134b51dae9SMat Martineau */ 57144b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 57154b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 57164b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 57174b51dae9SMat Martineau } else { 57184b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 57194b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 57204b51dae9SMat Martineau } 57214b51dae9SMat Martineau } 57224b51dae9SMat Martineau 57234b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 57244b51dae9SMat Martineau BT_DBG("Expected SREJ"); 57254b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 57264b51dae9SMat Martineau } 57274b51dae9SMat Martineau 57284b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 57294b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 57304b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 57314b51dae9SMat Martineau } 57324b51dae9SMat Martineau 57334b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 57344b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 57354b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 57364b51dae9SMat Martineau } 57374b51dae9SMat Martineau } 57384b51dae9SMat Martineau 57394b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 57404b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 57414b51dae9SMat Martineau chan->tx_win) { 57424b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 57434b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 57444b51dae9SMat Martineau } else { 57454b51dae9SMat Martineau BT_DBG("Expected"); 57464b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 57474b51dae9SMat Martineau } 57484b51dae9SMat Martineau } 57494b51dae9SMat Martineau 57504b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 57512d792818SGustavo Padovan __seq_offset(chan, chan->expected_tx_seq, chan->last_acked_seq)) { 57524b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 57534b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 57544b51dae9SMat Martineau } 57554b51dae9SMat Martineau 57564b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 57574b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 57584b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 57594b51dae9SMat Martineau * the remote stack receives and processes both polls, 57604b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 57614b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 57624b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 57634b51dae9SMat Martineau * request. 57644b51dae9SMat Martineau * 57654b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 57664b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 57674b51dae9SMat Martineau * invalid frames to be safely ignored. 57684b51dae9SMat Martineau * 57694b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 57704b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 57714b51dae9SMat Martineau * causes a disconnect. 57724b51dae9SMat Martineau */ 57734b51dae9SMat Martineau 57744b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 57754b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 57764b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 57774b51dae9SMat Martineau } else { 57784b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 57794b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 57804b51dae9SMat Martineau } 57814b51dae9SMat Martineau } else { 57824b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 57834b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 57844b51dae9SMat Martineau } 57854b51dae9SMat Martineau } 57864b51dae9SMat Martineau 5787d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 5788d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5789d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5790d2a7ac5dSMat Martineau { 5791d2a7ac5dSMat Martineau int err = 0; 5792d2a7ac5dSMat Martineau bool skb_in_use = 0; 5793d2a7ac5dSMat Martineau 5794d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5795d2a7ac5dSMat Martineau event); 5796d2a7ac5dSMat Martineau 5797d2a7ac5dSMat Martineau switch (event) { 5798d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5799d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 5800d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5801d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5802d2a7ac5dSMat Martineau 5803d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5804d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 5805d2a7ac5dSMat Martineau control->txseq); 5806d2a7ac5dSMat Martineau break; 5807d2a7ac5dSMat Martineau } 5808d2a7ac5dSMat Martineau 5809d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 5810d2a7ac5dSMat Martineau control->txseq); 5811d2a7ac5dSMat Martineau 5812d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 5813d2a7ac5dSMat Martineau skb_in_use = 1; 5814d2a7ac5dSMat Martineau 5815d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 5816d2a7ac5dSMat Martineau if (err) 5817d2a7ac5dSMat Martineau break; 5818d2a7ac5dSMat Martineau 5819d2a7ac5dSMat Martineau if (control->final) { 5820d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5821d2a7ac5dSMat Martineau &chan->conn_state)) { 5822d2a7ac5dSMat Martineau control->final = 0; 5823d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5824d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5825d2a7ac5dSMat Martineau } 5826d2a7ac5dSMat Martineau } 5827d2a7ac5dSMat Martineau 5828d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 5829d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5830d2a7ac5dSMat Martineau break; 5831d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5832d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5833d2a7ac5dSMat Martineau 5834d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 5835d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 5836d2a7ac5dSMat Martineau * when local busy is exited. 5837d2a7ac5dSMat Martineau */ 5838d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5839d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 5840d2a7ac5dSMat Martineau control->txseq); 5841d2a7ac5dSMat Martineau break; 5842d2a7ac5dSMat Martineau } 5843d2a7ac5dSMat Martineau 5844d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 5845d2a7ac5dSMat Martineau * must be sent for each missing frame. The 5846d2a7ac5dSMat Martineau * current frame is stored for later use. 5847d2a7ac5dSMat Martineau */ 5848d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5849d2a7ac5dSMat Martineau skb_in_use = 1; 5850d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5851d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5852d2a7ac5dSMat Martineau 5853d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 5854d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 5855d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5856d2a7ac5dSMat Martineau 5857d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 5858d2a7ac5dSMat Martineau break; 5859d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5860d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5861d2a7ac5dSMat Martineau break; 5862d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5863d2a7ac5dSMat Martineau break; 5864d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5865d2a7ac5dSMat Martineau default: 58665e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 5867d2a7ac5dSMat Martineau break; 5868d2a7ac5dSMat Martineau } 5869d2a7ac5dSMat Martineau break; 5870d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5871d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5872d2a7ac5dSMat Martineau if (control->final) { 5873d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5874d2a7ac5dSMat Martineau 5875e6a3ee6eSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state) && 5876e6a3ee6eSMat Martineau !__chan_is_moving(chan)) { 5877d2a7ac5dSMat Martineau control->final = 0; 5878d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5879d2a7ac5dSMat Martineau } 5880d2a7ac5dSMat Martineau 5881d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5882d2a7ac5dSMat Martineau } else if (control->poll) { 5883d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 5884d2a7ac5dSMat Martineau } else { 5885d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5886d2a7ac5dSMat Martineau &chan->conn_state) && 5887d2a7ac5dSMat Martineau chan->unacked_frames) 5888d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5889d2a7ac5dSMat Martineau 5890d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5891d2a7ac5dSMat Martineau } 5892d2a7ac5dSMat Martineau break; 5893d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5894d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5895d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5896d2a7ac5dSMat Martineau if (control && control->poll) { 5897d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5898d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 5899d2a7ac5dSMat Martineau } 5900d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 5901d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 5902d2a7ac5dSMat Martineau break; 5903d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5904d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5905d2a7ac5dSMat Martineau break; 5906d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5907d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5908d2a7ac5dSMat Martineau break; 5909d2a7ac5dSMat Martineau default: 5910d2a7ac5dSMat Martineau break; 5911d2a7ac5dSMat Martineau } 5912d2a7ac5dSMat Martineau 5913d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5914d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5915d2a7ac5dSMat Martineau kfree_skb(skb); 5916d2a7ac5dSMat Martineau } 5917d2a7ac5dSMat Martineau 5918d2a7ac5dSMat Martineau return err; 5919d2a7ac5dSMat Martineau } 5920d2a7ac5dSMat Martineau 5921d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 5922d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5923d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5924d2a7ac5dSMat Martineau { 5925d2a7ac5dSMat Martineau int err = 0; 5926d2a7ac5dSMat Martineau u16 txseq = control->txseq; 5927d2a7ac5dSMat Martineau bool skb_in_use = 0; 5928d2a7ac5dSMat Martineau 5929d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5930d2a7ac5dSMat Martineau event); 5931d2a7ac5dSMat Martineau 5932d2a7ac5dSMat Martineau switch (event) { 5933d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5934d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 5935d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5936d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 5937d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5938d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5939d2a7ac5dSMat Martineau skb_in_use = 1; 5940d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5941d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5942d2a7ac5dSMat Martineau 5943d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 5944d2a7ac5dSMat Martineau break; 5945d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 5946d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 5947d2a7ac5dSMat Martineau 5948d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5949d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5950d2a7ac5dSMat Martineau skb_in_use = 1; 5951d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5952d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5953d2a7ac5dSMat Martineau 5954d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 5955d2a7ac5dSMat Martineau if (err) 5956d2a7ac5dSMat Martineau break; 5957d2a7ac5dSMat Martineau 5958d2a7ac5dSMat Martineau break; 5959d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5960d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 5961d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 5962d2a7ac5dSMat Martineau * the missing 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(chan, control->txseq); 5971d2a7ac5dSMat Martineau break; 5972d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 5973d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 5974d2a7ac5dSMat Martineau * some expected retransmitted frames are 5975d2a7ac5dSMat Martineau * missing. Request retransmission of missing 5976d2a7ac5dSMat Martineau * SREJ'd frames. 5977d2a7ac5dSMat Martineau */ 5978d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5979d2a7ac5dSMat Martineau skb_in_use = 1; 5980d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5981d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5982d2a7ac5dSMat Martineau 5983d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5984d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 5985d2a7ac5dSMat Martineau break; 5986d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 5987d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 5988d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5989d2a7ac5dSMat Martineau break; 5990d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5991d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 5992d2a7ac5dSMat Martineau * was already received. Ignore it completely. 5993d2a7ac5dSMat Martineau */ 5994d2a7ac5dSMat Martineau break; 5995d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5996d2a7ac5dSMat Martineau break; 5997d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5998d2a7ac5dSMat Martineau default: 59995e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 6000d2a7ac5dSMat Martineau break; 6001d2a7ac5dSMat Martineau } 6002d2a7ac5dSMat Martineau break; 6003d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 6004d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 6005d2a7ac5dSMat Martineau if (control->final) { 6006d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 6007d2a7ac5dSMat Martineau 6008d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 6009d2a7ac5dSMat Martineau &chan->conn_state)) { 6010d2a7ac5dSMat Martineau control->final = 0; 6011d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 6012d2a7ac5dSMat Martineau } 6013d2a7ac5dSMat Martineau 6014d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 6015d2a7ac5dSMat Martineau } else if (control->poll) { 6016d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 6017d2a7ac5dSMat Martineau &chan->conn_state) && 6018d2a7ac5dSMat Martineau chan->unacked_frames) { 6019d2a7ac5dSMat Martineau __set_retrans_timer(chan); 6020d2a7ac5dSMat Martineau } 6021d2a7ac5dSMat Martineau 6022d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 6023d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 6024d2a7ac5dSMat Martineau } else { 6025d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 6026d2a7ac5dSMat Martineau &chan->conn_state) && 6027d2a7ac5dSMat Martineau chan->unacked_frames) 6028d2a7ac5dSMat Martineau __set_retrans_timer(chan); 6029d2a7ac5dSMat Martineau 6030d2a7ac5dSMat Martineau l2cap_send_ack(chan); 6031d2a7ac5dSMat Martineau } 6032d2a7ac5dSMat Martineau break; 6033d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 6034d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 6035d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 6036d2a7ac5dSMat Martineau if (control->poll) { 6037d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 6038d2a7ac5dSMat Martineau } else { 6039d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 6040d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 6041d2a7ac5dSMat Martineau rr_control.sframe = 1; 6042d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 6043d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 6044d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 6045d2a7ac5dSMat Martineau } 6046d2a7ac5dSMat Martineau 6047d2a7ac5dSMat Martineau break; 6048d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 6049d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 6050d2a7ac5dSMat Martineau break; 6051d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 6052d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 6053d2a7ac5dSMat Martineau break; 6054d2a7ac5dSMat Martineau } 6055d2a7ac5dSMat Martineau 6056d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 6057d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 6058d2a7ac5dSMat Martineau kfree_skb(skb); 6059d2a7ac5dSMat Martineau } 6060d2a7ac5dSMat Martineau 6061d2a7ac5dSMat Martineau return err; 6062d2a7ac5dSMat Martineau } 6063d2a7ac5dSMat Martineau 606432b32735SMat Martineau static int l2cap_finish_move(struct l2cap_chan *chan) 606532b32735SMat Martineau { 606632b32735SMat Martineau BT_DBG("chan %p", chan); 606732b32735SMat Martineau 606832b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 606932b32735SMat Martineau 607032b32735SMat Martineau if (chan->hs_hcon) 607132b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 607232b32735SMat Martineau else 607332b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 607432b32735SMat Martineau 607532b32735SMat Martineau return l2cap_resegment(chan); 607632b32735SMat Martineau } 607732b32735SMat Martineau 607832b32735SMat Martineau static int l2cap_rx_state_wait_p(struct l2cap_chan *chan, 607932b32735SMat Martineau struct l2cap_ctrl *control, 608032b32735SMat Martineau struct sk_buff *skb, u8 event) 608132b32735SMat Martineau { 608232b32735SMat Martineau int err; 608332b32735SMat Martineau 608432b32735SMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 608532b32735SMat Martineau event); 608632b32735SMat Martineau 608732b32735SMat Martineau if (!control->poll) 608832b32735SMat Martineau return -EPROTO; 608932b32735SMat Martineau 609032b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 609132b32735SMat Martineau 609232b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 609332b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 609432b32735SMat Martineau else 609532b32735SMat Martineau chan->tx_send_head = NULL; 609632b32735SMat Martineau 609732b32735SMat Martineau /* Rewind next_tx_seq to the point expected 609832b32735SMat Martineau * by the receiver. 609932b32735SMat Martineau */ 610032b32735SMat Martineau chan->next_tx_seq = control->reqseq; 610132b32735SMat Martineau chan->unacked_frames = 0; 610232b32735SMat Martineau 610332b32735SMat Martineau err = l2cap_finish_move(chan); 610432b32735SMat Martineau if (err) 610532b32735SMat Martineau return err; 610632b32735SMat Martineau 610732b32735SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 610832b32735SMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 610932b32735SMat Martineau 611032b32735SMat Martineau if (event == L2CAP_EV_RECV_IFRAME) 611132b32735SMat Martineau return -EPROTO; 611232b32735SMat Martineau 611332b32735SMat Martineau return l2cap_rx_state_recv(chan, control, NULL, event); 611432b32735SMat Martineau } 611532b32735SMat Martineau 611632b32735SMat Martineau static int l2cap_rx_state_wait_f(struct l2cap_chan *chan, 611732b32735SMat Martineau struct l2cap_ctrl *control, 611832b32735SMat Martineau struct sk_buff *skb, u8 event) 611932b32735SMat Martineau { 612032b32735SMat Martineau int err; 612132b32735SMat Martineau 612232b32735SMat Martineau if (!control->final) 612332b32735SMat Martineau return -EPROTO; 612432b32735SMat Martineau 612532b32735SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 612632b32735SMat Martineau 612732b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 612832b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 612932b32735SMat Martineau 613032b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 613132b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 613232b32735SMat Martineau else 613332b32735SMat Martineau chan->tx_send_head = NULL; 613432b32735SMat Martineau 613532b32735SMat Martineau /* Rewind next_tx_seq to the point expected 613632b32735SMat Martineau * by the receiver. 613732b32735SMat Martineau */ 613832b32735SMat Martineau chan->next_tx_seq = control->reqseq; 613932b32735SMat Martineau chan->unacked_frames = 0; 614032b32735SMat Martineau 614132b32735SMat Martineau if (chan->hs_hcon) 614232b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 614332b32735SMat Martineau else 614432b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 614532b32735SMat Martineau 614632b32735SMat Martineau err = l2cap_resegment(chan); 614732b32735SMat Martineau 614832b32735SMat Martineau if (!err) 614932b32735SMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 615032b32735SMat Martineau 615132b32735SMat Martineau return err; 615232b32735SMat Martineau } 615332b32735SMat Martineau 6154d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 6155d2a7ac5dSMat Martineau { 6156d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 6157d2a7ac5dSMat Martineau u16 unacked; 6158d2a7ac5dSMat Martineau 6159d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 6160d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 6161d2a7ac5dSMat Martineau } 6162d2a7ac5dSMat Martineau 6163cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 6164cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 61650a708f8fSGustavo F. Padovan { 6166d2a7ac5dSMat Martineau int err = 0; 6167d2a7ac5dSMat Martineau 6168d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 6169d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 6170d2a7ac5dSMat Martineau 6171d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 6172d2a7ac5dSMat Martineau switch (chan->rx_state) { 6173d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 6174d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 6175d2a7ac5dSMat Martineau break; 6176d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 6177d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 6178d2a7ac5dSMat Martineau event); 6179d2a7ac5dSMat Martineau break; 618032b32735SMat Martineau case L2CAP_RX_STATE_WAIT_P: 618132b32735SMat Martineau err = l2cap_rx_state_wait_p(chan, control, skb, event); 618232b32735SMat Martineau break; 618332b32735SMat Martineau case L2CAP_RX_STATE_WAIT_F: 618432b32735SMat Martineau err = l2cap_rx_state_wait_f(chan, control, skb, event); 618532b32735SMat Martineau break; 6186d2a7ac5dSMat Martineau default: 6187d2a7ac5dSMat Martineau /* shut it down */ 6188d2a7ac5dSMat Martineau break; 6189d2a7ac5dSMat Martineau } 6190d2a7ac5dSMat Martineau } else { 6191d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 6192d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 6193d2a7ac5dSMat Martineau chan->expected_ack_seq); 61945e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 6195d2a7ac5dSMat Martineau } 6196d2a7ac5dSMat Martineau 6197d2a7ac5dSMat Martineau return err; 6198cec8ab6eSMat Martineau } 6199cec8ab6eSMat Martineau 6200cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 6201cec8ab6eSMat Martineau struct sk_buff *skb) 6202cec8ab6eSMat Martineau { 62034b51dae9SMat Martineau int err = 0; 62044b51dae9SMat Martineau 62054b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 62064b51dae9SMat Martineau chan->rx_state); 62074b51dae9SMat Martineau 62084b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 62094b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 62104b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 62114b51dae9SMat Martineau 62124b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 62134b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 62144b51dae9SMat Martineau 62154b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 62164b51dae9SMat Martineau 62174b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 62184b51dae9SMat Martineau } else { 62194b51dae9SMat Martineau if (chan->sdu) { 62204b51dae9SMat Martineau kfree_skb(chan->sdu); 62214b51dae9SMat Martineau chan->sdu = NULL; 62224b51dae9SMat Martineau } 62234b51dae9SMat Martineau chan->sdu_last_frag = NULL; 62244b51dae9SMat Martineau chan->sdu_len = 0; 62254b51dae9SMat Martineau 62264b51dae9SMat Martineau if (skb) { 62274b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 62284b51dae9SMat Martineau kfree_skb(skb); 62294b51dae9SMat Martineau } 62304b51dae9SMat Martineau } 62314b51dae9SMat Martineau 62324b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 62334b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 62344b51dae9SMat Martineau 62354b51dae9SMat Martineau return err; 6236cec8ab6eSMat Martineau } 6237cec8ab6eSMat Martineau 6238cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 6239cec8ab6eSMat Martineau { 6240cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 6241cec8ab6eSMat Martineau u16 len; 6242cec8ab6eSMat Martineau u8 event; 62430a708f8fSGustavo F. Padovan 6244b76bbd66SMat Martineau __unpack_control(chan, skb); 6245b76bbd66SMat Martineau 62460a708f8fSGustavo F. Padovan len = skb->len; 62470a708f8fSGustavo F. Padovan 62480a708f8fSGustavo F. Padovan /* 62490a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 62500a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 6251cec8ab6eSMat Martineau * procedures and ask for retransmission. 62520a708f8fSGustavo F. Padovan */ 625347d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 62540a708f8fSGustavo F. Padovan goto drop; 62550a708f8fSGustavo F. Padovan 6256cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 625703a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 62580a708f8fSGustavo F. Padovan 625947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 626003a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 62610a708f8fSGustavo F. Padovan 626247d1ec61SGustavo F. Padovan if (len > chan->mps) { 62635e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 62640a708f8fSGustavo F. Padovan goto drop; 62650a708f8fSGustavo F. Padovan } 62660a708f8fSGustavo F. Padovan 6267cec8ab6eSMat Martineau if (!control->sframe) { 6268cec8ab6eSMat Martineau int err; 62690a708f8fSGustavo F. Padovan 6270cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 6271cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 6272cec8ab6eSMat Martineau control->txseq); 6273836be934SAndrei Emeltchenko 6274cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 6275cec8ab6eSMat Martineau * valid in TX WAIT_F 6276cec8ab6eSMat Martineau */ 6277cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 62780a708f8fSGustavo F. Padovan goto drop; 62790a708f8fSGustavo F. Padovan 6280cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 6281cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 6282cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 62830a708f8fSGustavo F. Padovan } else { 6284cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 6285cec8ab6eSMat Martineau } 6286cec8ab6eSMat Martineau 6287cec8ab6eSMat Martineau if (err) 62885e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 6289cec8ab6eSMat Martineau } else { 6290cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 6291cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 6292cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 6293cec8ab6eSMat Martineau }; 6294cec8ab6eSMat Martineau 6295cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 6296cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 6297cec8ab6eSMat Martineau goto drop; 6298cec8ab6eSMat Martineau 6299cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 6300cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 6301cec8ab6eSMat Martineau control->super); 6302cec8ab6eSMat Martineau 63030a708f8fSGustavo F. Padovan if (len != 0) { 63041bb166e6SAndrei Emeltchenko BT_ERR("Trailing bytes: %d in sframe", len); 63055e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 63060a708f8fSGustavo F. Padovan goto drop; 63070a708f8fSGustavo F. Padovan } 63080a708f8fSGustavo F. Padovan 6309cec8ab6eSMat Martineau /* Validate F and P bits */ 6310cec8ab6eSMat Martineau if (control->final && (control->poll || 6311cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 6312cec8ab6eSMat Martineau goto drop; 6313cec8ab6eSMat Martineau 6314cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 6315cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 63165e4e3972SAndrei Emeltchenko l2cap_send_disconn_req(chan, ECONNRESET); 63170a708f8fSGustavo F. Padovan } 63180a708f8fSGustavo F. Padovan 63190a708f8fSGustavo F. Padovan return 0; 63200a708f8fSGustavo F. Padovan 63210a708f8fSGustavo F. Padovan drop: 63220a708f8fSGustavo F. Padovan kfree_skb(skb); 63230a708f8fSGustavo F. Padovan return 0; 63240a708f8fSGustavo F. Padovan } 63250a708f8fSGustavo F. Padovan 632613ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 632713ca56e0SAndrei Emeltchenko struct sk_buff *skb) 63280a708f8fSGustavo F. Padovan { 632948454079SGustavo F. Padovan struct l2cap_chan *chan; 63300a708f8fSGustavo F. Padovan 6331baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 633248454079SGustavo F. Padovan if (!chan) { 633397e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 633497e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 633597e8e89dSAndrei Emeltchenko if (!chan) { 633697e8e89dSAndrei Emeltchenko kfree_skb(skb); 633713ca56e0SAndrei Emeltchenko return; 633897e8e89dSAndrei Emeltchenko } 633997e8e89dSAndrei Emeltchenko 634097e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 634197e8e89dSAndrei Emeltchenko } else { 63420a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 63436be36555SAndrei Emeltchenko /* Drop packet and return */ 63443379013bSDan Carpenter kfree_skb(skb); 634513ca56e0SAndrei Emeltchenko return; 63460a708f8fSGustavo F. Padovan } 634797e8e89dSAndrei Emeltchenko } 63480a708f8fSGustavo F. Padovan 634949208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 63500a708f8fSGustavo F. Padovan 635189bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 63520a708f8fSGustavo F. Padovan goto drop; 63530a708f8fSGustavo F. Padovan 63540c1bc5c6SGustavo F. Padovan switch (chan->mode) { 63550a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 63560a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 63570a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 63580a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 63590a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 63600a708f8fSGustavo F. Padovan 63610c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 63620a708f8fSGustavo F. Padovan goto drop; 63630a708f8fSGustavo F. Padovan 636480b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 63650a708f8fSGustavo F. Padovan goto done; 63660a708f8fSGustavo F. Padovan break; 63670a708f8fSGustavo F. Padovan 63680a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 63690a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 6370cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 63710a708f8fSGustavo F. Padovan goto done; 63720a708f8fSGustavo F. Padovan 63730a708f8fSGustavo F. Padovan default: 63740c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 63750a708f8fSGustavo F. Padovan break; 63760a708f8fSGustavo F. Padovan } 63770a708f8fSGustavo F. Padovan 63780a708f8fSGustavo F. Padovan drop: 63790a708f8fSGustavo F. Padovan kfree_skb(skb); 63800a708f8fSGustavo F. Padovan 63810a708f8fSGustavo F. Padovan done: 63826be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 63830a708f8fSGustavo F. Padovan } 63840a708f8fSGustavo F. Padovan 638584104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 638684104b24SAndrei Emeltchenko struct sk_buff *skb) 63870a708f8fSGustavo F. Padovan { 638823691d75SGustavo F. Padovan struct l2cap_chan *chan; 63890a708f8fSGustavo F. Padovan 6390c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 639123691d75SGustavo F. Padovan if (!chan) 63920a708f8fSGustavo F. Padovan goto drop; 63930a708f8fSGustavo F. Padovan 63945b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 63950a708f8fSGustavo F. Padovan 639689bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 63970a708f8fSGustavo F. Padovan goto drop; 63980a708f8fSGustavo F. Padovan 6399e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 64000a708f8fSGustavo F. Padovan goto drop; 64010a708f8fSGustavo F. Padovan 640280b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 640384104b24SAndrei Emeltchenko return; 64040a708f8fSGustavo F. Padovan 64050a708f8fSGustavo F. Padovan drop: 64060a708f8fSGustavo F. Padovan kfree_skb(skb); 64070a708f8fSGustavo F. Padovan } 64080a708f8fSGustavo F. Padovan 640972f78356SMarcel Holtmann static void l2cap_att_channel(struct l2cap_conn *conn, 6410d9b88702SAndrei Emeltchenko struct sk_buff *skb) 64119f69bda6SGustavo F. Padovan { 641223691d75SGustavo F. Padovan struct l2cap_chan *chan; 64139f69bda6SGustavo F. Padovan 6414af1c0134SJohan Hedberg chan = l2cap_global_chan_by_scid(BT_CONNECTED, L2CAP_CID_ATT, 641572f78356SMarcel Holtmann conn->src, conn->dst); 641623691d75SGustavo F. Padovan if (!chan) 64179f69bda6SGustavo F. Padovan goto drop; 64189f69bda6SGustavo F. Padovan 64195b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 64209f69bda6SGustavo F. Padovan 6421e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 64229f69bda6SGustavo F. Padovan goto drop; 64239f69bda6SGustavo F. Padovan 642480b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 64256810fca7SAndrei Emeltchenko return; 64269f69bda6SGustavo F. Padovan 64279f69bda6SGustavo F. Padovan drop: 64289f69bda6SGustavo F. Padovan kfree_skb(skb); 64299f69bda6SGustavo F. Padovan } 64309f69bda6SGustavo F. Padovan 64310a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 64320a708f8fSGustavo F. Padovan { 64330a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 64340a708f8fSGustavo F. Padovan u16 cid, len; 64350a708f8fSGustavo F. Padovan __le16 psm; 64360a708f8fSGustavo F. Padovan 64370a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 64380a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 64390a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 64400a708f8fSGustavo F. Padovan 64410a708f8fSGustavo F. Padovan if (len != skb->len) { 64420a708f8fSGustavo F. Padovan kfree_skb(skb); 64430a708f8fSGustavo F. Padovan return; 64440a708f8fSGustavo F. Padovan } 64450a708f8fSGustavo F. Padovan 64460a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 64470a708f8fSGustavo F. Padovan 64480a708f8fSGustavo F. Padovan switch (cid) { 64493300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 6450c5623556SJohan Hedberg l2cap_le_sig_channel(conn, skb); 6451c5623556SJohan Hedberg break; 64520a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 64530a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 64540a708f8fSGustavo F. Padovan break; 64550a708f8fSGustavo F. Padovan 64560a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 6457097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 64580181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 64590a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 64600a708f8fSGustavo F. Padovan break; 64610a708f8fSGustavo F. Padovan 6462073d1cf3SJohan Hedberg case L2CAP_CID_ATT: 646372f78356SMarcel Holtmann l2cap_att_channel(conn, skb); 64649f69bda6SGustavo F. Padovan break; 64659f69bda6SGustavo F. Padovan 6466b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 6467b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 6468b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 6469b501d6a1SAnderson Briglia break; 6470b501d6a1SAnderson Briglia 64710a708f8fSGustavo F. Padovan default: 64720a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 64730a708f8fSGustavo F. Padovan break; 64740a708f8fSGustavo F. Padovan } 64750a708f8fSGustavo F. Padovan } 64760a708f8fSGustavo F. Padovan 64770a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 64780a708f8fSGustavo F. Padovan 6479686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 64800a708f8fSGustavo F. Padovan { 64810a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 648223691d75SGustavo F. Padovan struct l2cap_chan *c; 64830a708f8fSGustavo F. Padovan 64846ed93dc6SAndrei Emeltchenko BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 64850a708f8fSGustavo F. Padovan 64860a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 648723691d75SGustavo F. Padovan read_lock(&chan_list_lock); 648823691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 648923691d75SGustavo F. Padovan struct sock *sk = c->sk; 64904343478fSGustavo F. Padovan 649189bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 64920a708f8fSGustavo F. Padovan continue; 64930a708f8fSGustavo F. Padovan 64940a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 64950a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 649643bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 64970a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 64980a708f8fSGustavo F. Padovan exact++; 64990a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 65000a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 650143bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 65020a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 65030a708f8fSGustavo F. Padovan } 65040a708f8fSGustavo F. Padovan } 650523691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 65060a708f8fSGustavo F. Padovan 65070a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 65080a708f8fSGustavo F. Padovan } 65090a708f8fSGustavo F. Padovan 65109e664631SAndrei Emeltchenko void l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 65110a708f8fSGustavo F. Padovan { 65120a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 65130a708f8fSGustavo F. Padovan 65146ed93dc6SAndrei Emeltchenko BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status); 65150a708f8fSGustavo F. Padovan 65160a708f8fSGustavo F. Padovan if (!status) { 6517baf43251SClaudio Takahasi conn = l2cap_conn_add(hcon); 65180a708f8fSGustavo F. Padovan if (conn) 65190a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 6520ba6fc317SAndrei Emeltchenko } else { 6521e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 6522ba6fc317SAndrei Emeltchenko } 65230a708f8fSGustavo F. Padovan } 65240a708f8fSGustavo F. Padovan 6525686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 65260a708f8fSGustavo F. Padovan { 65270a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 65280a708f8fSGustavo F. Padovan 65290a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 65300a708f8fSGustavo F. Padovan 6531686ebf28SUlisses Furquim if (!conn) 65329f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 65330a708f8fSGustavo F. Padovan return conn->disc_reason; 65340a708f8fSGustavo F. Padovan } 65350a708f8fSGustavo F. Padovan 65369e664631SAndrei Emeltchenko void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 65370a708f8fSGustavo F. Padovan { 65380a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 65390a708f8fSGustavo F. Padovan 6540e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 65410a708f8fSGustavo F. Padovan } 65420a708f8fSGustavo F. Padovan 65434343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 65440a708f8fSGustavo F. Padovan { 6545715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 65460a708f8fSGustavo F. Padovan return; 65470a708f8fSGustavo F. Padovan 65480a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 65494343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 6550ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 65514343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 65520f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 65530a708f8fSGustavo F. Padovan } else { 65544343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 6555c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 65560a708f8fSGustavo F. Padovan } 65570a708f8fSGustavo F. Padovan } 65580a708f8fSGustavo F. Padovan 6559686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 65600a708f8fSGustavo F. Padovan { 65610a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 656248454079SGustavo F. Padovan struct l2cap_chan *chan; 65630a708f8fSGustavo F. Padovan 65640a708f8fSGustavo F. Padovan if (!conn) 65650a708f8fSGustavo F. Padovan return 0; 65660a708f8fSGustavo F. Padovan 656789d8b407SAndrei Emeltchenko BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt); 65680a708f8fSGustavo F. Padovan 6569160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 657035d4adccSHemant Gupta if (!status && encrypt) 6571160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 657217cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 6573160dc6acSVinicius Costa Gomes } 6574160dc6acSVinicius Costa Gomes 65753df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 65760a708f8fSGustavo F. Padovan 65773df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 65786be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 65790a708f8fSGustavo F. Padovan 658089d8b407SAndrei Emeltchenko BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid, 658189d8b407SAndrei Emeltchenko state_to_string(chan->state)); 6582f1cb9af5SVinicius Costa Gomes 658378eb2f98SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 658478eb2f98SAndrei Emeltchenko l2cap_chan_unlock(chan); 658578eb2f98SAndrei Emeltchenko continue; 658678eb2f98SAndrei Emeltchenko } 658778eb2f98SAndrei Emeltchenko 6588073d1cf3SJohan Hedberg if (chan->scid == L2CAP_CID_ATT) { 6589f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 6590f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 6591cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 6592f1cb9af5SVinicius Costa Gomes } 6593f1cb9af5SVinicius Costa Gomes 65946be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 6595f1cb9af5SVinicius Costa Gomes continue; 6596f1cb9af5SVinicius Costa Gomes } 6597f1cb9af5SVinicius Costa Gomes 659896eff46eSAndrei Emeltchenko if (!__l2cap_no_conn_pending(chan)) { 65996be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 66000a708f8fSGustavo F. Padovan continue; 66010a708f8fSGustavo F. Padovan } 66020a708f8fSGustavo F. Padovan 660389bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 660489bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 6605a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 6606a7d7723aSGustavo Padovan 6607c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 6608a7d7723aSGustavo Padovan sk->sk_state_change(sk); 6609a7d7723aSGustavo Padovan 66104343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 66116be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 66120a708f8fSGustavo F. Padovan continue; 66130a708f8fSGustavo F. Padovan } 66140a708f8fSGustavo F. Padovan 661589bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 66160a708f8fSGustavo F. Padovan if (!status) { 661793c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 66180a708f8fSGustavo F. Padovan } else { 6619ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 66200a708f8fSGustavo F. Padovan } 662189bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 66226be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 66230a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6624df3c3931SJohan Hedberg __u16 res, stat; 66250a708f8fSGustavo F. Padovan 66266be36555SAndrei Emeltchenko lock_sock(sk); 66276be36555SAndrei Emeltchenko 66280a708f8fSGustavo F. Padovan if (!status) { 6629c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 6630c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 6631df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 6632df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 66332dc4e510SGustavo Padovan chan->ops->defer(chan); 6634df3c3931SJohan Hedberg } else { 66350e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 6636df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 6637df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 6638df3c3931SJohan Hedberg } 66390a708f8fSGustavo F. Padovan } else { 66400e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 6641ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 6642df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 6643df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 66440a708f8fSGustavo F. Padovan } 66450a708f8fSGustavo F. Padovan 66466be36555SAndrei Emeltchenko release_sock(sk); 66476be36555SAndrei Emeltchenko 6648fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6649fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6650df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 6651df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 6652fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6653fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 66542d369359SMat Martineau 66552d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 66562d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 66572d369359SMat Martineau char buf[128]; 66582d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 66592d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 66602d369359SMat Martineau L2CAP_CONF_REQ, 66612d369359SMat Martineau l2cap_build_conf_req(chan, buf), 66622d369359SMat Martineau buf); 66632d369359SMat Martineau chan->num_conf_req++; 66642d369359SMat Martineau } 66650a708f8fSGustavo F. Padovan } 66660a708f8fSGustavo F. Padovan 66676be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 66680a708f8fSGustavo F. Padovan } 66690a708f8fSGustavo F. Padovan 66703df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 66710a708f8fSGustavo F. Padovan 66720a708f8fSGustavo F. Padovan return 0; 66730a708f8fSGustavo F. Padovan } 66740a708f8fSGustavo F. Padovan 6675686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 66760a708f8fSGustavo F. Padovan { 66770a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 6678d73a0988SAndrei Emeltchenko struct l2cap_hdr *hdr; 6679d73a0988SAndrei Emeltchenko int len; 66800a708f8fSGustavo F. Padovan 66811d13a254SAndrei Emeltchenko /* For AMP controller do not create l2cap conn */ 66821d13a254SAndrei Emeltchenko if (!conn && hcon->hdev->dev_type != HCI_BREDR) 66831d13a254SAndrei Emeltchenko goto drop; 66840a708f8fSGustavo F. Padovan 66850a708f8fSGustavo F. Padovan if (!conn) 6686baf43251SClaudio Takahasi conn = l2cap_conn_add(hcon); 66870a708f8fSGustavo F. Padovan 66880a708f8fSGustavo F. Padovan if (!conn) 66890a708f8fSGustavo F. Padovan goto drop; 66900a708f8fSGustavo F. Padovan 66910a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 66920a708f8fSGustavo F. Padovan 6693d73a0988SAndrei Emeltchenko switch (flags) { 6694d73a0988SAndrei Emeltchenko case ACL_START: 6695d73a0988SAndrei Emeltchenko case ACL_START_NO_FLUSH: 6696d73a0988SAndrei Emeltchenko case ACL_COMPLETE: 66970a708f8fSGustavo F. Padovan if (conn->rx_len) { 66980a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 66990a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 67000a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 67010a708f8fSGustavo F. Padovan conn->rx_len = 0; 67020a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67030a708f8fSGustavo F. Padovan } 67040a708f8fSGustavo F. Padovan 67050a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 67060a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 67070a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 67080a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67090a708f8fSGustavo F. Padovan goto drop; 67100a708f8fSGustavo F. Padovan } 67110a708f8fSGustavo F. Padovan 67120a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 67130a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 67140a708f8fSGustavo F. Padovan 67150a708f8fSGustavo F. Padovan if (len == skb->len) { 67160a708f8fSGustavo F. Padovan /* Complete frame received */ 67170a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 67180a708f8fSGustavo F. Padovan return 0; 67190a708f8fSGustavo F. Padovan } 67200a708f8fSGustavo F. Padovan 67210a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 67220a708f8fSGustavo F. Padovan 67230a708f8fSGustavo F. Padovan if (skb->len > len) { 67240a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 67250a708f8fSGustavo F. Padovan skb->len, len); 67260a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67270a708f8fSGustavo F. Padovan goto drop; 67280a708f8fSGustavo F. Padovan } 67290a708f8fSGustavo F. Padovan 67300a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 67318bcde1f2SGustavo Padovan conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL); 67320a708f8fSGustavo F. Padovan if (!conn->rx_skb) 67330a708f8fSGustavo F. Padovan goto drop; 67340a708f8fSGustavo F. Padovan 67350a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 67360a708f8fSGustavo F. Padovan skb->len); 67370a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 6738d73a0988SAndrei Emeltchenko break; 6739d73a0988SAndrei Emeltchenko 6740d73a0988SAndrei Emeltchenko case ACL_CONT: 67410a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 67420a708f8fSGustavo F. Padovan 67430a708f8fSGustavo F. Padovan if (!conn->rx_len) { 67440a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 67450a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67460a708f8fSGustavo F. Padovan goto drop; 67470a708f8fSGustavo F. Padovan } 67480a708f8fSGustavo F. Padovan 67490a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 67500a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 67510a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 67520a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 67530a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 67540a708f8fSGustavo F. Padovan conn->rx_len = 0; 67550a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 67560a708f8fSGustavo F. Padovan goto drop; 67570a708f8fSGustavo F. Padovan } 67580a708f8fSGustavo F. Padovan 67590a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 67600a708f8fSGustavo F. Padovan skb->len); 67610a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 67620a708f8fSGustavo F. Padovan 67630a708f8fSGustavo F. Padovan if (!conn->rx_len) { 67640a708f8fSGustavo F. Padovan /* Complete frame received */ 67650a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 67660a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 67670a708f8fSGustavo F. Padovan } 6768d73a0988SAndrei Emeltchenko break; 67690a708f8fSGustavo F. Padovan } 67700a708f8fSGustavo F. Padovan 67710a708f8fSGustavo F. Padovan drop: 67720a708f8fSGustavo F. Padovan kfree_skb(skb); 67730a708f8fSGustavo F. Padovan return 0; 67740a708f8fSGustavo F. Padovan } 67750a708f8fSGustavo F. Padovan 67760a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 67770a708f8fSGustavo F. Padovan { 677823691d75SGustavo F. Padovan struct l2cap_chan *c; 67790a708f8fSGustavo F. Padovan 6780333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 67810a708f8fSGustavo F. Padovan 678223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 678323691d75SGustavo F. Padovan struct sock *sk = c->sk; 67840a708f8fSGustavo F. Padovan 6785fcb73338SAndrei Emeltchenko seq_printf(f, "%pMR %pMR %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 6786fcb73338SAndrei Emeltchenko &bt_sk(sk)->src, &bt_sk(sk)->dst, 678789bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 678823691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 678923691d75SGustavo F. Padovan c->sec_level, c->mode); 67900a708f8fSGustavo F. Padovan } 67910a708f8fSGustavo F. Padovan 6792333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 67930a708f8fSGustavo F. Padovan 67940a708f8fSGustavo F. Padovan return 0; 67950a708f8fSGustavo F. Padovan } 67960a708f8fSGustavo F. Padovan 67970a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 67980a708f8fSGustavo F. Padovan { 67990a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 68000a708f8fSGustavo F. Padovan } 68010a708f8fSGustavo F. Padovan 68020a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 68030a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 68040a708f8fSGustavo F. Padovan .read = seq_read, 68050a708f8fSGustavo F. Padovan .llseek = seq_lseek, 68060a708f8fSGustavo F. Padovan .release = single_release, 68070a708f8fSGustavo F. Padovan }; 68080a708f8fSGustavo F. Padovan 68090a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 68100a708f8fSGustavo F. Padovan 681164274518SGustavo F. Padovan int __init l2cap_init(void) 68120a708f8fSGustavo F. Padovan { 68130a708f8fSGustavo F. Padovan int err; 68140a708f8fSGustavo F. Padovan 6815bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 68160a708f8fSGustavo F. Padovan if (err < 0) 68170a708f8fSGustavo F. Padovan return err; 68180a708f8fSGustavo F. Padovan 68190a708f8fSGustavo F. Padovan if (bt_debugfs) { 68202d792818SGustavo Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, bt_debugfs, 68212d792818SGustavo Padovan NULL, &l2cap_debugfs_fops); 68220a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 68230a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 68240a708f8fSGustavo F. Padovan } 68250a708f8fSGustavo F. Padovan 68260a708f8fSGustavo F. Padovan return 0; 68270a708f8fSGustavo F. Padovan } 68280a708f8fSGustavo F. Padovan 682964274518SGustavo F. Padovan void l2cap_exit(void) 68300a708f8fSGustavo F. Padovan { 68310a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 6832bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 68330a708f8fSGustavo F. Padovan } 68340a708f8fSGustavo F. Padovan 68350a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 68360a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 6837