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> 41*5ce66b59SAndrei 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); 564519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 574519de9aSGustavo F. Padovan struct l2cap_chan *chan, int err); 580a708f8fSGustavo F. Padovan 59d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 60608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event); 61608bcc6dSMat Martineau 620a708f8fSGustavo F. Padovan /* ---- L2CAP channels ---- */ 6371ba0e56SGustavo F. Padovan 642d792818SGustavo Padovan static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, 652d792818SGustavo Padovan u16 cid) 660a708f8fSGustavo F. Padovan { 673df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 68baa7e1faSGustavo F. Padovan 693df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 703df91ea2SAndrei Emeltchenko if (c->dcid == cid) 713df91ea2SAndrei Emeltchenko return c; 720a708f8fSGustavo F. Padovan } 733df91ea2SAndrei Emeltchenko return NULL; 74baa7e1faSGustavo F. Padovan } 750a708f8fSGustavo F. Padovan 762d792818SGustavo Padovan static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, 772d792818SGustavo Padovan u16 cid) 780a708f8fSGustavo F. Padovan { 793df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 80baa7e1faSGustavo F. Padovan 813df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 823df91ea2SAndrei Emeltchenko if (c->scid == cid) 833df91ea2SAndrei Emeltchenko return c; 840a708f8fSGustavo F. Padovan } 853df91ea2SAndrei Emeltchenko return NULL; 86baa7e1faSGustavo F. Padovan } 870a708f8fSGustavo F. Padovan 880a708f8fSGustavo F. Padovan /* Find channel with given SCID. 89ef191adeSMat Martineau * Returns locked channel. */ 902d792818SGustavo Padovan static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, 912d792818SGustavo Padovan u16 cid) 920a708f8fSGustavo F. Padovan { 9348454079SGustavo F. Padovan struct l2cap_chan *c; 94baa7e1faSGustavo F. Padovan 953df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 96baa7e1faSGustavo F. Padovan c = __l2cap_get_chan_by_scid(conn, cid); 97ef191adeSMat Martineau if (c) 98ef191adeSMat Martineau l2cap_chan_lock(c); 993df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 1003df91ea2SAndrei Emeltchenko 10148454079SGustavo F. Padovan return c; 1020a708f8fSGustavo F. Padovan } 1030a708f8fSGustavo F. Padovan 104b1a130b7SMat Martineau /* Find channel with given DCID. 105b1a130b7SMat Martineau * Returns locked channel. 106b1a130b7SMat Martineau */ 107b1a130b7SMat Martineau static struct l2cap_chan *l2cap_get_chan_by_dcid(struct l2cap_conn *conn, 108b1a130b7SMat Martineau u16 cid) 109b1a130b7SMat Martineau { 110b1a130b7SMat Martineau struct l2cap_chan *c; 111b1a130b7SMat Martineau 112b1a130b7SMat Martineau mutex_lock(&conn->chan_lock); 113b1a130b7SMat Martineau c = __l2cap_get_chan_by_dcid(conn, cid); 114b1a130b7SMat Martineau if (c) 115b1a130b7SMat Martineau l2cap_chan_lock(c); 116b1a130b7SMat Martineau mutex_unlock(&conn->chan_lock); 117b1a130b7SMat Martineau 118b1a130b7SMat Martineau return c; 119b1a130b7SMat Martineau } 120b1a130b7SMat Martineau 1212d792818SGustavo Padovan static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, 1222d792818SGustavo Padovan u8 ident) 1230a708f8fSGustavo F. Padovan { 1243df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 125baa7e1faSGustavo F. Padovan 1263df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 1273df91ea2SAndrei Emeltchenko if (c->ident == ident) 1283df91ea2SAndrei Emeltchenko return c; 1290a708f8fSGustavo F. Padovan } 1303df91ea2SAndrei Emeltchenko return NULL; 131baa7e1faSGustavo F. Padovan } 1320a708f8fSGustavo F. Padovan 1335b155ef9SMat Martineau static struct l2cap_chan *l2cap_get_chan_by_ident(struct l2cap_conn *conn, 1345b155ef9SMat Martineau u8 ident) 1355b155ef9SMat Martineau { 1365b155ef9SMat Martineau struct l2cap_chan *c; 1375b155ef9SMat Martineau 1385b155ef9SMat Martineau mutex_lock(&conn->chan_lock); 1395b155ef9SMat Martineau c = __l2cap_get_chan_by_ident(conn, ident); 1405b155ef9SMat Martineau if (c) 1415b155ef9SMat Martineau l2cap_chan_lock(c); 1425b155ef9SMat Martineau mutex_unlock(&conn->chan_lock); 1435b155ef9SMat Martineau 1445b155ef9SMat Martineau return c; 1455b155ef9SMat Martineau } 1465b155ef9SMat Martineau 14723691d75SGustavo F. Padovan static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src) 1489e4425ffSGustavo F. Padovan { 14923691d75SGustavo F. Padovan struct l2cap_chan *c; 1509e4425ffSGustavo F. Padovan 15123691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 15223691d75SGustavo F. Padovan if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src)) 15323691d75SGustavo F. Padovan return c; 1549e4425ffSGustavo F. Padovan } 155250938cbSSzymon Janc return NULL; 156250938cbSSzymon Janc } 1579e4425ffSGustavo F. Padovan 1589e4425ffSGustavo F. Padovan int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm) 1599e4425ffSGustavo F. Padovan { 16073b2ec18SGustavo F. Padovan int err; 16173b2ec18SGustavo F. Padovan 162333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1639e4425ffSGustavo F. Padovan 16423691d75SGustavo F. Padovan if (psm && __l2cap_global_chan_by_addr(psm, src)) { 16573b2ec18SGustavo F. Padovan err = -EADDRINUSE; 16673b2ec18SGustavo F. Padovan goto done; 1679e4425ffSGustavo F. Padovan } 1689e4425ffSGustavo F. Padovan 16973b2ec18SGustavo F. Padovan if (psm) { 1709e4425ffSGustavo F. Padovan chan->psm = psm; 1719e4425ffSGustavo F. Padovan chan->sport = psm; 17273b2ec18SGustavo F. Padovan err = 0; 17373b2ec18SGustavo F. Padovan } else { 17473b2ec18SGustavo F. Padovan u16 p; 1759e4425ffSGustavo F. Padovan 17673b2ec18SGustavo F. Padovan err = -EINVAL; 17773b2ec18SGustavo F. Padovan for (p = 0x1001; p < 0x1100; p += 2) 17823691d75SGustavo F. Padovan if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) { 17973b2ec18SGustavo F. Padovan chan->psm = cpu_to_le16(p); 18073b2ec18SGustavo F. Padovan chan->sport = cpu_to_le16(p); 18173b2ec18SGustavo F. Padovan err = 0; 18273b2ec18SGustavo F. Padovan break; 18373b2ec18SGustavo F. Padovan } 18473b2ec18SGustavo F. Padovan } 18573b2ec18SGustavo F. Padovan 18673b2ec18SGustavo F. Padovan done: 187333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 18873b2ec18SGustavo F. Padovan return err; 1899e4425ffSGustavo F. Padovan } 1909e4425ffSGustavo F. Padovan 1919e4425ffSGustavo F. Padovan int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid) 1929e4425ffSGustavo F. Padovan { 193333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1949e4425ffSGustavo F. Padovan 1959e4425ffSGustavo F. Padovan chan->scid = scid; 1969e4425ffSGustavo F. Padovan 197333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 1989e4425ffSGustavo F. Padovan 1999e4425ffSGustavo F. Padovan return 0; 2009e4425ffSGustavo F. Padovan } 2019e4425ffSGustavo F. Padovan 202baa7e1faSGustavo F. Padovan static u16 l2cap_alloc_cid(struct l2cap_conn *conn) 2030a708f8fSGustavo F. Padovan { 2040a708f8fSGustavo F. Padovan u16 cid = L2CAP_CID_DYN_START; 2050a708f8fSGustavo F. Padovan 2060a708f8fSGustavo F. Padovan for (; cid < L2CAP_CID_DYN_END; cid++) { 207baa7e1faSGustavo F. Padovan if (!__l2cap_get_chan_by_scid(conn, cid)) 2080a708f8fSGustavo F. Padovan return cid; 2090a708f8fSGustavo F. Padovan } 2100a708f8fSGustavo F. Padovan 2110a708f8fSGustavo F. Padovan return 0; 2120a708f8fSGustavo F. Padovan } 2130a708f8fSGustavo F. Padovan 2140e587be7SAndrei Emeltchenko static void __l2cap_state_change(struct l2cap_chan *chan, int state) 21589bc500eSGustavo F. Padovan { 21642d2d87cSAndrei Emeltchenko BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state), 217badaaa00SGustavo F. Padovan state_to_string(state)); 218badaaa00SGustavo F. Padovan 21989bc500eSGustavo F. Padovan chan->state = state; 22080b98027SGustavo Padovan chan->ops->state_change(chan, state); 22189bc500eSGustavo F. Padovan } 22289bc500eSGustavo F. Padovan 2230e587be7SAndrei Emeltchenko static void l2cap_state_change(struct l2cap_chan *chan, int state) 2240e587be7SAndrei Emeltchenko { 2250e587be7SAndrei Emeltchenko struct sock *sk = chan->sk; 2260e587be7SAndrei Emeltchenko 2270e587be7SAndrei Emeltchenko lock_sock(sk); 2280e587be7SAndrei Emeltchenko __l2cap_state_change(chan, state); 2290e587be7SAndrei Emeltchenko release_sock(sk); 2300e587be7SAndrei Emeltchenko } 2310e587be7SAndrei Emeltchenko 2322e0052e4SAndrei Emeltchenko static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2332e0052e4SAndrei Emeltchenko { 2342e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2352e0052e4SAndrei Emeltchenko 2362e0052e4SAndrei Emeltchenko sk->sk_err = err; 2372e0052e4SAndrei Emeltchenko } 2382e0052e4SAndrei Emeltchenko 2392e0052e4SAndrei Emeltchenko static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2402e0052e4SAndrei Emeltchenko { 2412e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2422e0052e4SAndrei Emeltchenko 2432e0052e4SAndrei Emeltchenko lock_sock(sk); 2442e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 2452e0052e4SAndrei Emeltchenko release_sock(sk); 2462e0052e4SAndrei Emeltchenko } 2472e0052e4SAndrei Emeltchenko 2484239d16fSMat Martineau static void __set_retrans_timer(struct l2cap_chan *chan) 2494239d16fSMat Martineau { 2504239d16fSMat Martineau if (!delayed_work_pending(&chan->monitor_timer) && 2514239d16fSMat Martineau chan->retrans_timeout) { 2524239d16fSMat Martineau l2cap_set_timer(chan, &chan->retrans_timer, 2534239d16fSMat Martineau msecs_to_jiffies(chan->retrans_timeout)); 2544239d16fSMat Martineau } 2554239d16fSMat Martineau } 2564239d16fSMat Martineau 2574239d16fSMat Martineau static void __set_monitor_timer(struct l2cap_chan *chan) 2584239d16fSMat Martineau { 2594239d16fSMat Martineau __clear_retrans_timer(chan); 2604239d16fSMat Martineau if (chan->monitor_timeout) { 2614239d16fSMat Martineau l2cap_set_timer(chan, &chan->monitor_timer, 2624239d16fSMat Martineau msecs_to_jiffies(chan->monitor_timeout)); 2634239d16fSMat Martineau } 2644239d16fSMat Martineau } 2654239d16fSMat Martineau 266608bcc6dSMat Martineau static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head, 267608bcc6dSMat Martineau u16 seq) 268608bcc6dSMat Martineau { 269608bcc6dSMat Martineau struct sk_buff *skb; 270608bcc6dSMat Martineau 271608bcc6dSMat Martineau skb_queue_walk(head, skb) { 272608bcc6dSMat Martineau if (bt_cb(skb)->control.txseq == seq) 273608bcc6dSMat Martineau return skb; 274608bcc6dSMat Martineau } 275608bcc6dSMat Martineau 276608bcc6dSMat Martineau return NULL; 277608bcc6dSMat Martineau } 278608bcc6dSMat Martineau 2793c588192SMat Martineau /* ---- L2CAP sequence number lists ---- */ 2803c588192SMat Martineau 2813c588192SMat Martineau /* For ERTM, ordered lists of sequence numbers must be tracked for 2823c588192SMat Martineau * SREJ requests that are received and for frames that are to be 2833c588192SMat Martineau * retransmitted. These seq_list functions implement a singly-linked 2843c588192SMat Martineau * list in an array, where membership in the list can also be checked 2853c588192SMat Martineau * in constant time. Items can also be added to the tail of the list 2863c588192SMat Martineau * and removed from the head in constant time, without further memory 2873c588192SMat Martineau * allocs or frees. 2883c588192SMat Martineau */ 2893c588192SMat Martineau 2903c588192SMat Martineau static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) 2913c588192SMat Martineau { 2923c588192SMat Martineau size_t alloc_size, i; 2933c588192SMat Martineau 2943c588192SMat Martineau /* Allocated size is a power of 2 to map sequence numbers 2953c588192SMat Martineau * (which may be up to 14 bits) in to a smaller array that is 2963c588192SMat Martineau * sized for the negotiated ERTM transmit windows. 2973c588192SMat Martineau */ 2983c588192SMat Martineau alloc_size = roundup_pow_of_two(size); 2993c588192SMat Martineau 3003c588192SMat Martineau seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); 3013c588192SMat Martineau if (!seq_list->list) 3023c588192SMat Martineau return -ENOMEM; 3033c588192SMat Martineau 3043c588192SMat Martineau seq_list->mask = alloc_size - 1; 3053c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3063c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3073c588192SMat Martineau for (i = 0; i < alloc_size; i++) 3083c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3093c588192SMat Martineau 3103c588192SMat Martineau return 0; 3113c588192SMat Martineau } 3123c588192SMat Martineau 3133c588192SMat Martineau static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list) 3143c588192SMat Martineau { 3153c588192SMat Martineau kfree(seq_list->list); 3163c588192SMat Martineau } 3173c588192SMat Martineau 3183c588192SMat Martineau static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list, 3193c588192SMat Martineau u16 seq) 3203c588192SMat Martineau { 3213c588192SMat Martineau /* Constant-time check for list membership */ 3223c588192SMat Martineau return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR; 3233c588192SMat Martineau } 3243c588192SMat Martineau 3253c588192SMat Martineau static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq) 3263c588192SMat Martineau { 3273c588192SMat Martineau u16 mask = seq_list->mask; 3283c588192SMat Martineau 3293c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) { 3303c588192SMat Martineau /* In case someone tries to pop the head of an empty list */ 3313c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3323c588192SMat Martineau } else if (seq_list->head == seq) { 3333c588192SMat Martineau /* Head can be removed in constant time */ 3343c588192SMat Martineau seq_list->head = seq_list->list[seq & mask]; 3353c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3363c588192SMat Martineau 3373c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_TAIL) { 3383c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3393c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3403c588192SMat Martineau } 3413c588192SMat Martineau } else { 3423c588192SMat Martineau /* Walk the list to find the sequence number */ 3433c588192SMat Martineau u16 prev = seq_list->head; 3443c588192SMat Martineau while (seq_list->list[prev & mask] != seq) { 3453c588192SMat Martineau prev = seq_list->list[prev & mask]; 3463c588192SMat Martineau if (prev == L2CAP_SEQ_LIST_TAIL) 3473c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3483c588192SMat Martineau } 3493c588192SMat Martineau 3503c588192SMat Martineau /* Unlink the number from the list and clear it */ 3513c588192SMat Martineau seq_list->list[prev & mask] = seq_list->list[seq & mask]; 3523c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3533c588192SMat Martineau if (seq_list->tail == seq) 3543c588192SMat Martineau seq_list->tail = prev; 3553c588192SMat Martineau } 3563c588192SMat Martineau return seq; 3573c588192SMat Martineau } 3583c588192SMat Martineau 3593c588192SMat Martineau static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list) 3603c588192SMat Martineau { 3613c588192SMat Martineau /* Remove the head in constant time */ 3623c588192SMat Martineau return l2cap_seq_list_remove(seq_list, seq_list->head); 3633c588192SMat Martineau } 3643c588192SMat Martineau 3653c588192SMat Martineau static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list) 3663c588192SMat Martineau { 3673c588192SMat Martineau u16 i; 368f522ae36SGustavo Padovan 369f522ae36SGustavo Padovan if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) 370f522ae36SGustavo Padovan return; 371f522ae36SGustavo Padovan 3723c588192SMat Martineau for (i = 0; i <= seq_list->mask; i++) 3733c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3743c588192SMat Martineau 3753c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3763c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3773c588192SMat Martineau } 3783c588192SMat Martineau 3793c588192SMat Martineau static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq) 3803c588192SMat Martineau { 3813c588192SMat Martineau u16 mask = seq_list->mask; 3823c588192SMat Martineau 3833c588192SMat Martineau /* All appends happen in constant time */ 3843c588192SMat Martineau 385f522ae36SGustavo Padovan if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR) 386f522ae36SGustavo Padovan return; 387f522ae36SGustavo Padovan 3883c588192SMat Martineau if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR) 3893c588192SMat Martineau seq_list->head = seq; 3903c588192SMat Martineau else 3913c588192SMat Martineau seq_list->list[seq_list->tail & mask] = seq; 3923c588192SMat Martineau 3933c588192SMat Martineau seq_list->tail = seq; 3943c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL; 3953c588192SMat Martineau } 3963c588192SMat Martineau 397721c4181SGustavo F. Padovan static void l2cap_chan_timeout(struct work_struct *work) 398ab07801dSGustavo F. Padovan { 399721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 400721c4181SGustavo F. Padovan chan_timer.work); 4013df91ea2SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 402ab07801dSGustavo F. Padovan int reason; 403ab07801dSGustavo F. Padovan 404e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s", chan, state_to_string(chan->state)); 405ab07801dSGustavo F. Padovan 4063df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 4076be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 408ab07801dSGustavo F. Padovan 40989bc500eSGustavo F. Padovan if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG) 410ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 41189bc500eSGustavo F. Padovan else if (chan->state == BT_CONNECT && 412ab07801dSGustavo F. Padovan chan->sec_level != BT_SECURITY_SDP) 413ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 414ab07801dSGustavo F. Padovan else 415ab07801dSGustavo F. Padovan reason = ETIMEDOUT; 416ab07801dSGustavo F. Padovan 4170f852724SGustavo F. Padovan l2cap_chan_close(chan, reason); 418ab07801dSGustavo F. Padovan 4196be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 420ab07801dSGustavo F. Padovan 42180b98027SGustavo Padovan chan->ops->close(chan); 4223df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 4233df91ea2SAndrei Emeltchenko 424371fd835SUlisses Furquim l2cap_chan_put(chan); 425ab07801dSGustavo F. Padovan } 426ab07801dSGustavo F. Padovan 427eef1d9b6SGustavo Padovan struct l2cap_chan *l2cap_chan_create(void) 4280a708f8fSGustavo F. Padovan { 42948454079SGustavo F. Padovan struct l2cap_chan *chan; 4300a708f8fSGustavo F. Padovan 43148454079SGustavo F. Padovan chan = kzalloc(sizeof(*chan), GFP_ATOMIC); 43248454079SGustavo F. Padovan if (!chan) 43348454079SGustavo F. Padovan return NULL; 4340a708f8fSGustavo F. Padovan 435c03b355eSAndrei Emeltchenko mutex_init(&chan->lock); 436c03b355eSAndrei Emeltchenko 437333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 43823691d75SGustavo F. Padovan list_add(&chan->global_l, &chan_list); 439333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 44023691d75SGustavo F. Padovan 441721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout); 442ab07801dSGustavo F. Padovan 44389bc500eSGustavo F. Padovan chan->state = BT_OPEN; 44489bc500eSGustavo F. Padovan 445144ad330SSyam Sidhardhan kref_init(&chan->kref); 44671ba0e56SGustavo F. Padovan 4472827011fSMat Martineau /* This flag is cleared in l2cap_chan_ready() */ 4482827011fSMat Martineau set_bit(CONF_NOT_COMPLETE, &chan->conf_state); 4492827011fSMat Martineau 450eef1d9b6SGustavo Padovan BT_DBG("chan %p", chan); 451abc545b8SSzymon Janc 45248454079SGustavo F. Padovan return chan; 4530a708f8fSGustavo F. Padovan } 4540a708f8fSGustavo F. Padovan 455144ad330SSyam Sidhardhan static void l2cap_chan_destroy(struct kref *kref) 4566ff5abbfSGustavo F. Padovan { 457144ad330SSyam Sidhardhan struct l2cap_chan *chan = container_of(kref, struct l2cap_chan, kref); 458144ad330SSyam Sidhardhan 4594af66c69SJaganath Kanakkassery BT_DBG("chan %p", chan); 4604af66c69SJaganath Kanakkassery 461333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 46223691d75SGustavo F. Padovan list_del(&chan->global_l); 463333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 46423691d75SGustavo F. Padovan 4654af66c69SJaganath Kanakkassery kfree(chan); 4666ff5abbfSGustavo F. Padovan } 4676ff5abbfSGustavo F. Padovan 46830648372SJaganath Kanakkassery void l2cap_chan_hold(struct l2cap_chan *c) 46930648372SJaganath Kanakkassery { 470144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 47130648372SJaganath Kanakkassery 472144ad330SSyam Sidhardhan kref_get(&c->kref); 47330648372SJaganath Kanakkassery } 47430648372SJaganath Kanakkassery 47530648372SJaganath Kanakkassery void l2cap_chan_put(struct l2cap_chan *c) 47630648372SJaganath Kanakkassery { 477144ad330SSyam Sidhardhan BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount)); 47830648372SJaganath Kanakkassery 479144ad330SSyam Sidhardhan kref_put(&c->kref, l2cap_chan_destroy); 48030648372SJaganath Kanakkassery } 48130648372SJaganath Kanakkassery 482bd4b1653SAndrei Emeltchenko void l2cap_chan_set_defaults(struct l2cap_chan *chan) 483bd4b1653SAndrei Emeltchenko { 484bd4b1653SAndrei Emeltchenko chan->fcs = L2CAP_FCS_CRC16; 485bd4b1653SAndrei Emeltchenko chan->max_tx = L2CAP_DEFAULT_MAX_TX; 486bd4b1653SAndrei Emeltchenko chan->tx_win = L2CAP_DEFAULT_TX_WINDOW; 487bd4b1653SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 488c20f8e35SMat Martineau chan->ack_win = L2CAP_DEFAULT_TX_WINDOW; 489bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 490bd4b1653SAndrei Emeltchenko 491bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 492bd4b1653SAndrei Emeltchenko } 493bd4b1653SAndrei Emeltchenko 49493c3e8f5SAndrei Emeltchenko void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4950a708f8fSGustavo F. Padovan { 4960a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 497097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4980a708f8fSGustavo F. Padovan 4999f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 5000a708f8fSGustavo F. Padovan 5018c1d787bSGustavo F. Padovan chan->conn = conn; 5020a708f8fSGustavo F. Padovan 5035491120eSAndrei Emeltchenko switch (chan->chan_type) { 5045491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 505b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 506b62f328bSVille Tervo /* LE connection */ 5076fcb06a2SAndre Guedes chan->omtu = L2CAP_DEFAULT_MTU; 508fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 509fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 510b62f328bSVille Tervo } else { 5110a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 512fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 5130c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 514b62f328bSVille Tervo } 5155491120eSAndrei Emeltchenko break; 5165491120eSAndrei Emeltchenko 5175491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 5180a708f8fSGustavo F. Padovan /* Connectionless socket */ 519fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 520fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 5210c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5225491120eSAndrei Emeltchenko break; 5235491120eSAndrei Emeltchenko 524416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 525416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 526416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 527416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 528416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 529416fa752SAndrei Emeltchenko break; 530416fa752SAndrei Emeltchenko 5315491120eSAndrei Emeltchenko default: 5320a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 533fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 534fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 5350c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 5360a708f8fSGustavo F. Padovan } 5370a708f8fSGustavo F. Padovan 5388f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 5398f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 5408f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 5418f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 5428f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 5438936fa6dSAndrei Emeltchenko chan->local_flush_to = L2CAP_EFS_DEFAULT_FLUSH_TO; 5448f7975b1SAndrei Emeltchenko 545371fd835SUlisses Furquim l2cap_chan_hold(chan); 546baa7e1faSGustavo F. Padovan 5473df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 548643162a8SAndrei Emeltchenko } 549643162a8SAndrei Emeltchenko 550466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 551643162a8SAndrei Emeltchenko { 552643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 553643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 5543df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5550a708f8fSGustavo F. Padovan } 5560a708f8fSGustavo F. Padovan 557466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5580a708f8fSGustavo F. Padovan { 5598c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5600a708f8fSGustavo F. Padovan 561c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5620a708f8fSGustavo F. Padovan 56349208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5640a708f8fSGustavo F. Padovan 5650a708f8fSGustavo F. Padovan if (conn) { 56656f60984SAndrei Emeltchenko struct amp_mgr *mgr = conn->hcon->amp_mgr; 567baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5683df91ea2SAndrei Emeltchenko list_del(&chan->list); 5693d57dc68SGustavo F. Padovan 570371fd835SUlisses Furquim l2cap_chan_put(chan); 571baa7e1faSGustavo F. Padovan 5728c1d787bSGustavo F. Padovan chan->conn = NULL; 5733cabbfdaSAndrei Emeltchenko 5743cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 5750a708f8fSGustavo F. Padovan hci_conn_put(conn->hcon); 57656f60984SAndrei Emeltchenko 57756f60984SAndrei Emeltchenko if (mgr && mgr->bredr_chan == chan) 57856f60984SAndrei Emeltchenko mgr->bredr_chan = NULL; 5790a708f8fSGustavo F. Padovan } 5800a708f8fSGustavo F. Padovan 581c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5826be36555SAndrei Emeltchenko 5832827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5846ff5abbfSGustavo F. Padovan return; 5852ead70b8SGustavo F. Padovan 586ee556f66SGustavo Padovan switch(chan->mode) { 587ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 588ee556f66SGustavo Padovan break; 5890a708f8fSGustavo F. Padovan 590ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5911a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5921a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5931a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 5940a708f8fSGustavo F. Padovan 595f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 5960a708f8fSGustavo F. Padovan 5973c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 5983c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 599ee556f66SGustavo Padovan 600ee556f66SGustavo Padovan /* fall through */ 601ee556f66SGustavo Padovan 602ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 603ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 604ee556f66SGustavo Padovan break; 6050a708f8fSGustavo F. Padovan } 606ee556f66SGustavo Padovan 607ee556f66SGustavo Padovan return; 6080a708f8fSGustavo F. Padovan } 6090a708f8fSGustavo F. Padovan 6100f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 6114519de9aSGustavo F. Padovan { 6124519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6134519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 6144519de9aSGustavo F. Padovan 6152d792818SGustavo Padovan BT_DBG("chan %p state %s sk %p", chan, state_to_string(chan->state), 6162d792818SGustavo Padovan sk); 6174519de9aSGustavo F. Padovan 61889bc500eSGustavo F. Padovan switch (chan->state) { 6194519de9aSGustavo F. Padovan case BT_LISTEN: 620c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6214519de9aSGustavo F. Padovan break; 6224519de9aSGustavo F. Padovan 6234519de9aSGustavo F. Padovan case BT_CONNECTED: 6244519de9aSGustavo F. Padovan case BT_CONFIG: 625715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6264519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 627c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 6284519de9aSGustavo F. Padovan l2cap_send_disconn_req(conn, chan, reason); 6294519de9aSGustavo F. Padovan } else 6304519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6314519de9aSGustavo F. Padovan break; 6324519de9aSGustavo F. Padovan 6334519de9aSGustavo F. Padovan case BT_CONNECT2: 634715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 6354519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 6364519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6374519de9aSGustavo F. Padovan __u16 result; 6384519de9aSGustavo F. Padovan 639c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 6404519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 6414519de9aSGustavo F. Padovan else 6424519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 64389bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 6444519de9aSGustavo F. Padovan 6454519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6464519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6474519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 648ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 6494519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6504519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 6514519de9aSGustavo F. Padovan } 6524519de9aSGustavo F. Padovan 6534519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6544519de9aSGustavo F. Padovan break; 6554519de9aSGustavo F. Padovan 6564519de9aSGustavo F. Padovan case BT_CONNECT: 6574519de9aSGustavo F. Padovan case BT_DISCONN: 6584519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6594519de9aSGustavo F. Padovan break; 6604519de9aSGustavo F. Padovan 6614519de9aSGustavo F. Padovan default: 662c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6634519de9aSGustavo F. Padovan break; 6644519de9aSGustavo F. Padovan } 6654519de9aSGustavo F. Padovan } 6664519de9aSGustavo F. Padovan 6674343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6680a708f8fSGustavo F. Padovan { 669715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6704343478fSGustavo F. Padovan switch (chan->sec_level) { 6710a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6720a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6730a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6740a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6750a708f8fSGustavo F. Padovan default: 6760a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6770a708f8fSGustavo F. Padovan } 6782983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6794343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6804343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6810a708f8fSGustavo F. Padovan 6824343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6830a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6840a708f8fSGustavo F. Padovan else 6850a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6860a708f8fSGustavo F. Padovan } else { 6874343478fSGustavo F. Padovan switch (chan->sec_level) { 6880a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6890a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6900a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6910a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6920a708f8fSGustavo F. Padovan default: 6930a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6940a708f8fSGustavo F. Padovan } 6950a708f8fSGustavo F. Padovan } 6960a708f8fSGustavo F. Padovan } 6970a708f8fSGustavo F. Padovan 6980a708f8fSGustavo F. Padovan /* Service level security */ 699d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 7000a708f8fSGustavo F. Padovan { 7018c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 7020a708f8fSGustavo F. Padovan __u8 auth_type; 7030a708f8fSGustavo F. Padovan 7044343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 7050a708f8fSGustavo F. Padovan 7064343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 7070a708f8fSGustavo F. Padovan } 7080a708f8fSGustavo F. Padovan 709b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 7100a708f8fSGustavo F. Padovan { 7110a708f8fSGustavo F. Padovan u8 id; 7120a708f8fSGustavo F. Padovan 7130a708f8fSGustavo F. Padovan /* Get next available identificator. 7140a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 7150a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 7160a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 7170a708f8fSGustavo F. Padovan */ 7180a708f8fSGustavo F. Padovan 719333055f2SGustavo F. Padovan spin_lock(&conn->lock); 7200a708f8fSGustavo F. Padovan 7210a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 7220a708f8fSGustavo F. Padovan conn->tx_ident = 1; 7230a708f8fSGustavo F. Padovan 7240a708f8fSGustavo F. Padovan id = conn->tx_ident; 7250a708f8fSGustavo F. Padovan 726333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 7270a708f8fSGustavo F. Padovan 7280a708f8fSGustavo F. Padovan return id; 7290a708f8fSGustavo F. Padovan } 7300a708f8fSGustavo F. Padovan 7312d792818SGustavo Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 7322d792818SGustavo Padovan void *data) 7330a708f8fSGustavo F. Padovan { 7340a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 7350a708f8fSGustavo F. Padovan u8 flags; 7360a708f8fSGustavo F. Padovan 7370a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 7380a708f8fSGustavo F. Padovan 7390a708f8fSGustavo F. Padovan if (!skb) 7400a708f8fSGustavo F. Padovan return; 7410a708f8fSGustavo F. Padovan 7420a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 7430a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 7440a708f8fSGustavo F. Padovan else 7450a708f8fSGustavo F. Padovan flags = ACL_START; 7460a708f8fSGustavo F. Padovan 74714b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 7485e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 74914b12d0bSJaikumar Ganesh 75073d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 7510a708f8fSGustavo F. Padovan } 7520a708f8fSGustavo F. Padovan 75302b0fbb9SMat Martineau static bool __chan_is_moving(struct l2cap_chan *chan) 75402b0fbb9SMat Martineau { 75502b0fbb9SMat Martineau return chan->move_state != L2CAP_MOVE_STABLE && 75602b0fbb9SMat Martineau chan->move_state != L2CAP_MOVE_WAIT_PREPARE; 75702b0fbb9SMat Martineau } 75802b0fbb9SMat Martineau 75973d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 76073d80debSLuiz Augusto von Dentz { 76173d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 76273d80debSLuiz Augusto von Dentz u16 flags; 76373d80debSLuiz Augusto von Dentz 76473d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 76573d80debSLuiz Augusto von Dentz skb->priority); 76673d80debSLuiz Augusto von Dentz 767d5f8a75dSMat Martineau if (chan->hs_hcon && !__chan_is_moving(chan)) { 768d5f8a75dSMat Martineau if (chan->hs_hchan) 769d5f8a75dSMat Martineau hci_send_acl(chan->hs_hchan, skb, ACL_COMPLETE); 770d5f8a75dSMat Martineau else 771d5f8a75dSMat Martineau kfree_skb(skb); 772d5f8a75dSMat Martineau 773d5f8a75dSMat Martineau return; 774d5f8a75dSMat Martineau } 775d5f8a75dSMat Martineau 77673d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 77773d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 77873d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 77973d80debSLuiz Augusto von Dentz else 78073d80debSLuiz Augusto von Dentz flags = ACL_START; 78173d80debSLuiz Augusto von Dentz 78273d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 78373d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7840a708f8fSGustavo F. Padovan } 7850a708f8fSGustavo F. Padovan 786b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 787b5c6aaedSMat Martineau { 788b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 789b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 790b5c6aaedSMat Martineau 791b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 792b5c6aaedSMat Martineau /* S-Frame */ 793b5c6aaedSMat Martineau control->sframe = 1; 794b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 795b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 796b5c6aaedSMat Martineau 797b5c6aaedSMat Martineau control->sar = 0; 798b5c6aaedSMat Martineau control->txseq = 0; 799b5c6aaedSMat Martineau } else { 800b5c6aaedSMat Martineau /* I-Frame */ 801b5c6aaedSMat Martineau control->sframe = 0; 802b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 803b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 804b5c6aaedSMat Martineau 805b5c6aaedSMat Martineau control->poll = 0; 806b5c6aaedSMat Martineau control->super = 0; 807b5c6aaedSMat Martineau } 808b5c6aaedSMat Martineau } 809b5c6aaedSMat Martineau 810b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 811b5c6aaedSMat Martineau { 812b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 813b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 814b5c6aaedSMat Martineau 815b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 816b5c6aaedSMat Martineau /* S-Frame */ 817b5c6aaedSMat Martineau control->sframe = 1; 818b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 819b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 820b5c6aaedSMat Martineau 821b5c6aaedSMat Martineau control->sar = 0; 822b5c6aaedSMat Martineau control->txseq = 0; 823b5c6aaedSMat Martineau } else { 824b5c6aaedSMat Martineau /* I-Frame */ 825b5c6aaedSMat Martineau control->sframe = 0; 826b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 827b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 828b5c6aaedSMat Martineau 829b5c6aaedSMat Martineau control->poll = 0; 830b5c6aaedSMat Martineau control->super = 0; 831b5c6aaedSMat Martineau } 832b5c6aaedSMat Martineau } 833b5c6aaedSMat Martineau 834b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 835b5c6aaedSMat Martineau struct sk_buff *skb) 836b5c6aaedSMat Martineau { 837b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 838b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 839b5c6aaedSMat Martineau &bt_cb(skb)->control); 840cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 841b5c6aaedSMat Martineau } else { 842b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 843b5c6aaedSMat Martineau &bt_cb(skb)->control); 844cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 845b5c6aaedSMat Martineau } 846b5c6aaedSMat Martineau } 847b5c6aaedSMat Martineau 848b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 849b5c6aaedSMat Martineau { 850b5c6aaedSMat Martineau u32 packed; 851b5c6aaedSMat Martineau 852b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 853b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 854b5c6aaedSMat Martineau 855b5c6aaedSMat Martineau if (control->sframe) { 856b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 857b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 858b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 859b5c6aaedSMat Martineau } else { 860b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 861b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 862b5c6aaedSMat Martineau } 863b5c6aaedSMat Martineau 864b5c6aaedSMat Martineau return packed; 865b5c6aaedSMat Martineau } 866b5c6aaedSMat Martineau 867b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 868b5c6aaedSMat Martineau { 869b5c6aaedSMat Martineau u16 packed; 870b5c6aaedSMat Martineau 871b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 872b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 873b5c6aaedSMat Martineau 874b5c6aaedSMat Martineau if (control->sframe) { 875b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 876b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 877b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 878b5c6aaedSMat Martineau } else { 879b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 880b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 881b5c6aaedSMat Martineau } 882b5c6aaedSMat Martineau 883b5c6aaedSMat Martineau return packed; 884b5c6aaedSMat Martineau } 885b5c6aaedSMat Martineau 886b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 887b5c6aaedSMat Martineau struct l2cap_ctrl *control, 888b5c6aaedSMat Martineau struct sk_buff *skb) 889b5c6aaedSMat Martineau { 890b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 891b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 892b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 893b5c6aaedSMat Martineau } else { 894b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 895b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 896b5c6aaedSMat Martineau } 897b5c6aaedSMat Martineau } 898b5c6aaedSMat Martineau 899ba7aa64fSGustavo Padovan static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan) 900ba7aa64fSGustavo Padovan { 901ba7aa64fSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 902ba7aa64fSGustavo Padovan return L2CAP_EXT_HDR_SIZE; 903ba7aa64fSGustavo Padovan else 904ba7aa64fSGustavo Padovan return L2CAP_ENH_HDR_SIZE; 905ba7aa64fSGustavo Padovan } 906ba7aa64fSGustavo Padovan 907a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 908a67d7f6fSMat Martineau u32 control) 9090a708f8fSGustavo F. Padovan { 9100a708f8fSGustavo F. Padovan struct sk_buff *skb; 9110a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 912ba7aa64fSGustavo Padovan int hlen = __ertm_hdr_size(chan); 9130a708f8fSGustavo F. Padovan 9140a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 91503a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 9160a708f8fSGustavo F. Padovan 917a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 9180a708f8fSGustavo F. Padovan 9190a708f8fSGustavo F. Padovan if (!skb) 920a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 9210a708f8fSGustavo F. Padovan 9220a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 9230a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 924fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 92588843ab0SAndrei Emeltchenko 926a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 927a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 928a67d7f6fSMat Martineau else 929a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 9300a708f8fSGustavo F. Padovan 93147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 932a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 93303a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 9340a708f8fSGustavo F. Padovan } 9350a708f8fSGustavo F. Padovan 93673d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 937a67d7f6fSMat Martineau return skb; 938a67d7f6fSMat Martineau } 939a67d7f6fSMat Martineau 940a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 941a67d7f6fSMat Martineau struct l2cap_ctrl *control) 942a67d7f6fSMat Martineau { 943a67d7f6fSMat Martineau struct sk_buff *skb; 944a67d7f6fSMat Martineau u32 control_field; 945a67d7f6fSMat Martineau 946a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 947a67d7f6fSMat Martineau 948a67d7f6fSMat Martineau if (!control->sframe) 949a67d7f6fSMat Martineau return; 950a67d7f6fSMat Martineau 951b99e13adSMat Martineau if (__chan_is_moving(chan)) 952b99e13adSMat Martineau return; 953b99e13adSMat Martineau 954a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 955a67d7f6fSMat Martineau !control->poll) 956a67d7f6fSMat Martineau control->final = 1; 957a67d7f6fSMat Martineau 958a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 959a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 960a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 961a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 962a67d7f6fSMat Martineau 963a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 964a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 965a67d7f6fSMat Martineau __clear_ack_timer(chan); 966a67d7f6fSMat Martineau } 967a67d7f6fSMat Martineau 968a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 969a67d7f6fSMat Martineau control->final, control->poll, control->super); 970a67d7f6fSMat Martineau 971a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 972a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 973a67d7f6fSMat Martineau else 974a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 975a67d7f6fSMat Martineau 976a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 977a67d7f6fSMat Martineau if (!IS_ERR(skb)) 97873d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9790a708f8fSGustavo F. Padovan } 9800a708f8fSGustavo F. Padovan 981c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9820a708f8fSGustavo F. Padovan { 983c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9840a708f8fSGustavo F. Padovan 985c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 986c9e3d5e0SMat Martineau 987c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 988c9e3d5e0SMat Martineau control.sframe = 1; 989c9e3d5e0SMat Martineau control.poll = poll; 990c9e3d5e0SMat Martineau 991c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 992c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 993c9e3d5e0SMat Martineau else 994c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 995c9e3d5e0SMat Martineau 996c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 997c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 9980a708f8fSGustavo F. Padovan } 9990a708f8fSGustavo F. Padovan 1000b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 10010a708f8fSGustavo F. Padovan { 1002c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 10030a708f8fSGustavo F. Padovan } 10040a708f8fSGustavo F. Padovan 100593c3e8f5SAndrei Emeltchenko static bool __amp_capable(struct l2cap_chan *chan) 100693c3e8f5SAndrei Emeltchenko { 100793c3e8f5SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 100893c3e8f5SAndrei Emeltchenko 100993c3e8f5SAndrei Emeltchenko if (enable_hs && 101093c3e8f5SAndrei Emeltchenko chan->chan_policy == BT_CHANNEL_POLICY_AMP_PREFERRED && 101193c3e8f5SAndrei Emeltchenko conn->fixed_chan_mask & L2CAP_FC_A2MP) 101293c3e8f5SAndrei Emeltchenko return true; 101393c3e8f5SAndrei Emeltchenko else 101493c3e8f5SAndrei Emeltchenko return false; 101593c3e8f5SAndrei Emeltchenko } 101693c3e8f5SAndrei Emeltchenko 1017*5ce66b59SAndrei Emeltchenko static bool l2cap_check_efs(struct l2cap_chan *chan) 1018*5ce66b59SAndrei Emeltchenko { 1019*5ce66b59SAndrei Emeltchenko /* Check EFS parameters */ 1020*5ce66b59SAndrei Emeltchenko return true; 1021*5ce66b59SAndrei Emeltchenko } 1022*5ce66b59SAndrei Emeltchenko 10232766be48SAndrei Emeltchenko void l2cap_send_conn_req(struct l2cap_chan *chan) 10249b27f350SAndrei Emeltchenko { 10259b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 10269b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 10279b27f350SAndrei Emeltchenko 10289b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 10299b27f350SAndrei Emeltchenko req.psm = chan->psm; 10309b27f350SAndrei Emeltchenko 10319b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 10329b27f350SAndrei Emeltchenko 10339b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 10349b27f350SAndrei Emeltchenko 10359b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 10369b27f350SAndrei Emeltchenko } 10379b27f350SAndrei Emeltchenko 10388eb200bdSMat Martineau static void l2cap_send_create_chan_req(struct l2cap_chan *chan, u8 amp_id) 10398eb200bdSMat Martineau { 10408eb200bdSMat Martineau struct l2cap_create_chan_req req; 10418eb200bdSMat Martineau req.scid = cpu_to_le16(chan->scid); 10428eb200bdSMat Martineau req.psm = chan->psm; 10438eb200bdSMat Martineau req.amp_id = amp_id; 10448eb200bdSMat Martineau 10458eb200bdSMat Martineau chan->ident = l2cap_get_ident(chan->conn); 10468eb200bdSMat Martineau 10478eb200bdSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_REQ, 10488eb200bdSMat Martineau sizeof(req), &req); 10498eb200bdSMat Martineau } 10508eb200bdSMat Martineau 105102b0fbb9SMat Martineau static void l2cap_move_setup(struct l2cap_chan *chan) 105202b0fbb9SMat Martineau { 105302b0fbb9SMat Martineau struct sk_buff *skb; 105402b0fbb9SMat Martineau 105502b0fbb9SMat Martineau BT_DBG("chan %p", chan); 105602b0fbb9SMat Martineau 105702b0fbb9SMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 105802b0fbb9SMat Martineau return; 105902b0fbb9SMat Martineau 106002b0fbb9SMat Martineau __clear_retrans_timer(chan); 106102b0fbb9SMat Martineau __clear_monitor_timer(chan); 106202b0fbb9SMat Martineau __clear_ack_timer(chan); 106302b0fbb9SMat Martineau 106402b0fbb9SMat Martineau chan->retry_count = 0; 106502b0fbb9SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 106602b0fbb9SMat Martineau if (bt_cb(skb)->control.retries) 106702b0fbb9SMat Martineau bt_cb(skb)->control.retries = 1; 106802b0fbb9SMat Martineau else 106902b0fbb9SMat Martineau break; 107002b0fbb9SMat Martineau } 107102b0fbb9SMat Martineau 107202b0fbb9SMat Martineau chan->expected_tx_seq = chan->buffer_seq; 107302b0fbb9SMat Martineau 107402b0fbb9SMat Martineau clear_bit(CONN_REJ_ACT, &chan->conn_state); 107502b0fbb9SMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 107602b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 107702b0fbb9SMat Martineau l2cap_seq_list_clear(&chan->srej_list); 107802b0fbb9SMat Martineau skb_queue_purge(&chan->srej_q); 107902b0fbb9SMat Martineau 108002b0fbb9SMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 108102b0fbb9SMat Martineau chan->rx_state = L2CAP_RX_STATE_MOVE; 108202b0fbb9SMat Martineau 108302b0fbb9SMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 108402b0fbb9SMat Martineau } 108502b0fbb9SMat Martineau 10865f3847a4SMat Martineau static void l2cap_move_done(struct l2cap_chan *chan) 10875f3847a4SMat Martineau { 10885f3847a4SMat Martineau u8 move_role = chan->move_role; 10895f3847a4SMat Martineau BT_DBG("chan %p", chan); 10905f3847a4SMat Martineau 10915f3847a4SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 10925f3847a4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 10935f3847a4SMat Martineau 10945f3847a4SMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 10955f3847a4SMat Martineau return; 10965f3847a4SMat Martineau 10975f3847a4SMat Martineau switch (move_role) { 10985f3847a4SMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 10995f3847a4SMat Martineau l2cap_tx(chan, NULL, NULL, L2CAP_EV_EXPLICIT_POLL); 11005f3847a4SMat Martineau chan->rx_state = L2CAP_RX_STATE_WAIT_F; 11015f3847a4SMat Martineau break; 11025f3847a4SMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 11035f3847a4SMat Martineau chan->rx_state = L2CAP_RX_STATE_WAIT_P; 11045f3847a4SMat Martineau break; 11055f3847a4SMat Martineau } 11065f3847a4SMat Martineau } 11075f3847a4SMat Martineau 11089f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 11099f0caeb1SVinicius Costa Gomes { 11102827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 11119f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 11129f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 11139f0caeb1SVinicius Costa Gomes 111454a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 11159f0caeb1SVinicius Costa Gomes 111654a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 11179f0caeb1SVinicius Costa Gomes } 11189f0caeb1SVinicius Costa Gomes 111993c3e8f5SAndrei Emeltchenko static void l2cap_start_connection(struct l2cap_chan *chan) 112093c3e8f5SAndrei Emeltchenko { 112193c3e8f5SAndrei Emeltchenko if (__amp_capable(chan)) { 112293c3e8f5SAndrei Emeltchenko BT_DBG("chan %p AMP capable: discover AMPs", chan); 112393c3e8f5SAndrei Emeltchenko a2mp_discover_amp(chan); 112493c3e8f5SAndrei Emeltchenko } else { 112593c3e8f5SAndrei Emeltchenko l2cap_send_conn_req(chan); 112693c3e8f5SAndrei Emeltchenko } 112793c3e8f5SAndrei Emeltchenko } 112893c3e8f5SAndrei Emeltchenko 1129fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 11300a708f8fSGustavo F. Padovan { 11318c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 11320a708f8fSGustavo F. Padovan 11339f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 11349f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 11359f0caeb1SVinicius Costa Gomes return; 11369f0caeb1SVinicius Costa Gomes } 11379f0caeb1SVinicius Costa Gomes 11380a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 11390a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 11400a708f8fSGustavo F. Padovan return; 11410a708f8fSGustavo F. Padovan 1142d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 114393c3e8f5SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) { 114493c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 114593c3e8f5SAndrei Emeltchenko } 11460a708f8fSGustavo F. Padovan } else { 11470a708f8fSGustavo F. Padovan struct l2cap_info_req req; 1148ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 11490a708f8fSGustavo F. Padovan 11500a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 11510a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 11520a708f8fSGustavo F. Padovan 1153ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 11540a708f8fSGustavo F. Padovan 11552d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 11562d792818SGustavo Padovan sizeof(req), &req); 11570a708f8fSGustavo F. Padovan } 11580a708f8fSGustavo F. Padovan } 11590a708f8fSGustavo F. Padovan 11600a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 11610a708f8fSGustavo F. Padovan { 11620a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 11630a708f8fSGustavo F. Padovan if (!disable_ertm) 11640a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 11650a708f8fSGustavo F. Padovan 11660a708f8fSGustavo F. Padovan switch (mode) { 11670a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 11680a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 11690a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 11700a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 11710a708f8fSGustavo F. Padovan default: 11720a708f8fSGustavo F. Padovan return 0x00; 11730a708f8fSGustavo F. Padovan } 11740a708f8fSGustavo F. Padovan } 11750a708f8fSGustavo F. Padovan 11762d792818SGustavo Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 11772d792818SGustavo Padovan struct l2cap_chan *chan, int err) 11780a708f8fSGustavo F. Padovan { 11796be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 11800a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 11810a708f8fSGustavo F. Padovan 11820a708f8fSGustavo F. Padovan if (!conn) 11830a708f8fSGustavo F. Padovan return; 11840a708f8fSGustavo F. Padovan 1185aad3d0e3SAndrei Emeltchenko if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) { 11861a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 11871a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 11881a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 11890a708f8fSGustavo F. Padovan } 11900a708f8fSGustavo F. Padovan 1191416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1192d117773cSGustavo Padovan l2cap_state_change(chan, BT_DISCONN); 1193416fa752SAndrei Emeltchenko return; 1194416fa752SAndrei Emeltchenko } 1195416fa752SAndrei Emeltchenko 1196fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1197fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 11982d792818SGustavo Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_DISCONN_REQ, 11992d792818SGustavo Padovan sizeof(req), &req); 12000a708f8fSGustavo F. Padovan 12016be36555SAndrei Emeltchenko lock_sock(sk); 12020e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 12032e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 12046be36555SAndrei Emeltchenko release_sock(sk); 12050a708f8fSGustavo F. Padovan } 12060a708f8fSGustavo F. Padovan 12070a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 12080a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 12090a708f8fSGustavo F. Padovan { 12103df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 12110a708f8fSGustavo F. Padovan 12120a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12130a708f8fSGustavo F. Padovan 12143df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12150a708f8fSGustavo F. Padovan 12163df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 121748454079SGustavo F. Padovan struct sock *sk = chan->sk; 1218baa7e1faSGustavo F. Padovan 12196be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12200a708f8fSGustavo F. Padovan 1221715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12226be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12230a708f8fSGustavo F. Padovan continue; 12240a708f8fSGustavo F. Padovan } 12250a708f8fSGustavo F. Padovan 122689bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1227d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1228b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 12296be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12300a708f8fSGustavo F. Padovan continue; 12310a708f8fSGustavo F. Padovan } 12320a708f8fSGustavo F. Padovan 1233c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1234c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1235c1360a1cSGustavo F. Padovan &chan->conf_state)) { 12360f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 12376be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12380a708f8fSGustavo F. Padovan continue; 12390a708f8fSGustavo F. Padovan } 12400a708f8fSGustavo F. Padovan 124193c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 12420a708f8fSGustavo F. Padovan 124389bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 12440a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 12450a708f8fSGustavo F. Padovan char buf[128]; 1246fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1247fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 12480a708f8fSGustavo F. Padovan 1249d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 12506be36555SAndrei Emeltchenko lock_sock(sk); 1251c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1252c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 1253ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1254ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 12552dc4e510SGustavo Padovan chan->ops->defer(chan); 12560a708f8fSGustavo F. Padovan 12570a708f8fSGustavo F. Padovan } else { 12580e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1259ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1260ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 12610a708f8fSGustavo F. Padovan } 12626be36555SAndrei Emeltchenko release_sock(sk); 12630a708f8fSGustavo F. Padovan } else { 1264ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1265ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 12660a708f8fSGustavo F. Padovan } 12670a708f8fSGustavo F. Padovan 1268fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1269fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 12700a708f8fSGustavo F. Padovan 1271c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 12720a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 12736be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12740a708f8fSGustavo F. Padovan continue; 12750a708f8fSGustavo F. Padovan } 12760a708f8fSGustavo F. Padovan 1277c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 12780a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 127973ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 128073ffa904SGustavo F. Padovan chan->num_conf_req++; 12810a708f8fSGustavo F. Padovan } 12820a708f8fSGustavo F. Padovan 12836be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12840a708f8fSGustavo F. Padovan } 12850a708f8fSGustavo F. Padovan 12863df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12870a708f8fSGustavo F. Padovan } 12880a708f8fSGustavo F. Padovan 1289c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1290b62f328bSVille Tervo * Returns closest match, locked. 1291b62f328bSVille Tervo */ 1292d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1293c2287681SIdo Yariv bdaddr_t *src, 1294c2287681SIdo Yariv bdaddr_t *dst) 1295b62f328bSVille Tervo { 129623691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1297b62f328bSVille Tervo 129823691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1299b62f328bSVille Tervo 130023691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 130123691d75SGustavo F. Padovan struct sock *sk = c->sk; 1302fe4128e0SGustavo F. Padovan 130389bc500eSGustavo F. Padovan if (state && c->state != state) 1304b62f328bSVille Tervo continue; 1305b62f328bSVille Tervo 130623691d75SGustavo F. Padovan if (c->scid == cid) { 1307c2287681SIdo Yariv int src_match, dst_match; 1308c2287681SIdo Yariv int src_any, dst_any; 1309c2287681SIdo Yariv 1310b62f328bSVille Tervo /* Exact match. */ 1311c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1312c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1313c2287681SIdo Yariv if (src_match && dst_match) { 131423691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 131523691d75SGustavo F. Padovan return c; 131623691d75SGustavo F. Padovan } 1317b62f328bSVille Tervo 1318b62f328bSVille Tervo /* Closest match */ 1319c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1320c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1321c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1322c2287681SIdo Yariv (src_any && dst_any)) 132323691d75SGustavo F. Padovan c1 = c; 1324b62f328bSVille Tervo } 1325b62f328bSVille Tervo } 1326280f294fSGustavo F. Padovan 132723691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1328b62f328bSVille Tervo 132923691d75SGustavo F. Padovan return c1; 1330b62f328bSVille Tervo } 1331b62f328bSVille Tervo 1332b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1333b62f328bSVille Tervo { 1334c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 133523691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1336b62f328bSVille Tervo 1337b62f328bSVille Tervo BT_DBG(""); 1338b62f328bSVille Tervo 1339b62f328bSVille Tervo /* Check if we have socket listening on cid */ 134023691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1341c2287681SIdo Yariv conn->src, conn->dst); 134223691d75SGustavo F. Padovan if (!pchan) 1343b62f328bSVille Tervo return; 1344b62f328bSVille Tervo 134523691d75SGustavo F. Padovan parent = pchan->sk; 134623691d75SGustavo F. Padovan 1347aa2ac881SGustavo F. Padovan lock_sock(parent); 134862f3a2cfSGustavo F. Padovan 134980b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 135080808e43SGustavo F. Padovan if (!chan) 1351b62f328bSVille Tervo goto clean; 1352b62f328bSVille Tervo 135380808e43SGustavo F. Padovan sk = chan->sk; 13545d41ce1dSGustavo F. Padovan 1355b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1356a9ea3ed9SSzymon Janc conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT; 1357b62f328bSVille Tervo 1358b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1359b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1360b62f328bSVille Tervo 13613d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 136248454079SGustavo F. Padovan 13636754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1364b62f328bSVille Tervo 1365b62f328bSVille Tervo clean: 1366aa2ac881SGustavo F. Padovan release_sock(parent); 1367b62f328bSVille Tervo } 1368b62f328bSVille Tervo 13690a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 13700a708f8fSGustavo F. Padovan { 137148454079SGustavo F. Padovan struct l2cap_chan *chan; 1372cc110922SVinicius Costa Gomes struct hci_conn *hcon = conn->hcon; 13730a708f8fSGustavo F. Padovan 13740a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 13750a708f8fSGustavo F. Padovan 1376cc110922SVinicius Costa Gomes if (!hcon->out && hcon->type == LE_LINK) 1377b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1378b62f328bSVille Tervo 1379cc110922SVinicius Costa Gomes if (hcon->out && hcon->type == LE_LINK) 1380cc110922SVinicius Costa Gomes smp_conn_security(hcon, hcon->pending_sec_level); 1381160dc6acSVinicius Costa Gomes 13823df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 13830a708f8fSGustavo F. Padovan 13843df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1385baa7e1faSGustavo F. Padovan 13866be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 13870a708f8fSGustavo F. Padovan 1388416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1389416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1390416fa752SAndrei Emeltchenko continue; 1391416fa752SAndrei Emeltchenko } 1392416fa752SAndrei Emeltchenko 1393cc110922SVinicius Costa Gomes if (hcon->type == LE_LINK) { 1394cc110922SVinicius Costa Gomes if (smp_conn_security(hcon, chan->sec_level)) 1395cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1396acd7d370SVille Tervo 139763128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 13986be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1399c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 14006be36555SAndrei Emeltchenko lock_sock(sk); 14010e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 14020a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 14036be36555SAndrei Emeltchenko release_sock(sk); 1404b501d6a1SAnderson Briglia 140589bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1406fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 14070a708f8fSGustavo F. Padovan 14086be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 14090a708f8fSGustavo F. Padovan } 14100a708f8fSGustavo F. Padovan 14113df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14120a708f8fSGustavo F. Padovan } 14130a708f8fSGustavo F. Padovan 14140a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 14150a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 14160a708f8fSGustavo F. Padovan { 141748454079SGustavo F. Padovan struct l2cap_chan *chan; 14180a708f8fSGustavo F. Padovan 14190a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 14200a708f8fSGustavo F. Padovan 14213df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 14220a708f8fSGustavo F. Padovan 14233df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1424ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 14251d8b1fd5SGustavo Padovan l2cap_chan_set_err(chan, err); 14260a708f8fSGustavo F. Padovan } 14270a708f8fSGustavo F. Padovan 14283df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14290a708f8fSGustavo F. Padovan } 14300a708f8fSGustavo F. Padovan 1431f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 14320a708f8fSGustavo F. Padovan { 1433f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1434030013d8SGustavo F. Padovan info_timer.work); 14350a708f8fSGustavo F. Padovan 14360a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 14370a708f8fSGustavo F. Padovan conn->info_ident = 0; 14380a708f8fSGustavo F. Padovan 14390a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 14400a708f8fSGustavo F. Padovan } 14410a708f8fSGustavo F. Padovan 14425d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 14435d3de7dfSVinicius Costa Gomes { 14445d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 14455d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 14465d3de7dfSVinicius Costa Gomes 14475d3de7dfSVinicius Costa Gomes if (!conn) 14485d3de7dfSVinicius Costa Gomes return; 14495d3de7dfSVinicius Costa Gomes 14505d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 14515d3de7dfSVinicius Costa Gomes 14525d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 14535d3de7dfSVinicius Costa Gomes 14543df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 14553df91ea2SAndrei Emeltchenko 14565d3de7dfSVinicius Costa Gomes /* Kill channels */ 14575d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 145861d6ef3eSMat Martineau l2cap_chan_hold(chan); 14596be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 14606be36555SAndrei Emeltchenko 14615d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 14626be36555SAndrei Emeltchenko 14636be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 14646be36555SAndrei Emeltchenko 146580b98027SGustavo Padovan chan->ops->close(chan); 146661d6ef3eSMat Martineau l2cap_chan_put(chan); 14675d3de7dfSVinicius Costa Gomes } 14685d3de7dfSVinicius Costa Gomes 14693df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 14703df91ea2SAndrei Emeltchenko 147173d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 147273d80debSLuiz Augusto von Dentz 14735d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1474127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 14755d3de7dfSVinicius Costa Gomes 147651a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1477127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 14788aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1479d26a2345SVinicius Costa Gomes } 14805d3de7dfSVinicius Costa Gomes 14815d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 14825d3de7dfSVinicius Costa Gomes kfree(conn); 14835d3de7dfSVinicius Costa Gomes } 14845d3de7dfSVinicius Costa Gomes 14856c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 14865d3de7dfSVinicius Costa Gomes { 14876c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 14886c9d42a1SGustavo F. Padovan security_timer.work); 14895d3de7dfSVinicius Costa Gomes 1490d06cc416SJohan Hedberg BT_DBG("conn %p", conn); 1491d06cc416SJohan Hedberg 1492d06cc416SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 1493d06cc416SJohan Hedberg smp_chan_destroy(conn); 14945d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 14955d3de7dfSVinicius Costa Gomes } 1496d06cc416SJohan Hedberg } 14975d3de7dfSVinicius Costa Gomes 14980a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 14990a708f8fSGustavo F. Padovan { 15000a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 150173d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 15020a708f8fSGustavo F. Padovan 15030a708f8fSGustavo F. Padovan if (conn || status) 15040a708f8fSGustavo F. Padovan return conn; 15050a708f8fSGustavo F. Padovan 150673d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 150773d80debSLuiz Augusto von Dentz if (!hchan) 15080a708f8fSGustavo F. Padovan return NULL; 15090a708f8fSGustavo F. Padovan 15108bcde1f2SGustavo Padovan conn = kzalloc(sizeof(struct l2cap_conn), GFP_KERNEL); 151173d80debSLuiz Augusto von Dentz if (!conn) { 151273d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 151373d80debSLuiz Augusto von Dentz return NULL; 151473d80debSLuiz Augusto von Dentz } 151573d80debSLuiz Augusto von Dentz 15160a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 15170a708f8fSGustavo F. Padovan conn->hcon = hcon; 151873d80debSLuiz Augusto von Dentz conn->hchan = hchan; 15190a708f8fSGustavo F. Padovan 152073d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 15210a708f8fSGustavo F. Padovan 1522dcc042d5SAndrei Emeltchenko switch (hcon->type) { 1523dcc042d5SAndrei Emeltchenko case AMP_LINK: 1524dcc042d5SAndrei Emeltchenko conn->mtu = hcon->hdev->block_mtu; 1525dcc042d5SAndrei Emeltchenko break; 1526dcc042d5SAndrei Emeltchenko 1527dcc042d5SAndrei Emeltchenko case LE_LINK: 1528dcc042d5SAndrei Emeltchenko if (hcon->hdev->le_mtu) { 1529acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1530dcc042d5SAndrei Emeltchenko break; 1531dcc042d5SAndrei Emeltchenko } 1532dcc042d5SAndrei Emeltchenko /* fall through */ 1533dcc042d5SAndrei Emeltchenko 1534dcc042d5SAndrei Emeltchenko default: 15350a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1536dcc042d5SAndrei Emeltchenko break; 1537dcc042d5SAndrei Emeltchenko } 1538acd7d370SVille Tervo 15390a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 15400a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 15410a708f8fSGustavo F. Padovan 15420a708f8fSGustavo F. Padovan conn->feat_mask = 0; 15430a708f8fSGustavo F. Padovan 15440a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 15453df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1546baa7e1faSGustavo F. Padovan 1547baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 15480a708f8fSGustavo F. Padovan 15495d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 15506c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 15515d3de7dfSVinicius Costa Gomes else 1552030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 15530a708f8fSGustavo F. Padovan 15549f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 15550a708f8fSGustavo F. Padovan 15560a708f8fSGustavo F. Padovan return conn; 15570a708f8fSGustavo F. Padovan } 15580a708f8fSGustavo F. Padovan 15590a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 15600a708f8fSGustavo F. Padovan 1561c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 15620a708f8fSGustavo F. Padovan * Returns closest match. 15630a708f8fSGustavo F. Padovan */ 1564c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1565c2287681SIdo Yariv bdaddr_t *src, 1566c2287681SIdo Yariv bdaddr_t *dst) 15670a708f8fSGustavo F. Padovan { 156823691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 15690a708f8fSGustavo F. Padovan 157023691d75SGustavo F. Padovan read_lock(&chan_list_lock); 15710a708f8fSGustavo F. Padovan 157223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 157323691d75SGustavo F. Padovan struct sock *sk = c->sk; 1574fe4128e0SGustavo F. Padovan 157589bc500eSGustavo F. Padovan if (state && c->state != state) 15760a708f8fSGustavo F. Padovan continue; 15770a708f8fSGustavo F. Padovan 157823691d75SGustavo F. Padovan if (c->psm == psm) { 1579c2287681SIdo Yariv int src_match, dst_match; 1580c2287681SIdo Yariv int src_any, dst_any; 1581c2287681SIdo Yariv 15820a708f8fSGustavo F. Padovan /* Exact match. */ 1583c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1584c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1585c2287681SIdo Yariv if (src_match && dst_match) { 1586a7567b20SJohannes Berg read_unlock(&chan_list_lock); 158723691d75SGustavo F. Padovan return c; 158823691d75SGustavo F. Padovan } 15890a708f8fSGustavo F. Padovan 15900a708f8fSGustavo F. Padovan /* Closest match */ 1591c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1592c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1593c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1594c2287681SIdo Yariv (src_any && dst_any)) 159523691d75SGustavo F. Padovan c1 = c; 15960a708f8fSGustavo F. Padovan } 15970a708f8fSGustavo F. Padovan } 15980a708f8fSGustavo F. Padovan 159923691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 16000a708f8fSGustavo F. Padovan 160123691d75SGustavo F. Padovan return c1; 16020a708f8fSGustavo F. Padovan } 16030a708f8fSGustavo F. Padovan 16048e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 16058e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 16060a708f8fSGustavo F. Padovan { 16075d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 16080a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 16090a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 16100a708f8fSGustavo F. Padovan struct hci_conn *hcon; 16110a708f8fSGustavo F. Padovan struct hci_dev *hdev; 16120a708f8fSGustavo F. Padovan __u8 auth_type; 16130a708f8fSGustavo F. Padovan int err; 16140a708f8fSGustavo F. Padovan 16156ed93dc6SAndrei Emeltchenko BT_DBG("%pMR -> %pMR (type %u) psm 0x%2.2x", src, dst, 1616ab19516aSSyam Sidhardhan dst_type, __le16_to_cpu(psm)); 16170a708f8fSGustavo F. Padovan 16180a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 16190a708f8fSGustavo F. Padovan if (!hdev) 16200a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 16210a708f8fSGustavo F. Padovan 162209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16230a708f8fSGustavo F. Padovan 16246be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 162503a00194SGustavo F. Padovan 162603a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 162703a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 162803a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 162903a00194SGustavo F. Padovan err = -EINVAL; 163003a00194SGustavo F. Padovan goto done; 163103a00194SGustavo F. Padovan } 163203a00194SGustavo F. Padovan 163303a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 163403a00194SGustavo F. Padovan err = -EINVAL; 163503a00194SGustavo F. Padovan goto done; 163603a00194SGustavo F. Padovan } 163703a00194SGustavo F. Padovan 163803a00194SGustavo F. Padovan switch (chan->mode) { 163903a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 164003a00194SGustavo F. Padovan break; 164103a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 164203a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 164303a00194SGustavo F. Padovan if (!disable_ertm) 164403a00194SGustavo F. Padovan break; 164503a00194SGustavo F. Padovan /* fall through */ 164603a00194SGustavo F. Padovan default: 164703a00194SGustavo F. Padovan err = -ENOTSUPP; 164803a00194SGustavo F. Padovan goto done; 164903a00194SGustavo F. Padovan } 165003a00194SGustavo F. Padovan 16510797e01dSGustavo Padovan switch (chan->state) { 165203a00194SGustavo F. Padovan case BT_CONNECT: 165303a00194SGustavo F. Padovan case BT_CONNECT2: 165403a00194SGustavo F. Padovan case BT_CONFIG: 165503a00194SGustavo F. Padovan /* Already connecting */ 165603a00194SGustavo F. Padovan err = 0; 165703a00194SGustavo F. Padovan goto done; 165803a00194SGustavo F. Padovan 165903a00194SGustavo F. Padovan case BT_CONNECTED: 166003a00194SGustavo F. Padovan /* Already connected */ 166103a00194SGustavo F. Padovan err = -EISCONN; 166203a00194SGustavo F. Padovan goto done; 166303a00194SGustavo F. Padovan 166403a00194SGustavo F. Padovan case BT_OPEN: 166503a00194SGustavo F. Padovan case BT_BOUND: 166603a00194SGustavo F. Padovan /* Can connect */ 166703a00194SGustavo F. Padovan break; 166803a00194SGustavo F. Padovan 166903a00194SGustavo F. Padovan default: 167003a00194SGustavo F. Padovan err = -EBADFD; 167103a00194SGustavo F. Padovan goto done; 167203a00194SGustavo F. Padovan } 167303a00194SGustavo F. Padovan 167403a00194SGustavo F. Padovan /* Set destination address and psm */ 16750797e01dSGustavo Padovan lock_sock(sk); 16769219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 16776be36555SAndrei Emeltchenko release_sock(sk); 16786be36555SAndrei Emeltchenko 167903a00194SGustavo F. Padovan chan->psm = psm; 168003a00194SGustavo F. Padovan chan->dcid = cid; 16810a708f8fSGustavo F. Padovan 16824343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 16830a708f8fSGustavo F. Padovan 1684fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 16858e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 16864343478fSGustavo F. Padovan chan->sec_level, auth_type); 1687acd7d370SVille Tervo else 16888e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 16894343478fSGustavo F. Padovan chan->sec_level, auth_type); 1690acd7d370SVille Tervo 169130e76272SVille Tervo if (IS_ERR(hcon)) { 169230e76272SVille Tervo err = PTR_ERR(hcon); 16930a708f8fSGustavo F. Padovan goto done; 169430e76272SVille Tervo } 16950a708f8fSGustavo F. Padovan 16960a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 16970a708f8fSGustavo F. Padovan if (!conn) { 16980a708f8fSGustavo F. Padovan hci_conn_put(hcon); 169930e76272SVille Tervo err = -ENOMEM; 17000a708f8fSGustavo F. Padovan goto done; 17010a708f8fSGustavo F. Padovan } 17020a708f8fSGustavo F. Padovan 17039f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 17049f0caeb1SVinicius Costa Gomes err = 0; 17059f0caeb1SVinicius Costa Gomes 17069f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 17079f0caeb1SVinicius Costa Gomes err = -EBUSY; 17089f0caeb1SVinicius Costa Gomes hci_conn_put(hcon); 17099f0caeb1SVinicius Costa Gomes } 17109f0caeb1SVinicius Costa Gomes 17119f0caeb1SVinicius Costa Gomes if (err) 17129f0caeb1SVinicius Costa Gomes goto done; 17139f0caeb1SVinicius Costa Gomes } 17149f0caeb1SVinicius Costa Gomes 17150a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 17160a708f8fSGustavo F. Padovan bacpy(src, conn->src); 17170a708f8fSGustavo F. Padovan 17186be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 171948454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 17206be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 172148454079SGustavo F. Padovan 17226be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1723c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 17240a708f8fSGustavo F. Padovan 17250a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1726715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1727c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1728d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 17296be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 17300a708f8fSGustavo F. Padovan } else 1731fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 17320a708f8fSGustavo F. Padovan } 17330a708f8fSGustavo F. Padovan 173430e76272SVille Tervo err = 0; 173530e76272SVille Tervo 17360a708f8fSGustavo F. Padovan done: 17376be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 173809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17390a708f8fSGustavo F. Padovan hci_dev_put(hdev); 17400a708f8fSGustavo F. Padovan return err; 17410a708f8fSGustavo F. Padovan } 17420a708f8fSGustavo F. Padovan 1743dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 17440a708f8fSGustavo F. Padovan { 17458c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 17460a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 17470a708f8fSGustavo F. Padovan int err = 0; 17480a708f8fSGustavo F. Padovan int timeo = HZ/5; 17490a708f8fSGustavo F. Padovan 17500a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 17510a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1752a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 17530a708f8fSGustavo F. Padovan if (!timeo) 17540a708f8fSGustavo F. Padovan timeo = HZ/5; 17550a708f8fSGustavo F. Padovan 17560a708f8fSGustavo F. Padovan if (signal_pending(current)) { 17570a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 17580a708f8fSGustavo F. Padovan break; 17590a708f8fSGustavo F. Padovan } 17600a708f8fSGustavo F. Padovan 17610a708f8fSGustavo F. Padovan release_sock(sk); 17620a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 17630a708f8fSGustavo F. Padovan lock_sock(sk); 1764a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 17650a708f8fSGustavo F. Padovan 17660a708f8fSGustavo F. Padovan err = sock_error(sk); 17670a708f8fSGustavo F. Padovan if (err) 17680a708f8fSGustavo F. Padovan break; 17690a708f8fSGustavo F. Padovan } 17700a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 17710a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 17720a708f8fSGustavo F. Padovan return err; 17730a708f8fSGustavo F. Padovan } 17740a708f8fSGustavo F. Padovan 1775721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 17760a708f8fSGustavo F. Padovan { 1777721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1778721c4181SGustavo F. Padovan monitor_timer.work); 17790a708f8fSGustavo F. Padovan 1780525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 17810a708f8fSGustavo F. Padovan 17826be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 17836be36555SAndrei Emeltchenko 178480909e04SMat Martineau if (!chan->conn) { 17856be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 17868d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 17870a708f8fSGustavo F. Padovan return; 17880a708f8fSGustavo F. Padovan } 17890a708f8fSGustavo F. Padovan 1790401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 17910a708f8fSGustavo F. Padovan 17926be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 17938d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 17940a708f8fSGustavo F. Padovan } 17950a708f8fSGustavo F. Padovan 1796721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 17970a708f8fSGustavo F. Padovan { 1798721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1799721c4181SGustavo F. Padovan retrans_timer.work); 18000a708f8fSGustavo F. Padovan 180149208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 18020a708f8fSGustavo F. Padovan 18036be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 18046be36555SAndrei Emeltchenko 180580909e04SMat Martineau if (!chan->conn) { 180680909e04SMat Martineau l2cap_chan_unlock(chan); 180780909e04SMat Martineau l2cap_chan_put(chan); 180880909e04SMat Martineau return; 180980909e04SMat Martineau } 18100a708f8fSGustavo F. Padovan 1811401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 18126be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 18138d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 18140a708f8fSGustavo F. Padovan } 18150a708f8fSGustavo F. Padovan 1816d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 18173733937dSMat Martineau struct sk_buff_head *skbs) 18180a708f8fSGustavo F. Padovan { 18190a708f8fSGustavo F. Padovan struct sk_buff *skb; 18203733937dSMat Martineau struct l2cap_ctrl *control; 18210a708f8fSGustavo F. Padovan 18223733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 18233733937dSMat Martineau 1824b99e13adSMat Martineau if (__chan_is_moving(chan)) 1825b99e13adSMat Martineau return; 1826b99e13adSMat Martineau 18273733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 18283733937dSMat Martineau 18293733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 18303733937dSMat Martineau 18313733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 18323733937dSMat Martineau 18333733937dSMat Martineau bt_cb(skb)->control.retries = 1; 18343733937dSMat Martineau control = &bt_cb(skb)->control; 18353733937dSMat Martineau 18363733937dSMat Martineau control->reqseq = 0; 18373733937dSMat Martineau control->txseq = chan->next_tx_seq; 18383733937dSMat Martineau 18393733937dSMat Martineau __pack_control(chan, control, skb); 18400a708f8fSGustavo F. Padovan 184147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 18423733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 18433733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 18440a708f8fSGustavo F. Padovan } 18450a708f8fSGustavo F. Padovan 18464343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 18470a708f8fSGustavo F. Padovan 1848b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 18493733937dSMat Martineau 1850836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 18513733937dSMat Martineau chan->frames_sent++; 18520a708f8fSGustavo F. Padovan } 18530a708f8fSGustavo F. Padovan } 18540a708f8fSGustavo F. Padovan 185567c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 18560a708f8fSGustavo F. Padovan { 18570a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 185818a48e76SMat Martineau struct l2cap_ctrl *control; 185918a48e76SMat Martineau int sent = 0; 186018a48e76SMat Martineau 186118a48e76SMat Martineau BT_DBG("chan %p", chan); 18620a708f8fSGustavo F. Padovan 186389bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 18640a708f8fSGustavo F. Padovan return -ENOTCONN; 18650a708f8fSGustavo F. Padovan 186694122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 186794122bbeSMat Martineau return 0; 186894122bbeSMat Martineau 1869b99e13adSMat Martineau if (__chan_is_moving(chan)) 1870b99e13adSMat Martineau return 0; 1871b99e13adSMat Martineau 187218a48e76SMat Martineau while (chan->tx_send_head && 187318a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 187418a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 18750a708f8fSGustavo F. Padovan 187618a48e76SMat Martineau skb = chan->tx_send_head; 18770a708f8fSGustavo F. Padovan 187818a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 187918a48e76SMat Martineau control = &bt_cb(skb)->control; 18800a708f8fSGustavo F. Padovan 1881e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 188218a48e76SMat Martineau control->final = 1; 1883e2ab4353SGustavo F. Padovan 188418a48e76SMat Martineau control->reqseq = chan->buffer_seq; 188518a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 188618a48e76SMat Martineau control->txseq = chan->next_tx_seq; 18870a708f8fSGustavo F. Padovan 188818a48e76SMat Martineau __pack_control(chan, control, skb); 18890a708f8fSGustavo F. Padovan 189047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 189118a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 189218a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 18930a708f8fSGustavo F. Padovan } 18940a708f8fSGustavo F. Padovan 189518a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 189618a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 189718a48e76SMat Martineau */ 189818a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 189918a48e76SMat Martineau 190018a48e76SMat Martineau if (!tx_skb) 190118a48e76SMat Martineau break; 19020a708f8fSGustavo F. Padovan 19031a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 19040a708f8fSGustavo F. Padovan 1905836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 19066a026610SGustavo F. Padovan chan->unacked_frames++; 19076a026610SGustavo F. Padovan chan->frames_sent++; 190818a48e76SMat Martineau sent++; 19090a708f8fSGustavo F. Padovan 191058d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 191158d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 19120a708f8fSGustavo F. Padovan else 191358d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 191418a48e76SMat Martineau 191518a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 1916b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 19170a708f8fSGustavo F. Padovan } 19180a708f8fSGustavo F. Padovan 1919b4400672SAndrei Emeltchenko BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent, 1920b4400672SAndrei Emeltchenko chan->unacked_frames, skb_queue_len(&chan->tx_q)); 192118a48e76SMat Martineau 192218a48e76SMat Martineau return sent; 19230a708f8fSGustavo F. Padovan } 19240a708f8fSGustavo F. Padovan 1925e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1926e1fbd4c1SMat Martineau { 1927e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1928e1fbd4c1SMat Martineau struct sk_buff *skb; 1929e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1930e1fbd4c1SMat Martineau u16 seq; 1931e1fbd4c1SMat Martineau 1932e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1933e1fbd4c1SMat Martineau 1934e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1935e1fbd4c1SMat Martineau return; 1936e1fbd4c1SMat Martineau 1937b99e13adSMat Martineau if (__chan_is_moving(chan)) 1938b99e13adSMat Martineau return; 1939b99e13adSMat Martineau 1940e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1941e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1942e1fbd4c1SMat Martineau 1943e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1944e1fbd4c1SMat Martineau if (!skb) { 1945e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1946e1fbd4c1SMat Martineau seq); 1947e1fbd4c1SMat Martineau continue; 1948e1fbd4c1SMat Martineau } 1949e1fbd4c1SMat Martineau 1950e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1951e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1952e1fbd4c1SMat Martineau 1953e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1954e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1955e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 1956e1fbd4c1SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 1957e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1958e1fbd4c1SMat Martineau break; 1959e1fbd4c1SMat Martineau } 1960e1fbd4c1SMat Martineau 1961e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1962e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1963e1fbd4c1SMat Martineau control.final = 1; 1964e1fbd4c1SMat Martineau else 1965e1fbd4c1SMat Martineau control.final = 0; 1966e1fbd4c1SMat Martineau 1967e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1968e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1969e1fbd4c1SMat Martineau * writeable copy 1970e1fbd4c1SMat Martineau */ 19718bcde1f2SGustavo Padovan tx_skb = skb_copy(skb, GFP_KERNEL); 1972e1fbd4c1SMat Martineau } else { 19738bcde1f2SGustavo Padovan tx_skb = skb_clone(skb, GFP_KERNEL); 1974e1fbd4c1SMat Martineau } 1975e1fbd4c1SMat Martineau 1976e1fbd4c1SMat Martineau if (!tx_skb) { 1977e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1978e1fbd4c1SMat Martineau break; 1979e1fbd4c1SMat Martineau } 1980e1fbd4c1SMat Martineau 1981e1fbd4c1SMat Martineau /* Update skb contents */ 1982e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1983e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1984e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1985e1fbd4c1SMat Martineau } else { 1986e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1987e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1988e1fbd4c1SMat Martineau } 1989e1fbd4c1SMat Martineau 1990e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1991e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1992e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1993e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1994e1fbd4c1SMat Martineau } 1995e1fbd4c1SMat Martineau 1996e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1997e1fbd4c1SMat Martineau 1998e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 1999e1fbd4c1SMat Martineau 2000e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 2001e1fbd4c1SMat Martineau } 2002e1fbd4c1SMat Martineau } 2003e1fbd4c1SMat Martineau 2004f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 2005f80842a8SMat Martineau struct l2cap_ctrl *control) 2006f80842a8SMat Martineau { 2007f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2008f80842a8SMat Martineau 2009f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 2010f80842a8SMat Martineau l2cap_ertm_resend(chan); 2011f80842a8SMat Martineau } 2012f80842a8SMat Martineau 2013d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 2014d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 2015d2a7ac5dSMat Martineau { 2016e1fbd4c1SMat Martineau struct sk_buff *skb; 2017e1fbd4c1SMat Martineau 2018e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2019e1fbd4c1SMat Martineau 2020e1fbd4c1SMat Martineau if (control->poll) 2021e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 2022e1fbd4c1SMat Martineau 2023e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 2024e1fbd4c1SMat Martineau 2025e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 2026e1fbd4c1SMat Martineau return; 2027e1fbd4c1SMat Martineau 2028e1fbd4c1SMat Martineau if (chan->unacked_frames) { 2029e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 2030e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 2031e1fbd4c1SMat Martineau skb == chan->tx_send_head) 2032e1fbd4c1SMat Martineau break; 2033e1fbd4c1SMat Martineau } 2034e1fbd4c1SMat Martineau 2035e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 2036e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 2037e1fbd4c1SMat Martineau break; 2038e1fbd4c1SMat Martineau 2039e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 2040e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 2041e1fbd4c1SMat Martineau } 2042e1fbd4c1SMat Martineau 2043e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 2044e1fbd4c1SMat Martineau } 2045d2a7ac5dSMat Martineau } 2046d2a7ac5dSMat Martineau 2047b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 2048b17e73bbSSzymon Janc { 20490a0aba42SMat Martineau struct l2cap_ctrl control; 20500a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 20510a0aba42SMat Martineau chan->last_acked_seq); 20520a0aba42SMat Martineau int threshold; 20530a0aba42SMat Martineau 20540a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 20550a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 20560a0aba42SMat Martineau 20570a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 20580a0aba42SMat Martineau control.sframe = 1; 20590a0aba42SMat Martineau 20600a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 20610a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 2062b17e73bbSSzymon Janc __clear_ack_timer(chan); 20630a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 20640a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 20650a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 20660a0aba42SMat Martineau } else { 20670a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 20680a0aba42SMat Martineau l2cap_ertm_send(chan); 20690a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 20700a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 20710a0aba42SMat Martineau frames_to_ack = 0; 20720a0aba42SMat Martineau } 20730a0aba42SMat Martineau 2074c20f8e35SMat Martineau /* Ack now if the window is 3/4ths full. 20750a0aba42SMat Martineau * Calculate without mul or div 20760a0aba42SMat Martineau */ 2077c20f8e35SMat Martineau threshold = chan->ack_win; 20780a0aba42SMat Martineau threshold += threshold << 1; 20790a0aba42SMat Martineau threshold >>= 2; 20800a0aba42SMat Martineau 2081b4400672SAndrei Emeltchenko BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack, 20820a0aba42SMat Martineau threshold); 20830a0aba42SMat Martineau 20840a0aba42SMat Martineau if (frames_to_ack >= threshold) { 20850a0aba42SMat Martineau __clear_ack_timer(chan); 20860a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 20870a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 20880a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 20890a0aba42SMat Martineau frames_to_ack = 0; 20900a0aba42SMat Martineau } 20910a0aba42SMat Martineau 20920a0aba42SMat Martineau if (frames_to_ack) 20930a0aba42SMat Martineau __set_ack_timer(chan); 20940a0aba42SMat Martineau } 2095b17e73bbSSzymon Janc } 2096b17e73bbSSzymon Janc 209704124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 209804124681SGustavo F. Padovan struct msghdr *msg, int len, 209904124681SGustavo F. Padovan int count, struct sk_buff *skb) 21000a708f8fSGustavo F. Padovan { 21010952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 21020a708f8fSGustavo F. Padovan struct sk_buff **frag; 210390338947SGustavo Padovan int sent = 0; 21040a708f8fSGustavo F. Padovan 21050a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 21060a708f8fSGustavo F. Padovan return -EFAULT; 21070a708f8fSGustavo F. Padovan 21080a708f8fSGustavo F. Padovan sent += count; 21090a708f8fSGustavo F. Padovan len -= count; 21100a708f8fSGustavo F. Padovan 21110a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 21120a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 21130a708f8fSGustavo F. Padovan while (len) { 2114fbe00700SGustavo Padovan struct sk_buff *tmp; 2115fbe00700SGustavo Padovan 21160a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 21170a708f8fSGustavo F. Padovan 2118fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 211990338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 2120fbe00700SGustavo Padovan if (IS_ERR(tmp)) 2121fbe00700SGustavo Padovan return PTR_ERR(tmp); 21222f7719ceSAndrei Emeltchenko 2123fbe00700SGustavo Padovan *frag = tmp; 2124fbe00700SGustavo Padovan 21250a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 21260a708f8fSGustavo F. Padovan return -EFAULT; 21270a708f8fSGustavo F. Padovan 21285e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 21295e59b791SLuiz Augusto von Dentz 21300a708f8fSGustavo F. Padovan sent += count; 21310a708f8fSGustavo F. Padovan len -= count; 21320a708f8fSGustavo F. Padovan 21332d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 21342d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 21352d0ed3d5SGustavo Padovan 21360a708f8fSGustavo F. Padovan frag = &(*frag)->next; 21370a708f8fSGustavo F. Padovan } 21380a708f8fSGustavo F. Padovan 21390a708f8fSGustavo F. Padovan return sent; 21400a708f8fSGustavo F. Padovan } 21410a708f8fSGustavo F. Padovan 21425e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 21435e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 21445e59b791SLuiz Augusto von Dentz u32 priority) 21450a708f8fSGustavo F. Padovan { 21468c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 21470a708f8fSGustavo F. Padovan struct sk_buff *skb; 214803a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 21490a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 21500a708f8fSGustavo F. Padovan 2151b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu priority %u", chan, len, priority); 21520a708f8fSGustavo F. Padovan 21530a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 21542f7719ceSAndrei Emeltchenko 21552f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 215690338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 215790338947SGustavo Padovan if (IS_ERR(skb)) 215890338947SGustavo Padovan return skb; 21590a708f8fSGustavo F. Padovan 21605e59b791SLuiz Augusto von Dentz skb->priority = priority; 21615e59b791SLuiz Augusto von Dentz 21620a708f8fSGustavo F. Padovan /* Create L2CAP header */ 21630a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2164fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 2165daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 2166daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 21670a708f8fSGustavo F. Padovan 21680952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 21690a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 21700a708f8fSGustavo F. Padovan kfree_skb(skb); 21710a708f8fSGustavo F. Padovan return ERR_PTR(err); 21720a708f8fSGustavo F. Padovan } 21730a708f8fSGustavo F. Padovan return skb; 21740a708f8fSGustavo F. Padovan } 21750a708f8fSGustavo F. Padovan 21765e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 21775e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 21785e59b791SLuiz Augusto von Dentz u32 priority) 21790a708f8fSGustavo F. Padovan { 21808c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 21810a708f8fSGustavo F. Padovan struct sk_buff *skb; 2182f2ba7faeSGustavo Padovan int err, count; 21830a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 21840a708f8fSGustavo F. Padovan 2185b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 21860a708f8fSGustavo F. Padovan 2187f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 21882f7719ceSAndrei Emeltchenko 2189f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 219090338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 219190338947SGustavo Padovan if (IS_ERR(skb)) 219290338947SGustavo Padovan return skb; 21930a708f8fSGustavo F. Padovan 21945e59b791SLuiz Augusto von Dentz skb->priority = priority; 21955e59b791SLuiz Augusto von Dentz 21960a708f8fSGustavo F. Padovan /* Create L2CAP header */ 21970a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2198fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 21996ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 22000a708f8fSGustavo F. Padovan 22010952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 22020a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 22030a708f8fSGustavo F. Padovan kfree_skb(skb); 22040a708f8fSGustavo F. Padovan return ERR_PTR(err); 22050a708f8fSGustavo F. Padovan } 22060a708f8fSGustavo F. Padovan return skb; 22070a708f8fSGustavo F. Padovan } 22080a708f8fSGustavo F. Padovan 2209ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2210ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 221194122bbeSMat Martineau u16 sdulen) 22120a708f8fSGustavo F. Padovan { 22138c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 22140a708f8fSGustavo F. Padovan struct sk_buff *skb; 2215e4ca6d98SAndrei Emeltchenko int err, count, hlen; 22160a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 22170a708f8fSGustavo F. Padovan 2218b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 22190a708f8fSGustavo F. Padovan 22200a708f8fSGustavo F. Padovan if (!conn) 22210a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 22220a708f8fSGustavo F. Padovan 2223ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2224e4ca6d98SAndrei Emeltchenko 22250a708f8fSGustavo F. Padovan if (sdulen) 222603a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 22270a708f8fSGustavo F. Padovan 222847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 222903a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 22300a708f8fSGustavo F. Padovan 22310a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 22322f7719ceSAndrei Emeltchenko 22332f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 223490338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 223590338947SGustavo Padovan if (IS_ERR(skb)) 223690338947SGustavo Padovan return skb; 22370a708f8fSGustavo F. Padovan 22380a708f8fSGustavo F. Padovan /* Create L2CAP header */ 22390a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2240fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 22410a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 224288843ab0SAndrei Emeltchenko 224318a48e76SMat Martineau /* Control header is populated later */ 224418a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 224518a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 224618a48e76SMat Martineau else 224718a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 224888843ab0SAndrei Emeltchenko 22490a708f8fSGustavo F. Padovan if (sdulen) 225003a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 22510a708f8fSGustavo F. Padovan 22520952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 22530a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 22540a708f8fSGustavo F. Padovan kfree_skb(skb); 22550a708f8fSGustavo F. Padovan return ERR_PTR(err); 22560a708f8fSGustavo F. Padovan } 22570a708f8fSGustavo F. Padovan 225818a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 22593ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 22600a708f8fSGustavo F. Padovan return skb; 22610a708f8fSGustavo F. Padovan } 22620a708f8fSGustavo F. Padovan 226394122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 226494122bbeSMat Martineau struct sk_buff_head *seg_queue, 226594122bbeSMat Martineau struct msghdr *msg, size_t len) 22660a708f8fSGustavo F. Padovan { 22670a708f8fSGustavo F. Padovan struct sk_buff *skb; 226894122bbeSMat Martineau u16 sdu_len; 226994122bbeSMat Martineau size_t pdu_len; 227094122bbeSMat Martineau u8 sar; 22710a708f8fSGustavo F. Padovan 2272b4400672SAndrei Emeltchenko BT_DBG("chan %p, msg %p, len %zu", chan, msg, len); 22730a708f8fSGustavo F. Padovan 227494122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 227594122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 227694122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 227794122bbeSMat Martineau */ 227894122bbeSMat Martineau 227994122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 228094122bbeSMat Martineau pdu_len = chan->conn->mtu; 228194122bbeSMat Martineau 2282a549574dSMat Martineau /* Constrain PDU size for BR/EDR connections */ 2283a549574dSMat Martineau if (!chan->hs_hcon) 228494122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 228594122bbeSMat Martineau 228694122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 228735d401dfSGustavo Padovan if (chan->fcs) 228835d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 228935d401dfSGustavo Padovan 2290ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 229194122bbeSMat Martineau 229294122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 229394122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 229494122bbeSMat Martineau 229594122bbeSMat Martineau if (len <= pdu_len) { 229694122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 229794122bbeSMat Martineau sdu_len = 0; 229894122bbeSMat Martineau pdu_len = len; 229994122bbeSMat Martineau } else { 230094122bbeSMat Martineau sar = L2CAP_SAR_START; 230194122bbeSMat Martineau sdu_len = len; 230294122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 230394122bbeSMat Martineau } 23040a708f8fSGustavo F. Padovan 23050a708f8fSGustavo F. Padovan while (len > 0) { 230694122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 23070a708f8fSGustavo F. Padovan 23080a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 230994122bbeSMat Martineau __skb_queue_purge(seg_queue); 23100a708f8fSGustavo F. Padovan return PTR_ERR(skb); 23110a708f8fSGustavo F. Padovan } 23120a708f8fSGustavo F. Padovan 231394122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 231494122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 23150a708f8fSGustavo F. Padovan 231694122bbeSMat Martineau len -= pdu_len; 231794122bbeSMat Martineau if (sdu_len) { 231894122bbeSMat Martineau sdu_len = 0; 231994122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 232094122bbeSMat Martineau } 232194122bbeSMat Martineau 232294122bbeSMat Martineau if (len <= pdu_len) { 232394122bbeSMat Martineau sar = L2CAP_SAR_END; 232494122bbeSMat Martineau pdu_len = len; 232594122bbeSMat Martineau } else { 232694122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 232794122bbeSMat Martineau } 232894122bbeSMat Martineau } 232994122bbeSMat Martineau 2330f0f62799SGustavo Padovan return 0; 23310a708f8fSGustavo F. Padovan } 23320a708f8fSGustavo F. Padovan 23335e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 23345e59b791SLuiz Augusto von Dentz u32 priority) 23359a91a04aSGustavo F. Padovan { 23369a91a04aSGustavo F. Padovan struct sk_buff *skb; 23379a91a04aSGustavo F. Padovan int err; 233894122bbeSMat Martineau struct sk_buff_head seg_queue; 23399a91a04aSGustavo F. Padovan 23409a91a04aSGustavo F. Padovan /* Connectionless channel */ 2341715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 23425e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 23439a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 23449a91a04aSGustavo F. Padovan return PTR_ERR(skb); 23459a91a04aSGustavo F. Padovan 23469a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 23479a91a04aSGustavo F. Padovan return len; 23489a91a04aSGustavo F. Padovan } 23499a91a04aSGustavo F. Padovan 23509a91a04aSGustavo F. Padovan switch (chan->mode) { 23519a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 23529a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 23539a91a04aSGustavo F. Padovan if (len > chan->omtu) 23549a91a04aSGustavo F. Padovan return -EMSGSIZE; 23559a91a04aSGustavo F. Padovan 23569a91a04aSGustavo F. Padovan /* Create a basic PDU */ 23575e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 23589a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 23599a91a04aSGustavo F. Padovan return PTR_ERR(skb); 23609a91a04aSGustavo F. Padovan 23619a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 23629a91a04aSGustavo F. Padovan err = len; 23639a91a04aSGustavo F. Padovan break; 23649a91a04aSGustavo F. Padovan 23659a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 23669a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 236794122bbeSMat Martineau /* Check outgoing MTU */ 236894122bbeSMat Martineau if (len > chan->omtu) { 236994122bbeSMat Martineau err = -EMSGSIZE; 23709a91a04aSGustavo F. Padovan break; 23719a91a04aSGustavo F. Padovan } 23729a91a04aSGustavo F. Padovan 237394122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 237494122bbeSMat Martineau 237594122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 237694122bbeSMat Martineau * since it's possible to block while waiting for memory 237794122bbeSMat Martineau * allocation. 237894122bbeSMat Martineau */ 237994122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 238094122bbeSMat Martineau 238194122bbeSMat Martineau /* The channel could have been closed while segmenting, 238294122bbeSMat Martineau * check that it is still connected. 238394122bbeSMat Martineau */ 238494122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 238594122bbeSMat Martineau __skb_queue_purge(&seg_queue); 238694122bbeSMat Martineau err = -ENOTCONN; 23879a91a04aSGustavo F. Padovan } 23889a91a04aSGustavo F. Padovan 238994122bbeSMat Martineau if (err) 239094122bbeSMat Martineau break; 239194122bbeSMat Martineau 23923733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2393d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 23943733937dSMat Martineau else 2395d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 239694122bbeSMat Martineau 23979a91a04aSGustavo F. Padovan err = len; 23989a91a04aSGustavo F. Padovan 239994122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 240094122bbeSMat Martineau * seg_queue and need to be purged. 240194122bbeSMat Martineau */ 240294122bbeSMat Martineau __skb_queue_purge(&seg_queue); 24039a91a04aSGustavo F. Padovan break; 24049a91a04aSGustavo F. Padovan 24059a91a04aSGustavo F. Padovan default: 24069a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 24079a91a04aSGustavo F. Padovan err = -EBADFD; 24089a91a04aSGustavo F. Padovan } 24099a91a04aSGustavo F. Padovan 24109a91a04aSGustavo F. Padovan return err; 24119a91a04aSGustavo F. Padovan } 24129a91a04aSGustavo F. Padovan 2413d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2414d2a7ac5dSMat Martineau { 2415bed68bdeSMat Martineau struct l2cap_ctrl control; 2416bed68bdeSMat Martineau u16 seq; 2417bed68bdeSMat Martineau 2418b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2419bed68bdeSMat Martineau 2420bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2421bed68bdeSMat Martineau control.sframe = 1; 2422bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2423bed68bdeSMat Martineau 2424bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2425bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2426bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2427bed68bdeSMat Martineau control.reqseq = seq; 2428bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2429bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2430bed68bdeSMat Martineau } 2431bed68bdeSMat Martineau } 2432bed68bdeSMat Martineau 2433bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2434d2a7ac5dSMat Martineau } 2435d2a7ac5dSMat Martineau 2436d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2437d2a7ac5dSMat Martineau { 2438bed68bdeSMat Martineau struct l2cap_ctrl control; 2439bed68bdeSMat Martineau 2440bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2441bed68bdeSMat Martineau 2442bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2443bed68bdeSMat Martineau return; 2444bed68bdeSMat Martineau 2445bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2446bed68bdeSMat Martineau control.sframe = 1; 2447bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2448bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2449bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2450d2a7ac5dSMat Martineau } 2451d2a7ac5dSMat Martineau 2452d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2453d2a7ac5dSMat Martineau { 2454bed68bdeSMat Martineau struct l2cap_ctrl control; 2455bed68bdeSMat Martineau u16 initial_head; 2456bed68bdeSMat Martineau u16 seq; 2457bed68bdeSMat Martineau 2458b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2459bed68bdeSMat Martineau 2460bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2461bed68bdeSMat Martineau control.sframe = 1; 2462bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2463bed68bdeSMat Martineau 2464bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2465bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2466bed68bdeSMat Martineau 2467bed68bdeSMat Martineau do { 2468bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2469bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2470bed68bdeSMat Martineau break; 2471bed68bdeSMat Martineau 2472bed68bdeSMat Martineau control.reqseq = seq; 2473bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2474bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2475bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2476d2a7ac5dSMat Martineau } 2477d2a7ac5dSMat Martineau 2478608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2479608bcc6dSMat Martineau { 2480608bcc6dSMat Martineau struct sk_buff *acked_skb; 2481608bcc6dSMat Martineau u16 ackseq; 2482608bcc6dSMat Martineau 2483b4400672SAndrei Emeltchenko BT_DBG("chan %p, reqseq %u", chan, reqseq); 2484608bcc6dSMat Martineau 2485608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2486608bcc6dSMat Martineau return; 2487608bcc6dSMat Martineau 2488b4400672SAndrei Emeltchenko BT_DBG("expected_ack_seq %u, unacked_frames %u", 2489608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2490608bcc6dSMat Martineau 2491608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2492608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2493608bcc6dSMat Martineau 2494608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2495608bcc6dSMat Martineau if (acked_skb) { 2496608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2497608bcc6dSMat Martineau kfree_skb(acked_skb); 2498608bcc6dSMat Martineau chan->unacked_frames--; 2499608bcc6dSMat Martineau } 2500608bcc6dSMat Martineau } 2501608bcc6dSMat Martineau 2502608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2503608bcc6dSMat Martineau 2504608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2505608bcc6dSMat Martineau __clear_retrans_timer(chan); 2506608bcc6dSMat Martineau 2507b4400672SAndrei Emeltchenko BT_DBG("unacked_frames %u", chan->unacked_frames); 2508608bcc6dSMat Martineau } 2509608bcc6dSMat Martineau 2510608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2511608bcc6dSMat Martineau { 2512608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2513608bcc6dSMat Martineau 2514608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2515608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2516608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2517608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2518608bcc6dSMat Martineau } 2519608bcc6dSMat Martineau 2520d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2521608bcc6dSMat Martineau struct l2cap_ctrl *control, 2522608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2523608bcc6dSMat Martineau { 2524608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2525608bcc6dSMat Martineau event); 2526608bcc6dSMat Martineau 2527608bcc6dSMat Martineau switch (event) { 2528608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2529608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2530608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2531608bcc6dSMat Martineau 2532608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2533608bcc6dSMat Martineau l2cap_ertm_send(chan); 2534608bcc6dSMat Martineau break; 2535608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2536608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2537608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2538608bcc6dSMat Martineau 2539608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2540608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2541608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2542608bcc6dSMat Martineau */ 2543608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2544608bcc6dSMat Martineau } 2545608bcc6dSMat Martineau 2546608bcc6dSMat Martineau l2cap_send_ack(chan); 2547608bcc6dSMat Martineau 2548608bcc6dSMat Martineau break; 2549608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2550608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2551608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2552608bcc6dSMat Martineau 2553608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2554608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2555608bcc6dSMat Martineau 2556608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2557608bcc6dSMat Martineau local_control.sframe = 1; 2558608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2559608bcc6dSMat Martineau local_control.poll = 1; 2560608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2561a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2562608bcc6dSMat Martineau 2563608bcc6dSMat Martineau chan->retry_count = 1; 2564608bcc6dSMat Martineau __set_monitor_timer(chan); 2565608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2566608bcc6dSMat Martineau } 2567608bcc6dSMat Martineau break; 2568608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2569608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2570608bcc6dSMat Martineau break; 2571608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2572608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2573608bcc6dSMat Martineau chan->retry_count = 1; 2574608bcc6dSMat Martineau __set_monitor_timer(chan); 2575608bcc6dSMat Martineau __clear_ack_timer(chan); 2576608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2577608bcc6dSMat Martineau break; 2578608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2579608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2580608bcc6dSMat Martineau chan->retry_count = 1; 2581608bcc6dSMat Martineau __set_monitor_timer(chan); 2582608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2583608bcc6dSMat Martineau break; 2584608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2585608bcc6dSMat Martineau /* Nothing to process */ 2586608bcc6dSMat Martineau break; 2587608bcc6dSMat Martineau default: 2588608bcc6dSMat Martineau break; 2589608bcc6dSMat Martineau } 2590608bcc6dSMat Martineau } 2591608bcc6dSMat Martineau 2592d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2593608bcc6dSMat Martineau struct l2cap_ctrl *control, 2594608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2595608bcc6dSMat Martineau { 2596608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2597608bcc6dSMat Martineau event); 2598608bcc6dSMat Martineau 2599608bcc6dSMat Martineau switch (event) { 2600608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2601608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2602608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2603608bcc6dSMat Martineau /* Queue data, but don't send. */ 2604608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2605608bcc6dSMat Martineau break; 2606608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2607608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2608608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2609608bcc6dSMat Martineau 2610608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2611608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2612608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2613608bcc6dSMat Martineau */ 2614608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2615608bcc6dSMat Martineau } 2616608bcc6dSMat Martineau 2617608bcc6dSMat Martineau l2cap_send_ack(chan); 2618608bcc6dSMat Martineau 2619608bcc6dSMat Martineau break; 2620608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2621608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2622608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2623608bcc6dSMat Martineau 2624608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2625608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2626608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2627608bcc6dSMat Martineau local_control.sframe = 1; 2628608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2629608bcc6dSMat Martineau local_control.poll = 1; 2630608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2631a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2632608bcc6dSMat Martineau 2633608bcc6dSMat Martineau chan->retry_count = 1; 2634608bcc6dSMat Martineau __set_monitor_timer(chan); 2635608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2636608bcc6dSMat Martineau } 2637608bcc6dSMat Martineau break; 2638608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2639608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2640608bcc6dSMat Martineau 2641608bcc6dSMat Martineau /* Fall through */ 2642608bcc6dSMat Martineau 2643608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2644608bcc6dSMat Martineau if (control && control->final) { 2645608bcc6dSMat Martineau __clear_monitor_timer(chan); 2646608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2647608bcc6dSMat Martineau __set_retrans_timer(chan); 2648608bcc6dSMat Martineau chan->retry_count = 0; 2649608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2650608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2651608bcc6dSMat Martineau } 2652608bcc6dSMat Martineau break; 2653608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2654608bcc6dSMat Martineau /* Ignore */ 2655608bcc6dSMat Martineau break; 2656608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2657608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2658608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2659608bcc6dSMat Martineau __set_monitor_timer(chan); 2660608bcc6dSMat Martineau chan->retry_count++; 2661608bcc6dSMat Martineau } else { 2662608bcc6dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED); 2663608bcc6dSMat Martineau } 2664608bcc6dSMat Martineau break; 2665608bcc6dSMat Martineau default: 2666608bcc6dSMat Martineau break; 2667608bcc6dSMat Martineau } 2668608bcc6dSMat Martineau } 2669608bcc6dSMat Martineau 2670d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2671608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2672608bcc6dSMat Martineau { 2673608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2674608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2675608bcc6dSMat Martineau 2676608bcc6dSMat Martineau switch (chan->tx_state) { 2677608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2678d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2679608bcc6dSMat Martineau break; 2680608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2681d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2682608bcc6dSMat Martineau break; 2683608bcc6dSMat Martineau default: 2684608bcc6dSMat Martineau /* Ignore event */ 2685608bcc6dSMat Martineau break; 2686608bcc6dSMat Martineau } 2687608bcc6dSMat Martineau } 2688608bcc6dSMat Martineau 26894b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 26904b51dae9SMat Martineau struct l2cap_ctrl *control) 26914b51dae9SMat Martineau { 26924b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2693401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 26944b51dae9SMat Martineau } 26954b51dae9SMat Martineau 2696f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2697f80842a8SMat Martineau struct l2cap_ctrl *control) 2698f80842a8SMat Martineau { 2699f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2700401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2701f80842a8SMat Martineau } 2702f80842a8SMat Martineau 27030a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 27040a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 27050a708f8fSGustavo F. Padovan { 27060a708f8fSGustavo F. Padovan struct sk_buff *nskb; 270748454079SGustavo F. Padovan struct l2cap_chan *chan; 27080a708f8fSGustavo F. Padovan 27090a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 27100a708f8fSGustavo F. Padovan 27113df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 27123d57dc68SGustavo F. Padovan 27133df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 271448454079SGustavo F. Padovan struct sock *sk = chan->sk; 2715715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 27160a708f8fSGustavo F. Padovan continue; 27170a708f8fSGustavo F. Padovan 27180a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 27190a708f8fSGustavo F. Padovan if (skb->sk == sk) 27200a708f8fSGustavo F. Padovan continue; 27218bcde1f2SGustavo Padovan nskb = skb_clone(skb, GFP_KERNEL); 27220a708f8fSGustavo F. Padovan if (!nskb) 27230a708f8fSGustavo F. Padovan continue; 27240a708f8fSGustavo F. Padovan 272580b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 27260a708f8fSGustavo F. Padovan kfree_skb(nskb); 27270a708f8fSGustavo F. Padovan } 27283d57dc68SGustavo F. Padovan 27293df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 27300a708f8fSGustavo F. Padovan } 27310a708f8fSGustavo F. Padovan 27320a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 2733b4400672SAndrei Emeltchenko static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code, 2734b4400672SAndrei Emeltchenko u8 ident, u16 dlen, void *data) 27350a708f8fSGustavo F. Padovan { 27360a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 27370a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 27380a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 27390a708f8fSGustavo F. Padovan int len, count; 27400a708f8fSGustavo F. Padovan 2741b4400672SAndrei Emeltchenko BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u", 27420a708f8fSGustavo F. Padovan conn, code, ident, dlen); 27430a708f8fSGustavo F. Padovan 27440a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 27450a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 27460a708f8fSGustavo F. Padovan 27478bcde1f2SGustavo Padovan skb = bt_skb_alloc(count, GFP_KERNEL); 27480a708f8fSGustavo F. Padovan if (!skb) 27490a708f8fSGustavo F. Padovan return NULL; 27500a708f8fSGustavo F. Padovan 27510a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 27520a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 27533300d9a9SClaudio Takahasi 27543300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2755ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 27563300d9a9SClaudio Takahasi else 2757ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 27580a708f8fSGustavo F. Padovan 27590a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 27600a708f8fSGustavo F. Padovan cmd->code = code; 27610a708f8fSGustavo F. Padovan cmd->ident = ident; 27620a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 27630a708f8fSGustavo F. Padovan 27640a708f8fSGustavo F. Padovan if (dlen) { 27650a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 27660a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 27670a708f8fSGustavo F. Padovan data += count; 27680a708f8fSGustavo F. Padovan } 27690a708f8fSGustavo F. Padovan 27700a708f8fSGustavo F. Padovan len -= skb->len; 27710a708f8fSGustavo F. Padovan 27720a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 27730a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 27740a708f8fSGustavo F. Padovan while (len) { 27750a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 27760a708f8fSGustavo F. Padovan 27778bcde1f2SGustavo Padovan *frag = bt_skb_alloc(count, GFP_KERNEL); 27780a708f8fSGustavo F. Padovan if (!*frag) 27790a708f8fSGustavo F. Padovan goto fail; 27800a708f8fSGustavo F. Padovan 27810a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 27820a708f8fSGustavo F. Padovan 27830a708f8fSGustavo F. Padovan len -= count; 27840a708f8fSGustavo F. Padovan data += count; 27850a708f8fSGustavo F. Padovan 27860a708f8fSGustavo F. Padovan frag = &(*frag)->next; 27870a708f8fSGustavo F. Padovan } 27880a708f8fSGustavo F. Padovan 27890a708f8fSGustavo F. Padovan return skb; 27900a708f8fSGustavo F. Padovan 27910a708f8fSGustavo F. Padovan fail: 27920a708f8fSGustavo F. Padovan kfree_skb(skb); 27930a708f8fSGustavo F. Padovan return NULL; 27940a708f8fSGustavo F. Padovan } 27950a708f8fSGustavo F. Padovan 27962d792818SGustavo Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, 27972d792818SGustavo Padovan unsigned long *val) 27980a708f8fSGustavo F. Padovan { 27990a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 28000a708f8fSGustavo F. Padovan int len; 28010a708f8fSGustavo F. Padovan 28020a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 28030a708f8fSGustavo F. Padovan *ptr += len; 28040a708f8fSGustavo F. Padovan 28050a708f8fSGustavo F. Padovan *type = opt->type; 28060a708f8fSGustavo F. Padovan *olen = opt->len; 28070a708f8fSGustavo F. Padovan 28080a708f8fSGustavo F. Padovan switch (opt->len) { 28090a708f8fSGustavo F. Padovan case 1: 28100a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 28110a708f8fSGustavo F. Padovan break; 28120a708f8fSGustavo F. Padovan 28130a708f8fSGustavo F. Padovan case 2: 28140a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 28150a708f8fSGustavo F. Padovan break; 28160a708f8fSGustavo F. Padovan 28170a708f8fSGustavo F. Padovan case 4: 28180a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 28190a708f8fSGustavo F. Padovan break; 28200a708f8fSGustavo F. Padovan 28210a708f8fSGustavo F. Padovan default: 28220a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 28230a708f8fSGustavo F. Padovan break; 28240a708f8fSGustavo F. Padovan } 28250a708f8fSGustavo F. Padovan 2826b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val); 28270a708f8fSGustavo F. Padovan return len; 28280a708f8fSGustavo F. Padovan } 28290a708f8fSGustavo F. Padovan 28300a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 28310a708f8fSGustavo F. Padovan { 28320a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 28330a708f8fSGustavo F. Padovan 2834b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val); 28350a708f8fSGustavo F. Padovan 28360a708f8fSGustavo F. Padovan opt->type = type; 28370a708f8fSGustavo F. Padovan opt->len = len; 28380a708f8fSGustavo F. Padovan 28390a708f8fSGustavo F. Padovan switch (len) { 28400a708f8fSGustavo F. Padovan case 1: 28410a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 28420a708f8fSGustavo F. Padovan break; 28430a708f8fSGustavo F. Padovan 28440a708f8fSGustavo F. Padovan case 2: 28450a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 28460a708f8fSGustavo F. Padovan break; 28470a708f8fSGustavo F. Padovan 28480a708f8fSGustavo F. Padovan case 4: 28490a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 28500a708f8fSGustavo F. Padovan break; 28510a708f8fSGustavo F. Padovan 28520a708f8fSGustavo F. Padovan default: 28530a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 28540a708f8fSGustavo F. Padovan break; 28550a708f8fSGustavo F. Padovan } 28560a708f8fSGustavo F. Padovan 28570a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 28580a708f8fSGustavo F. Padovan } 28590a708f8fSGustavo F. Padovan 2860f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2861f89cef09SAndrei Emeltchenko { 2862f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2863f89cef09SAndrei Emeltchenko 2864f89cef09SAndrei Emeltchenko switch (chan->mode) { 2865f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2866f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2867f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2868f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2869f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2870ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 28718936fa6dSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_EFS_DEFAULT_FLUSH_TO); 2872f89cef09SAndrei Emeltchenko break; 2873f89cef09SAndrei Emeltchenko 2874f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2875f89cef09SAndrei Emeltchenko efs.id = 1; 2876f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2877f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2878f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2879f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2880f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2881f89cef09SAndrei Emeltchenko break; 2882f89cef09SAndrei Emeltchenko 2883f89cef09SAndrei Emeltchenko default: 2884f89cef09SAndrei Emeltchenko return; 2885f89cef09SAndrei Emeltchenko } 2886f89cef09SAndrei Emeltchenko 2887f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2888f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2889f89cef09SAndrei Emeltchenko } 2890f89cef09SAndrei Emeltchenko 2891721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 28920a708f8fSGustavo F. Padovan { 2893721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2894721c4181SGustavo F. Padovan ack_timer.work); 28950362520bSMat Martineau u16 frames_to_ack; 28960a708f8fSGustavo F. Padovan 28972fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 28982fb9b3d4SGustavo F. Padovan 28996be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 29006be36555SAndrei Emeltchenko 29010362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 29020362520bSMat Martineau chan->last_acked_seq); 29030362520bSMat Martineau 29040362520bSMat Martineau if (frames_to_ack) 29050362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 29066be36555SAndrei Emeltchenko 29076be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 290809bfb2eeSSzymon Janc l2cap_chan_put(chan); 29090a708f8fSGustavo F. Padovan } 29100a708f8fSGustavo F. Padovan 2911466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 29120a708f8fSGustavo F. Padovan { 29133c588192SMat Martineau int err; 29143c588192SMat Martineau 2915105bdf9eSMat Martineau chan->next_tx_seq = 0; 2916105bdf9eSMat Martineau chan->expected_tx_seq = 0; 291742e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 29186a026610SGustavo F. Padovan chan->unacked_frames = 0; 291942e5c802SGustavo F. Padovan chan->buffer_seq = 0; 29206a026610SGustavo F. Padovan chan->frames_sent = 0; 2921105bdf9eSMat Martineau chan->last_acked_seq = 0; 2922105bdf9eSMat Martineau chan->sdu = NULL; 2923105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2924105bdf9eSMat Martineau chan->sdu_len = 0; 2925105bdf9eSMat Martineau 2926d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2927d34c34fbSMat Martineau 292808333283SMat Martineau chan->local_amp_id = 0; 292908333283SMat Martineau chan->move_id = 0; 293008333283SMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 293108333283SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 293208333283SMat Martineau 2933105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2934105bdf9eSMat Martineau return 0; 2935105bdf9eSMat Martineau 2936105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2937105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 29380a708f8fSGustavo F. Padovan 2939721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2940721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2941721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 29420a708f8fSGustavo F. Padovan 2943f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 29440a708f8fSGustavo F. Padovan 29453c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 29463c588192SMat Martineau if (err < 0) 29473c588192SMat Martineau return err; 29483c588192SMat Martineau 29499dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 29509dc9affcSMat Martineau if (err < 0) 29519dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 29529dc9affcSMat Martineau 29539dc9affcSMat Martineau return err; 29540a708f8fSGustavo F. Padovan } 29550a708f8fSGustavo F. Padovan 29560a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 29570a708f8fSGustavo F. Padovan { 29580a708f8fSGustavo F. Padovan switch (mode) { 29590a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 29600a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 29610a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 29620a708f8fSGustavo F. Padovan return mode; 29630a708f8fSGustavo F. Padovan /* fall through */ 29640a708f8fSGustavo F. Padovan default: 29650a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 29660a708f8fSGustavo F. Padovan } 29670a708f8fSGustavo F. Padovan } 29680a708f8fSGustavo F. Padovan 29696327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 29706327eb98SAndrei Emeltchenko { 29716327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 29726327eb98SAndrei Emeltchenko } 29736327eb98SAndrei Emeltchenko 2974f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2975f89cef09SAndrei Emeltchenko { 2976f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2977f89cef09SAndrei Emeltchenko } 2978f89cef09SAndrei Emeltchenko 297936c86c85SMat Martineau static void __l2cap_set_ertm_timeouts(struct l2cap_chan *chan, 298036c86c85SMat Martineau struct l2cap_conf_rfc *rfc) 298136c86c85SMat Martineau { 298236c86c85SMat Martineau if (chan->local_amp_id && chan->hs_hcon) { 298336c86c85SMat Martineau u64 ertm_to = chan->hs_hcon->hdev->amp_be_flush_to; 298436c86c85SMat Martineau 298536c86c85SMat Martineau /* Class 1 devices have must have ERTM timeouts 298636c86c85SMat Martineau * exceeding the Link Supervision Timeout. The 298736c86c85SMat Martineau * default Link Supervision Timeout for AMP 298836c86c85SMat Martineau * controllers is 10 seconds. 298936c86c85SMat Martineau * 299036c86c85SMat Martineau * Class 1 devices use 0xffffffff for their 299136c86c85SMat Martineau * best-effort flush timeout, so the clamping logic 299236c86c85SMat Martineau * will result in a timeout that meets the above 299336c86c85SMat Martineau * requirement. ERTM timeouts are 16-bit values, so 299436c86c85SMat Martineau * the maximum timeout is 65.535 seconds. 299536c86c85SMat Martineau */ 299636c86c85SMat Martineau 299736c86c85SMat Martineau /* Convert timeout to milliseconds and round */ 299836c86c85SMat Martineau ertm_to = DIV_ROUND_UP_ULL(ertm_to, 1000); 299936c86c85SMat Martineau 300036c86c85SMat Martineau /* This is the recommended formula for class 2 devices 300136c86c85SMat Martineau * that start ERTM timers when packets are sent to the 300236c86c85SMat Martineau * controller. 300336c86c85SMat Martineau */ 300436c86c85SMat Martineau ertm_to = 3 * ertm_to + 500; 300536c86c85SMat Martineau 300636c86c85SMat Martineau if (ertm_to > 0xffff) 300736c86c85SMat Martineau ertm_to = 0xffff; 300836c86c85SMat Martineau 300936c86c85SMat Martineau rfc->retrans_timeout = cpu_to_le16((u16) ertm_to); 301036c86c85SMat Martineau rfc->monitor_timeout = rfc->retrans_timeout; 301136c86c85SMat Martineau } else { 301236c86c85SMat Martineau rfc->retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 301336c86c85SMat Martineau rfc->monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 301436c86c85SMat Martineau } 301536c86c85SMat Martineau } 301636c86c85SMat Martineau 30176327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 30186327eb98SAndrei Emeltchenko { 30196327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 3020836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 30216327eb98SAndrei Emeltchenko /* use extended control field */ 30226327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 3023836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 3024836be934SAndrei Emeltchenko } else { 30256327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 30266327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 3027836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 3028836be934SAndrei Emeltchenko } 3029c20f8e35SMat Martineau chan->ack_win = chan->tx_win; 30306327eb98SAndrei Emeltchenko } 30316327eb98SAndrei Emeltchenko 3032710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 30330a708f8fSGustavo F. Padovan { 30340a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 30350c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 30360a708f8fSGustavo F. Padovan void *ptr = req->data; 3037c8f79162SAndrei Emeltchenko u16 size; 30380a708f8fSGustavo F. Padovan 303949208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 30400a708f8fSGustavo F. Padovan 304173ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 30420a708f8fSGustavo F. Padovan goto done; 30430a708f8fSGustavo F. Padovan 30440c1bc5c6SGustavo F. Padovan switch (chan->mode) { 30450a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 30460a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3047c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 30480a708f8fSGustavo F. Padovan break; 30490a708f8fSGustavo F. Padovan 3050f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 3051f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 3052f89cef09SAndrei Emeltchenko 30530a708f8fSGustavo F. Padovan /* fall through */ 30540a708f8fSGustavo F. Padovan default: 30558c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 30560a708f8fSGustavo F. Padovan break; 30570a708f8fSGustavo F. Padovan } 30580a708f8fSGustavo F. Padovan 30590a708f8fSGustavo F. Padovan done: 30600c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 30610c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 30620a708f8fSGustavo F. Padovan 30630c1bc5c6SGustavo F. Padovan switch (chan->mode) { 30640a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 30658c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 30668c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 30670a708f8fSGustavo F. Padovan break; 30680a708f8fSGustavo F. Padovan 30690a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 30700a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 30710a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 30720a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 30730a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 30740a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 30750a708f8fSGustavo F. Padovan 30760a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 30770a708f8fSGustavo F. Padovan (unsigned long) &rfc); 30780a708f8fSGustavo F. Padovan break; 30790a708f8fSGustavo F. Padovan 30800a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30810a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 308247d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 308336c86c85SMat Martineau 308436c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 3085c8f79162SAndrei Emeltchenko 3086c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 30872d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3088c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3089c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 30900a708f8fSGustavo F. Padovan 30916327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 30926327eb98SAndrei Emeltchenko 30936327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 30946327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 30950a708f8fSGustavo F. Padovan 30960a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 30970a708f8fSGustavo F. Padovan (unsigned long) &rfc); 30980a708f8fSGustavo F. Padovan 3099f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3100f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3101f89cef09SAndrei Emeltchenko 31028c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 31030a708f8fSGustavo F. Padovan break; 31040a708f8fSGustavo F. Padovan 310547d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 3106c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 310747d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 310847d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 31090a708f8fSGustavo F. Padovan } 31106327eb98SAndrei Emeltchenko 31116327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 31126327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 31136327eb98SAndrei Emeltchenko chan->tx_win); 31140a708f8fSGustavo F. Padovan break; 31150a708f8fSGustavo F. Padovan 31160a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3117273759e2SMat Martineau l2cap_txwin_setup(chan); 31180a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 31190a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 31200a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 31210a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 31220a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 3123c8f79162SAndrei Emeltchenko 3124c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 31252d792818SGustavo Padovan L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE - 3126c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3127c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 31280a708f8fSGustavo F. Padovan 31290a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 31300a708f8fSGustavo F. Padovan (unsigned long) &rfc); 31310a708f8fSGustavo F. Padovan 3132f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 3133f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 3134f89cef09SAndrei Emeltchenko 31358c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 31360a708f8fSGustavo F. Padovan break; 31370a708f8fSGustavo F. Padovan 313847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 3139c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 314047d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 314147d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 31420a708f8fSGustavo F. Padovan } 31430a708f8fSGustavo F. Padovan break; 31440a708f8fSGustavo F. Padovan } 31450a708f8fSGustavo F. Padovan 3146fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 314759e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 31480a708f8fSGustavo F. Padovan 31490a708f8fSGustavo F. Padovan return ptr - data; 31500a708f8fSGustavo F. Padovan } 31510a708f8fSGustavo F. Padovan 315273ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 31530a708f8fSGustavo F. Padovan { 31540a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 31550a708f8fSGustavo F. Padovan void *ptr = rsp->data; 315673ffa904SGustavo F. Padovan void *req = chan->conf_req; 315773ffa904SGustavo F. Padovan int len = chan->conf_len; 31580a708f8fSGustavo F. Padovan int type, hint, olen; 31590a708f8fSGustavo F. Padovan unsigned long val; 31600a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 316142dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 316242dceae2SAndrei Emeltchenko u8 remote_efs = 0; 31630a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 31640a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 3165c8f79162SAndrei Emeltchenko u16 size; 31660a708f8fSGustavo F. Padovan 316773ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 31680a708f8fSGustavo F. Padovan 31690a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 31700a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 31710a708f8fSGustavo F. Padovan 31720a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 31730a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 31740a708f8fSGustavo F. Padovan 31750a708f8fSGustavo F. Padovan switch (type) { 31760a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 31770a708f8fSGustavo F. Padovan mtu = val; 31780a708f8fSGustavo F. Padovan break; 31790a708f8fSGustavo F. Padovan 31800a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 31810c1bc5c6SGustavo F. Padovan chan->flush_to = val; 31820a708f8fSGustavo F. Padovan break; 31830a708f8fSGustavo F. Padovan 31840a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 31850a708f8fSGustavo F. Padovan break; 31860a708f8fSGustavo F. Padovan 31870a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 31880a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 31890a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 31900a708f8fSGustavo F. Padovan break; 31910a708f8fSGustavo F. Padovan 31920a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 31930a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 3194c1360a1cSGustavo F. Padovan set_bit(CONF_NO_FCS_RECV, &chan->conf_state); 319542dceae2SAndrei Emeltchenko break; 31960a708f8fSGustavo F. Padovan 319742dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 319842dceae2SAndrei Emeltchenko remote_efs = 1; 319942dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 320042dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 32010a708f8fSGustavo F. Padovan break; 32020a708f8fSGustavo F. Padovan 32036327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 32046327eb98SAndrei Emeltchenko if (!enable_hs) 32056327eb98SAndrei Emeltchenko return -ECONNREFUSED; 32066327eb98SAndrei Emeltchenko 32076327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 32086327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 3209836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 32106327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 32110a708f8fSGustavo F. Padovan break; 32120a708f8fSGustavo F. Padovan 32130a708f8fSGustavo F. Padovan default: 32140a708f8fSGustavo F. Padovan if (hint) 32150a708f8fSGustavo F. Padovan break; 32160a708f8fSGustavo F. Padovan 32170a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 32180a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 32190a708f8fSGustavo F. Padovan break; 32200a708f8fSGustavo F. Padovan } 32210a708f8fSGustavo F. Padovan } 32220a708f8fSGustavo F. Padovan 322373ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 32240a708f8fSGustavo F. Padovan goto done; 32250a708f8fSGustavo F. Padovan 32260c1bc5c6SGustavo F. Padovan switch (chan->mode) { 32270a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 32280a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 3229c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 32300c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 32318c1d787bSGustavo F. Padovan chan->conn->feat_mask); 32320a708f8fSGustavo F. Padovan break; 32330a708f8fSGustavo F. Padovan } 32340a708f8fSGustavo F. Padovan 323542dceae2SAndrei Emeltchenko if (remote_efs) { 323642dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 323742dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 323842dceae2SAndrei Emeltchenko else 323942dceae2SAndrei Emeltchenko return -ECONNREFUSED; 324042dceae2SAndrei Emeltchenko } 324142dceae2SAndrei Emeltchenko 32420c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 32430a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32440a708f8fSGustavo F. Padovan 32450a708f8fSGustavo F. Padovan break; 32460a708f8fSGustavo F. Padovan } 32470a708f8fSGustavo F. Padovan 32480a708f8fSGustavo F. Padovan done: 32490c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 32500a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 32510c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 32520a708f8fSGustavo F. Padovan 325373ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 32540a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32550a708f8fSGustavo F. Padovan 32562d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 32572d792818SGustavo Padovan (unsigned long) &rfc); 32580a708f8fSGustavo F. Padovan } 32590a708f8fSGustavo F. Padovan 32600a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 32610a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 32620a708f8fSGustavo F. Padovan * which ones we don't like. */ 32630a708f8fSGustavo F. Padovan 32640a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 32650a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 32660a708f8fSGustavo F. Padovan else { 32670c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3268c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 32690a708f8fSGustavo F. Padovan } 32700c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 32710a708f8fSGustavo F. Padovan 327242dceae2SAndrei Emeltchenko if (remote_efs) { 327342dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 327442dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 327542dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 327642dceae2SAndrei Emeltchenko 327742dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 327842dceae2SAndrei Emeltchenko 327942dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 328042dceae2SAndrei Emeltchenko return -ECONNREFUSED; 328142dceae2SAndrei Emeltchenko 328242dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 328342dceae2SAndrei Emeltchenko sizeof(efs), 328442dceae2SAndrei Emeltchenko (unsigned long) &efs); 32850e8b207eSAndrei Emeltchenko } else { 32863e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 32870e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 32880e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 328942dceae2SAndrei Emeltchenko } 329042dceae2SAndrei Emeltchenko } 329142dceae2SAndrei Emeltchenko 32920a708f8fSGustavo F. Padovan switch (rfc.mode) { 32930a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 329447d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3295c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 32960a708f8fSGustavo F. Padovan break; 32970a708f8fSGustavo F. Padovan 32980a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 32996327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 33002c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 33016327eb98SAndrei Emeltchenko else 33026327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 33036327eb98SAndrei Emeltchenko 33042c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 33050a708f8fSGustavo F. Padovan 3306c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 33072d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 33082d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3309c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3310c8f79162SAndrei Emeltchenko chan->remote_mps = size; 33110a708f8fSGustavo F. Padovan 331236c86c85SMat Martineau __l2cap_set_ertm_timeouts(chan, &rfc); 33130a708f8fSGustavo F. Padovan 3314c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 33150a708f8fSGustavo F. Padovan 33160a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 33170a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 33180a708f8fSGustavo F. Padovan 331942dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 332042dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 332142dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 332242dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 332342dceae2SAndrei Emeltchenko chan->remote_flush_to = 332442dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 332542dceae2SAndrei Emeltchenko chan->remote_acc_lat = 332642dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 332742dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 332842dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 332942dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 33302d792818SGustavo Padovan sizeof(efs), 33312d792818SGustavo Padovan (unsigned long) &efs); 333242dceae2SAndrei Emeltchenko } 33330a708f8fSGustavo F. Padovan break; 33340a708f8fSGustavo F. Padovan 33350a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3336c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 33372d792818SGustavo Padovan chan->conn->mtu - L2CAP_EXT_HDR_SIZE - 33382d792818SGustavo Padovan L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE); 3339c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3340c8f79162SAndrei Emeltchenko chan->remote_mps = size; 33410a708f8fSGustavo F. Padovan 3342c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 33430a708f8fSGustavo F. Padovan 33442d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 33452d792818SGustavo Padovan (unsigned long) &rfc); 33460a708f8fSGustavo F. Padovan 33470a708f8fSGustavo F. Padovan break; 33480a708f8fSGustavo F. Padovan 33490a708f8fSGustavo F. Padovan default: 33500a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 33510a708f8fSGustavo F. Padovan 33520a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 33530c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 33540a708f8fSGustavo F. Padovan } 33550a708f8fSGustavo F. Padovan 33560a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3357c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 33580a708f8fSGustavo F. Padovan } 3359fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 33600a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 336159e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 33620a708f8fSGustavo F. Padovan 33630a708f8fSGustavo F. Padovan return ptr - data; 33640a708f8fSGustavo F. Padovan } 33650a708f8fSGustavo F. Padovan 33662d792818SGustavo Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, 33672d792818SGustavo Padovan void *data, u16 *result) 33680a708f8fSGustavo F. Padovan { 33690a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 33700a708f8fSGustavo F. Padovan void *ptr = req->data; 33710a708f8fSGustavo F. Padovan int type, olen; 33720a708f8fSGustavo F. Padovan unsigned long val; 337336e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 337466af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 33750a708f8fSGustavo F. Padovan 3376fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 33770a708f8fSGustavo F. Padovan 33780a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 33790a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 33800a708f8fSGustavo F. Padovan 33810a708f8fSGustavo F. Padovan switch (type) { 33820a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 33830a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 33840a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 33850c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 33860a708f8fSGustavo F. Padovan } else 33870c1bc5c6SGustavo F. Padovan chan->imtu = val; 33880c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 33890a708f8fSGustavo F. Padovan break; 33900a708f8fSGustavo F. Padovan 33910a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 33920c1bc5c6SGustavo F. Padovan chan->flush_to = val; 33930a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 33940c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 33950a708f8fSGustavo F. Padovan break; 33960a708f8fSGustavo F. Padovan 33970a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 33980a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 33990a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 34000a708f8fSGustavo F. Padovan 3401c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 34020c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 34030a708f8fSGustavo F. Padovan return -ECONNREFUSED; 34040a708f8fSGustavo F. Padovan 340547d1ec61SGustavo F. Padovan chan->fcs = 0; 34060a708f8fSGustavo F. Padovan 34070a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 34080a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 34090a708f8fSGustavo F. Padovan break; 34106327eb98SAndrei Emeltchenko 34116327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 3412c20f8e35SMat Martineau chan->ack_win = min_t(u16, val, chan->ack_win); 34133e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 34143e6b3b95SGustavo F. Padovan chan->tx_win); 34156327eb98SAndrei Emeltchenko break; 341666af7aafSAndrei Emeltchenko 341766af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 341866af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 341966af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 342066af7aafSAndrei Emeltchenko 342166af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 342266af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 342366af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 342466af7aafSAndrei Emeltchenko return -ECONNREFUSED; 342566af7aafSAndrei Emeltchenko 34262d792818SGustavo Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, sizeof(efs), 34272d792818SGustavo Padovan (unsigned long) &efs); 342866af7aafSAndrei Emeltchenko break; 34290a708f8fSGustavo F. Padovan } 34300a708f8fSGustavo F. Padovan } 34310a708f8fSGustavo F. Padovan 34320c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 34330a708f8fSGustavo F. Padovan return -ECONNREFUSED; 34340a708f8fSGustavo F. Padovan 34350c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 34360a708f8fSGustavo F. Padovan 34370e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 34380a708f8fSGustavo F. Padovan switch (rfc.mode) { 34390a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 344047d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 344147d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 344247d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3443c20f8e35SMat Martineau if (!test_bit(FLAG_EXT_CTRL, &chan->flags)) 3444c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3445c20f8e35SMat Martineau rfc.txwin_size); 344666af7aafSAndrei Emeltchenko 344766af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 344866af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 344966af7aafSAndrei Emeltchenko chan->local_sdu_itime = 345066af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 345166af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 345266af7aafSAndrei Emeltchenko chan->local_flush_to = 345366af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 345466af7aafSAndrei Emeltchenko } 34550a708f8fSGustavo F. Padovan break; 345666af7aafSAndrei Emeltchenko 34570a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 345847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 34590a708f8fSGustavo F. Padovan } 34600a708f8fSGustavo F. Padovan } 34610a708f8fSGustavo F. Padovan 3462fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 346359e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 34640a708f8fSGustavo F. Padovan 34650a708f8fSGustavo F. Padovan return ptr - data; 34660a708f8fSGustavo F. Padovan } 34670a708f8fSGustavo F. Padovan 34682d792818SGustavo Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, 34692d792818SGustavo Padovan u16 result, u16 flags) 34700a708f8fSGustavo F. Padovan { 34710a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 34720a708f8fSGustavo F. Padovan void *ptr = rsp->data; 34730a708f8fSGustavo F. Padovan 3474fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 34750a708f8fSGustavo F. Padovan 3476fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 34770a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 34780a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 34790a708f8fSGustavo F. Padovan 34800a708f8fSGustavo F. Padovan return ptr - data; 34810a708f8fSGustavo F. Padovan } 34820a708f8fSGustavo F. Padovan 34838c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3484710f9b0aSGustavo F. Padovan { 3485710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 34868c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3487710f9b0aSGustavo F. Padovan u8 buf[128]; 3488439f34acSAndrei Emeltchenko u8 rsp_code; 3489710f9b0aSGustavo F. Padovan 3490fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3491fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3492ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3493ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3494439f34acSAndrei Emeltchenko 3495439f34acSAndrei Emeltchenko if (chan->hs_hcon) 3496439f34acSAndrei Emeltchenko rsp_code = L2CAP_CREATE_CHAN_RSP; 3497439f34acSAndrei Emeltchenko else 3498439f34acSAndrei Emeltchenko rsp_code = L2CAP_CONN_RSP; 3499439f34acSAndrei Emeltchenko 3500439f34acSAndrei Emeltchenko BT_DBG("chan %p rsp_code %u", chan, rsp_code); 3501439f34acSAndrei Emeltchenko 3502439f34acSAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, rsp_code, sizeof(rsp), &rsp); 3503710f9b0aSGustavo F. Padovan 3504c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3505710f9b0aSGustavo F. Padovan return; 3506710f9b0aSGustavo F. Padovan 3507710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3508710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3509710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3510710f9b0aSGustavo F. Padovan } 3511710f9b0aSGustavo F. Padovan 351247d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 35130a708f8fSGustavo F. Padovan { 35140a708f8fSGustavo F. Padovan int type, olen; 35150a708f8fSGustavo F. Padovan unsigned long val; 3516c20f8e35SMat Martineau /* Use sane default values in case a misbehaving remote device 3517c20f8e35SMat Martineau * did not send an RFC or extended window size option. 3518c20f8e35SMat Martineau */ 3519c20f8e35SMat Martineau u16 txwin_ext = chan->ack_win; 3520c20f8e35SMat Martineau struct l2cap_conf_rfc rfc = { 3521c20f8e35SMat Martineau .mode = chan->mode, 3522c20f8e35SMat Martineau .retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO), 3523c20f8e35SMat Martineau .monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO), 3524c20f8e35SMat Martineau .max_pdu_size = cpu_to_le16(chan->imtu), 3525c20f8e35SMat Martineau .txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW), 3526c20f8e35SMat Martineau }; 35270a708f8fSGustavo F. Padovan 352847d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 35290a708f8fSGustavo F. Padovan 35300c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 35310a708f8fSGustavo F. Padovan return; 35320a708f8fSGustavo F. Padovan 35330a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 35340a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 35350a708f8fSGustavo F. Padovan 3536c20f8e35SMat Martineau switch (type) { 3537c20f8e35SMat Martineau case L2CAP_CONF_RFC: 3538c20f8e35SMat Martineau if (olen == sizeof(rfc)) 35390a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 3540c20f8e35SMat Martineau break; 3541c20f8e35SMat Martineau case L2CAP_CONF_EWS: 3542c20f8e35SMat Martineau txwin_ext = val; 3543c20f8e35SMat Martineau break; 3544c20f8e35SMat Martineau } 35450a708f8fSGustavo F. Padovan } 35460a708f8fSGustavo F. Padovan 35470a708f8fSGustavo F. Padovan switch (rfc.mode) { 35480a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 354947d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 355047d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 355147d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3552c20f8e35SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 3553c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, txwin_ext); 3554c20f8e35SMat Martineau else 3555c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3556c20f8e35SMat Martineau rfc.txwin_size); 35570a708f8fSGustavo F. Padovan break; 35580a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 355947d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 35600a708f8fSGustavo F. Padovan } 35610a708f8fSGustavo F. Padovan } 35620a708f8fSGustavo F. Padovan 35632d792818SGustavo Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, 35642d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 35650a708f8fSGustavo F. Padovan { 3566e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 35670a708f8fSGustavo F. Padovan 3568e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 35690a708f8fSGustavo F. Padovan return 0; 35700a708f8fSGustavo F. Padovan 35710a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 35720a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 357317cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 35740a708f8fSGustavo F. Padovan 35750a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 35760a708f8fSGustavo F. Padovan conn->info_ident = 0; 35770a708f8fSGustavo F. Padovan 35780a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 35790a708f8fSGustavo F. Padovan } 35800a708f8fSGustavo F. Padovan 35810a708f8fSGustavo F. Padovan return 0; 35820a708f8fSGustavo F. Padovan } 35830a708f8fSGustavo F. Padovan 35841700915fSMat Martineau static struct l2cap_chan *l2cap_connect(struct l2cap_conn *conn, 35851700915fSMat Martineau struct l2cap_cmd_hdr *cmd, 35864c89b6aaSMat Martineau u8 *data, u8 rsp_code, u8 amp_id) 35870a708f8fSGustavo F. Padovan { 35880a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 35890a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 359023691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 35910a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 35920a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 35930a708f8fSGustavo F. Padovan 35940a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 35950a708f8fSGustavo F. Padovan __le16 psm = req->psm; 35960a708f8fSGustavo F. Padovan 3597097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 35980a708f8fSGustavo F. Padovan 35990a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3600c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 360123691d75SGustavo F. Padovan if (!pchan) { 36020a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 36030a708f8fSGustavo F. Padovan goto sendresp; 36040a708f8fSGustavo F. Padovan } 36050a708f8fSGustavo F. Padovan 360623691d75SGustavo F. Padovan parent = pchan->sk; 360723691d75SGustavo F. Padovan 36083df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3609aa2ac881SGustavo F. Padovan lock_sock(parent); 36100a708f8fSGustavo F. Padovan 36110a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 36122983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 36130a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 36149f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 36150a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 36160a708f8fSGustavo F. Padovan goto response; 36170a708f8fSGustavo F. Padovan } 36180a708f8fSGustavo F. Padovan 36190a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 36200a708f8fSGustavo F. Padovan 36212dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 36222dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 36232dfa1003SGustavo Padovan goto response; 36242dfa1003SGustavo Padovan 362580b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 362680808e43SGustavo F. Padovan if (!chan) 36270a708f8fSGustavo F. Padovan goto response; 36280a708f8fSGustavo F. Padovan 362980808e43SGustavo F. Padovan sk = chan->sk; 363080808e43SGustavo F. Padovan 36310a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 36320a708f8fSGustavo F. Padovan 36330a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 36340a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3635fe4128e0SGustavo F. Padovan chan->psm = psm; 3636fe4128e0SGustavo F. Padovan chan->dcid = scid; 36371700915fSMat Martineau chan->local_amp_id = amp_id; 36380a708f8fSGustavo F. Padovan 36396be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 364048454079SGustavo F. Padovan 3641fe4128e0SGustavo F. Padovan dcid = chan->scid; 36420a708f8fSGustavo F. Padovan 3643c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 36440a708f8fSGustavo F. Padovan 3645fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 36460a708f8fSGustavo F. Padovan 36470a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3648d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3649c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 36500e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 36510a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 36520a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 36532dc4e510SGustavo Padovan chan->ops->defer(chan); 36540a708f8fSGustavo F. Padovan } else { 36551700915fSMat Martineau /* Force pending result for AMP controllers. 36561700915fSMat Martineau * The connection will succeed after the 36571700915fSMat Martineau * physical link is up. 36581700915fSMat Martineau */ 36591700915fSMat Martineau if (amp_id) { 36601700915fSMat Martineau __l2cap_state_change(chan, BT_CONNECT2); 36611700915fSMat Martineau result = L2CAP_CR_PEND; 36621700915fSMat Martineau } else { 36630e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 36640a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 36651700915fSMat Martineau } 36660a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 36670a708f8fSGustavo F. Padovan } 36680a708f8fSGustavo F. Padovan } else { 36690e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 36700a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 36710a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 36720a708f8fSGustavo F. Padovan } 36730a708f8fSGustavo F. Padovan } else { 36740e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 36750a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 36760a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 36770a708f8fSGustavo F. Padovan } 36780a708f8fSGustavo F. Padovan 36790a708f8fSGustavo F. Padovan response: 3680aa2ac881SGustavo F. Padovan release_sock(parent); 36813df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 36820a708f8fSGustavo F. Padovan 36830a708f8fSGustavo F. Padovan sendresp: 36840a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 36850a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 36860a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 36870a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 36884c89b6aaSMat Martineau l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp); 36890a708f8fSGustavo F. Padovan 36900a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 36910a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3692ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 36930a708f8fSGustavo F. Padovan 36940a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 36950a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 36960a708f8fSGustavo F. Padovan 3697ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 36980a708f8fSGustavo F. Padovan 36992d792818SGustavo Padovan l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ, 37002d792818SGustavo Padovan sizeof(info), &info); 37010a708f8fSGustavo F. Padovan } 37020a708f8fSGustavo F. Padovan 3703c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 37040a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 37050a708f8fSGustavo F. Padovan u8 buf[128]; 3706c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 37070a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 370873ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 370973ffa904SGustavo F. Padovan chan->num_conf_req++; 37100a708f8fSGustavo F. Padovan } 37111700915fSMat Martineau 37121700915fSMat Martineau return chan; 37134c89b6aaSMat Martineau } 37140a708f8fSGustavo F. Padovan 37154c89b6aaSMat Martineau static int l2cap_connect_req(struct l2cap_conn *conn, 37164c89b6aaSMat Martineau struct l2cap_cmd_hdr *cmd, u8 *data) 37174c89b6aaSMat Martineau { 3718300229f9SGustavo Padovan l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP, 0); 37190a708f8fSGustavo F. Padovan return 0; 37200a708f8fSGustavo F. Padovan } 37210a708f8fSGustavo F. Padovan 37225909cf30SMat Martineau static int l2cap_connect_create_rsp(struct l2cap_conn *conn, 37232d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 37240a708f8fSGustavo F. Padovan { 37250a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 37260a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 372748454079SGustavo F. Padovan struct l2cap_chan *chan; 37280a708f8fSGustavo F. Padovan u8 req[128]; 37293df91ea2SAndrei Emeltchenko int err; 37300a708f8fSGustavo F. Padovan 37310a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 37320a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 37330a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 37340a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 37350a708f8fSGustavo F. Padovan 37361b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 37371b009c98SAndrei Emeltchenko dcid, scid, result, status); 37380a708f8fSGustavo F. Padovan 37393df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37403df91ea2SAndrei Emeltchenko 37410a708f8fSGustavo F. Padovan if (scid) { 37423df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 37433df91ea2SAndrei Emeltchenko if (!chan) { 37443df91ea2SAndrei Emeltchenko err = -EFAULT; 37453df91ea2SAndrei Emeltchenko goto unlock; 37463df91ea2SAndrei Emeltchenko } 37470a708f8fSGustavo F. Padovan } else { 37483df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 37493df91ea2SAndrei Emeltchenko if (!chan) { 37503df91ea2SAndrei Emeltchenko err = -EFAULT; 37513df91ea2SAndrei Emeltchenko goto unlock; 37523df91ea2SAndrei Emeltchenko } 37530a708f8fSGustavo F. Padovan } 37540a708f8fSGustavo F. Padovan 37553df91ea2SAndrei Emeltchenko err = 0; 37563df91ea2SAndrei Emeltchenko 37576be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 375848454079SGustavo F. Padovan 37590a708f8fSGustavo F. Padovan switch (result) { 37600a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 376189bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3762fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3763fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3764c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 37650a708f8fSGustavo F. Padovan 3766c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 37670a708f8fSGustavo F. Padovan break; 37680a708f8fSGustavo F. Padovan 37690a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 377073ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 377173ffa904SGustavo F. Padovan chan->num_conf_req++; 37720a708f8fSGustavo F. Padovan break; 37730a708f8fSGustavo F. Padovan 37740a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3775c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 37760a708f8fSGustavo F. Padovan break; 37770a708f8fSGustavo F. Padovan 37780a708f8fSGustavo F. Padovan default: 377948454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 37800a708f8fSGustavo F. Padovan break; 37810a708f8fSGustavo F. Padovan } 37820a708f8fSGustavo F. Padovan 37836be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37843df91ea2SAndrei Emeltchenko 37853df91ea2SAndrei Emeltchenko unlock: 37863df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37873df91ea2SAndrei Emeltchenko 37883df91ea2SAndrei Emeltchenko return err; 37890a708f8fSGustavo F. Padovan } 37900a708f8fSGustavo F. Padovan 379147d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 37920a708f8fSGustavo F. Padovan { 37930a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 37940a708f8fSGustavo F. Padovan * sides request it. 37950a708f8fSGustavo F. Padovan */ 37960c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 379747d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3798c1360a1cSGustavo F. Padovan else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) 379947d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 38000a708f8fSGustavo F. Padovan } 38010a708f8fSGustavo F. Padovan 380229d8a590SAndrei Emeltchenko static void l2cap_send_efs_conf_rsp(struct l2cap_chan *chan, void *data, 380329d8a590SAndrei Emeltchenko u8 ident, u16 flags) 380429d8a590SAndrei Emeltchenko { 380529d8a590SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 380629d8a590SAndrei Emeltchenko 380729d8a590SAndrei Emeltchenko BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident, 380829d8a590SAndrei Emeltchenko flags); 380929d8a590SAndrei Emeltchenko 381029d8a590SAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 381129d8a590SAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 381229d8a590SAndrei Emeltchenko 381329d8a590SAndrei Emeltchenko l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP, 381429d8a590SAndrei Emeltchenko l2cap_build_conf_rsp(chan, data, 381529d8a590SAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), data); 381629d8a590SAndrei Emeltchenko } 381729d8a590SAndrei Emeltchenko 38182d792818SGustavo Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, 38192d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 38202d792818SGustavo Padovan u8 *data) 38210a708f8fSGustavo F. Padovan { 38220a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 38230a708f8fSGustavo F. Padovan u16 dcid, flags; 38240a708f8fSGustavo F. Padovan u8 rsp[64]; 382548454079SGustavo F. Padovan struct l2cap_chan *chan; 38263c588192SMat Martineau int len, err = 0; 38270a708f8fSGustavo F. Padovan 38280a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 38290a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 38300a708f8fSGustavo F. Padovan 38310a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 38320a708f8fSGustavo F. Padovan 3833baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 383448454079SGustavo F. Padovan if (!chan) 38350a708f8fSGustavo F. Padovan return -ENOENT; 38360a708f8fSGustavo F. Padovan 3837033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3838e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 38390a708f8fSGustavo F. Padovan 3840ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3841e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3842e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3843e2fd318eSIlia Kolomisnky 38440a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 38450a708f8fSGustavo F. Padovan sizeof(rej), &rej); 38460a708f8fSGustavo F. Padovan goto unlock; 38470a708f8fSGustavo F. Padovan } 38480a708f8fSGustavo F. Padovan 38490a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 38500a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 38517ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 38520a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3853fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 38540a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 38550a708f8fSGustavo F. Padovan goto unlock; 38560a708f8fSGustavo F. Padovan } 38570a708f8fSGustavo F. Padovan 38580a708f8fSGustavo F. Padovan /* Store config. */ 385973ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 386073ffa904SGustavo F. Padovan chan->conf_len += len; 38610a708f8fSGustavo F. Padovan 386259e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 38630a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 38640a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3865fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 38665325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 38670a708f8fSGustavo F. Padovan goto unlock; 38680a708f8fSGustavo F. Padovan } 38690a708f8fSGustavo F. Padovan 38700a708f8fSGustavo F. Padovan /* Complete config. */ 387173ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 38720a708f8fSGustavo F. Padovan if (len < 0) { 3873e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 38740a708f8fSGustavo F. Padovan goto unlock; 38750a708f8fSGustavo F. Padovan } 38760a708f8fSGustavo F. Padovan 38771500109bSMat Martineau chan->ident = cmd->ident; 38780a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 387973ffa904SGustavo F. Padovan chan->num_conf_rsp++; 38800a708f8fSGustavo F. Padovan 38810a708f8fSGustavo F. Padovan /* Reset config buffer. */ 388273ffa904SGustavo F. Padovan chan->conf_len = 0; 38830a708f8fSGustavo F. Padovan 3884c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 38850a708f8fSGustavo F. Padovan goto unlock; 38860a708f8fSGustavo F. Padovan 3887c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 388847d1ec61SGustavo F. Padovan set_default_fcs(chan); 38890a708f8fSGustavo F. Padovan 3890105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3891105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 38923c588192SMat Martineau err = l2cap_ertm_init(chan); 38930a708f8fSGustavo F. Padovan 38943c588192SMat Martineau if (err < 0) 38953c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 38963c588192SMat Martineau else 3897cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 38983c588192SMat Martineau 38990a708f8fSGustavo F. Padovan goto unlock; 39000a708f8fSGustavo F. Padovan } 39010a708f8fSGustavo F. Padovan 3902c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 39030a708f8fSGustavo F. Padovan u8 buf[64]; 39040a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 390573ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 390673ffa904SGustavo F. Padovan chan->num_conf_req++; 39070a708f8fSGustavo F. Padovan } 39080a708f8fSGustavo F. Padovan 39090e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 39100e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 39110e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 39120e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 39130e8b207eSAndrei Emeltchenko 39140e8b207eSAndrei Emeltchenko /* check compatibility */ 39150e8b207eSAndrei Emeltchenko 391679de886dSAndrei Emeltchenko /* Send rsp for BR/EDR channel */ 391779de886dSAndrei Emeltchenko if (!chan->ctrl_id) 391829d8a590SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, rsp, cmd->ident, flags); 391979de886dSAndrei Emeltchenko else 392079de886dSAndrei Emeltchenko chan->ident = cmd->ident; 39210e8b207eSAndrei Emeltchenko } 39220e8b207eSAndrei Emeltchenko 39230a708f8fSGustavo F. Padovan unlock: 39246be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 39253c588192SMat Martineau return err; 39260a708f8fSGustavo F. Padovan } 39270a708f8fSGustavo F. Padovan 39282d792818SGustavo Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, 39292d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 39300a708f8fSGustavo F. Padovan { 39310a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 39320a708f8fSGustavo F. Padovan u16 scid, flags, result; 393348454079SGustavo F. Padovan struct l2cap_chan *chan; 393461386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 39353c588192SMat Martineau int err = 0; 39360a708f8fSGustavo F. Padovan 39370a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 39380a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 39390a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 39400a708f8fSGustavo F. Padovan 394161386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 394261386cbaSAndrei Emeltchenko result, len); 39430a708f8fSGustavo F. Padovan 3944baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 394548454079SGustavo F. Padovan if (!chan) 39460a708f8fSGustavo F. Padovan return 0; 39470a708f8fSGustavo F. Padovan 39480a708f8fSGustavo F. Padovan switch (result) { 39490a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 395047d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 39510e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 39520a708f8fSGustavo F. Padovan break; 39530a708f8fSGustavo F. Padovan 39540e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 39550e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 39560e8b207eSAndrei Emeltchenko 39570e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 39580e8b207eSAndrei Emeltchenko char buf[64]; 39590e8b207eSAndrei Emeltchenko 39600e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 39610e8b207eSAndrei Emeltchenko buf, &result); 39620e8b207eSAndrei Emeltchenko if (len < 0) { 39630e8b207eSAndrei Emeltchenko l2cap_send_disconn_req(conn, chan, ECONNRESET); 39640e8b207eSAndrei Emeltchenko goto done; 39650e8b207eSAndrei Emeltchenko } 39660e8b207eSAndrei Emeltchenko 3967*5ce66b59SAndrei Emeltchenko if (!chan->ctrl_id) { 396879de886dSAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, buf, cmd->ident, 396979de886dSAndrei Emeltchenko 0); 3970*5ce66b59SAndrei Emeltchenko } else { 3971*5ce66b59SAndrei Emeltchenko if (l2cap_check_efs(chan)) { 3972*5ce66b59SAndrei Emeltchenko amp_create_logical_link(chan); 397379de886dSAndrei Emeltchenko chan->ident = cmd->ident; 39740e8b207eSAndrei Emeltchenko } 3975*5ce66b59SAndrei Emeltchenko } 3976*5ce66b59SAndrei Emeltchenko } 39770e8b207eSAndrei Emeltchenko goto done; 39780e8b207eSAndrei Emeltchenko 39790a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 398073ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 39810a708f8fSGustavo F. Padovan char req[64]; 39820a708f8fSGustavo F. Padovan 39830a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 3984e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 39850a708f8fSGustavo F. Padovan goto done; 39860a708f8fSGustavo F. Padovan } 39870a708f8fSGustavo F. Padovan 39880a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 39890a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 3990b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 3991b4450035SGustavo F. Padovan req, &result); 39920a708f8fSGustavo F. Padovan if (len < 0) { 3993e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 39940a708f8fSGustavo F. Padovan goto done; 39950a708f8fSGustavo F. Padovan } 39960a708f8fSGustavo F. Padovan 39970a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 39980a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 399973ffa904SGustavo F. Padovan chan->num_conf_req++; 40000a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 40010a708f8fSGustavo F. Padovan goto done; 40020a708f8fSGustavo F. Padovan break; 40030a708f8fSGustavo F. Padovan } 40040a708f8fSGustavo F. Padovan 40050a708f8fSGustavo F. Padovan default: 40066be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 40072e0052e4SAndrei Emeltchenko 4008ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 4009e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 40100a708f8fSGustavo F. Padovan goto done; 40110a708f8fSGustavo F. Padovan } 40120a708f8fSGustavo F. Padovan 401359e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 40140a708f8fSGustavo F. Padovan goto done; 40150a708f8fSGustavo F. Padovan 4016c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 40170a708f8fSGustavo F. Padovan 4018c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 401947d1ec61SGustavo F. Padovan set_default_fcs(chan); 40200a708f8fSGustavo F. Padovan 4021105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 4022105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 40233c588192SMat Martineau err = l2cap_ertm_init(chan); 40240a708f8fSGustavo F. Padovan 40253c588192SMat Martineau if (err < 0) 40263c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 40273c588192SMat Martineau else 4028cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 40290a708f8fSGustavo F. Padovan } 40300a708f8fSGustavo F. Padovan 40310a708f8fSGustavo F. Padovan done: 40326be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 40333c588192SMat Martineau return err; 40340a708f8fSGustavo F. Padovan } 40350a708f8fSGustavo F. Padovan 40362d792818SGustavo Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, 40372d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 40380a708f8fSGustavo F. Padovan { 40390a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 40400a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 40410a708f8fSGustavo F. Padovan u16 dcid, scid; 404248454079SGustavo F. Padovan struct l2cap_chan *chan; 40430a708f8fSGustavo F. Padovan struct sock *sk; 40440a708f8fSGustavo F. Padovan 40450a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 40460a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 40470a708f8fSGustavo F. Padovan 40480a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 40490a708f8fSGustavo F. Padovan 40503df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 40513df91ea2SAndrei Emeltchenko 40523df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 40533df91ea2SAndrei Emeltchenko if (!chan) { 40543df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 40550a708f8fSGustavo F. Padovan return 0; 40563df91ea2SAndrei Emeltchenko } 40570a708f8fSGustavo F. Padovan 40586be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 40596be36555SAndrei Emeltchenko 406048454079SGustavo F. Padovan sk = chan->sk; 406148454079SGustavo F. Padovan 4062fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 4063fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 40640a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 40650a708f8fSGustavo F. Padovan 40666be36555SAndrei Emeltchenko lock_sock(sk); 40670a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 40686be36555SAndrei Emeltchenko release_sock(sk); 40690a708f8fSGustavo F. Padovan 407061d6ef3eSMat Martineau l2cap_chan_hold(chan); 407148454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 40726be36555SAndrei Emeltchenko 40736be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 40740a708f8fSGustavo F. Padovan 407580b98027SGustavo Padovan chan->ops->close(chan); 407661d6ef3eSMat Martineau l2cap_chan_put(chan); 40773df91ea2SAndrei Emeltchenko 40783df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 40793df91ea2SAndrei Emeltchenko 40800a708f8fSGustavo F. Padovan return 0; 40810a708f8fSGustavo F. Padovan } 40820a708f8fSGustavo F. Padovan 40832d792818SGustavo Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, 40842d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 40850a708f8fSGustavo F. Padovan { 40860a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 40870a708f8fSGustavo F. Padovan u16 dcid, scid; 408848454079SGustavo F. Padovan struct l2cap_chan *chan; 40890a708f8fSGustavo F. Padovan 40900a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 40910a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 40920a708f8fSGustavo F. Padovan 40930a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 40940a708f8fSGustavo F. Padovan 40953df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 40963df91ea2SAndrei Emeltchenko 40973df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 40983df91ea2SAndrei Emeltchenko if (!chan) { 40993df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 41000a708f8fSGustavo F. Padovan return 0; 41013df91ea2SAndrei Emeltchenko } 41020a708f8fSGustavo F. Padovan 41036be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 410448454079SGustavo F. Padovan 410561d6ef3eSMat Martineau l2cap_chan_hold(chan); 410648454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 41076be36555SAndrei Emeltchenko 41086be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 41090a708f8fSGustavo F. Padovan 411080b98027SGustavo Padovan chan->ops->close(chan); 411161d6ef3eSMat Martineau l2cap_chan_put(chan); 41123df91ea2SAndrei Emeltchenko 41133df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 41143df91ea2SAndrei Emeltchenko 41150a708f8fSGustavo F. Padovan return 0; 41160a708f8fSGustavo F. Padovan } 41170a708f8fSGustavo F. Padovan 41182d792818SGustavo Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, 41192d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 41200a708f8fSGustavo F. Padovan { 41210a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 41220a708f8fSGustavo F. Padovan u16 type; 41230a708f8fSGustavo F. Padovan 41240a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 41250a708f8fSGustavo F. Padovan 41260a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 41270a708f8fSGustavo F. Padovan 41280a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 41290a708f8fSGustavo F. Padovan u8 buf[8]; 41300a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 41310a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 4132ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 4133ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 41340a708f8fSGustavo F. Padovan if (!disable_ertm) 41350a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 41360a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 4137a5fd6f30SAndrei Emeltchenko if (enable_hs) 41386327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 41396327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 4140a5fd6f30SAndrei Emeltchenko 41410a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 41422d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 41432d792818SGustavo Padovan buf); 41440a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 41450a708f8fSGustavo F. Padovan u8 buf[12]; 41460a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 414750a147cdSMat Martineau 414850a147cdSMat Martineau if (enable_hs) 414950a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 415050a147cdSMat Martineau else 415150a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 415250a147cdSMat Martineau 4153ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 4154ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 4155c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 41562d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf), 41572d792818SGustavo Padovan buf); 41580a708f8fSGustavo F. Padovan } else { 41590a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 41600a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 4161ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 41622d792818SGustavo Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), 41632d792818SGustavo Padovan &rsp); 41640a708f8fSGustavo F. Padovan } 41650a708f8fSGustavo F. Padovan 41660a708f8fSGustavo F. Padovan return 0; 41670a708f8fSGustavo F. Padovan } 41680a708f8fSGustavo F. Padovan 41692d792818SGustavo Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, 41702d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u8 *data) 41710a708f8fSGustavo F. Padovan { 41720a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 41730a708f8fSGustavo F. Padovan u16 type, result; 41740a708f8fSGustavo F. Padovan 41750a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 41760a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 41770a708f8fSGustavo F. Padovan 41780a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 41790a708f8fSGustavo F. Padovan 4180e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 4181e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 4182e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 4183e90165beSAndrei Emeltchenko return 0; 4184e90165beSAndrei Emeltchenko 418517cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 41860a708f8fSGustavo F. Padovan 41870a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 41880a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 41890a708f8fSGustavo F. Padovan conn->info_ident = 0; 41900a708f8fSGustavo F. Padovan 41910a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 41920a708f8fSGustavo F. Padovan 41930a708f8fSGustavo F. Padovan return 0; 41940a708f8fSGustavo F. Padovan } 41950a708f8fSGustavo F. Padovan 4196978c93b9SAndrei Emeltchenko switch (type) { 4197978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 41980a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 41990a708f8fSGustavo F. Padovan 42000a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 42010a708f8fSGustavo F. Padovan struct l2cap_info_req req; 4202ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 42030a708f8fSGustavo F. Padovan 42040a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 42050a708f8fSGustavo F. Padovan 42060a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 42070a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 42080a708f8fSGustavo F. Padovan } else { 42090a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 42100a708f8fSGustavo F. Padovan conn->info_ident = 0; 42110a708f8fSGustavo F. Padovan 42120a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 42130a708f8fSGustavo F. Padovan } 4214978c93b9SAndrei Emeltchenko break; 4215978c93b9SAndrei Emeltchenko 4216978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 4217978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 42180a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 42190a708f8fSGustavo F. Padovan conn->info_ident = 0; 42200a708f8fSGustavo F. Padovan 42210a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 4222978c93b9SAndrei Emeltchenko break; 42230a708f8fSGustavo F. Padovan } 42240a708f8fSGustavo F. Padovan 42250a708f8fSGustavo F. Padovan return 0; 42260a708f8fSGustavo F. Padovan } 42270a708f8fSGustavo F. Padovan 42281700915fSMat Martineau static int l2cap_create_channel_req(struct l2cap_conn *conn, 42292d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 42302d792818SGustavo Padovan u16 cmd_len, void *data) 4231f94ff6ffSMat Martineau { 4232f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 42331700915fSMat Martineau struct l2cap_chan *chan; 4234f94ff6ffSMat Martineau u16 psm, scid; 4235f94ff6ffSMat Martineau 4236f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 4237f94ff6ffSMat Martineau return -EPROTO; 4238f94ff6ffSMat Martineau 4239f94ff6ffSMat Martineau if (!enable_hs) 4240f94ff6ffSMat Martineau return -EINVAL; 4241f94ff6ffSMat Martineau 4242f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 4243f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 4244f94ff6ffSMat Martineau 4245ad0ac6caSAndrei Emeltchenko BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id); 4246f94ff6ffSMat Martineau 42471700915fSMat Martineau if (req->amp_id) { 42481700915fSMat Martineau struct hci_dev *hdev; 42491700915fSMat Martineau 42501700915fSMat Martineau /* Validate AMP controller id */ 42511700915fSMat Martineau hdev = hci_dev_get(req->amp_id); 42521700915fSMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 42531700915fSMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 42541700915fSMat Martineau struct l2cap_create_chan_rsp rsp; 42551700915fSMat Martineau 4256f94ff6ffSMat Martineau rsp.dcid = 0; 4257f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 42581700915fSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_CR_BAD_AMP); 42598ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 4260f94ff6ffSMat Martineau 4261f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 4262f94ff6ffSMat Martineau sizeof(rsp), &rsp); 4263f94ff6ffSMat Martineau 42641700915fSMat Martineau if (hdev) 42651700915fSMat Martineau hci_dev_put(hdev); 42661700915fSMat Martineau 42671700915fSMat Martineau return 0; 42681700915fSMat Martineau } 42691700915fSMat Martineau 42701700915fSMat Martineau hci_dev_put(hdev); 42711700915fSMat Martineau } 42721700915fSMat Martineau 42731700915fSMat Martineau chan = l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP, 42741700915fSMat Martineau req->amp_id); 42751700915fSMat Martineau 4276f94ff6ffSMat Martineau return 0; 4277f94ff6ffSMat Martineau } 4278f94ff6ffSMat Martineau 42798eb200bdSMat Martineau static void l2cap_send_move_chan_req(struct l2cap_chan *chan, u8 dest_amp_id) 42808eb200bdSMat Martineau { 42818eb200bdSMat Martineau struct l2cap_move_chan_req req; 42828eb200bdSMat Martineau u8 ident; 42838eb200bdSMat Martineau 42848eb200bdSMat Martineau BT_DBG("chan %p, dest_amp_id %d", chan, dest_amp_id); 42858eb200bdSMat Martineau 42868eb200bdSMat Martineau ident = l2cap_get_ident(chan->conn); 42878eb200bdSMat Martineau chan->ident = ident; 42888eb200bdSMat Martineau 42898eb200bdSMat Martineau req.icid = cpu_to_le16(chan->scid); 42908eb200bdSMat Martineau req.dest_amp_id = dest_amp_id; 42918eb200bdSMat Martineau 42928eb200bdSMat Martineau l2cap_send_cmd(chan->conn, ident, L2CAP_MOVE_CHAN_REQ, sizeof(req), 42938eb200bdSMat Martineau &req); 42948eb200bdSMat Martineau 42958eb200bdSMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 42968eb200bdSMat Martineau } 42978eb200bdSMat Martineau 42981500109bSMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_chan *chan, u16 result) 42998d5a04a1SMat Martineau { 43008d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 43018d5a04a1SMat Martineau 43021500109bSMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 43038d5a04a1SMat Martineau 43041500109bSMat Martineau rsp.icid = cpu_to_le16(chan->dcid); 43058d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 43068d5a04a1SMat Martineau 43071500109bSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_RSP, 43081500109bSMat Martineau sizeof(rsp), &rsp); 43098d5a04a1SMat Martineau } 43108d5a04a1SMat Martineau 43115b155ef9SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_chan *chan, u16 result) 43128d5a04a1SMat Martineau { 43138d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 43148d5a04a1SMat Martineau 43155b155ef9SMat Martineau BT_DBG("chan %p, result 0x%4.4x", chan, result); 43168d5a04a1SMat Martineau 43175b155ef9SMat Martineau chan->ident = l2cap_get_ident(chan->conn); 43188d5a04a1SMat Martineau 43195b155ef9SMat Martineau cfm.icid = cpu_to_le16(chan->scid); 43208d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 43218d5a04a1SMat Martineau 43225b155ef9SMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_CFM, 43235b155ef9SMat Martineau sizeof(cfm), &cfm); 43245b155ef9SMat Martineau 43255b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_TIMEOUT); 43265b155ef9SMat Martineau } 43275b155ef9SMat Martineau 43285b155ef9SMat Martineau static void l2cap_send_move_chan_cfm_icid(struct l2cap_conn *conn, u16 icid) 43295b155ef9SMat Martineau { 43305b155ef9SMat Martineau struct l2cap_move_chan_cfm cfm; 43315b155ef9SMat Martineau 43325b155ef9SMat Martineau BT_DBG("conn %p, icid 0x%4.4x", conn, icid); 43335b155ef9SMat Martineau 43345b155ef9SMat Martineau cfm.icid = cpu_to_le16(icid); 43355b155ef9SMat Martineau cfm.result = __constant_cpu_to_le16(L2CAP_MC_UNCONFIRMED); 43365b155ef9SMat Martineau 43375b155ef9SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_MOVE_CHAN_CFM, 43385b155ef9SMat Martineau sizeof(cfm), &cfm); 43398d5a04a1SMat Martineau } 43408d5a04a1SMat Martineau 43418d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 43428d5a04a1SMat Martineau u16 icid) 43438d5a04a1SMat Martineau { 43448d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 43458d5a04a1SMat Martineau 4346ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 43478d5a04a1SMat Martineau 43488d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 43498d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 43508d5a04a1SMat Martineau } 43518d5a04a1SMat Martineau 43525f3847a4SMat Martineau static void __release_logical_link(struct l2cap_chan *chan) 43535f3847a4SMat Martineau { 43545f3847a4SMat Martineau chan->hs_hchan = NULL; 43555f3847a4SMat Martineau chan->hs_hcon = NULL; 43565f3847a4SMat Martineau 43575f3847a4SMat Martineau /* Placeholder - release the logical link */ 43585f3847a4SMat Martineau } 43595f3847a4SMat Martineau 43601500109bSMat Martineau static void l2cap_logical_fail(struct l2cap_chan *chan) 43611500109bSMat Martineau { 43621500109bSMat Martineau /* Logical link setup failed */ 43631500109bSMat Martineau if (chan->state != BT_CONNECTED) { 43641500109bSMat Martineau /* Create channel failure, disconnect */ 43651500109bSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 43661500109bSMat Martineau return; 43671500109bSMat Martineau } 43681500109bSMat Martineau 43691500109bSMat Martineau switch (chan->move_role) { 43701500109bSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 43711500109bSMat Martineau l2cap_move_done(chan); 43721500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_SUPP); 43731500109bSMat Martineau break; 43741500109bSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 43751500109bSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_COMP || 43761500109bSMat Martineau chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_CFM) { 43771500109bSMat Martineau /* Remote has only sent pending or 43781500109bSMat Martineau * success responses, clean up 43791500109bSMat Martineau */ 43801500109bSMat Martineau l2cap_move_done(chan); 43811500109bSMat Martineau } 43821500109bSMat Martineau 43831500109bSMat Martineau /* Other amp move states imply that the move 43841500109bSMat Martineau * has already aborted 43851500109bSMat Martineau */ 43861500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 43871500109bSMat Martineau break; 43881500109bSMat Martineau } 43891500109bSMat Martineau } 43901500109bSMat Martineau 43911500109bSMat Martineau static void l2cap_logical_finish_create(struct l2cap_chan *chan, 43921500109bSMat Martineau struct hci_chan *hchan) 43931500109bSMat Martineau { 43941500109bSMat Martineau struct l2cap_conf_rsp rsp; 43951500109bSMat Martineau 4396336178a3SAndrei Emeltchenko chan->hs_hchan = hchan; 43971500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 43981500109bSMat Martineau 439935ba9561SAndrei Emeltchenko l2cap_send_efs_conf_rsp(chan, &rsp, chan->ident, 0); 44001500109bSMat Martineau 44011500109bSMat Martineau if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 4402fe79c6feSAndrei Emeltchenko int err; 44031500109bSMat Martineau 44041500109bSMat Martineau set_default_fcs(chan); 44051500109bSMat Martineau 44061500109bSMat Martineau err = l2cap_ertm_init(chan); 44071500109bSMat Martineau if (err < 0) 44081500109bSMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 44091500109bSMat Martineau else 44101500109bSMat Martineau l2cap_chan_ready(chan); 44111500109bSMat Martineau } 44121500109bSMat Martineau } 44131500109bSMat Martineau 44141500109bSMat Martineau static void l2cap_logical_finish_move(struct l2cap_chan *chan, 44151500109bSMat Martineau struct hci_chan *hchan) 44161500109bSMat Martineau { 44171500109bSMat Martineau chan->hs_hcon = hchan->conn; 44181500109bSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 44191500109bSMat Martineau 44201500109bSMat Martineau BT_DBG("move_state %d", chan->move_state); 44211500109bSMat Martineau 44221500109bSMat Martineau switch (chan->move_state) { 44231500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 44241500109bSMat Martineau /* Move confirm will be sent after a success 44251500109bSMat Martineau * response is received 44261500109bSMat Martineau */ 44271500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 44281500109bSMat Martineau break; 44291500109bSMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_CFM: 44301500109bSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 44311500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 44321500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 44331500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 44341500109bSMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 44351500109bSMat Martineau } else if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 44361500109bSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 44371500109bSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 44381500109bSMat Martineau } 44391500109bSMat Martineau break; 44401500109bSMat Martineau default: 44411500109bSMat Martineau /* Move was not in expected state, free the channel */ 44421500109bSMat Martineau __release_logical_link(chan); 44431500109bSMat Martineau 44441500109bSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 44451500109bSMat Martineau } 44461500109bSMat Martineau } 44471500109bSMat Martineau 44481500109bSMat Martineau /* Call with chan locked */ 444927695fb4SAndrei Emeltchenko void l2cap_logical_cfm(struct l2cap_chan *chan, struct hci_chan *hchan, 44505b155ef9SMat Martineau u8 status) 44515b155ef9SMat Martineau { 44521500109bSMat Martineau BT_DBG("chan %p, hchan %p, status %d", chan, hchan, status); 44531500109bSMat Martineau 44541500109bSMat Martineau if (status) { 44551500109bSMat Martineau l2cap_logical_fail(chan); 44561500109bSMat Martineau __release_logical_link(chan); 44575b155ef9SMat Martineau return; 44585b155ef9SMat Martineau } 44595b155ef9SMat Martineau 44601500109bSMat Martineau if (chan->state != BT_CONNECTED) { 44611500109bSMat Martineau /* Ignore logical link if channel is on BR/EDR */ 44621500109bSMat Martineau if (chan->local_amp_id) 44631500109bSMat Martineau l2cap_logical_finish_create(chan, hchan); 44641500109bSMat Martineau } else { 44651500109bSMat Martineau l2cap_logical_finish_move(chan, hchan); 44661500109bSMat Martineau } 44671500109bSMat Martineau } 44681500109bSMat Martineau 44693f7a56c4SMat Martineau void l2cap_move_start(struct l2cap_chan *chan) 44703f7a56c4SMat Martineau { 44713f7a56c4SMat Martineau BT_DBG("chan %p", chan); 44723f7a56c4SMat Martineau 44733f7a56c4SMat Martineau if (chan->local_amp_id == HCI_BREDR_ID) { 44743f7a56c4SMat Martineau if (chan->chan_policy != BT_CHANNEL_POLICY_AMP_PREFERRED) 44753f7a56c4SMat Martineau return; 44763f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 44773f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 44783f7a56c4SMat Martineau /* Placeholder - start physical link setup */ 44793f7a56c4SMat Martineau } else { 44803f7a56c4SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_INITIATOR; 44813f7a56c4SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 44823f7a56c4SMat Martineau chan->move_id = 0; 44833f7a56c4SMat Martineau l2cap_move_setup(chan); 44843f7a56c4SMat Martineau l2cap_send_move_chan_req(chan, 0); 44853f7a56c4SMat Martineau } 44863f7a56c4SMat Martineau } 44873f7a56c4SMat Martineau 44888eb200bdSMat Martineau static void l2cap_do_create(struct l2cap_chan *chan, int result, 44898eb200bdSMat Martineau u8 local_amp_id, u8 remote_amp_id) 44908eb200bdSMat Martineau { 44918eb200bdSMat Martineau if (!test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 44928eb200bdSMat Martineau struct l2cap_conn_rsp rsp; 44938eb200bdSMat Martineau char buf[128]; 44948eb200bdSMat Martineau rsp.scid = cpu_to_le16(chan->dcid); 44958eb200bdSMat Martineau rsp.dcid = cpu_to_le16(chan->scid); 44968eb200bdSMat Martineau 44978eb200bdSMat Martineau /* Incoming channel on AMP */ 44988eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 44998eb200bdSMat Martineau /* Send successful response */ 45008eb200bdSMat Martineau rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS); 45018eb200bdSMat Martineau rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO); 45028eb200bdSMat Martineau } else { 45038eb200bdSMat Martineau /* Send negative response */ 45048eb200bdSMat Martineau rsp.result = cpu_to_le16(L2CAP_CR_NO_MEM); 45058eb200bdSMat Martineau rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO); 45068eb200bdSMat Martineau } 45078eb200bdSMat Martineau 45088eb200bdSMat Martineau l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_RSP, 45098eb200bdSMat Martineau sizeof(rsp), &rsp); 45108eb200bdSMat Martineau 45118eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 45128eb200bdSMat Martineau __l2cap_state_change(chan, BT_CONFIG); 45138eb200bdSMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 45148eb200bdSMat Martineau l2cap_send_cmd(chan->conn, l2cap_get_ident(chan->conn), 45158eb200bdSMat Martineau L2CAP_CONF_REQ, 45168eb200bdSMat Martineau l2cap_build_conf_req(chan, buf), buf); 45178eb200bdSMat Martineau chan->num_conf_req++; 45188eb200bdSMat Martineau } 45198eb200bdSMat Martineau } else { 45208eb200bdSMat Martineau /* Outgoing channel on AMP */ 45218eb200bdSMat Martineau if (result == L2CAP_CR_SUCCESS) { 45228eb200bdSMat Martineau chan->local_amp_id = local_amp_id; 45238eb200bdSMat Martineau l2cap_send_create_chan_req(chan, remote_amp_id); 45248eb200bdSMat Martineau } else { 45258eb200bdSMat Martineau /* Revert to BR/EDR connect */ 45268eb200bdSMat Martineau l2cap_send_conn_req(chan); 45278eb200bdSMat Martineau } 45288eb200bdSMat Martineau } 45298eb200bdSMat Martineau } 45308eb200bdSMat Martineau 45318eb200bdSMat Martineau static void l2cap_do_move_initiate(struct l2cap_chan *chan, u8 local_amp_id, 45328eb200bdSMat Martineau u8 remote_amp_id) 45338eb200bdSMat Martineau { 45348eb200bdSMat Martineau l2cap_move_setup(chan); 45358eb200bdSMat Martineau chan->move_id = local_amp_id; 45368eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP; 45378eb200bdSMat Martineau 45388eb200bdSMat Martineau l2cap_send_move_chan_req(chan, remote_amp_id); 45398eb200bdSMat Martineau } 45408eb200bdSMat Martineau 45418eb200bdSMat Martineau static void l2cap_do_move_respond(struct l2cap_chan *chan, int result) 45428eb200bdSMat Martineau { 45438eb200bdSMat Martineau struct hci_chan *hchan = NULL; 45448eb200bdSMat Martineau 45458eb200bdSMat Martineau /* Placeholder - get hci_chan for logical link */ 45468eb200bdSMat Martineau 45478eb200bdSMat Martineau if (hchan) { 45488eb200bdSMat Martineau if (hchan->state == BT_CONNECTED) { 45498eb200bdSMat Martineau /* Logical link is ready to go */ 45508eb200bdSMat Martineau chan->hs_hcon = hchan->conn; 45518eb200bdSMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 45528eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 45538eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS); 45548eb200bdSMat Martineau 45558eb200bdSMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 45568eb200bdSMat Martineau } else { 45578eb200bdSMat Martineau /* Wait for logical link to be ready */ 45588eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 45598eb200bdSMat Martineau } 45608eb200bdSMat Martineau } else { 45618eb200bdSMat Martineau /* Logical link not available */ 45628eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_ALLOWED); 45638eb200bdSMat Martineau } 45648eb200bdSMat Martineau } 45658eb200bdSMat Martineau 45668eb200bdSMat Martineau static void l2cap_do_move_cancel(struct l2cap_chan *chan, int result) 45678eb200bdSMat Martineau { 45688eb200bdSMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) { 45698eb200bdSMat Martineau u8 rsp_result; 45708eb200bdSMat Martineau if (result == -EINVAL) 45718eb200bdSMat Martineau rsp_result = L2CAP_MR_BAD_ID; 45728eb200bdSMat Martineau else 45738eb200bdSMat Martineau rsp_result = L2CAP_MR_NOT_ALLOWED; 45748eb200bdSMat Martineau 45758eb200bdSMat Martineau l2cap_send_move_chan_rsp(chan, rsp_result); 45768eb200bdSMat Martineau } 45778eb200bdSMat Martineau 45788eb200bdSMat Martineau chan->move_role = L2CAP_MOVE_ROLE_NONE; 45798eb200bdSMat Martineau chan->move_state = L2CAP_MOVE_STABLE; 45808eb200bdSMat Martineau 45818eb200bdSMat Martineau /* Restart data transmission */ 45828eb200bdSMat Martineau l2cap_ertm_send(chan); 45838eb200bdSMat Martineau } 45848eb200bdSMat Martineau 4585770bfefaSAndrei Emeltchenko void l2cap_physical_cfm(struct l2cap_chan *chan, int result) 45868eb200bdSMat Martineau { 4587770bfefaSAndrei Emeltchenko u8 local_amp_id = chan->local_amp_id; 4588770bfefaSAndrei Emeltchenko u8 remote_amp_id = chan->ctrl_id; 4589770bfefaSAndrei Emeltchenko 45908eb200bdSMat Martineau BT_DBG("chan %p, result %d, local_amp_id %d, remote_amp_id %d", 45918eb200bdSMat Martineau chan, result, local_amp_id, remote_amp_id); 45928eb200bdSMat Martineau 45938eb200bdSMat Martineau l2cap_chan_lock(chan); 45948eb200bdSMat Martineau 45958eb200bdSMat Martineau if (chan->state == BT_DISCONN || chan->state == BT_CLOSED) { 45968eb200bdSMat Martineau l2cap_chan_unlock(chan); 45978eb200bdSMat Martineau return; 45988eb200bdSMat Martineau } 45998eb200bdSMat Martineau 46008eb200bdSMat Martineau if (chan->state != BT_CONNECTED) { 46018eb200bdSMat Martineau l2cap_do_create(chan, result, local_amp_id, remote_amp_id); 46028eb200bdSMat Martineau } else if (result != L2CAP_MR_SUCCESS) { 46038eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 46048eb200bdSMat Martineau } else { 46058eb200bdSMat Martineau switch (chan->move_role) { 46068eb200bdSMat Martineau case L2CAP_MOVE_ROLE_INITIATOR: 46078eb200bdSMat Martineau l2cap_do_move_initiate(chan, local_amp_id, 46088eb200bdSMat Martineau remote_amp_id); 46098eb200bdSMat Martineau break; 46108eb200bdSMat Martineau case L2CAP_MOVE_ROLE_RESPONDER: 46118eb200bdSMat Martineau l2cap_do_move_respond(chan, result); 46128eb200bdSMat Martineau break; 46138eb200bdSMat Martineau default: 46148eb200bdSMat Martineau l2cap_do_move_cancel(chan, result); 46158eb200bdSMat Martineau break; 46168eb200bdSMat Martineau } 46178eb200bdSMat Martineau } 46188eb200bdSMat Martineau 46198eb200bdSMat Martineau l2cap_chan_unlock(chan); 46208eb200bdSMat Martineau } 46218eb200bdSMat Martineau 46228d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 4623ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4624ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 46258d5a04a1SMat Martineau { 46268d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 46271500109bSMat Martineau struct l2cap_move_chan_rsp rsp; 462802b0fbb9SMat Martineau struct l2cap_chan *chan; 46298d5a04a1SMat Martineau u16 icid = 0; 46308d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 46318d5a04a1SMat Martineau 46328d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 46338d5a04a1SMat Martineau return -EPROTO; 46348d5a04a1SMat Martineau 46358d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 46368d5a04a1SMat Martineau 4637ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id); 46388d5a04a1SMat Martineau 46398d5a04a1SMat Martineau if (!enable_hs) 46408d5a04a1SMat Martineau return -EINVAL; 46418d5a04a1SMat Martineau 464202b0fbb9SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 464302b0fbb9SMat Martineau if (!chan) { 46441500109bSMat Martineau rsp.icid = cpu_to_le16(icid); 46451500109bSMat Martineau rsp.result = __constant_cpu_to_le16(L2CAP_MR_NOT_ALLOWED); 46461500109bSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_MOVE_CHAN_RSP, 46471500109bSMat Martineau sizeof(rsp), &rsp); 464802b0fbb9SMat Martineau return 0; 464902b0fbb9SMat Martineau } 465002b0fbb9SMat Martineau 46511500109bSMat Martineau chan->ident = cmd->ident; 46521500109bSMat Martineau 465302b0fbb9SMat Martineau if (chan->scid < L2CAP_CID_DYN_START || 465402b0fbb9SMat Martineau chan->chan_policy == BT_CHANNEL_POLICY_BREDR_ONLY || 465502b0fbb9SMat Martineau (chan->mode != L2CAP_MODE_ERTM && 465602b0fbb9SMat Martineau chan->mode != L2CAP_MODE_STREAMING)) { 465702b0fbb9SMat Martineau result = L2CAP_MR_NOT_ALLOWED; 465802b0fbb9SMat Martineau goto send_move_response; 465902b0fbb9SMat Martineau } 466002b0fbb9SMat Martineau 466102b0fbb9SMat Martineau if (chan->local_amp_id == req->dest_amp_id) { 466202b0fbb9SMat Martineau result = L2CAP_MR_SAME_ID; 466302b0fbb9SMat Martineau goto send_move_response; 466402b0fbb9SMat Martineau } 466502b0fbb9SMat Martineau 466602b0fbb9SMat Martineau if (req->dest_amp_id) { 466702b0fbb9SMat Martineau struct hci_dev *hdev; 466802b0fbb9SMat Martineau hdev = hci_dev_get(req->dest_amp_id); 466902b0fbb9SMat Martineau if (!hdev || hdev->dev_type != HCI_AMP || 467002b0fbb9SMat Martineau !test_bit(HCI_UP, &hdev->flags)) { 467102b0fbb9SMat Martineau if (hdev) 467202b0fbb9SMat Martineau hci_dev_put(hdev); 467302b0fbb9SMat Martineau 467402b0fbb9SMat Martineau result = L2CAP_MR_BAD_ID; 467502b0fbb9SMat Martineau goto send_move_response; 467602b0fbb9SMat Martineau } 467702b0fbb9SMat Martineau hci_dev_put(hdev); 467802b0fbb9SMat Martineau } 467902b0fbb9SMat Martineau 468002b0fbb9SMat Martineau /* Detect a move collision. Only send a collision response 468102b0fbb9SMat Martineau * if this side has "lost", otherwise proceed with the move. 468202b0fbb9SMat Martineau * The winner has the larger bd_addr. 468302b0fbb9SMat Martineau */ 468402b0fbb9SMat Martineau if ((__chan_is_moving(chan) || 468502b0fbb9SMat Martineau chan->move_role != L2CAP_MOVE_ROLE_NONE) && 468602b0fbb9SMat Martineau bacmp(conn->src, conn->dst) > 0) { 468702b0fbb9SMat Martineau result = L2CAP_MR_COLLISION; 468802b0fbb9SMat Martineau goto send_move_response; 468902b0fbb9SMat Martineau } 469002b0fbb9SMat Martineau 469102b0fbb9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 469202b0fbb9SMat Martineau l2cap_move_setup(chan); 469302b0fbb9SMat Martineau chan->move_id = req->dest_amp_id; 469402b0fbb9SMat Martineau icid = chan->dcid; 469502b0fbb9SMat Martineau 469602b0fbb9SMat Martineau if (!req->dest_amp_id) { 469702b0fbb9SMat Martineau /* Moving to BR/EDR */ 469802b0fbb9SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 469902b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 470002b0fbb9SMat Martineau result = L2CAP_MR_PEND; 470102b0fbb9SMat Martineau } else { 470202b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM; 470302b0fbb9SMat Martineau result = L2CAP_MR_SUCCESS; 470402b0fbb9SMat Martineau } 470502b0fbb9SMat Martineau } else { 470602b0fbb9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_PREPARE; 470702b0fbb9SMat Martineau /* Placeholder - uncomment when amp functions are available */ 470802b0fbb9SMat Martineau /*amp_accept_physical(chan, req->dest_amp_id);*/ 470902b0fbb9SMat Martineau result = L2CAP_MR_PEND; 471002b0fbb9SMat Martineau } 471102b0fbb9SMat Martineau 471202b0fbb9SMat Martineau send_move_response: 47131500109bSMat Martineau l2cap_send_move_chan_rsp(chan, result); 47148d5a04a1SMat Martineau 471502b0fbb9SMat Martineau l2cap_chan_unlock(chan); 471602b0fbb9SMat Martineau 47178d5a04a1SMat Martineau return 0; 47188d5a04a1SMat Martineau } 47198d5a04a1SMat Martineau 47205b155ef9SMat Martineau static void l2cap_move_continue(struct l2cap_conn *conn, u16 icid, u16 result) 47215b155ef9SMat Martineau { 47225b155ef9SMat Martineau struct l2cap_chan *chan; 47235b155ef9SMat Martineau struct hci_chan *hchan = NULL; 47245b155ef9SMat Martineau 47255b155ef9SMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 47265b155ef9SMat Martineau if (!chan) { 47275b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 47285b155ef9SMat Martineau return; 47295b155ef9SMat Martineau } 47305b155ef9SMat Martineau 47315b155ef9SMat Martineau __clear_chan_timer(chan); 47325b155ef9SMat Martineau if (result == L2CAP_MR_PEND) 47335b155ef9SMat Martineau __set_chan_timer(chan, L2CAP_MOVE_ERTX_TIMEOUT); 47345b155ef9SMat Martineau 47355b155ef9SMat Martineau switch (chan->move_state) { 47365b155ef9SMat Martineau case L2CAP_MOVE_WAIT_LOGICAL_COMP: 47375b155ef9SMat Martineau /* Move confirm will be sent when logical link 47385b155ef9SMat Martineau * is complete. 47395b155ef9SMat Martineau */ 47405b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 47415b155ef9SMat Martineau break; 47425b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP_SUCCESS: 47435b155ef9SMat Martineau if (result == L2CAP_MR_PEND) { 47445b155ef9SMat Martineau break; 47455b155ef9SMat Martineau } else if (test_bit(CONN_LOCAL_BUSY, 47465b155ef9SMat Martineau &chan->conn_state)) { 47475b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY; 47485b155ef9SMat Martineau } else { 47495b155ef9SMat Martineau /* Logical link is up or moving to BR/EDR, 47505b155ef9SMat Martineau * proceed with move 47515b155ef9SMat Martineau */ 47525b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP; 47535b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 47545b155ef9SMat Martineau } 47555b155ef9SMat Martineau break; 47565b155ef9SMat Martineau case L2CAP_MOVE_WAIT_RSP: 47575b155ef9SMat Martineau /* Moving to AMP */ 47585b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 47595b155ef9SMat Martineau /* Remote is ready, send confirm immediately 47605b155ef9SMat Martineau * after logical link is ready 47615b155ef9SMat Martineau */ 47625b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM; 47635b155ef9SMat Martineau } else { 47645b155ef9SMat Martineau /* Both logical link and move success 47655b155ef9SMat Martineau * are required to confirm 47665b155ef9SMat Martineau */ 47675b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_COMP; 47685b155ef9SMat Martineau } 47695b155ef9SMat Martineau 47705b155ef9SMat Martineau /* Placeholder - get hci_chan for logical link */ 47715b155ef9SMat Martineau if (!hchan) { 47725b155ef9SMat Martineau /* Logical link not available */ 47735b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 47745b155ef9SMat Martineau break; 47755b155ef9SMat Martineau } 47765b155ef9SMat Martineau 47775b155ef9SMat Martineau /* If the logical link is not yet connected, do not 47785b155ef9SMat Martineau * send confirmation. 47795b155ef9SMat Martineau */ 47805b155ef9SMat Martineau if (hchan->state != BT_CONNECTED) 47815b155ef9SMat Martineau break; 47825b155ef9SMat Martineau 47835b155ef9SMat Martineau /* Logical link is already ready to go */ 47845b155ef9SMat Martineau 47855b155ef9SMat Martineau chan->hs_hcon = hchan->conn; 47865b155ef9SMat Martineau chan->hs_hcon->l2cap_data = chan->conn; 47875b155ef9SMat Martineau 47885b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS) { 47895b155ef9SMat Martineau /* Can confirm now */ 47905b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED); 47915b155ef9SMat Martineau } else { 47925b155ef9SMat Martineau /* Now only need move success 47935b155ef9SMat Martineau * to confirm 47945b155ef9SMat Martineau */ 47955b155ef9SMat Martineau chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS; 47965b155ef9SMat Martineau } 47975b155ef9SMat Martineau 47985b155ef9SMat Martineau l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS); 47995b155ef9SMat Martineau break; 48005b155ef9SMat Martineau default: 48015b155ef9SMat Martineau /* Any other amp move state means the move failed. */ 48025b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 48035b155ef9SMat Martineau l2cap_move_done(chan); 48045b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 48055b155ef9SMat Martineau } 48065b155ef9SMat Martineau 48075b155ef9SMat Martineau l2cap_chan_unlock(chan); 48085b155ef9SMat Martineau } 48095b155ef9SMat Martineau 48105b155ef9SMat Martineau static void l2cap_move_fail(struct l2cap_conn *conn, u8 ident, u16 icid, 48115b155ef9SMat Martineau u16 result) 48125b155ef9SMat Martineau { 48135b155ef9SMat Martineau struct l2cap_chan *chan; 48145b155ef9SMat Martineau 48155b155ef9SMat Martineau chan = l2cap_get_chan_by_ident(conn, ident); 48165b155ef9SMat Martineau if (!chan) { 48175b155ef9SMat Martineau /* Could not locate channel, icid is best guess */ 48185b155ef9SMat Martineau l2cap_send_move_chan_cfm_icid(conn, icid); 48195b155ef9SMat Martineau return; 48205b155ef9SMat Martineau } 48215b155ef9SMat Martineau 48225b155ef9SMat Martineau __clear_chan_timer(chan); 48235b155ef9SMat Martineau 48245b155ef9SMat Martineau if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) { 48255b155ef9SMat Martineau if (result == L2CAP_MR_COLLISION) { 48265b155ef9SMat Martineau chan->move_role = L2CAP_MOVE_ROLE_RESPONDER; 48275b155ef9SMat Martineau } else { 48285b155ef9SMat Martineau /* Cleanup - cancel move */ 48295b155ef9SMat Martineau chan->move_id = chan->local_amp_id; 48305b155ef9SMat Martineau l2cap_move_done(chan); 48315b155ef9SMat Martineau } 48325b155ef9SMat Martineau } 48335b155ef9SMat Martineau 48345b155ef9SMat Martineau l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED); 48355b155ef9SMat Martineau 48365b155ef9SMat Martineau l2cap_chan_unlock(chan); 48375b155ef9SMat Martineau } 48385b155ef9SMat Martineau 48395b155ef9SMat Martineau static int l2cap_move_channel_rsp(struct l2cap_conn *conn, 4840ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4841ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 48428d5a04a1SMat Martineau { 48438d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 48448d5a04a1SMat Martineau u16 icid, result; 48458d5a04a1SMat Martineau 48468d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 48478d5a04a1SMat Martineau return -EPROTO; 48488d5a04a1SMat Martineau 48498d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 48508d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 48518d5a04a1SMat Martineau 4852ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 48538d5a04a1SMat Martineau 48545b155ef9SMat Martineau if (result == L2CAP_MR_SUCCESS || result == L2CAP_MR_PEND) 48555b155ef9SMat Martineau l2cap_move_continue(conn, icid, result); 48565b155ef9SMat Martineau else 48575b155ef9SMat Martineau l2cap_move_fail(conn, cmd->ident, icid, result); 48588d5a04a1SMat Martineau 48598d5a04a1SMat Martineau return 0; 48608d5a04a1SMat Martineau } 48618d5a04a1SMat Martineau 48625f3847a4SMat Martineau static int l2cap_move_channel_confirm(struct l2cap_conn *conn, 4863ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4864ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 48658d5a04a1SMat Martineau { 48668d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 48675f3847a4SMat Martineau struct l2cap_chan *chan; 48688d5a04a1SMat Martineau u16 icid, result; 48698d5a04a1SMat Martineau 48708d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 48718d5a04a1SMat Martineau return -EPROTO; 48728d5a04a1SMat Martineau 48738d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 48748d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 48758d5a04a1SMat Martineau 4876ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 48778d5a04a1SMat Martineau 48785f3847a4SMat Martineau chan = l2cap_get_chan_by_dcid(conn, icid); 48795f3847a4SMat Martineau if (!chan) { 48805f3847a4SMat Martineau /* Spec requires a response even if the icid was not found */ 48818d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 48825f3847a4SMat Martineau return 0; 48835f3847a4SMat Martineau } 48845f3847a4SMat Martineau 48855f3847a4SMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM) { 48865f3847a4SMat Martineau if (result == L2CAP_MC_CONFIRMED) { 48875f3847a4SMat Martineau chan->local_amp_id = chan->move_id; 48885f3847a4SMat Martineau if (!chan->local_amp_id) 48895f3847a4SMat Martineau __release_logical_link(chan); 48905f3847a4SMat Martineau } else { 48915f3847a4SMat Martineau chan->move_id = chan->local_amp_id; 48925f3847a4SMat Martineau } 48935f3847a4SMat Martineau 48945f3847a4SMat Martineau l2cap_move_done(chan); 48955f3847a4SMat Martineau } 48965f3847a4SMat Martineau 48975f3847a4SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 48985f3847a4SMat Martineau 48995f3847a4SMat Martineau l2cap_chan_unlock(chan); 49008d5a04a1SMat Martineau 49018d5a04a1SMat Martineau return 0; 49028d5a04a1SMat Martineau } 49038d5a04a1SMat Martineau 49048d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 4905ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4906ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 49078d5a04a1SMat Martineau { 49088d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 49093fd71a0aSMat Martineau struct l2cap_chan *chan; 49108d5a04a1SMat Martineau u16 icid; 49118d5a04a1SMat Martineau 49128d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 49138d5a04a1SMat Martineau return -EPROTO; 49148d5a04a1SMat Martineau 49158d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 49168d5a04a1SMat Martineau 4917ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 49188d5a04a1SMat Martineau 49193fd71a0aSMat Martineau chan = l2cap_get_chan_by_scid(conn, icid); 49203fd71a0aSMat Martineau if (!chan) 49213fd71a0aSMat Martineau return 0; 49223fd71a0aSMat Martineau 49233fd71a0aSMat Martineau __clear_chan_timer(chan); 49243fd71a0aSMat Martineau 49253fd71a0aSMat Martineau if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM_RSP) { 49263fd71a0aSMat Martineau chan->local_amp_id = chan->move_id; 49273fd71a0aSMat Martineau 49283fd71a0aSMat Martineau if (!chan->local_amp_id && chan->hs_hchan) 49293fd71a0aSMat Martineau __release_logical_link(chan); 49303fd71a0aSMat Martineau 49313fd71a0aSMat Martineau l2cap_move_done(chan); 49323fd71a0aSMat Martineau } 49333fd71a0aSMat Martineau 49343fd71a0aSMat Martineau l2cap_chan_unlock(chan); 49353fd71a0aSMat Martineau 49368d5a04a1SMat Martineau return 0; 49378d5a04a1SMat Martineau } 49388d5a04a1SMat Martineau 4939e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4940de73115aSClaudio Takahasi u16 to_multiplier) 4941de73115aSClaudio Takahasi { 4942de73115aSClaudio Takahasi u16 max_latency; 4943de73115aSClaudio Takahasi 4944de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4945de73115aSClaudio Takahasi return -EINVAL; 4946de73115aSClaudio Takahasi 4947de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4948de73115aSClaudio Takahasi return -EINVAL; 4949de73115aSClaudio Takahasi 4950de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4951de73115aSClaudio Takahasi return -EINVAL; 4952de73115aSClaudio Takahasi 4953de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 4954de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 4955de73115aSClaudio Takahasi return -EINVAL; 4956de73115aSClaudio Takahasi 4957de73115aSClaudio Takahasi return 0; 4958de73115aSClaudio Takahasi } 4959de73115aSClaudio Takahasi 4960de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 49612d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, 49622d792818SGustavo Padovan u8 *data) 4963de73115aSClaudio Takahasi { 4964de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 4965de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 4966de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 4967de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 49682ce603ebSClaudio Takahasi int err; 4969de73115aSClaudio Takahasi 4970de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 4971de73115aSClaudio Takahasi return -EINVAL; 4972de73115aSClaudio Takahasi 4973de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 4974de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 4975de73115aSClaudio Takahasi return -EPROTO; 4976de73115aSClaudio Takahasi 4977de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 4978de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 4979de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 4980de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 4981de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 4982de73115aSClaudio Takahasi 4983de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 4984de73115aSClaudio Takahasi min, max, latency, to_multiplier); 4985de73115aSClaudio Takahasi 4986de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 49872ce603ebSClaudio Takahasi 49882ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 49892ce603ebSClaudio Takahasi if (err) 4990ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 4991de73115aSClaudio Takahasi else 4992ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 4993de73115aSClaudio Takahasi 4994de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 4995de73115aSClaudio Takahasi sizeof(rsp), &rsp); 4996de73115aSClaudio Takahasi 49972ce603ebSClaudio Takahasi if (!err) 49982ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 49992ce603ebSClaudio Takahasi 5000de73115aSClaudio Takahasi return 0; 5001de73115aSClaudio Takahasi } 5002de73115aSClaudio Takahasi 50033300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 50042d792818SGustavo Padovan struct l2cap_cmd_hdr *cmd, u16 cmd_len, 50052d792818SGustavo Padovan u8 *data) 50063300d9a9SClaudio Takahasi { 50073300d9a9SClaudio Takahasi int err = 0; 50083300d9a9SClaudio Takahasi 50093300d9a9SClaudio Takahasi switch (cmd->code) { 50103300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 50113300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 50123300d9a9SClaudio Takahasi break; 50133300d9a9SClaudio Takahasi 50143300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 50153300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 50163300d9a9SClaudio Takahasi break; 50173300d9a9SClaudio Takahasi 50183300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 5019f5a2598dSMat Martineau case L2CAP_CREATE_CHAN_RSP: 50205909cf30SMat Martineau err = l2cap_connect_create_rsp(conn, cmd, data); 50213300d9a9SClaudio Takahasi break; 50223300d9a9SClaudio Takahasi 50233300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 50243300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 50253300d9a9SClaudio Takahasi break; 50263300d9a9SClaudio Takahasi 50273300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 50283300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 50293300d9a9SClaudio Takahasi break; 50303300d9a9SClaudio Takahasi 50313300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 50323300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 50333300d9a9SClaudio Takahasi break; 50343300d9a9SClaudio Takahasi 50353300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 50363300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 50373300d9a9SClaudio Takahasi break; 50383300d9a9SClaudio Takahasi 50393300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 50403300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 50413300d9a9SClaudio Takahasi break; 50423300d9a9SClaudio Takahasi 50433300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 50443300d9a9SClaudio Takahasi break; 50453300d9a9SClaudio Takahasi 50463300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 50473300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 50483300d9a9SClaudio Takahasi break; 50493300d9a9SClaudio Takahasi 50503300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 50513300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 50523300d9a9SClaudio Takahasi break; 50533300d9a9SClaudio Takahasi 5054f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 5055f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 5056f94ff6ffSMat Martineau break; 5057f94ff6ffSMat Martineau 50588d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 50598d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 50608d5a04a1SMat Martineau break; 50618d5a04a1SMat Martineau 50628d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 50638d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 50648d5a04a1SMat Martineau break; 50658d5a04a1SMat Martineau 50668d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 50678d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 50688d5a04a1SMat Martineau break; 50698d5a04a1SMat Martineau 50708d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 50718d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 50728d5a04a1SMat Martineau break; 50738d5a04a1SMat Martineau 50743300d9a9SClaudio Takahasi default: 50753300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 50763300d9a9SClaudio Takahasi err = -EINVAL; 50773300d9a9SClaudio Takahasi break; 50783300d9a9SClaudio Takahasi } 50793300d9a9SClaudio Takahasi 50803300d9a9SClaudio Takahasi return err; 50813300d9a9SClaudio Takahasi } 50823300d9a9SClaudio Takahasi 50833300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 50843300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 50853300d9a9SClaudio Takahasi { 50863300d9a9SClaudio Takahasi switch (cmd->code) { 50873300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 50883300d9a9SClaudio Takahasi return 0; 50893300d9a9SClaudio Takahasi 50903300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 5091de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 50923300d9a9SClaudio Takahasi 50933300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 50943300d9a9SClaudio Takahasi return 0; 50953300d9a9SClaudio Takahasi 50963300d9a9SClaudio Takahasi default: 50973300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 50983300d9a9SClaudio Takahasi return -EINVAL; 50993300d9a9SClaudio Takahasi } 51003300d9a9SClaudio Takahasi } 51013300d9a9SClaudio Takahasi 51023300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 51033300d9a9SClaudio Takahasi struct sk_buff *skb) 51040a708f8fSGustavo F. Padovan { 51050a708f8fSGustavo F. Padovan u8 *data = skb->data; 51060a708f8fSGustavo F. Padovan int len = skb->len; 51070a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 51083300d9a9SClaudio Takahasi int err; 51090a708f8fSGustavo F. Padovan 51100a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 51110a708f8fSGustavo F. Padovan 51120a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 51130a708f8fSGustavo F. Padovan u16 cmd_len; 51140a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 51150a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 51160a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 51170a708f8fSGustavo F. Padovan 51180a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 51190a708f8fSGustavo F. Padovan 51202d792818SGustavo Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, 51212d792818SGustavo Padovan cmd.ident); 51220a708f8fSGustavo F. Padovan 51230a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 51240a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 51250a708f8fSGustavo F. Padovan break; 51260a708f8fSGustavo F. Padovan } 51270a708f8fSGustavo F. Padovan 51283300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 51293300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 51303300d9a9SClaudio Takahasi else 51313300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 51320a708f8fSGustavo F. Padovan 51330a708f8fSGustavo F. Padovan if (err) { 5134e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 51352c6d1a2eSGustavo F. Padovan 51362c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 51370a708f8fSGustavo F. Padovan 51380a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 5139ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 51402d792818SGustavo Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, 51412d792818SGustavo Padovan sizeof(rej), &rej); 51420a708f8fSGustavo F. Padovan } 51430a708f8fSGustavo F. Padovan 51440a708f8fSGustavo F. Padovan data += cmd_len; 51450a708f8fSGustavo F. Padovan len -= cmd_len; 51460a708f8fSGustavo F. Padovan } 51470a708f8fSGustavo F. Padovan 51480a708f8fSGustavo F. Padovan kfree_skb(skb); 51490a708f8fSGustavo F. Padovan } 51500a708f8fSGustavo F. Padovan 515147d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 51520a708f8fSGustavo F. Padovan { 51530a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 5154e4ca6d98SAndrei Emeltchenko int hdr_size; 5155e4ca6d98SAndrei Emeltchenko 5156e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 5157e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 5158e4ca6d98SAndrei Emeltchenko else 5159e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 51600a708f8fSGustavo F. Padovan 516147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 516203a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 51630a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 51640a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 51650a708f8fSGustavo F. Padovan 51660a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 51670a708f8fSGustavo F. Padovan return -EBADMSG; 51680a708f8fSGustavo F. Padovan } 51690a708f8fSGustavo F. Padovan return 0; 51700a708f8fSGustavo F. Padovan } 51710a708f8fSGustavo F. Padovan 51726ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 51730a708f8fSGustavo F. Padovan { 5174e31f7633SMat Martineau struct l2cap_ctrl control; 51750a708f8fSGustavo F. Padovan 5176e31f7633SMat Martineau BT_DBG("chan %p", chan); 51770a708f8fSGustavo F. Padovan 5178e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 5179e31f7633SMat Martineau control.sframe = 1; 5180e31f7633SMat Martineau control.final = 1; 5181e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 5182e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 51830a708f8fSGustavo F. Padovan 5184e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5185e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 5186e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 51870a708f8fSGustavo F. Padovan } 51880a708f8fSGustavo F. Padovan 5189e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 5190e31f7633SMat Martineau chan->unacked_frames > 0) 5191e31f7633SMat Martineau __set_retrans_timer(chan); 51920a708f8fSGustavo F. Padovan 5193e31f7633SMat Martineau /* Send pending iframes */ 5194525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 51950a708f8fSGustavo F. Padovan 5196e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 5197e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 5198e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 5199e31f7633SMat Martineau * send it now. 5200e31f7633SMat Martineau */ 5201e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 5202e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 52030a708f8fSGustavo F. Padovan } 52040a708f8fSGustavo F. Padovan } 52050a708f8fSGustavo F. Padovan 52062d792818SGustavo Padovan static void append_skb_frag(struct sk_buff *skb, struct sk_buff *new_frag, 52072d792818SGustavo Padovan struct sk_buff **last_frag) 52080a708f8fSGustavo F. Padovan { 520984084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 521084084a31SMat Martineau * skb->data_len reflects only data in fragments 521184084a31SMat Martineau */ 521284084a31SMat Martineau if (!skb_has_frag_list(skb)) 521384084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 521484084a31SMat Martineau 521584084a31SMat Martineau new_frag->next = NULL; 521684084a31SMat Martineau 521784084a31SMat Martineau (*last_frag)->next = new_frag; 521884084a31SMat Martineau *last_frag = new_frag; 521984084a31SMat Martineau 522084084a31SMat Martineau skb->len += new_frag->len; 522184084a31SMat Martineau skb->data_len += new_frag->len; 522284084a31SMat Martineau skb->truesize += new_frag->truesize; 522384084a31SMat Martineau } 522484084a31SMat Martineau 52254b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 52264b51dae9SMat Martineau struct l2cap_ctrl *control) 522784084a31SMat Martineau { 522884084a31SMat Martineau int err = -EINVAL; 52290a708f8fSGustavo F. Padovan 52304b51dae9SMat Martineau switch (control->sar) { 52317e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 523284084a31SMat Martineau if (chan->sdu) 523384084a31SMat Martineau break; 52340a708f8fSGustavo F. Padovan 523580b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 523684084a31SMat Martineau break; 52370a708f8fSGustavo F. Padovan 52387e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 523984084a31SMat Martineau if (chan->sdu) 524084084a31SMat Martineau break; 52410a708f8fSGustavo F. Padovan 52426f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 524303a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 52440a708f8fSGustavo F. Padovan 524584084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 524684084a31SMat Martineau err = -EMSGSIZE; 524784084a31SMat Martineau break; 524884084a31SMat Martineau } 52490a708f8fSGustavo F. Padovan 525084084a31SMat Martineau if (skb->len >= chan->sdu_len) 525184084a31SMat Martineau break; 525284084a31SMat Martineau 525384084a31SMat Martineau chan->sdu = skb; 525484084a31SMat Martineau chan->sdu_last_frag = skb; 525584084a31SMat Martineau 525684084a31SMat Martineau skb = NULL; 525784084a31SMat Martineau err = 0; 52580a708f8fSGustavo F. Padovan break; 52590a708f8fSGustavo F. Padovan 52607e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 52616f61fd47SGustavo F. Padovan if (!chan->sdu) 526284084a31SMat Martineau break; 52630a708f8fSGustavo F. Padovan 526484084a31SMat Martineau append_skb_frag(chan->sdu, skb, 526584084a31SMat Martineau &chan->sdu_last_frag); 526684084a31SMat Martineau skb = NULL; 52670a708f8fSGustavo F. Padovan 526884084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 526984084a31SMat Martineau break; 52700a708f8fSGustavo F. Padovan 527184084a31SMat Martineau err = 0; 52720a708f8fSGustavo F. Padovan break; 52730a708f8fSGustavo F. Padovan 52747e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 52756f61fd47SGustavo F. Padovan if (!chan->sdu) 527684084a31SMat Martineau break; 52770a708f8fSGustavo F. Padovan 527884084a31SMat Martineau append_skb_frag(chan->sdu, skb, 527984084a31SMat Martineau &chan->sdu_last_frag); 528084084a31SMat Martineau skb = NULL; 52810a708f8fSGustavo F. Padovan 528284084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 528384084a31SMat Martineau break; 52840a708f8fSGustavo F. Padovan 528580b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 52860a708f8fSGustavo F. Padovan 528784084a31SMat Martineau if (!err) { 528884084a31SMat Martineau /* Reassembly complete */ 528984084a31SMat Martineau chan->sdu = NULL; 529084084a31SMat Martineau chan->sdu_last_frag = NULL; 529184084a31SMat Martineau chan->sdu_len = 0; 52920a708f8fSGustavo F. Padovan } 52930a708f8fSGustavo F. Padovan break; 52940a708f8fSGustavo F. Padovan } 52950a708f8fSGustavo F. Padovan 529684084a31SMat Martineau if (err) { 52970a708f8fSGustavo F. Padovan kfree_skb(skb); 52986f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 52996f61fd47SGustavo F. Padovan chan->sdu = NULL; 530084084a31SMat Martineau chan->sdu_last_frag = NULL; 530184084a31SMat Martineau chan->sdu_len = 0; 530284084a31SMat Martineau } 53030a708f8fSGustavo F. Padovan 530484084a31SMat Martineau return err; 53050a708f8fSGustavo F. Padovan } 53060a708f8fSGustavo F. Padovan 530732b32735SMat Martineau static int l2cap_resegment(struct l2cap_chan *chan) 530832b32735SMat Martineau { 530932b32735SMat Martineau /* Placeholder */ 531032b32735SMat Martineau return 0; 531132b32735SMat Martineau } 531232b32735SMat Martineau 5313e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 53140a708f8fSGustavo F. Padovan { 531561aa4f5bSMat Martineau u8 event; 531661aa4f5bSMat Martineau 531761aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 531861aa4f5bSMat Martineau return; 531961aa4f5bSMat Martineau 532061aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 5321401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 53220a708f8fSGustavo F. Padovan } 53230a708f8fSGustavo F. Padovan 5324d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 5325d2a7ac5dSMat Martineau { 532663838725SMat Martineau int err = 0; 532763838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 532863838725SMat Martineau * until a gap is encountered. 532963838725SMat Martineau */ 533063838725SMat Martineau 533163838725SMat Martineau BT_DBG("chan %p", chan); 533263838725SMat Martineau 533363838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 533463838725SMat Martineau struct sk_buff *skb; 533563838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 533663838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 533763838725SMat Martineau 533863838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 533963838725SMat Martineau 534063838725SMat Martineau if (!skb) 534163838725SMat Martineau break; 534263838725SMat Martineau 534363838725SMat Martineau skb_unlink(skb, &chan->srej_q); 534463838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 534563838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 534663838725SMat Martineau if (err) 534763838725SMat Martineau break; 534863838725SMat Martineau } 534963838725SMat Martineau 535063838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 535163838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 535263838725SMat Martineau l2cap_send_ack(chan); 535363838725SMat Martineau } 535463838725SMat Martineau 535563838725SMat Martineau return err; 5356d2a7ac5dSMat Martineau } 5357d2a7ac5dSMat Martineau 5358d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 5359d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5360d2a7ac5dSMat Martineau { 5361f80842a8SMat Martineau struct sk_buff *skb; 5362f80842a8SMat Martineau 5363f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 5364f80842a8SMat Martineau 5365f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 5366f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 5367f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5368f80842a8SMat Martineau return; 5369f80842a8SMat Martineau } 5370f80842a8SMat Martineau 5371f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5372f80842a8SMat Martineau 5373f80842a8SMat Martineau if (skb == NULL) { 5374f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 5375f80842a8SMat Martineau control->reqseq); 5376f80842a8SMat Martineau return; 5377f80842a8SMat Martineau } 5378f80842a8SMat Martineau 5379f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 5380f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 5381f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5382f80842a8SMat Martineau return; 5383f80842a8SMat Martineau } 5384f80842a8SMat Martineau 5385f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5386f80842a8SMat Martineau 5387f80842a8SMat Martineau if (control->poll) { 5388f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 5389f80842a8SMat Martineau 5390f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5391f80842a8SMat Martineau l2cap_retransmit(chan, control); 5392f80842a8SMat Martineau l2cap_ertm_send(chan); 5393f80842a8SMat Martineau 5394f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 5395f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 5396f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 5397f80842a8SMat Martineau } 5398f80842a8SMat Martineau } else { 5399f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 5400f80842a8SMat Martineau 5401f80842a8SMat Martineau if (control->final) { 5402f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 5403f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 5404f80842a8SMat Martineau &chan->conn_state)) 5405f80842a8SMat Martineau l2cap_retransmit(chan, control); 5406f80842a8SMat Martineau } else { 5407f80842a8SMat Martineau l2cap_retransmit(chan, control); 5408f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 5409f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 5410f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 5411f80842a8SMat Martineau } 5412f80842a8SMat Martineau } 5413f80842a8SMat Martineau } 5414d2a7ac5dSMat Martineau } 5415d2a7ac5dSMat Martineau 5416d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 5417d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 5418d2a7ac5dSMat Martineau { 5419fcd289dfSMat Martineau struct sk_buff *skb; 5420fcd289dfSMat Martineau 5421fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 5422fcd289dfSMat Martineau 5423fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 5424fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 5425fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5426fcd289dfSMat Martineau return; 5427fcd289dfSMat Martineau } 5428fcd289dfSMat Martineau 5429fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 5430fcd289dfSMat Martineau 5431fcd289dfSMat Martineau if (chan->max_tx && skb && 5432fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 5433fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 5434fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5435fcd289dfSMat Martineau return; 5436fcd289dfSMat Martineau } 5437fcd289dfSMat Martineau 5438fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5439fcd289dfSMat Martineau 5440fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 5441fcd289dfSMat Martineau 5442fcd289dfSMat Martineau if (control->final) { 5443fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 5444fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5445fcd289dfSMat Martineau } else { 5446fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 5447fcd289dfSMat Martineau l2cap_ertm_send(chan); 5448fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 5449fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 5450fcd289dfSMat Martineau } 5451d2a7ac5dSMat Martineau } 5452d2a7ac5dSMat Martineau 54534b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 54544b51dae9SMat Martineau { 54554b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 54564b51dae9SMat Martineau 54574b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 54584b51dae9SMat Martineau chan->expected_tx_seq); 54594b51dae9SMat Martineau 54604b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 54614b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 54624b51dae9SMat Martineau chan->tx_win) { 54634b51dae9SMat Martineau /* See notes below regarding "double poll" and 54644b51dae9SMat Martineau * invalid packets. 54654b51dae9SMat Martineau */ 54664b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 54674b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 54684b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 54694b51dae9SMat Martineau } else { 54704b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 54714b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 54724b51dae9SMat Martineau } 54734b51dae9SMat Martineau } 54744b51dae9SMat Martineau 54754b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 54764b51dae9SMat Martineau BT_DBG("Expected SREJ"); 54774b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 54784b51dae9SMat Martineau } 54794b51dae9SMat Martineau 54804b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 54814b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 54824b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 54834b51dae9SMat Martineau } 54844b51dae9SMat Martineau 54854b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 54864b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 54874b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 54884b51dae9SMat Martineau } 54894b51dae9SMat Martineau } 54904b51dae9SMat Martineau 54914b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 54924b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 54934b51dae9SMat Martineau chan->tx_win) { 54944b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 54954b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 54964b51dae9SMat Martineau } else { 54974b51dae9SMat Martineau BT_DBG("Expected"); 54984b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 54994b51dae9SMat Martineau } 55004b51dae9SMat Martineau } 55014b51dae9SMat Martineau 55024b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 55032d792818SGustavo Padovan __seq_offset(chan, chan->expected_tx_seq, chan->last_acked_seq)) { 55044b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 55054b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 55064b51dae9SMat Martineau } 55074b51dae9SMat Martineau 55084b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 55094b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 55104b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 55114b51dae9SMat Martineau * the remote stack receives and processes both polls, 55124b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 55134b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 55144b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 55154b51dae9SMat Martineau * request. 55164b51dae9SMat Martineau * 55174b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 55184b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 55194b51dae9SMat Martineau * invalid frames to be safely ignored. 55204b51dae9SMat Martineau * 55214b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 55224b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 55234b51dae9SMat Martineau * causes a disconnect. 55244b51dae9SMat Martineau */ 55254b51dae9SMat Martineau 55264b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 55274b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 55284b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 55294b51dae9SMat Martineau } else { 55304b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 55314b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 55324b51dae9SMat Martineau } 55334b51dae9SMat Martineau } else { 55344b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 55354b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 55364b51dae9SMat Martineau } 55374b51dae9SMat Martineau } 55384b51dae9SMat Martineau 5539d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 5540d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5541d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5542d2a7ac5dSMat Martineau { 5543d2a7ac5dSMat Martineau int err = 0; 5544d2a7ac5dSMat Martineau bool skb_in_use = 0; 5545d2a7ac5dSMat Martineau 5546d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5547d2a7ac5dSMat Martineau event); 5548d2a7ac5dSMat Martineau 5549d2a7ac5dSMat Martineau switch (event) { 5550d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5551d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 5552d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5553d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5554d2a7ac5dSMat Martineau 5555d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5556d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 5557d2a7ac5dSMat Martineau control->txseq); 5558d2a7ac5dSMat Martineau break; 5559d2a7ac5dSMat Martineau } 5560d2a7ac5dSMat Martineau 5561d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 5562d2a7ac5dSMat Martineau control->txseq); 5563d2a7ac5dSMat Martineau 5564d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 5565d2a7ac5dSMat Martineau skb_in_use = 1; 5566d2a7ac5dSMat Martineau 5567d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 5568d2a7ac5dSMat Martineau if (err) 5569d2a7ac5dSMat Martineau break; 5570d2a7ac5dSMat Martineau 5571d2a7ac5dSMat Martineau if (control->final) { 5572d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5573d2a7ac5dSMat Martineau &chan->conn_state)) { 5574d2a7ac5dSMat Martineau control->final = 0; 5575d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5576d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5577d2a7ac5dSMat Martineau } 5578d2a7ac5dSMat Martineau } 5579d2a7ac5dSMat Martineau 5580d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 5581d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5582d2a7ac5dSMat Martineau break; 5583d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5584d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5585d2a7ac5dSMat Martineau 5586d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 5587d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 5588d2a7ac5dSMat Martineau * when local busy is exited. 5589d2a7ac5dSMat Martineau */ 5590d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 5591d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 5592d2a7ac5dSMat Martineau control->txseq); 5593d2a7ac5dSMat Martineau break; 5594d2a7ac5dSMat Martineau } 5595d2a7ac5dSMat Martineau 5596d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 5597d2a7ac5dSMat Martineau * must be sent for each missing frame. The 5598d2a7ac5dSMat Martineau * current frame is stored for later use. 5599d2a7ac5dSMat Martineau */ 5600d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5601d2a7ac5dSMat Martineau skb_in_use = 1; 5602d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5603d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5604d2a7ac5dSMat Martineau 5605d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 5606d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 5607d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5608d2a7ac5dSMat Martineau 5609d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 5610d2a7ac5dSMat Martineau break; 5611d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5612d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5613d2a7ac5dSMat Martineau break; 5614d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5615d2a7ac5dSMat Martineau break; 5616d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5617d2a7ac5dSMat Martineau default: 5618d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5619d2a7ac5dSMat Martineau ECONNRESET); 5620d2a7ac5dSMat Martineau break; 5621d2a7ac5dSMat Martineau } 5622d2a7ac5dSMat Martineau break; 5623d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5624d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5625d2a7ac5dSMat Martineau if (control->final) { 5626d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5627d2a7ac5dSMat Martineau 5628e6a3ee6eSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state) && 5629e6a3ee6eSMat Martineau !__chan_is_moving(chan)) { 5630d2a7ac5dSMat Martineau control->final = 0; 5631d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5632d2a7ac5dSMat Martineau } 5633d2a7ac5dSMat Martineau 5634d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5635d2a7ac5dSMat Martineau } else if (control->poll) { 5636d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 5637d2a7ac5dSMat Martineau } else { 5638d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5639d2a7ac5dSMat Martineau &chan->conn_state) && 5640d2a7ac5dSMat Martineau chan->unacked_frames) 5641d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5642d2a7ac5dSMat Martineau 5643d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5644d2a7ac5dSMat Martineau } 5645d2a7ac5dSMat Martineau break; 5646d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5647d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5648d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5649d2a7ac5dSMat Martineau if (control && control->poll) { 5650d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5651d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 5652d2a7ac5dSMat Martineau } 5653d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 5654d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 5655d2a7ac5dSMat Martineau break; 5656d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5657d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5658d2a7ac5dSMat Martineau break; 5659d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5660d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5661d2a7ac5dSMat Martineau break; 5662d2a7ac5dSMat Martineau default: 5663d2a7ac5dSMat Martineau break; 5664d2a7ac5dSMat Martineau } 5665d2a7ac5dSMat Martineau 5666d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5667d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5668d2a7ac5dSMat Martineau kfree_skb(skb); 5669d2a7ac5dSMat Martineau } 5670d2a7ac5dSMat Martineau 5671d2a7ac5dSMat Martineau return err; 5672d2a7ac5dSMat Martineau } 5673d2a7ac5dSMat Martineau 5674d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 5675d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 5676d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 5677d2a7ac5dSMat Martineau { 5678d2a7ac5dSMat Martineau int err = 0; 5679d2a7ac5dSMat Martineau u16 txseq = control->txseq; 5680d2a7ac5dSMat Martineau bool skb_in_use = 0; 5681d2a7ac5dSMat Martineau 5682d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 5683d2a7ac5dSMat Martineau event); 5684d2a7ac5dSMat Martineau 5685d2a7ac5dSMat Martineau switch (event) { 5686d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 5687d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 5688d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 5689d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 5690d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5691d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5692d2a7ac5dSMat Martineau skb_in_use = 1; 5693d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5694d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5695d2a7ac5dSMat Martineau 5696d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 5697d2a7ac5dSMat Martineau break; 5698d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 5699d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 5700d2a7ac5dSMat Martineau 5701d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5702d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5703d2a7ac5dSMat Martineau skb_in_use = 1; 5704d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5705d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5706d2a7ac5dSMat Martineau 5707d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 5708d2a7ac5dSMat Martineau if (err) 5709d2a7ac5dSMat Martineau break; 5710d2a7ac5dSMat Martineau 5711d2a7ac5dSMat Martineau break; 5712d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 5713d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 5714d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 5715d2a7ac5dSMat Martineau * the missing frames. 5716d2a7ac5dSMat Martineau */ 5717d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5718d2a7ac5dSMat Martineau skb_in_use = 1; 5719d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5720d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5721d2a7ac5dSMat Martineau 5722d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5723d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 5724d2a7ac5dSMat Martineau break; 5725d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 5726d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 5727d2a7ac5dSMat Martineau * some expected retransmitted frames are 5728d2a7ac5dSMat Martineau * missing. Request retransmission of missing 5729d2a7ac5dSMat Martineau * SREJ'd frames. 5730d2a7ac5dSMat Martineau */ 5731d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 5732d2a7ac5dSMat Martineau skb_in_use = 1; 5733d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 5734d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 5735d2a7ac5dSMat Martineau 5736d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5737d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 5738d2a7ac5dSMat Martineau break; 5739d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 5740d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 5741d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5742d2a7ac5dSMat Martineau break; 5743d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 5744d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 5745d2a7ac5dSMat Martineau * was already received. Ignore it completely. 5746d2a7ac5dSMat Martineau */ 5747d2a7ac5dSMat Martineau break; 5748d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 5749d2a7ac5dSMat Martineau break; 5750d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 5751d2a7ac5dSMat Martineau default: 5752d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5753d2a7ac5dSMat Martineau ECONNRESET); 5754d2a7ac5dSMat Martineau break; 5755d2a7ac5dSMat Martineau } 5756d2a7ac5dSMat Martineau break; 5757d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 5758d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5759d2a7ac5dSMat Martineau if (control->final) { 5760d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5761d2a7ac5dSMat Martineau 5762d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 5763d2a7ac5dSMat Martineau &chan->conn_state)) { 5764d2a7ac5dSMat Martineau control->final = 0; 5765d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 5766d2a7ac5dSMat Martineau } 5767d2a7ac5dSMat Martineau 5768d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 5769d2a7ac5dSMat Martineau } else if (control->poll) { 5770d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5771d2a7ac5dSMat Martineau &chan->conn_state) && 5772d2a7ac5dSMat Martineau chan->unacked_frames) { 5773d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5774d2a7ac5dSMat Martineau } 5775d2a7ac5dSMat Martineau 5776d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 5777d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5778d2a7ac5dSMat Martineau } else { 5779d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 5780d2a7ac5dSMat Martineau &chan->conn_state) && 5781d2a7ac5dSMat Martineau chan->unacked_frames) 5782d2a7ac5dSMat Martineau __set_retrans_timer(chan); 5783d2a7ac5dSMat Martineau 5784d2a7ac5dSMat Martineau l2cap_send_ack(chan); 5785d2a7ac5dSMat Martineau } 5786d2a7ac5dSMat Martineau break; 5787d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 5788d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 5789d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 5790d2a7ac5dSMat Martineau if (control->poll) { 5791d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 5792d2a7ac5dSMat Martineau } else { 5793d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 5794d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 5795d2a7ac5dSMat Martineau rr_control.sframe = 1; 5796d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 5797d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 5798d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 5799d2a7ac5dSMat Martineau } 5800d2a7ac5dSMat Martineau 5801d2a7ac5dSMat Martineau break; 5802d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 5803d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 5804d2a7ac5dSMat Martineau break; 5805d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 5806d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 5807d2a7ac5dSMat Martineau break; 5808d2a7ac5dSMat Martineau } 5809d2a7ac5dSMat Martineau 5810d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 5811d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 5812d2a7ac5dSMat Martineau kfree_skb(skb); 5813d2a7ac5dSMat Martineau } 5814d2a7ac5dSMat Martineau 5815d2a7ac5dSMat Martineau return err; 5816d2a7ac5dSMat Martineau } 5817d2a7ac5dSMat Martineau 581832b32735SMat Martineau static int l2cap_finish_move(struct l2cap_chan *chan) 581932b32735SMat Martineau { 582032b32735SMat Martineau BT_DBG("chan %p", chan); 582132b32735SMat Martineau 582232b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 582332b32735SMat Martineau 582432b32735SMat Martineau if (chan->hs_hcon) 582532b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 582632b32735SMat Martineau else 582732b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 582832b32735SMat Martineau 582932b32735SMat Martineau return l2cap_resegment(chan); 583032b32735SMat Martineau } 583132b32735SMat Martineau 583232b32735SMat Martineau static int l2cap_rx_state_wait_p(struct l2cap_chan *chan, 583332b32735SMat Martineau struct l2cap_ctrl *control, 583432b32735SMat Martineau struct sk_buff *skb, u8 event) 583532b32735SMat Martineau { 583632b32735SMat Martineau int err; 583732b32735SMat Martineau 583832b32735SMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 583932b32735SMat Martineau event); 584032b32735SMat Martineau 584132b32735SMat Martineau if (!control->poll) 584232b32735SMat Martineau return -EPROTO; 584332b32735SMat Martineau 584432b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 584532b32735SMat Martineau 584632b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 584732b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 584832b32735SMat Martineau else 584932b32735SMat Martineau chan->tx_send_head = NULL; 585032b32735SMat Martineau 585132b32735SMat Martineau /* Rewind next_tx_seq to the point expected 585232b32735SMat Martineau * by the receiver. 585332b32735SMat Martineau */ 585432b32735SMat Martineau chan->next_tx_seq = control->reqseq; 585532b32735SMat Martineau chan->unacked_frames = 0; 585632b32735SMat Martineau 585732b32735SMat Martineau err = l2cap_finish_move(chan); 585832b32735SMat Martineau if (err) 585932b32735SMat Martineau return err; 586032b32735SMat Martineau 586132b32735SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 586232b32735SMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 586332b32735SMat Martineau 586432b32735SMat Martineau if (event == L2CAP_EV_RECV_IFRAME) 586532b32735SMat Martineau return -EPROTO; 586632b32735SMat Martineau 586732b32735SMat Martineau return l2cap_rx_state_recv(chan, control, NULL, event); 586832b32735SMat Martineau } 586932b32735SMat Martineau 587032b32735SMat Martineau static int l2cap_rx_state_wait_f(struct l2cap_chan *chan, 587132b32735SMat Martineau struct l2cap_ctrl *control, 587232b32735SMat Martineau struct sk_buff *skb, u8 event) 587332b32735SMat Martineau { 587432b32735SMat Martineau int err; 587532b32735SMat Martineau 587632b32735SMat Martineau if (!control->final) 587732b32735SMat Martineau return -EPROTO; 587832b32735SMat Martineau 587932b32735SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 588032b32735SMat Martineau 588132b32735SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 588232b32735SMat Martineau l2cap_process_reqseq(chan, control->reqseq); 588332b32735SMat Martineau 588432b32735SMat Martineau if (!skb_queue_empty(&chan->tx_q)) 588532b32735SMat Martineau chan->tx_send_head = skb_peek(&chan->tx_q); 588632b32735SMat Martineau else 588732b32735SMat Martineau chan->tx_send_head = NULL; 588832b32735SMat Martineau 588932b32735SMat Martineau /* Rewind next_tx_seq to the point expected 589032b32735SMat Martineau * by the receiver. 589132b32735SMat Martineau */ 589232b32735SMat Martineau chan->next_tx_seq = control->reqseq; 589332b32735SMat Martineau chan->unacked_frames = 0; 589432b32735SMat Martineau 589532b32735SMat Martineau if (chan->hs_hcon) 589632b32735SMat Martineau chan->conn->mtu = chan->hs_hcon->hdev->block_mtu; 589732b32735SMat Martineau else 589832b32735SMat Martineau chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu; 589932b32735SMat Martineau 590032b32735SMat Martineau err = l2cap_resegment(chan); 590132b32735SMat Martineau 590232b32735SMat Martineau if (!err) 590332b32735SMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 590432b32735SMat Martineau 590532b32735SMat Martineau return err; 590632b32735SMat Martineau } 590732b32735SMat Martineau 5908d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 5909d2a7ac5dSMat Martineau { 5910d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 5911d2a7ac5dSMat Martineau u16 unacked; 5912d2a7ac5dSMat Martineau 5913d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 5914d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 5915d2a7ac5dSMat Martineau } 5916d2a7ac5dSMat Martineau 5917cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5918cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 59190a708f8fSGustavo F. Padovan { 5920d2a7ac5dSMat Martineau int err = 0; 5921d2a7ac5dSMat Martineau 5922d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 5923d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 5924d2a7ac5dSMat Martineau 5925d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 5926d2a7ac5dSMat Martineau switch (chan->rx_state) { 5927d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 5928d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 5929d2a7ac5dSMat Martineau break; 5930d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 5931d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 5932d2a7ac5dSMat Martineau event); 5933d2a7ac5dSMat Martineau break; 593432b32735SMat Martineau case L2CAP_RX_STATE_WAIT_P: 593532b32735SMat Martineau err = l2cap_rx_state_wait_p(chan, control, skb, event); 593632b32735SMat Martineau break; 593732b32735SMat Martineau case L2CAP_RX_STATE_WAIT_F: 593832b32735SMat Martineau err = l2cap_rx_state_wait_f(chan, control, skb, event); 593932b32735SMat Martineau break; 5940d2a7ac5dSMat Martineau default: 5941d2a7ac5dSMat Martineau /* shut it down */ 5942d2a7ac5dSMat Martineau break; 5943d2a7ac5dSMat Martineau } 5944d2a7ac5dSMat Martineau } else { 5945d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 5946d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 5947d2a7ac5dSMat Martineau chan->expected_ack_seq); 5948d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5949d2a7ac5dSMat Martineau } 5950d2a7ac5dSMat Martineau 5951d2a7ac5dSMat Martineau return err; 5952cec8ab6eSMat Martineau } 5953cec8ab6eSMat Martineau 5954cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5955cec8ab6eSMat Martineau struct sk_buff *skb) 5956cec8ab6eSMat Martineau { 59574b51dae9SMat Martineau int err = 0; 59584b51dae9SMat Martineau 59594b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 59604b51dae9SMat Martineau chan->rx_state); 59614b51dae9SMat Martineau 59624b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 59634b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 59644b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 59654b51dae9SMat Martineau 59664b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 59674b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 59684b51dae9SMat Martineau 59694b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 59704b51dae9SMat Martineau 59714b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 59724b51dae9SMat Martineau } else { 59734b51dae9SMat Martineau if (chan->sdu) { 59744b51dae9SMat Martineau kfree_skb(chan->sdu); 59754b51dae9SMat Martineau chan->sdu = NULL; 59764b51dae9SMat Martineau } 59774b51dae9SMat Martineau chan->sdu_last_frag = NULL; 59784b51dae9SMat Martineau chan->sdu_len = 0; 59794b51dae9SMat Martineau 59804b51dae9SMat Martineau if (skb) { 59814b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 59824b51dae9SMat Martineau kfree_skb(skb); 59834b51dae9SMat Martineau } 59844b51dae9SMat Martineau } 59854b51dae9SMat Martineau 59864b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 59874b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 59884b51dae9SMat Martineau 59894b51dae9SMat Martineau return err; 5990cec8ab6eSMat Martineau } 5991cec8ab6eSMat Martineau 5992cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 5993cec8ab6eSMat Martineau { 5994cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 5995cec8ab6eSMat Martineau u16 len; 5996cec8ab6eSMat Martineau u8 event; 59970a708f8fSGustavo F. Padovan 5998b76bbd66SMat Martineau __unpack_control(chan, skb); 5999b76bbd66SMat Martineau 60000a708f8fSGustavo F. Padovan len = skb->len; 60010a708f8fSGustavo F. Padovan 60020a708f8fSGustavo F. Padovan /* 60030a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 60040a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 6005cec8ab6eSMat Martineau * procedures and ask for retransmission. 60060a708f8fSGustavo F. Padovan */ 600747d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 60080a708f8fSGustavo F. Padovan goto drop; 60090a708f8fSGustavo F. Padovan 6010cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 601103a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 60120a708f8fSGustavo F. Padovan 601347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 601403a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 60150a708f8fSGustavo F. Padovan 601647d1ec61SGustavo F. Padovan if (len > chan->mps) { 60178c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 60180a708f8fSGustavo F. Padovan goto drop; 60190a708f8fSGustavo F. Padovan } 60200a708f8fSGustavo F. Padovan 6021cec8ab6eSMat Martineau if (!control->sframe) { 6022cec8ab6eSMat Martineau int err; 60230a708f8fSGustavo F. Padovan 6024cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 6025cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 6026cec8ab6eSMat Martineau control->txseq); 6027836be934SAndrei Emeltchenko 6028cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 6029cec8ab6eSMat Martineau * valid in TX WAIT_F 6030cec8ab6eSMat Martineau */ 6031cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 60320a708f8fSGustavo F. Padovan goto drop; 60330a708f8fSGustavo F. Padovan 6034cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 6035cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 6036cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 60370a708f8fSGustavo F. Padovan } else { 6038cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 6039cec8ab6eSMat Martineau } 6040cec8ab6eSMat Martineau 6041cec8ab6eSMat Martineau if (err) 6042cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 6043cec8ab6eSMat Martineau ECONNRESET); 6044cec8ab6eSMat Martineau } else { 6045cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 6046cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 6047cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 6048cec8ab6eSMat Martineau }; 6049cec8ab6eSMat Martineau 6050cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 6051cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 6052cec8ab6eSMat Martineau goto drop; 6053cec8ab6eSMat Martineau 6054cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 6055cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 6056cec8ab6eSMat Martineau control->super); 6057cec8ab6eSMat Martineau 60580a708f8fSGustavo F. Padovan if (len != 0) { 60590a708f8fSGustavo F. Padovan BT_ERR("%d", len); 60608c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 60610a708f8fSGustavo F. Padovan goto drop; 60620a708f8fSGustavo F. Padovan } 60630a708f8fSGustavo F. Padovan 6064cec8ab6eSMat Martineau /* Validate F and P bits */ 6065cec8ab6eSMat Martineau if (control->final && (control->poll || 6066cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 6067cec8ab6eSMat Martineau goto drop; 6068cec8ab6eSMat Martineau 6069cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 6070cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 6071cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 60720a708f8fSGustavo F. Padovan } 60730a708f8fSGustavo F. Padovan 60740a708f8fSGustavo F. Padovan return 0; 60750a708f8fSGustavo F. Padovan 60760a708f8fSGustavo F. Padovan drop: 60770a708f8fSGustavo F. Padovan kfree_skb(skb); 60780a708f8fSGustavo F. Padovan return 0; 60790a708f8fSGustavo F. Padovan } 60800a708f8fSGustavo F. Padovan 608113ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 608213ca56e0SAndrei Emeltchenko struct sk_buff *skb) 60830a708f8fSGustavo F. Padovan { 608448454079SGustavo F. Padovan struct l2cap_chan *chan; 60850a708f8fSGustavo F. Padovan 6086baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 608748454079SGustavo F. Padovan if (!chan) { 608897e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 608997e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 609097e8e89dSAndrei Emeltchenko if (!chan) { 609197e8e89dSAndrei Emeltchenko kfree_skb(skb); 609213ca56e0SAndrei Emeltchenko return; 609397e8e89dSAndrei Emeltchenko } 609497e8e89dSAndrei Emeltchenko 609597e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 609697e8e89dSAndrei Emeltchenko } else { 60970a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 60986be36555SAndrei Emeltchenko /* Drop packet and return */ 60993379013bSDan Carpenter kfree_skb(skb); 610013ca56e0SAndrei Emeltchenko return; 61010a708f8fSGustavo F. Padovan } 610297e8e89dSAndrei Emeltchenko } 61030a708f8fSGustavo F. Padovan 610449208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 61050a708f8fSGustavo F. Padovan 610689bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 61070a708f8fSGustavo F. Padovan goto drop; 61080a708f8fSGustavo F. Padovan 61090c1bc5c6SGustavo F. Padovan switch (chan->mode) { 61100a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 61110a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 61120a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 61130a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 61140a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 61150a708f8fSGustavo F. Padovan 61160c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 61170a708f8fSGustavo F. Padovan goto drop; 61180a708f8fSGustavo F. Padovan 611980b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 61200a708f8fSGustavo F. Padovan goto done; 61210a708f8fSGustavo F. Padovan break; 61220a708f8fSGustavo F. Padovan 61230a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 61240a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 6125cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 61260a708f8fSGustavo F. Padovan goto done; 61270a708f8fSGustavo F. Padovan 61280a708f8fSGustavo F. Padovan default: 61290c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 61300a708f8fSGustavo F. Padovan break; 61310a708f8fSGustavo F. Padovan } 61320a708f8fSGustavo F. Padovan 61330a708f8fSGustavo F. Padovan drop: 61340a708f8fSGustavo F. Padovan kfree_skb(skb); 61350a708f8fSGustavo F. Padovan 61360a708f8fSGustavo F. Padovan done: 61376be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 61380a708f8fSGustavo F. Padovan } 61390a708f8fSGustavo F. Padovan 614084104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 614184104b24SAndrei Emeltchenko struct sk_buff *skb) 61420a708f8fSGustavo F. Padovan { 614323691d75SGustavo F. Padovan struct l2cap_chan *chan; 61440a708f8fSGustavo F. Padovan 6145c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 614623691d75SGustavo F. Padovan if (!chan) 61470a708f8fSGustavo F. Padovan goto drop; 61480a708f8fSGustavo F. Padovan 61495b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 61500a708f8fSGustavo F. Padovan 615189bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 61520a708f8fSGustavo F. Padovan goto drop; 61530a708f8fSGustavo F. Padovan 6154e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 61550a708f8fSGustavo F. Padovan goto drop; 61560a708f8fSGustavo F. Padovan 615780b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 615884104b24SAndrei Emeltchenko return; 61590a708f8fSGustavo F. Padovan 61600a708f8fSGustavo F. Padovan drop: 61610a708f8fSGustavo F. Padovan kfree_skb(skb); 61620a708f8fSGustavo F. Padovan } 61630a708f8fSGustavo F. Padovan 61646810fca7SAndrei Emeltchenko static void l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 6165d9b88702SAndrei Emeltchenko struct sk_buff *skb) 61669f69bda6SGustavo F. Padovan { 616723691d75SGustavo F. Padovan struct l2cap_chan *chan; 61689f69bda6SGustavo F. Padovan 6169c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 617023691d75SGustavo F. Padovan if (!chan) 61719f69bda6SGustavo F. Padovan goto drop; 61729f69bda6SGustavo F. Padovan 61735b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 61749f69bda6SGustavo F. Padovan 617589bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 61769f69bda6SGustavo F. Padovan goto drop; 61779f69bda6SGustavo F. Padovan 6178e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 61799f69bda6SGustavo F. Padovan goto drop; 61809f69bda6SGustavo F. Padovan 618180b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 61826810fca7SAndrei Emeltchenko return; 61839f69bda6SGustavo F. Padovan 61849f69bda6SGustavo F. Padovan drop: 61859f69bda6SGustavo F. Padovan kfree_skb(skb); 61869f69bda6SGustavo F. Padovan } 61879f69bda6SGustavo F. Padovan 61880a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 61890a708f8fSGustavo F. Padovan { 61900a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 61910a708f8fSGustavo F. Padovan u16 cid, len; 61920a708f8fSGustavo F. Padovan __le16 psm; 61930a708f8fSGustavo F. Padovan 61940a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 61950a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 61960a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 61970a708f8fSGustavo F. Padovan 61980a708f8fSGustavo F. Padovan if (len != skb->len) { 61990a708f8fSGustavo F. Padovan kfree_skb(skb); 62000a708f8fSGustavo F. Padovan return; 62010a708f8fSGustavo F. Padovan } 62020a708f8fSGustavo F. Padovan 62030a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 62040a708f8fSGustavo F. Padovan 62050a708f8fSGustavo F. Padovan switch (cid) { 62063300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 62070a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 62080a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 62090a708f8fSGustavo F. Padovan break; 62100a708f8fSGustavo F. Padovan 62110a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 6212097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 62130181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 62140a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 62150a708f8fSGustavo F. Padovan break; 62160a708f8fSGustavo F. Padovan 62179f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 62189f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 62199f69bda6SGustavo F. Padovan break; 62209f69bda6SGustavo F. Padovan 6221b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 6222b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 6223b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 6224b501d6a1SAnderson Briglia break; 6225b501d6a1SAnderson Briglia 62260a708f8fSGustavo F. Padovan default: 62270a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 62280a708f8fSGustavo F. Padovan break; 62290a708f8fSGustavo F. Padovan } 62300a708f8fSGustavo F. Padovan } 62310a708f8fSGustavo F. Padovan 62320a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 62330a708f8fSGustavo F. Padovan 6234686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 62350a708f8fSGustavo F. Padovan { 62360a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 623723691d75SGustavo F. Padovan struct l2cap_chan *c; 62380a708f8fSGustavo F. Padovan 62396ed93dc6SAndrei Emeltchenko BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr); 62400a708f8fSGustavo F. Padovan 62410a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 624223691d75SGustavo F. Padovan read_lock(&chan_list_lock); 624323691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 624423691d75SGustavo F. Padovan struct sock *sk = c->sk; 62454343478fSGustavo F. Padovan 624689bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 62470a708f8fSGustavo F. Padovan continue; 62480a708f8fSGustavo F. Padovan 62490a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 62500a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 625143bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 62520a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 62530a708f8fSGustavo F. Padovan exact++; 62540a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 62550a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 625643bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 62570a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 62580a708f8fSGustavo F. Padovan } 62590a708f8fSGustavo F. Padovan } 626023691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 62610a708f8fSGustavo F. Padovan 62620a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 62630a708f8fSGustavo F. Padovan } 62640a708f8fSGustavo F. Padovan 62659e664631SAndrei Emeltchenko void l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 62660a708f8fSGustavo F. Padovan { 62670a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 62680a708f8fSGustavo F. Padovan 62696ed93dc6SAndrei Emeltchenko BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status); 62700a708f8fSGustavo F. Padovan 62710a708f8fSGustavo F. Padovan if (!status) { 62720a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 62730a708f8fSGustavo F. Padovan if (conn) 62740a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 6275ba6fc317SAndrei Emeltchenko } else { 6276e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 6277ba6fc317SAndrei Emeltchenko } 62780a708f8fSGustavo F. Padovan } 62790a708f8fSGustavo F. Padovan 6280686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 62810a708f8fSGustavo F. Padovan { 62820a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 62830a708f8fSGustavo F. Padovan 62840a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 62850a708f8fSGustavo F. Padovan 6286686ebf28SUlisses Furquim if (!conn) 62879f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 62880a708f8fSGustavo F. Padovan return conn->disc_reason; 62890a708f8fSGustavo F. Padovan } 62900a708f8fSGustavo F. Padovan 62919e664631SAndrei Emeltchenko void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 62920a708f8fSGustavo F. Padovan { 62930a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 62940a708f8fSGustavo F. Padovan 6295e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 62960a708f8fSGustavo F. Padovan } 62970a708f8fSGustavo F. Padovan 62984343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 62990a708f8fSGustavo F. Padovan { 6300715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 63010a708f8fSGustavo F. Padovan return; 63020a708f8fSGustavo F. Padovan 63030a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 63044343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 6305ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 63064343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 63070f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 63080a708f8fSGustavo F. Padovan } else { 63094343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 6310c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 63110a708f8fSGustavo F. Padovan } 63120a708f8fSGustavo F. Padovan } 63130a708f8fSGustavo F. Padovan 6314686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 63150a708f8fSGustavo F. Padovan { 63160a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 631748454079SGustavo F. Padovan struct l2cap_chan *chan; 63180a708f8fSGustavo F. Padovan 63190a708f8fSGustavo F. Padovan if (!conn) 63200a708f8fSGustavo F. Padovan return 0; 63210a708f8fSGustavo F. Padovan 632289d8b407SAndrei Emeltchenko BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt); 63230a708f8fSGustavo F. Padovan 6324160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 632535d4adccSHemant Gupta if (!status && encrypt) 6326160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 632717cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 6328160dc6acSVinicius Costa Gomes } 6329160dc6acSVinicius Costa Gomes 63303df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 63310a708f8fSGustavo F. Padovan 63323df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 63336be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 63340a708f8fSGustavo F. Padovan 633589d8b407SAndrei Emeltchenko BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid, 633689d8b407SAndrei Emeltchenko state_to_string(chan->state)); 6337f1cb9af5SVinicius Costa Gomes 633878eb2f98SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 633978eb2f98SAndrei Emeltchenko l2cap_chan_unlock(chan); 634078eb2f98SAndrei Emeltchenko continue; 634178eb2f98SAndrei Emeltchenko } 634278eb2f98SAndrei Emeltchenko 6343f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 6344f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 6345f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 6346cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 6347f1cb9af5SVinicius Costa Gomes } 6348f1cb9af5SVinicius Costa Gomes 63496be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 6350f1cb9af5SVinicius Costa Gomes continue; 6351f1cb9af5SVinicius Costa Gomes } 6352f1cb9af5SVinicius Costa Gomes 6353c1360a1cSGustavo F. Padovan if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 63546be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 63550a708f8fSGustavo F. Padovan continue; 63560a708f8fSGustavo F. Padovan } 63570a708f8fSGustavo F. Padovan 635889bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 635989bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 6360a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 6361a7d7723aSGustavo Padovan 6362c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 6363a7d7723aSGustavo Padovan sk->sk_state_change(sk); 6364a7d7723aSGustavo Padovan 63654343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 63666be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 63670a708f8fSGustavo F. Padovan continue; 63680a708f8fSGustavo F. Padovan } 63690a708f8fSGustavo F. Padovan 637089bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 63710a708f8fSGustavo F. Padovan if (!status) { 637293c3e8f5SAndrei Emeltchenko l2cap_start_connection(chan); 63730a708f8fSGustavo F. Padovan } else { 6374ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 63750a708f8fSGustavo F. Padovan } 637689bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 63776be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 63780a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 6379df3c3931SJohan Hedberg __u16 res, stat; 63800a708f8fSGustavo F. Padovan 63816be36555SAndrei Emeltchenko lock_sock(sk); 63826be36555SAndrei Emeltchenko 63830a708f8fSGustavo F. Padovan if (!status) { 6384c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 6385c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 6386df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 6387df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 63882dc4e510SGustavo Padovan chan->ops->defer(chan); 6389df3c3931SJohan Hedberg } else { 63900e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 6391df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 6392df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 6393df3c3931SJohan Hedberg } 63940a708f8fSGustavo F. Padovan } else { 63950e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 6396ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 6397df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 6398df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 63990a708f8fSGustavo F. Padovan } 64000a708f8fSGustavo F. Padovan 64016be36555SAndrei Emeltchenko release_sock(sk); 64026be36555SAndrei Emeltchenko 6403fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 6404fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 6405df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 6406df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 6407fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 6408fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 64092d369359SMat Martineau 64102d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 64112d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 64122d369359SMat Martineau char buf[128]; 64132d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 64142d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 64152d369359SMat Martineau L2CAP_CONF_REQ, 64162d369359SMat Martineau l2cap_build_conf_req(chan, buf), 64172d369359SMat Martineau buf); 64182d369359SMat Martineau chan->num_conf_req++; 64192d369359SMat Martineau } 64200a708f8fSGustavo F. Padovan } 64210a708f8fSGustavo F. Padovan 64226be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 64230a708f8fSGustavo F. Padovan } 64240a708f8fSGustavo F. Padovan 64253df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 64260a708f8fSGustavo F. Padovan 64270a708f8fSGustavo F. Padovan return 0; 64280a708f8fSGustavo F. Padovan } 64290a708f8fSGustavo F. Padovan 6430686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 64310a708f8fSGustavo F. Padovan { 64320a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 6433d73a0988SAndrei Emeltchenko struct l2cap_hdr *hdr; 6434d73a0988SAndrei Emeltchenko int len; 64350a708f8fSGustavo F. Padovan 64361d13a254SAndrei Emeltchenko /* For AMP controller do not create l2cap conn */ 64371d13a254SAndrei Emeltchenko if (!conn && hcon->hdev->dev_type != HCI_BREDR) 64381d13a254SAndrei Emeltchenko goto drop; 64390a708f8fSGustavo F. Padovan 64400a708f8fSGustavo F. Padovan if (!conn) 64410a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 64420a708f8fSGustavo F. Padovan 64430a708f8fSGustavo F. Padovan if (!conn) 64440a708f8fSGustavo F. Padovan goto drop; 64450a708f8fSGustavo F. Padovan 64460a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 64470a708f8fSGustavo F. Padovan 6448d73a0988SAndrei Emeltchenko switch (flags) { 6449d73a0988SAndrei Emeltchenko case ACL_START: 6450d73a0988SAndrei Emeltchenko case ACL_START_NO_FLUSH: 6451d73a0988SAndrei Emeltchenko case ACL_COMPLETE: 64520a708f8fSGustavo F. Padovan if (conn->rx_len) { 64530a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 64540a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 64550a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 64560a708f8fSGustavo F. Padovan conn->rx_len = 0; 64570a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 64580a708f8fSGustavo F. Padovan } 64590a708f8fSGustavo F. Padovan 64600a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 64610a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 64620a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 64630a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 64640a708f8fSGustavo F. Padovan goto drop; 64650a708f8fSGustavo F. Padovan } 64660a708f8fSGustavo F. Padovan 64670a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 64680a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 64690a708f8fSGustavo F. Padovan 64700a708f8fSGustavo F. Padovan if (len == skb->len) { 64710a708f8fSGustavo F. Padovan /* Complete frame received */ 64720a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 64730a708f8fSGustavo F. Padovan return 0; 64740a708f8fSGustavo F. Padovan } 64750a708f8fSGustavo F. Padovan 64760a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 64770a708f8fSGustavo F. Padovan 64780a708f8fSGustavo F. Padovan if (skb->len > len) { 64790a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 64800a708f8fSGustavo F. Padovan skb->len, len); 64810a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 64820a708f8fSGustavo F. Padovan goto drop; 64830a708f8fSGustavo F. Padovan } 64840a708f8fSGustavo F. Padovan 64850a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 64868bcde1f2SGustavo Padovan conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL); 64870a708f8fSGustavo F. Padovan if (!conn->rx_skb) 64880a708f8fSGustavo F. Padovan goto drop; 64890a708f8fSGustavo F. Padovan 64900a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 64910a708f8fSGustavo F. Padovan skb->len); 64920a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 6493d73a0988SAndrei Emeltchenko break; 6494d73a0988SAndrei Emeltchenko 6495d73a0988SAndrei Emeltchenko case ACL_CONT: 64960a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 64970a708f8fSGustavo F. Padovan 64980a708f8fSGustavo F. Padovan if (!conn->rx_len) { 64990a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 65000a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 65010a708f8fSGustavo F. Padovan goto drop; 65020a708f8fSGustavo F. Padovan } 65030a708f8fSGustavo F. Padovan 65040a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 65050a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 65060a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 65070a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 65080a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 65090a708f8fSGustavo F. Padovan conn->rx_len = 0; 65100a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 65110a708f8fSGustavo F. Padovan goto drop; 65120a708f8fSGustavo F. Padovan } 65130a708f8fSGustavo F. Padovan 65140a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 65150a708f8fSGustavo F. Padovan skb->len); 65160a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 65170a708f8fSGustavo F. Padovan 65180a708f8fSGustavo F. Padovan if (!conn->rx_len) { 65190a708f8fSGustavo F. Padovan /* Complete frame received */ 65200a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 65210a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 65220a708f8fSGustavo F. Padovan } 6523d73a0988SAndrei Emeltchenko break; 65240a708f8fSGustavo F. Padovan } 65250a708f8fSGustavo F. Padovan 65260a708f8fSGustavo F. Padovan drop: 65270a708f8fSGustavo F. Padovan kfree_skb(skb); 65280a708f8fSGustavo F. Padovan return 0; 65290a708f8fSGustavo F. Padovan } 65300a708f8fSGustavo F. Padovan 65310a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 65320a708f8fSGustavo F. Padovan { 653323691d75SGustavo F. Padovan struct l2cap_chan *c; 65340a708f8fSGustavo F. Padovan 6535333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 65360a708f8fSGustavo F. Padovan 653723691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 653823691d75SGustavo F. Padovan struct sock *sk = c->sk; 65390a708f8fSGustavo F. Padovan 6540fcb73338SAndrei Emeltchenko seq_printf(f, "%pMR %pMR %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 6541fcb73338SAndrei Emeltchenko &bt_sk(sk)->src, &bt_sk(sk)->dst, 654289bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 654323691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 654423691d75SGustavo F. Padovan c->sec_level, c->mode); 65450a708f8fSGustavo F. Padovan } 65460a708f8fSGustavo F. Padovan 6547333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 65480a708f8fSGustavo F. Padovan 65490a708f8fSGustavo F. Padovan return 0; 65500a708f8fSGustavo F. Padovan } 65510a708f8fSGustavo F. Padovan 65520a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 65530a708f8fSGustavo F. Padovan { 65540a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 65550a708f8fSGustavo F. Padovan } 65560a708f8fSGustavo F. Padovan 65570a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 65580a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 65590a708f8fSGustavo F. Padovan .read = seq_read, 65600a708f8fSGustavo F. Padovan .llseek = seq_lseek, 65610a708f8fSGustavo F. Padovan .release = single_release, 65620a708f8fSGustavo F. Padovan }; 65630a708f8fSGustavo F. Padovan 65640a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 65650a708f8fSGustavo F. Padovan 656664274518SGustavo F. Padovan int __init l2cap_init(void) 65670a708f8fSGustavo F. Padovan { 65680a708f8fSGustavo F. Padovan int err; 65690a708f8fSGustavo F. Padovan 6570bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 65710a708f8fSGustavo F. Padovan if (err < 0) 65720a708f8fSGustavo F. Padovan return err; 65730a708f8fSGustavo F. Padovan 65740a708f8fSGustavo F. Padovan if (bt_debugfs) { 65752d792818SGustavo Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, bt_debugfs, 65762d792818SGustavo Padovan NULL, &l2cap_debugfs_fops); 65770a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 65780a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 65790a708f8fSGustavo F. Padovan } 65800a708f8fSGustavo F. Padovan 65810a708f8fSGustavo F. Padovan return 0; 65820a708f8fSGustavo F. Padovan } 65830a708f8fSGustavo F. Padovan 658464274518SGustavo F. Padovan void l2cap_exit(void) 65850a708f8fSGustavo F. Padovan { 65860a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 6587bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 65880a708f8fSGustavo F. Padovan } 65890a708f8fSGustavo F. Padovan 65900a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 65910a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 6592