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> 400a708f8fSGustavo F. Padovan 41d1de6d46SMat Martineau bool disable_ertm; 420a708f8fSGustavo F. Padovan 430a708f8fSGustavo F. Padovan static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN; 4450a147cdSMat Martineau static u8 l2cap_fixed_chan[8] = { L2CAP_FC_L2CAP, }; 450a708f8fSGustavo F. Padovan 46b5ad8b7fSJohannes Berg static LIST_HEAD(chan_list); 47b5ad8b7fSJohannes Berg static DEFINE_RWLOCK(chan_list_lock); 480a708f8fSGustavo F. Padovan 490a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 500a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data); 514519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 524519de9aSGustavo F. Padovan void *data); 53710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data); 544519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 554519de9aSGustavo F. Padovan struct l2cap_chan *chan, int err); 560a708f8fSGustavo F. Padovan 57d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 58608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event); 59608bcc6dSMat Martineau 600a708f8fSGustavo F. Padovan /* ---- L2CAP channels ---- */ 6171ba0e56SGustavo F. Padovan 62baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, u16 cid) 630a708f8fSGustavo F. Padovan { 643df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 65baa7e1faSGustavo F. Padovan 663df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 673df91ea2SAndrei Emeltchenko if (c->dcid == cid) 683df91ea2SAndrei Emeltchenko return c; 690a708f8fSGustavo F. Padovan } 703df91ea2SAndrei Emeltchenko return NULL; 71baa7e1faSGustavo F. Padovan } 720a708f8fSGustavo F. Padovan 73baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid) 740a708f8fSGustavo F. Padovan { 753df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 76baa7e1faSGustavo F. Padovan 773df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 783df91ea2SAndrei Emeltchenko if (c->scid == cid) 793df91ea2SAndrei Emeltchenko return c; 800a708f8fSGustavo F. Padovan } 813df91ea2SAndrei Emeltchenko return NULL; 82baa7e1faSGustavo F. Padovan } 830a708f8fSGustavo F. Padovan 840a708f8fSGustavo F. Padovan /* Find channel with given SCID. 85ef191adeSMat Martineau * Returns locked channel. */ 86baa7e1faSGustavo F. Padovan static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid) 870a708f8fSGustavo F. Padovan { 8848454079SGustavo F. Padovan struct l2cap_chan *c; 89baa7e1faSGustavo F. Padovan 903df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 91baa7e1faSGustavo F. Padovan c = __l2cap_get_chan_by_scid(conn, cid); 92ef191adeSMat Martineau if (c) 93ef191adeSMat Martineau l2cap_chan_lock(c); 943df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 953df91ea2SAndrei Emeltchenko 9648454079SGustavo F. Padovan return c; 970a708f8fSGustavo F. Padovan } 980a708f8fSGustavo F. Padovan 99baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident) 1000a708f8fSGustavo F. Padovan { 1013df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 102baa7e1faSGustavo F. Padovan 1033df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 1043df91ea2SAndrei Emeltchenko if (c->ident == ident) 1053df91ea2SAndrei Emeltchenko return c; 1060a708f8fSGustavo F. Padovan } 1073df91ea2SAndrei Emeltchenko return NULL; 108baa7e1faSGustavo F. Padovan } 1090a708f8fSGustavo F. Padovan 11023691d75SGustavo F. Padovan static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src) 1119e4425ffSGustavo F. Padovan { 11223691d75SGustavo F. Padovan struct l2cap_chan *c; 1139e4425ffSGustavo F. Padovan 11423691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 11523691d75SGustavo F. Padovan if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src)) 11623691d75SGustavo F. Padovan return c; 1179e4425ffSGustavo F. Padovan } 118250938cbSSzymon Janc return NULL; 119250938cbSSzymon Janc } 1209e4425ffSGustavo F. Padovan 1219e4425ffSGustavo F. Padovan int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm) 1229e4425ffSGustavo F. Padovan { 12373b2ec18SGustavo F. Padovan int err; 12473b2ec18SGustavo F. Padovan 125333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1269e4425ffSGustavo F. Padovan 12723691d75SGustavo F. Padovan if (psm && __l2cap_global_chan_by_addr(psm, src)) { 12873b2ec18SGustavo F. Padovan err = -EADDRINUSE; 12973b2ec18SGustavo F. Padovan goto done; 1309e4425ffSGustavo F. Padovan } 1319e4425ffSGustavo F. Padovan 13273b2ec18SGustavo F. Padovan if (psm) { 1339e4425ffSGustavo F. Padovan chan->psm = psm; 1349e4425ffSGustavo F. Padovan chan->sport = psm; 13573b2ec18SGustavo F. Padovan err = 0; 13673b2ec18SGustavo F. Padovan } else { 13773b2ec18SGustavo F. Padovan u16 p; 1389e4425ffSGustavo F. Padovan 13973b2ec18SGustavo F. Padovan err = -EINVAL; 14073b2ec18SGustavo F. Padovan for (p = 0x1001; p < 0x1100; p += 2) 14123691d75SGustavo F. Padovan if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) { 14273b2ec18SGustavo F. Padovan chan->psm = cpu_to_le16(p); 14373b2ec18SGustavo F. Padovan chan->sport = cpu_to_le16(p); 14473b2ec18SGustavo F. Padovan err = 0; 14573b2ec18SGustavo F. Padovan break; 14673b2ec18SGustavo F. Padovan } 14773b2ec18SGustavo F. Padovan } 14873b2ec18SGustavo F. Padovan 14973b2ec18SGustavo F. Padovan done: 150333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 15173b2ec18SGustavo F. Padovan return err; 1529e4425ffSGustavo F. Padovan } 1539e4425ffSGustavo F. Padovan 1549e4425ffSGustavo F. Padovan int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid) 1559e4425ffSGustavo F. Padovan { 156333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1579e4425ffSGustavo F. Padovan 1589e4425ffSGustavo F. Padovan chan->scid = scid; 1599e4425ffSGustavo F. Padovan 160333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 1619e4425ffSGustavo F. Padovan 1629e4425ffSGustavo F. Padovan return 0; 1639e4425ffSGustavo F. Padovan } 1649e4425ffSGustavo F. Padovan 165baa7e1faSGustavo F. Padovan static u16 l2cap_alloc_cid(struct l2cap_conn *conn) 1660a708f8fSGustavo F. Padovan { 1670a708f8fSGustavo F. Padovan u16 cid = L2CAP_CID_DYN_START; 1680a708f8fSGustavo F. Padovan 1690a708f8fSGustavo F. Padovan for (; cid < L2CAP_CID_DYN_END; cid++) { 170baa7e1faSGustavo F. Padovan if (!__l2cap_get_chan_by_scid(conn, cid)) 1710a708f8fSGustavo F. Padovan return cid; 1720a708f8fSGustavo F. Padovan } 1730a708f8fSGustavo F. Padovan 1740a708f8fSGustavo F. Padovan return 0; 1750a708f8fSGustavo F. Padovan } 1760a708f8fSGustavo F. Padovan 1770e587be7SAndrei Emeltchenko static void __l2cap_state_change(struct l2cap_chan *chan, int state) 17889bc500eSGustavo F. Padovan { 17942d2d87cSAndrei Emeltchenko BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state), 180badaaa00SGustavo F. Padovan state_to_string(state)); 181badaaa00SGustavo F. Padovan 18289bc500eSGustavo F. Padovan chan->state = state; 18380b98027SGustavo Padovan chan->ops->state_change(chan, state); 18489bc500eSGustavo F. Padovan } 18589bc500eSGustavo F. Padovan 1860e587be7SAndrei Emeltchenko static void l2cap_state_change(struct l2cap_chan *chan, int state) 1870e587be7SAndrei Emeltchenko { 1880e587be7SAndrei Emeltchenko struct sock *sk = chan->sk; 1890e587be7SAndrei Emeltchenko 1900e587be7SAndrei Emeltchenko lock_sock(sk); 1910e587be7SAndrei Emeltchenko __l2cap_state_change(chan, state); 1920e587be7SAndrei Emeltchenko release_sock(sk); 1930e587be7SAndrei Emeltchenko } 1940e587be7SAndrei Emeltchenko 1952e0052e4SAndrei Emeltchenko static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err) 1962e0052e4SAndrei Emeltchenko { 1972e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 1982e0052e4SAndrei Emeltchenko 1992e0052e4SAndrei Emeltchenko sk->sk_err = err; 2002e0052e4SAndrei Emeltchenko } 2012e0052e4SAndrei Emeltchenko 2022e0052e4SAndrei Emeltchenko static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2032e0052e4SAndrei Emeltchenko { 2042e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2052e0052e4SAndrei Emeltchenko 2062e0052e4SAndrei Emeltchenko lock_sock(sk); 2072e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 2082e0052e4SAndrei Emeltchenko release_sock(sk); 2092e0052e4SAndrei Emeltchenko } 2102e0052e4SAndrei Emeltchenko 2114239d16fSMat Martineau static void __set_retrans_timer(struct l2cap_chan *chan) 2124239d16fSMat Martineau { 2134239d16fSMat Martineau if (!delayed_work_pending(&chan->monitor_timer) && 2144239d16fSMat Martineau chan->retrans_timeout) { 2154239d16fSMat Martineau l2cap_set_timer(chan, &chan->retrans_timer, 2164239d16fSMat Martineau msecs_to_jiffies(chan->retrans_timeout)); 2174239d16fSMat Martineau } 2184239d16fSMat Martineau } 2194239d16fSMat Martineau 2204239d16fSMat Martineau static void __set_monitor_timer(struct l2cap_chan *chan) 2214239d16fSMat Martineau { 2224239d16fSMat Martineau __clear_retrans_timer(chan); 2234239d16fSMat Martineau if (chan->monitor_timeout) { 2244239d16fSMat Martineau l2cap_set_timer(chan, &chan->monitor_timer, 2254239d16fSMat Martineau msecs_to_jiffies(chan->monitor_timeout)); 2264239d16fSMat Martineau } 2274239d16fSMat Martineau } 2284239d16fSMat Martineau 229608bcc6dSMat Martineau static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head, 230608bcc6dSMat Martineau u16 seq) 231608bcc6dSMat Martineau { 232608bcc6dSMat Martineau struct sk_buff *skb; 233608bcc6dSMat Martineau 234608bcc6dSMat Martineau skb_queue_walk(head, skb) { 235608bcc6dSMat Martineau if (bt_cb(skb)->control.txseq == seq) 236608bcc6dSMat Martineau return skb; 237608bcc6dSMat Martineau } 238608bcc6dSMat Martineau 239608bcc6dSMat Martineau return NULL; 240608bcc6dSMat Martineau } 241608bcc6dSMat Martineau 2423c588192SMat Martineau /* ---- L2CAP sequence number lists ---- */ 2433c588192SMat Martineau 2443c588192SMat Martineau /* For ERTM, ordered lists of sequence numbers must be tracked for 2453c588192SMat Martineau * SREJ requests that are received and for frames that are to be 2463c588192SMat Martineau * retransmitted. These seq_list functions implement a singly-linked 2473c588192SMat Martineau * list in an array, where membership in the list can also be checked 2483c588192SMat Martineau * in constant time. Items can also be added to the tail of the list 2493c588192SMat Martineau * and removed from the head in constant time, without further memory 2503c588192SMat Martineau * allocs or frees. 2513c588192SMat Martineau */ 2523c588192SMat Martineau 2533c588192SMat Martineau static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) 2543c588192SMat Martineau { 2553c588192SMat Martineau size_t alloc_size, i; 2563c588192SMat Martineau 2573c588192SMat Martineau /* Allocated size is a power of 2 to map sequence numbers 2583c588192SMat Martineau * (which may be up to 14 bits) in to a smaller array that is 2593c588192SMat Martineau * sized for the negotiated ERTM transmit windows. 2603c588192SMat Martineau */ 2613c588192SMat Martineau alloc_size = roundup_pow_of_two(size); 2623c588192SMat Martineau 2633c588192SMat Martineau seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); 2643c588192SMat Martineau if (!seq_list->list) 2653c588192SMat Martineau return -ENOMEM; 2663c588192SMat Martineau 2673c588192SMat Martineau seq_list->mask = alloc_size - 1; 2683c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 2693c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 2703c588192SMat Martineau for (i = 0; i < alloc_size; i++) 2713c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 2723c588192SMat Martineau 2733c588192SMat Martineau return 0; 2743c588192SMat Martineau } 2753c588192SMat Martineau 2763c588192SMat Martineau static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list) 2773c588192SMat Martineau { 2783c588192SMat Martineau kfree(seq_list->list); 2793c588192SMat Martineau } 2803c588192SMat Martineau 2813c588192SMat Martineau static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list, 2823c588192SMat Martineau u16 seq) 2833c588192SMat Martineau { 2843c588192SMat Martineau /* Constant-time check for list membership */ 2853c588192SMat Martineau return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR; 2863c588192SMat Martineau } 2873c588192SMat Martineau 2883c588192SMat Martineau static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq) 2893c588192SMat Martineau { 2903c588192SMat Martineau u16 mask = seq_list->mask; 2913c588192SMat Martineau 2923c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) { 2933c588192SMat Martineau /* In case someone tries to pop the head of an empty list */ 2943c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 2953c588192SMat Martineau } else if (seq_list->head == seq) { 2963c588192SMat Martineau /* Head can be removed in constant time */ 2973c588192SMat Martineau seq_list->head = seq_list->list[seq & mask]; 2983c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 2993c588192SMat Martineau 3003c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_TAIL) { 3013c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3023c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3033c588192SMat Martineau } 3043c588192SMat Martineau } else { 3053c588192SMat Martineau /* Walk the list to find the sequence number */ 3063c588192SMat Martineau u16 prev = seq_list->head; 3073c588192SMat Martineau while (seq_list->list[prev & mask] != seq) { 3083c588192SMat Martineau prev = seq_list->list[prev & mask]; 3093c588192SMat Martineau if (prev == L2CAP_SEQ_LIST_TAIL) 3103c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3113c588192SMat Martineau } 3123c588192SMat Martineau 3133c588192SMat Martineau /* Unlink the number from the list and clear it */ 3143c588192SMat Martineau seq_list->list[prev & mask] = seq_list->list[seq & mask]; 3153c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3163c588192SMat Martineau if (seq_list->tail == seq) 3173c588192SMat Martineau seq_list->tail = prev; 3183c588192SMat Martineau } 3193c588192SMat Martineau return seq; 3203c588192SMat Martineau } 3213c588192SMat Martineau 3223c588192SMat Martineau static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list) 3233c588192SMat Martineau { 3243c588192SMat Martineau /* Remove the head in constant time */ 3253c588192SMat Martineau return l2cap_seq_list_remove(seq_list, seq_list->head); 3263c588192SMat Martineau } 3273c588192SMat Martineau 3283c588192SMat Martineau static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list) 3293c588192SMat Martineau { 3303c588192SMat Martineau u16 i; 331f522ae36SGustavo Padovan 332f522ae36SGustavo Padovan if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) 333f522ae36SGustavo Padovan return; 334f522ae36SGustavo Padovan 3353c588192SMat Martineau for (i = 0; i <= seq_list->mask; i++) 3363c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3373c588192SMat Martineau 3383c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3393c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3403c588192SMat Martineau } 3413c588192SMat Martineau 3423c588192SMat Martineau static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq) 3433c588192SMat Martineau { 3443c588192SMat Martineau u16 mask = seq_list->mask; 3453c588192SMat Martineau 3463c588192SMat Martineau /* All appends happen in constant time */ 3473c588192SMat Martineau 348f522ae36SGustavo Padovan if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR) 349f522ae36SGustavo Padovan return; 350f522ae36SGustavo Padovan 3513c588192SMat Martineau if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR) 3523c588192SMat Martineau seq_list->head = seq; 3533c588192SMat Martineau else 3543c588192SMat Martineau seq_list->list[seq_list->tail & mask] = seq; 3553c588192SMat Martineau 3563c588192SMat Martineau seq_list->tail = seq; 3573c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL; 3583c588192SMat Martineau } 3593c588192SMat Martineau 360721c4181SGustavo F. Padovan static void l2cap_chan_timeout(struct work_struct *work) 361ab07801dSGustavo F. Padovan { 362721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 363721c4181SGustavo F. Padovan chan_timer.work); 3643df91ea2SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 365ab07801dSGustavo F. Padovan int reason; 366ab07801dSGustavo F. Padovan 367e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s", chan, state_to_string(chan->state)); 368ab07801dSGustavo F. Padovan 3693df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3706be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 371ab07801dSGustavo F. Padovan 37289bc500eSGustavo F. Padovan if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG) 373ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 37489bc500eSGustavo F. Padovan else if (chan->state == BT_CONNECT && 375ab07801dSGustavo F. Padovan chan->sec_level != BT_SECURITY_SDP) 376ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 377ab07801dSGustavo F. Padovan else 378ab07801dSGustavo F. Padovan reason = ETIMEDOUT; 379ab07801dSGustavo F. Padovan 3800f852724SGustavo F. Padovan l2cap_chan_close(chan, reason); 381ab07801dSGustavo F. Padovan 3826be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 383ab07801dSGustavo F. Padovan 38480b98027SGustavo Padovan chan->ops->close(chan); 3853df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 3863df91ea2SAndrei Emeltchenko 387371fd835SUlisses Furquim l2cap_chan_put(chan); 388ab07801dSGustavo F. Padovan } 389ab07801dSGustavo F. Padovan 390eef1d9b6SGustavo Padovan struct l2cap_chan *l2cap_chan_create(void) 3910a708f8fSGustavo F. Padovan { 39248454079SGustavo F. Padovan struct l2cap_chan *chan; 3930a708f8fSGustavo F. Padovan 39448454079SGustavo F. Padovan chan = kzalloc(sizeof(*chan), GFP_ATOMIC); 39548454079SGustavo F. Padovan if (!chan) 39648454079SGustavo F. Padovan return NULL; 3970a708f8fSGustavo F. Padovan 398c03b355eSAndrei Emeltchenko mutex_init(&chan->lock); 399c03b355eSAndrei Emeltchenko 400333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 40123691d75SGustavo F. Padovan list_add(&chan->global_l, &chan_list); 402333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 40323691d75SGustavo F. Padovan 404721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout); 405ab07801dSGustavo F. Padovan 40689bc500eSGustavo F. Padovan chan->state = BT_OPEN; 40789bc500eSGustavo F. Padovan 40871ba0e56SGustavo F. Padovan atomic_set(&chan->refcnt, 1); 40971ba0e56SGustavo F. Padovan 4102827011fSMat Martineau /* This flag is cleared in l2cap_chan_ready() */ 4112827011fSMat Martineau set_bit(CONF_NOT_COMPLETE, &chan->conf_state); 4122827011fSMat Martineau 413eef1d9b6SGustavo Padovan BT_DBG("chan %p", chan); 414abc545b8SSzymon Janc 41548454079SGustavo F. Padovan return chan; 4160a708f8fSGustavo F. Padovan } 4170a708f8fSGustavo F. Padovan 41823691d75SGustavo F. Padovan void l2cap_chan_destroy(struct l2cap_chan *chan) 4196ff5abbfSGustavo F. Padovan { 420333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 42123691d75SGustavo F. Padovan list_del(&chan->global_l); 422333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 42323691d75SGustavo F. Padovan 424371fd835SUlisses Furquim l2cap_chan_put(chan); 4256ff5abbfSGustavo F. Padovan } 4266ff5abbfSGustavo F. Padovan 427bd4b1653SAndrei Emeltchenko void l2cap_chan_set_defaults(struct l2cap_chan *chan) 428bd4b1653SAndrei Emeltchenko { 429bd4b1653SAndrei Emeltchenko chan->fcs = L2CAP_FCS_CRC16; 430bd4b1653SAndrei Emeltchenko chan->max_tx = L2CAP_DEFAULT_MAX_TX; 431bd4b1653SAndrei Emeltchenko chan->tx_win = L2CAP_DEFAULT_TX_WINDOW; 432bd4b1653SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 433bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 434bd4b1653SAndrei Emeltchenko 435bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 436bd4b1653SAndrei Emeltchenko } 437bd4b1653SAndrei Emeltchenko 43814a28491SAndrei Emeltchenko static void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4390a708f8fSGustavo F. Padovan { 4400a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 441097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4420a708f8fSGustavo F. Padovan 4439f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 4440a708f8fSGustavo F. Padovan 4458c1d787bSGustavo F. Padovan chan->conn = conn; 4460a708f8fSGustavo F. Padovan 4475491120eSAndrei Emeltchenko switch (chan->chan_type) { 4485491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 449b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 450b62f328bSVille Tervo /* LE connection */ 4510c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_LE_DEFAULT_MTU; 452fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 453fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 454b62f328bSVille Tervo } else { 4550a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 456fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 4570c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 458b62f328bSVille Tervo } 4595491120eSAndrei Emeltchenko break; 4605491120eSAndrei Emeltchenko 4615491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 4620a708f8fSGustavo F. Padovan /* Connectionless socket */ 463fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 464fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 4650c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4665491120eSAndrei Emeltchenko break; 4675491120eSAndrei Emeltchenko 4685491120eSAndrei Emeltchenko default: 4690a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 470fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 471fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 4720c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4730a708f8fSGustavo F. Padovan } 4740a708f8fSGustavo F. Padovan 4758f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 4768f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 4778f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 4788f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 4798f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 4808f7975b1SAndrei Emeltchenko chan->local_flush_to = L2CAP_DEFAULT_FLUSH_TO; 4818f7975b1SAndrei Emeltchenko 482371fd835SUlisses Furquim l2cap_chan_hold(chan); 483baa7e1faSGustavo F. Padovan 4843df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 485643162a8SAndrei Emeltchenko } 486643162a8SAndrei Emeltchenko 487466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 488643162a8SAndrei Emeltchenko { 489643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 490643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 4913df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 4920a708f8fSGustavo F. Padovan } 4930a708f8fSGustavo F. Padovan 494466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 4950a708f8fSGustavo F. Padovan { 4968c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 4970a708f8fSGustavo F. Padovan 498c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 4990a708f8fSGustavo F. Padovan 50049208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5010a708f8fSGustavo F. Padovan 5020a708f8fSGustavo F. Padovan if (conn) { 503baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5043df91ea2SAndrei Emeltchenko list_del(&chan->list); 5053d57dc68SGustavo F. Padovan 506371fd835SUlisses Furquim l2cap_chan_put(chan); 507baa7e1faSGustavo F. Padovan 5088c1d787bSGustavo F. Padovan chan->conn = NULL; 5090a708f8fSGustavo F. Padovan hci_conn_put(conn->hcon); 5100a708f8fSGustavo F. Padovan } 5110a708f8fSGustavo F. Padovan 512c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 513c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5146be36555SAndrei Emeltchenko 5152827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5166ff5abbfSGustavo F. Padovan return; 5172ead70b8SGustavo F. Padovan 518ee556f66SGustavo Padovan switch(chan->mode) { 519ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 520ee556f66SGustavo Padovan break; 5210a708f8fSGustavo F. Padovan 522ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5231a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5241a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5251a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 5260a708f8fSGustavo F. Padovan 527f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 5280a708f8fSGustavo F. Padovan 5293c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 5303c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 531ee556f66SGustavo Padovan 532ee556f66SGustavo Padovan /* fall through */ 533ee556f66SGustavo Padovan 534ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 535ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 536ee556f66SGustavo Padovan break; 5370a708f8fSGustavo F. Padovan } 538ee556f66SGustavo Padovan 539ee556f66SGustavo Padovan return; 5400a708f8fSGustavo F. Padovan } 5410a708f8fSGustavo F. Padovan 5420f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 5434519de9aSGustavo F. Padovan { 5444519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5454519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 5464519de9aSGustavo F. Padovan 547e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s sk %p", chan, 548e05dcc32SAndrei Emeltchenko state_to_string(chan->state), sk); 5494519de9aSGustavo F. Padovan 55089bc500eSGustavo F. Padovan switch (chan->state) { 5514519de9aSGustavo F. Padovan case BT_LISTEN: 552c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 553c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 5544519de9aSGustavo F. Padovan break; 5554519de9aSGustavo F. Padovan 5564519de9aSGustavo F. Padovan case BT_CONNECTED: 5574519de9aSGustavo F. Padovan case BT_CONFIG: 558715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5594519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 560c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 5614519de9aSGustavo F. Padovan l2cap_send_disconn_req(conn, chan, reason); 5624519de9aSGustavo F. Padovan } else 5634519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5644519de9aSGustavo F. Padovan break; 5654519de9aSGustavo F. Padovan 5664519de9aSGustavo F. Padovan case BT_CONNECT2: 567715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5684519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 5694519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5704519de9aSGustavo F. Padovan __u16 result; 5714519de9aSGustavo F. Padovan 572c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 5734519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 5744519de9aSGustavo F. Padovan else 5754519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 57689bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 5774519de9aSGustavo F. Padovan 5784519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5794519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5804519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 581ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 5824519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5834519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 5844519de9aSGustavo F. Padovan } 5854519de9aSGustavo F. Padovan 5864519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5874519de9aSGustavo F. Padovan break; 5884519de9aSGustavo F. Padovan 5894519de9aSGustavo F. Padovan case BT_CONNECT: 5904519de9aSGustavo F. Padovan case BT_DISCONN: 5914519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5924519de9aSGustavo F. Padovan break; 5934519de9aSGustavo F. Padovan 5944519de9aSGustavo F. Padovan default: 595c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 596c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 5974519de9aSGustavo F. Padovan break; 5984519de9aSGustavo F. Padovan } 5994519de9aSGustavo F. Padovan } 6004519de9aSGustavo F. Padovan 6014343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6020a708f8fSGustavo F. Padovan { 603715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6044343478fSGustavo F. Padovan switch (chan->sec_level) { 6050a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6060a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6070a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6080a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6090a708f8fSGustavo F. Padovan default: 6100a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6110a708f8fSGustavo F. Padovan } 6122983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6134343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6144343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6150a708f8fSGustavo F. Padovan 6164343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6170a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6180a708f8fSGustavo F. Padovan else 6190a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6200a708f8fSGustavo F. Padovan } else { 6214343478fSGustavo F. Padovan switch (chan->sec_level) { 6220a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6230a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6240a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6250a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6260a708f8fSGustavo F. Padovan default: 6270a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6280a708f8fSGustavo F. Padovan } 6290a708f8fSGustavo F. Padovan } 6300a708f8fSGustavo F. Padovan } 6310a708f8fSGustavo F. Padovan 6320a708f8fSGustavo F. Padovan /* Service level security */ 633d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 6340a708f8fSGustavo F. Padovan { 6358c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6360a708f8fSGustavo F. Padovan __u8 auth_type; 6370a708f8fSGustavo F. Padovan 6384343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 6390a708f8fSGustavo F. Padovan 6404343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 6410a708f8fSGustavo F. Padovan } 6420a708f8fSGustavo F. Padovan 643b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 6440a708f8fSGustavo F. Padovan { 6450a708f8fSGustavo F. Padovan u8 id; 6460a708f8fSGustavo F. Padovan 6470a708f8fSGustavo F. Padovan /* Get next available identificator. 6480a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 6490a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 6500a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 6510a708f8fSGustavo F. Padovan */ 6520a708f8fSGustavo F. Padovan 653333055f2SGustavo F. Padovan spin_lock(&conn->lock); 6540a708f8fSGustavo F. Padovan 6550a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 6560a708f8fSGustavo F. Padovan conn->tx_ident = 1; 6570a708f8fSGustavo F. Padovan 6580a708f8fSGustavo F. Padovan id = conn->tx_ident; 6590a708f8fSGustavo F. Padovan 660333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 6610a708f8fSGustavo F. Padovan 6620a708f8fSGustavo F. Padovan return id; 6630a708f8fSGustavo F. Padovan } 6640a708f8fSGustavo F. Padovan 6654519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data) 6660a708f8fSGustavo F. Padovan { 6670a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 6680a708f8fSGustavo F. Padovan u8 flags; 6690a708f8fSGustavo F. Padovan 6700a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 6710a708f8fSGustavo F. Padovan 6720a708f8fSGustavo F. Padovan if (!skb) 6730a708f8fSGustavo F. Padovan return; 6740a708f8fSGustavo F. Padovan 6750a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 6760a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 6770a708f8fSGustavo F. Padovan else 6780a708f8fSGustavo F. Padovan flags = ACL_START; 6790a708f8fSGustavo F. Padovan 68014b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 6815e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 68214b12d0bSJaikumar Ganesh 68373d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 6840a708f8fSGustavo F. Padovan } 6850a708f8fSGustavo F. Padovan 68673d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 68773d80debSLuiz Augusto von Dentz { 68873d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 68973d80debSLuiz Augusto von Dentz u16 flags; 69073d80debSLuiz Augusto von Dentz 69173d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 69273d80debSLuiz Augusto von Dentz skb->priority); 69373d80debSLuiz Augusto von Dentz 69473d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 69573d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 69673d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 69773d80debSLuiz Augusto von Dentz else 69873d80debSLuiz Augusto von Dentz flags = ACL_START; 69973d80debSLuiz Augusto von Dentz 70073d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 70173d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7020a708f8fSGustavo F. Padovan } 7030a708f8fSGustavo F. Padovan 704b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 705b5c6aaedSMat Martineau { 706b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 707b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 708b5c6aaedSMat Martineau 709b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 710b5c6aaedSMat Martineau /* S-Frame */ 711b5c6aaedSMat Martineau control->sframe = 1; 712b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 713b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 714b5c6aaedSMat Martineau 715b5c6aaedSMat Martineau control->sar = 0; 716b5c6aaedSMat Martineau control->txseq = 0; 717b5c6aaedSMat Martineau } else { 718b5c6aaedSMat Martineau /* I-Frame */ 719b5c6aaedSMat Martineau control->sframe = 0; 720b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 721b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 722b5c6aaedSMat Martineau 723b5c6aaedSMat Martineau control->poll = 0; 724b5c6aaedSMat Martineau control->super = 0; 725b5c6aaedSMat Martineau } 726b5c6aaedSMat Martineau } 727b5c6aaedSMat Martineau 728b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 729b5c6aaedSMat Martineau { 730b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 731b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 732b5c6aaedSMat Martineau 733b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 734b5c6aaedSMat Martineau /* S-Frame */ 735b5c6aaedSMat Martineau control->sframe = 1; 736b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 737b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 738b5c6aaedSMat Martineau 739b5c6aaedSMat Martineau control->sar = 0; 740b5c6aaedSMat Martineau control->txseq = 0; 741b5c6aaedSMat Martineau } else { 742b5c6aaedSMat Martineau /* I-Frame */ 743b5c6aaedSMat Martineau control->sframe = 0; 744b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 745b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 746b5c6aaedSMat Martineau 747b5c6aaedSMat Martineau control->poll = 0; 748b5c6aaedSMat Martineau control->super = 0; 749b5c6aaedSMat Martineau } 750b5c6aaedSMat Martineau } 751b5c6aaedSMat Martineau 752b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 753b5c6aaedSMat Martineau struct sk_buff *skb) 754b5c6aaedSMat Martineau { 755b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 756b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 757b5c6aaedSMat Martineau &bt_cb(skb)->control); 758cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 759b5c6aaedSMat Martineau } else { 760b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 761b5c6aaedSMat Martineau &bt_cb(skb)->control); 762cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 763b5c6aaedSMat Martineau } 764b5c6aaedSMat Martineau } 765b5c6aaedSMat Martineau 766b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 767b5c6aaedSMat Martineau { 768b5c6aaedSMat Martineau u32 packed; 769b5c6aaedSMat Martineau 770b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 771b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 772b5c6aaedSMat Martineau 773b5c6aaedSMat Martineau if (control->sframe) { 774b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 775b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 776b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 777b5c6aaedSMat Martineau } else { 778b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 779b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 780b5c6aaedSMat Martineau } 781b5c6aaedSMat Martineau 782b5c6aaedSMat Martineau return packed; 783b5c6aaedSMat Martineau } 784b5c6aaedSMat Martineau 785b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 786b5c6aaedSMat Martineau { 787b5c6aaedSMat Martineau u16 packed; 788b5c6aaedSMat Martineau 789b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 790b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 791b5c6aaedSMat Martineau 792b5c6aaedSMat Martineau if (control->sframe) { 793b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 794b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 795b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 796b5c6aaedSMat Martineau } else { 797b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 798b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 799b5c6aaedSMat Martineau } 800b5c6aaedSMat Martineau 801b5c6aaedSMat Martineau return packed; 802b5c6aaedSMat Martineau } 803b5c6aaedSMat Martineau 804b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 805b5c6aaedSMat Martineau struct l2cap_ctrl *control, 806b5c6aaedSMat Martineau struct sk_buff *skb) 807b5c6aaedSMat Martineau { 808b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 809b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 810b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 811b5c6aaedSMat Martineau } else { 812b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 813b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 814b5c6aaedSMat Martineau } 815b5c6aaedSMat Martineau } 816b5c6aaedSMat Martineau 817a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 818a67d7f6fSMat Martineau u32 control) 8190a708f8fSGustavo F. Padovan { 8200a708f8fSGustavo F. Padovan struct sk_buff *skb; 8210a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 822a67d7f6fSMat Martineau int hlen; 8230a708f8fSGustavo F. Padovan 824e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 825e4ca6d98SAndrei Emeltchenko hlen = L2CAP_EXT_HDR_SIZE; 826e4ca6d98SAndrei Emeltchenko else 827e4ca6d98SAndrei Emeltchenko hlen = L2CAP_ENH_HDR_SIZE; 8280a708f8fSGustavo F. Padovan 8290a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 83003a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 8310a708f8fSGustavo F. Padovan 832a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 8330a708f8fSGustavo F. Padovan 8340a708f8fSGustavo F. Padovan if (!skb) 835a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 8360a708f8fSGustavo F. Padovan 8370a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 8380a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 839fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 84088843ab0SAndrei Emeltchenko 841a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 842a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 843a67d7f6fSMat Martineau else 844a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 8450a708f8fSGustavo F. Padovan 84647d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 847a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 84803a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 8490a708f8fSGustavo F. Padovan } 8500a708f8fSGustavo F. Padovan 85173d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 852a67d7f6fSMat Martineau return skb; 853a67d7f6fSMat Martineau } 854a67d7f6fSMat Martineau 855a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 856a67d7f6fSMat Martineau struct l2cap_ctrl *control) 857a67d7f6fSMat Martineau { 858a67d7f6fSMat Martineau struct sk_buff *skb; 859a67d7f6fSMat Martineau u32 control_field; 860a67d7f6fSMat Martineau 861a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 862a67d7f6fSMat Martineau 863a67d7f6fSMat Martineau if (!control->sframe) 864a67d7f6fSMat Martineau return; 865a67d7f6fSMat Martineau 866a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 867a67d7f6fSMat Martineau !control->poll) 868a67d7f6fSMat Martineau control->final = 1; 869a67d7f6fSMat Martineau 870a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 871a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 872a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 873a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 874a67d7f6fSMat Martineau 875a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 876a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 877a67d7f6fSMat Martineau __clear_ack_timer(chan); 878a67d7f6fSMat Martineau } 879a67d7f6fSMat Martineau 880a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 881a67d7f6fSMat Martineau control->final, control->poll, control->super); 882a67d7f6fSMat Martineau 883a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 884a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 885a67d7f6fSMat Martineau else 886a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 887a67d7f6fSMat Martineau 888a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 889a67d7f6fSMat Martineau if (!IS_ERR(skb)) 89073d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 8910a708f8fSGustavo F. Padovan } 8920a708f8fSGustavo F. Padovan 893c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 8940a708f8fSGustavo F. Padovan { 895c9e3d5e0SMat Martineau struct l2cap_ctrl control; 8960a708f8fSGustavo F. Padovan 897c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 898c9e3d5e0SMat Martineau 899c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 900c9e3d5e0SMat Martineau control.sframe = 1; 901c9e3d5e0SMat Martineau control.poll = poll; 902c9e3d5e0SMat Martineau 903c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 904c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 905c9e3d5e0SMat Martineau else 906c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 907c9e3d5e0SMat Martineau 908c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 909c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 9100a708f8fSGustavo F. Padovan } 9110a708f8fSGustavo F. Padovan 912b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 9130a708f8fSGustavo F. Padovan { 914c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 9150a708f8fSGustavo F. Padovan } 9160a708f8fSGustavo F. Padovan 9179b27f350SAndrei Emeltchenko static void l2cap_send_conn_req(struct l2cap_chan *chan) 9189b27f350SAndrei Emeltchenko { 9199b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 9209b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 9219b27f350SAndrei Emeltchenko 9229b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 9239b27f350SAndrei Emeltchenko req.psm = chan->psm; 9249b27f350SAndrei Emeltchenko 9259b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 9269b27f350SAndrei Emeltchenko 9279b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 9289b27f350SAndrei Emeltchenko 9299b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 9309b27f350SAndrei Emeltchenko } 9319b27f350SAndrei Emeltchenko 9329f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 9339f0caeb1SVinicius Costa Gomes { 9342827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 9359f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 9369f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 9379f0caeb1SVinicius Costa Gomes 93854a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 9399f0caeb1SVinicius Costa Gomes 94054a59aa2SAndrei Emeltchenko if (chan->ops->ready) 94154a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 9429f0caeb1SVinicius Costa Gomes } 9439f0caeb1SVinicius Costa Gomes 944fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 9450a708f8fSGustavo F. Padovan { 9468c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 9470a708f8fSGustavo F. Padovan 9489f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 9499f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 9509f0caeb1SVinicius Costa Gomes return; 9519f0caeb1SVinicius Costa Gomes } 9529f0caeb1SVinicius Costa Gomes 9530a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 9540a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 9550a708f8fSGustavo F. Padovan return; 9560a708f8fSGustavo F. Padovan 957d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 9589b27f350SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) 9599b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 9600a708f8fSGustavo F. Padovan } else { 9610a708f8fSGustavo F. Padovan struct l2cap_info_req req; 962ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 9630a708f8fSGustavo F. Padovan 9640a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 9650a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 9660a708f8fSGustavo F. Padovan 967ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 9680a708f8fSGustavo F. Padovan 9690a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 9700a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 9710a708f8fSGustavo F. Padovan } 9720a708f8fSGustavo F. Padovan } 9730a708f8fSGustavo F. Padovan 9740a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 9750a708f8fSGustavo F. Padovan { 9760a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 9770a708f8fSGustavo F. Padovan if (!disable_ertm) 9780a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 9790a708f8fSGustavo F. Padovan 9800a708f8fSGustavo F. Padovan switch (mode) { 9810a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 9820a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 9830a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 9840a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 9850a708f8fSGustavo F. Padovan default: 9860a708f8fSGustavo F. Padovan return 0x00; 9870a708f8fSGustavo F. Padovan } 9880a708f8fSGustavo F. Padovan } 9890a708f8fSGustavo F. Padovan 9904519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err) 9910a708f8fSGustavo F. Padovan { 9926be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 9930a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 9940a708f8fSGustavo F. Padovan 9950a708f8fSGustavo F. Padovan if (!conn) 9960a708f8fSGustavo F. Padovan return; 9970a708f8fSGustavo F. Padovan 9980c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_ERTM) { 9991a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 10001a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 10011a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 10020a708f8fSGustavo F. Padovan } 10030a708f8fSGustavo F. Padovan 1004fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1005fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 10060a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 10070a708f8fSGustavo F. Padovan L2CAP_DISCONN_REQ, sizeof(req), &req); 10080a708f8fSGustavo F. Padovan 10096be36555SAndrei Emeltchenko lock_sock(sk); 10100e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 10112e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 10126be36555SAndrei Emeltchenko release_sock(sk); 10130a708f8fSGustavo F. Padovan } 10140a708f8fSGustavo F. Padovan 10150a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 10160a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 10170a708f8fSGustavo F. Padovan { 10183df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 10190a708f8fSGustavo F. Padovan 10200a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 10210a708f8fSGustavo F. Padovan 10223df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 10230a708f8fSGustavo F. Padovan 10243df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 102548454079SGustavo F. Padovan struct sock *sk = chan->sk; 1026baa7e1faSGustavo F. Padovan 10276be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 10280a708f8fSGustavo F. Padovan 1029715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 10306be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10310a708f8fSGustavo F. Padovan continue; 10320a708f8fSGustavo F. Padovan } 10330a708f8fSGustavo F. Padovan 103489bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1035d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1036b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 10376be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10380a708f8fSGustavo F. Padovan continue; 10390a708f8fSGustavo F. Padovan } 10400a708f8fSGustavo F. Padovan 1041c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1042c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1043c1360a1cSGustavo F. Padovan &chan->conf_state)) { 10440f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 10456be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10460a708f8fSGustavo F. Padovan continue; 10470a708f8fSGustavo F. Padovan } 10480a708f8fSGustavo F. Padovan 10499b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 10500a708f8fSGustavo F. Padovan 105189bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 10520a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 10530a708f8fSGustavo F. Padovan char buf[128]; 1054fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1055fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 10560a708f8fSGustavo F. Padovan 1057d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 10586be36555SAndrei Emeltchenko lock_sock(sk); 1059c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1060c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 10610a708f8fSGustavo F. Padovan struct sock *parent = bt_sk(sk)->parent; 1062ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1063ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 106405e9a2f6SIlia Kolomisnky if (parent) 10650a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 10660a708f8fSGustavo F. Padovan 10670a708f8fSGustavo F. Padovan } else { 10680e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1069ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1070ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 10710a708f8fSGustavo F. Padovan } 10726be36555SAndrei Emeltchenko release_sock(sk); 10730a708f8fSGustavo F. Padovan } else { 1074ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1075ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 10760a708f8fSGustavo F. Padovan } 10770a708f8fSGustavo F. Padovan 1078fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1079fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 10800a708f8fSGustavo F. Padovan 1081c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 10820a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 10836be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10840a708f8fSGustavo F. Padovan continue; 10850a708f8fSGustavo F. Padovan } 10860a708f8fSGustavo F. Padovan 1087c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 10880a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 108973ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 109073ffa904SGustavo F. Padovan chan->num_conf_req++; 10910a708f8fSGustavo F. Padovan } 10920a708f8fSGustavo F. Padovan 10936be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10940a708f8fSGustavo F. Padovan } 10950a708f8fSGustavo F. Padovan 10963df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 10970a708f8fSGustavo F. Padovan } 10980a708f8fSGustavo F. Padovan 1099c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1100b62f328bSVille Tervo * Returns closest match, locked. 1101b62f328bSVille Tervo */ 1102d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1103c2287681SIdo Yariv bdaddr_t *src, 1104c2287681SIdo Yariv bdaddr_t *dst) 1105b62f328bSVille Tervo { 110623691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1107b62f328bSVille Tervo 110823691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1109b62f328bSVille Tervo 111023691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 111123691d75SGustavo F. Padovan struct sock *sk = c->sk; 1112fe4128e0SGustavo F. Padovan 111389bc500eSGustavo F. Padovan if (state && c->state != state) 1114b62f328bSVille Tervo continue; 1115b62f328bSVille Tervo 111623691d75SGustavo F. Padovan if (c->scid == cid) { 1117c2287681SIdo Yariv int src_match, dst_match; 1118c2287681SIdo Yariv int src_any, dst_any; 1119c2287681SIdo Yariv 1120b62f328bSVille Tervo /* Exact match. */ 1121c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1122c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1123c2287681SIdo Yariv if (src_match && dst_match) { 112423691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 112523691d75SGustavo F. Padovan return c; 112623691d75SGustavo F. Padovan } 1127b62f328bSVille Tervo 1128b62f328bSVille Tervo /* Closest match */ 1129c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1130c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1131c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1132c2287681SIdo Yariv (src_any && dst_any)) 113323691d75SGustavo F. Padovan c1 = c; 1134b62f328bSVille Tervo } 1135b62f328bSVille Tervo } 1136280f294fSGustavo F. Padovan 113723691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1138b62f328bSVille Tervo 113923691d75SGustavo F. Padovan return c1; 1140b62f328bSVille Tervo } 1141b62f328bSVille Tervo 1142b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1143b62f328bSVille Tervo { 1144c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 114523691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1146b62f328bSVille Tervo 1147b62f328bSVille Tervo BT_DBG(""); 1148b62f328bSVille Tervo 1149b62f328bSVille Tervo /* Check if we have socket listening on cid */ 115023691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1151c2287681SIdo Yariv conn->src, conn->dst); 115223691d75SGustavo F. Padovan if (!pchan) 1153b62f328bSVille Tervo return; 1154b62f328bSVille Tervo 115523691d75SGustavo F. Padovan parent = pchan->sk; 115623691d75SGustavo F. Padovan 1157aa2ac881SGustavo F. Padovan lock_sock(parent); 115862f3a2cfSGustavo F. Padovan 115980b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 116080808e43SGustavo F. Padovan if (!chan) 1161b62f328bSVille Tervo goto clean; 1162b62f328bSVille Tervo 116380808e43SGustavo F. Padovan sk = chan->sk; 11645d41ce1dSGustavo F. Padovan 1165b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1166b62f328bSVille Tervo 1167b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1168b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1169b62f328bSVille Tervo 1170d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 1171d1010240SGustavo F. Padovan 11723d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 117348454079SGustavo F. Padovan 11746754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1175b62f328bSVille Tervo 1176b62f328bSVille Tervo clean: 1177aa2ac881SGustavo F. Padovan release_sock(parent); 1178b62f328bSVille Tervo } 1179b62f328bSVille Tervo 11800a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 11810a708f8fSGustavo F. Padovan { 118248454079SGustavo F. Padovan struct l2cap_chan *chan; 11830a708f8fSGustavo F. Padovan 11840a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 11850a708f8fSGustavo F. Padovan 1186b62f328bSVille Tervo if (!conn->hcon->out && conn->hcon->type == LE_LINK) 1187b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1188b62f328bSVille Tervo 1189160dc6acSVinicius Costa Gomes if (conn->hcon->out && conn->hcon->type == LE_LINK) 1190160dc6acSVinicius Costa Gomes smp_conn_security(conn, conn->hcon->pending_sec_level); 1191160dc6acSVinicius Costa Gomes 11923df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 11930a708f8fSGustavo F. Padovan 11943df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1195baa7e1faSGustavo F. Padovan 11966be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 11970a708f8fSGustavo F. Padovan 119863128451SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 1199b501d6a1SAnderson Briglia if (smp_conn_security(conn, chan->sec_level)) 1200cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1201acd7d370SVille Tervo 120263128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12036be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1204c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 12056be36555SAndrei Emeltchenko lock_sock(sk); 12060e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 12070a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 12086be36555SAndrei Emeltchenko release_sock(sk); 1209b501d6a1SAnderson Briglia 121089bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1211fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 12120a708f8fSGustavo F. Padovan 12136be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12140a708f8fSGustavo F. Padovan } 12150a708f8fSGustavo F. Padovan 12163df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12170a708f8fSGustavo F. Padovan } 12180a708f8fSGustavo F. Padovan 12190a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 12200a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 12210a708f8fSGustavo F. Padovan { 122248454079SGustavo F. Padovan struct l2cap_chan *chan; 12230a708f8fSGustavo F. Padovan 12240a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12250a708f8fSGustavo F. Padovan 12263df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12270a708f8fSGustavo F. Padovan 12283df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1229ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 12302e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 12310a708f8fSGustavo F. Padovan } 12320a708f8fSGustavo F. Padovan 12333df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12340a708f8fSGustavo F. Padovan } 12350a708f8fSGustavo F. Padovan 1236f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 12370a708f8fSGustavo F. Padovan { 1238f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1239030013d8SGustavo F. Padovan info_timer.work); 12400a708f8fSGustavo F. Padovan 12410a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 12420a708f8fSGustavo F. Padovan conn->info_ident = 0; 12430a708f8fSGustavo F. Padovan 12440a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 12450a708f8fSGustavo F. Padovan } 12460a708f8fSGustavo F. Padovan 12475d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 12485d3de7dfSVinicius Costa Gomes { 12495d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 12505d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 12515d3de7dfSVinicius Costa Gomes 12525d3de7dfSVinicius Costa Gomes if (!conn) 12535d3de7dfSVinicius Costa Gomes return; 12545d3de7dfSVinicius Costa Gomes 12555d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 12565d3de7dfSVinicius Costa Gomes 12575d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 12585d3de7dfSVinicius Costa Gomes 12593df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12603df91ea2SAndrei Emeltchenko 12615d3de7dfSVinicius Costa Gomes /* Kill channels */ 12625d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 126361d6ef3eSMat Martineau l2cap_chan_hold(chan); 12646be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12656be36555SAndrei Emeltchenko 12665d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 12676be36555SAndrei Emeltchenko 12686be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12696be36555SAndrei Emeltchenko 127080b98027SGustavo Padovan chan->ops->close(chan); 127161d6ef3eSMat Martineau l2cap_chan_put(chan); 12725d3de7dfSVinicius Costa Gomes } 12735d3de7dfSVinicius Costa Gomes 12743df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12753df91ea2SAndrei Emeltchenko 127673d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 127773d80debSLuiz Augusto von Dentz 12785d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1279127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 12805d3de7dfSVinicius Costa Gomes 128151a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1282127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 12838aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1284d26a2345SVinicius Costa Gomes } 12855d3de7dfSVinicius Costa Gomes 12865d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 12875d3de7dfSVinicius Costa Gomes kfree(conn); 12885d3de7dfSVinicius Costa Gomes } 12895d3de7dfSVinicius Costa Gomes 12906c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 12915d3de7dfSVinicius Costa Gomes { 12926c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 12936c9d42a1SGustavo F. Padovan security_timer.work); 12945d3de7dfSVinicius Costa Gomes 12955d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 12965d3de7dfSVinicius Costa Gomes } 12975d3de7dfSVinicius Costa Gomes 12980a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 12990a708f8fSGustavo F. Padovan { 13000a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 130173d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 13020a708f8fSGustavo F. Padovan 13030a708f8fSGustavo F. Padovan if (conn || status) 13040a708f8fSGustavo F. Padovan return conn; 13050a708f8fSGustavo F. Padovan 130673d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 130773d80debSLuiz Augusto von Dentz if (!hchan) 13080a708f8fSGustavo F. Padovan return NULL; 13090a708f8fSGustavo F. Padovan 131073d80debSLuiz Augusto von Dentz conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC); 131173d80debSLuiz Augusto von Dentz if (!conn) { 131273d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 131373d80debSLuiz Augusto von Dentz return NULL; 131473d80debSLuiz Augusto von Dentz } 131573d80debSLuiz Augusto von Dentz 13160a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 13170a708f8fSGustavo F. Padovan conn->hcon = hcon; 131873d80debSLuiz Augusto von Dentz conn->hchan = hchan; 13190a708f8fSGustavo F. Padovan 132073d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 13210a708f8fSGustavo F. Padovan 1322acd7d370SVille Tervo if (hcon->hdev->le_mtu && hcon->type == LE_LINK) 1323acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1324acd7d370SVille Tervo else 13250a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1326acd7d370SVille Tervo 13270a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 13280a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 13290a708f8fSGustavo F. Padovan 13300a708f8fSGustavo F. Padovan conn->feat_mask = 0; 13310a708f8fSGustavo F. Padovan 13320a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 13333df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1334baa7e1faSGustavo F. Padovan 1335baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 13360a708f8fSGustavo F. Padovan 13375d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 13386c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 13395d3de7dfSVinicius Costa Gomes else 1340030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 13410a708f8fSGustavo F. Padovan 13429f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 13430a708f8fSGustavo F. Padovan 13440a708f8fSGustavo F. Padovan return conn; 13450a708f8fSGustavo F. Padovan } 13460a708f8fSGustavo F. Padovan 13470a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 13480a708f8fSGustavo F. Padovan 1349c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 13500a708f8fSGustavo F. Padovan * Returns closest match. 13510a708f8fSGustavo F. Padovan */ 1352c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1353c2287681SIdo Yariv bdaddr_t *src, 1354c2287681SIdo Yariv bdaddr_t *dst) 13550a708f8fSGustavo F. Padovan { 135623691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 13570a708f8fSGustavo F. Padovan 135823691d75SGustavo F. Padovan read_lock(&chan_list_lock); 13590a708f8fSGustavo F. Padovan 136023691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 136123691d75SGustavo F. Padovan struct sock *sk = c->sk; 1362fe4128e0SGustavo F. Padovan 136389bc500eSGustavo F. Padovan if (state && c->state != state) 13640a708f8fSGustavo F. Padovan continue; 13650a708f8fSGustavo F. Padovan 136623691d75SGustavo F. Padovan if (c->psm == psm) { 1367c2287681SIdo Yariv int src_match, dst_match; 1368c2287681SIdo Yariv int src_any, dst_any; 1369c2287681SIdo Yariv 13700a708f8fSGustavo F. Padovan /* Exact match. */ 1371c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1372c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1373c2287681SIdo Yariv if (src_match && dst_match) { 1374a7567b20SJohannes Berg read_unlock(&chan_list_lock); 137523691d75SGustavo F. Padovan return c; 137623691d75SGustavo F. Padovan } 13770a708f8fSGustavo F. Padovan 13780a708f8fSGustavo F. Padovan /* Closest match */ 1379c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1380c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1381c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1382c2287681SIdo Yariv (src_any && dst_any)) 138323691d75SGustavo F. Padovan c1 = c; 13840a708f8fSGustavo F. Padovan } 13850a708f8fSGustavo F. Padovan } 13860a708f8fSGustavo F. Padovan 138723691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 13880a708f8fSGustavo F. Padovan 138923691d75SGustavo F. Padovan return c1; 13900a708f8fSGustavo F. Padovan } 13910a708f8fSGustavo F. Padovan 13928e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 13938e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 13940a708f8fSGustavo F. Padovan { 13955d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 13960a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 13970a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 13980a708f8fSGustavo F. Padovan struct hci_conn *hcon; 13990a708f8fSGustavo F. Padovan struct hci_dev *hdev; 14000a708f8fSGustavo F. Padovan __u8 auth_type; 14010a708f8fSGustavo F. Padovan int err; 14020a708f8fSGustavo F. Padovan 14038e9f9892SAndre Guedes BT_DBG("%s -> %s (type %u) psm 0x%2.2x", batostr(src), batostr(dst), 14048e9f9892SAndre Guedes dst_type, __le16_to_cpu(chan->psm)); 14050a708f8fSGustavo F. Padovan 14060a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 14070a708f8fSGustavo F. Padovan if (!hdev) 14080a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 14090a708f8fSGustavo F. Padovan 141009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14110a708f8fSGustavo F. Padovan 14126be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 141303a00194SGustavo F. Padovan 141403a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 141503a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 141603a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 141703a00194SGustavo F. Padovan err = -EINVAL; 141803a00194SGustavo F. Padovan goto done; 141903a00194SGustavo F. Padovan } 142003a00194SGustavo F. Padovan 142103a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 142203a00194SGustavo F. Padovan err = -EINVAL; 142303a00194SGustavo F. Padovan goto done; 142403a00194SGustavo F. Padovan } 142503a00194SGustavo F. Padovan 142603a00194SGustavo F. Padovan switch (chan->mode) { 142703a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 142803a00194SGustavo F. Padovan break; 142903a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 143003a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 143103a00194SGustavo F. Padovan if (!disable_ertm) 143203a00194SGustavo F. Padovan break; 143303a00194SGustavo F. Padovan /* fall through */ 143403a00194SGustavo F. Padovan default: 143503a00194SGustavo F. Padovan err = -ENOTSUPP; 143603a00194SGustavo F. Padovan goto done; 143703a00194SGustavo F. Padovan } 143803a00194SGustavo F. Padovan 14390797e01dSGustavo Padovan switch (chan->state) { 144003a00194SGustavo F. Padovan case BT_CONNECT: 144103a00194SGustavo F. Padovan case BT_CONNECT2: 144203a00194SGustavo F. Padovan case BT_CONFIG: 144303a00194SGustavo F. Padovan /* Already connecting */ 144403a00194SGustavo F. Padovan err = 0; 144503a00194SGustavo F. Padovan goto done; 144603a00194SGustavo F. Padovan 144703a00194SGustavo F. Padovan case BT_CONNECTED: 144803a00194SGustavo F. Padovan /* Already connected */ 144903a00194SGustavo F. Padovan err = -EISCONN; 145003a00194SGustavo F. Padovan goto done; 145103a00194SGustavo F. Padovan 145203a00194SGustavo F. Padovan case BT_OPEN: 145303a00194SGustavo F. Padovan case BT_BOUND: 145403a00194SGustavo F. Padovan /* Can connect */ 145503a00194SGustavo F. Padovan break; 145603a00194SGustavo F. Padovan 145703a00194SGustavo F. Padovan default: 145803a00194SGustavo F. Padovan err = -EBADFD; 145903a00194SGustavo F. Padovan goto done; 146003a00194SGustavo F. Padovan } 146103a00194SGustavo F. Padovan 146203a00194SGustavo F. Padovan /* Set destination address and psm */ 14630797e01dSGustavo Padovan lock_sock(sk); 14649219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 14656be36555SAndrei Emeltchenko release_sock(sk); 14666be36555SAndrei Emeltchenko 146703a00194SGustavo F. Padovan chan->psm = psm; 146803a00194SGustavo F. Padovan chan->dcid = cid; 14690a708f8fSGustavo F. Padovan 14704343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 14710a708f8fSGustavo F. Padovan 1472fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 14738e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 14744343478fSGustavo F. Padovan chan->sec_level, auth_type); 1475acd7d370SVille Tervo else 14768e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 14774343478fSGustavo F. Padovan chan->sec_level, auth_type); 1478acd7d370SVille Tervo 147930e76272SVille Tervo if (IS_ERR(hcon)) { 148030e76272SVille Tervo err = PTR_ERR(hcon); 14810a708f8fSGustavo F. Padovan goto done; 148230e76272SVille Tervo } 14830a708f8fSGustavo F. Padovan 14840a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 14850a708f8fSGustavo F. Padovan if (!conn) { 14860a708f8fSGustavo F. Padovan hci_conn_put(hcon); 148730e76272SVille Tervo err = -ENOMEM; 14880a708f8fSGustavo F. Padovan goto done; 14890a708f8fSGustavo F. Padovan } 14900a708f8fSGustavo F. Padovan 14919f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 14929f0caeb1SVinicius Costa Gomes err = 0; 14939f0caeb1SVinicius Costa Gomes 14949f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 14959f0caeb1SVinicius Costa Gomes err = -EBUSY; 14969f0caeb1SVinicius Costa Gomes hci_conn_put(hcon); 14979f0caeb1SVinicius Costa Gomes } 14989f0caeb1SVinicius Costa Gomes 14999f0caeb1SVinicius Costa Gomes if (err) 15009f0caeb1SVinicius Costa Gomes goto done; 15019f0caeb1SVinicius Costa Gomes } 15029f0caeb1SVinicius Costa Gomes 15030a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 15040a708f8fSGustavo F. Padovan bacpy(src, conn->src); 15050a708f8fSGustavo F. Padovan 15066be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 150748454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 15086be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 150948454079SGustavo F. Padovan 15106be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1511c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 15120a708f8fSGustavo F. Padovan 15130a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1514715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1515c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1516d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 15176be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 15180a708f8fSGustavo F. Padovan } else 1519fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 15200a708f8fSGustavo F. Padovan } 15210a708f8fSGustavo F. Padovan 152230e76272SVille Tervo err = 0; 152330e76272SVille Tervo 15240a708f8fSGustavo F. Padovan done: 15256be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 152609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15270a708f8fSGustavo F. Padovan hci_dev_put(hdev); 15280a708f8fSGustavo F. Padovan return err; 15290a708f8fSGustavo F. Padovan } 15300a708f8fSGustavo F. Padovan 1531dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 15320a708f8fSGustavo F. Padovan { 15338c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 15340a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 15350a708f8fSGustavo F. Padovan int err = 0; 15360a708f8fSGustavo F. Padovan int timeo = HZ/5; 15370a708f8fSGustavo F. Padovan 15380a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 15390a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1540a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 15410a708f8fSGustavo F. Padovan if (!timeo) 15420a708f8fSGustavo F. Padovan timeo = HZ/5; 15430a708f8fSGustavo F. Padovan 15440a708f8fSGustavo F. Padovan if (signal_pending(current)) { 15450a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 15460a708f8fSGustavo F. Padovan break; 15470a708f8fSGustavo F. Padovan } 15480a708f8fSGustavo F. Padovan 15490a708f8fSGustavo F. Padovan release_sock(sk); 15500a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 15510a708f8fSGustavo F. Padovan lock_sock(sk); 1552a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 15530a708f8fSGustavo F. Padovan 15540a708f8fSGustavo F. Padovan err = sock_error(sk); 15550a708f8fSGustavo F. Padovan if (err) 15560a708f8fSGustavo F. Padovan break; 15570a708f8fSGustavo F. Padovan } 15580a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 15590a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 15600a708f8fSGustavo F. Padovan return err; 15610a708f8fSGustavo F. Padovan } 15620a708f8fSGustavo F. Padovan 1563721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 15640a708f8fSGustavo F. Padovan { 1565721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1566721c4181SGustavo F. Padovan monitor_timer.work); 15670a708f8fSGustavo F. Padovan 1568525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 15690a708f8fSGustavo F. Padovan 15706be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 15716be36555SAndrei Emeltchenko 157280909e04SMat Martineau if (!chan->conn) { 15736be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 15748d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 15750a708f8fSGustavo F. Padovan return; 15760a708f8fSGustavo F. Padovan } 15770a708f8fSGustavo F. Padovan 1578401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 15790a708f8fSGustavo F. Padovan 15806be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 15818d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 15820a708f8fSGustavo F. Padovan } 15830a708f8fSGustavo F. Padovan 1584721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 15850a708f8fSGustavo F. Padovan { 1586721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1587721c4181SGustavo F. Padovan retrans_timer.work); 15880a708f8fSGustavo F. Padovan 158949208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 15900a708f8fSGustavo F. Padovan 15916be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 15926be36555SAndrei Emeltchenko 159380909e04SMat Martineau if (!chan->conn) { 159480909e04SMat Martineau l2cap_chan_unlock(chan); 159580909e04SMat Martineau l2cap_chan_put(chan); 159680909e04SMat Martineau return; 159780909e04SMat Martineau } 15980a708f8fSGustavo F. Padovan 1599401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 16006be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16018d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16020a708f8fSGustavo F. Padovan } 16030a708f8fSGustavo F. Padovan 1604d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 16053733937dSMat Martineau struct sk_buff_head *skbs) 16060a708f8fSGustavo F. Padovan { 16070a708f8fSGustavo F. Padovan struct sk_buff *skb; 16083733937dSMat Martineau struct l2cap_ctrl *control; 16090a708f8fSGustavo F. Padovan 16103733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 16113733937dSMat Martineau 16123733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 16133733937dSMat Martineau 16143733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 16153733937dSMat Martineau 16163733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 16173733937dSMat Martineau 16183733937dSMat Martineau bt_cb(skb)->control.retries = 1; 16193733937dSMat Martineau control = &bt_cb(skb)->control; 16203733937dSMat Martineau 16213733937dSMat Martineau control->reqseq = 0; 16223733937dSMat Martineau control->txseq = chan->next_tx_seq; 16233733937dSMat Martineau 16243733937dSMat Martineau __pack_control(chan, control, skb); 16250a708f8fSGustavo F. Padovan 162647d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 16273733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 16283733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 16290a708f8fSGustavo F. Padovan } 16300a708f8fSGustavo F. Padovan 16314343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 16320a708f8fSGustavo F. Padovan 16333733937dSMat Martineau BT_DBG("Sent txseq %d", (int)control->txseq); 16343733937dSMat Martineau 1635836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 16363733937dSMat Martineau chan->frames_sent++; 16370a708f8fSGustavo F. Padovan } 16380a708f8fSGustavo F. Padovan } 16390a708f8fSGustavo F. Padovan 164067c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 16410a708f8fSGustavo F. Padovan { 16420a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 164318a48e76SMat Martineau struct l2cap_ctrl *control; 164418a48e76SMat Martineau int sent = 0; 164518a48e76SMat Martineau 164618a48e76SMat Martineau BT_DBG("chan %p", chan); 16470a708f8fSGustavo F. Padovan 164889bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 16490a708f8fSGustavo F. Padovan return -ENOTCONN; 16500a708f8fSGustavo F. Padovan 165194122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 165294122bbeSMat Martineau return 0; 165394122bbeSMat Martineau 165418a48e76SMat Martineau while (chan->tx_send_head && 165518a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 165618a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 16570a708f8fSGustavo F. Padovan 165818a48e76SMat Martineau skb = chan->tx_send_head; 16590a708f8fSGustavo F. Padovan 166018a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 166118a48e76SMat Martineau control = &bt_cb(skb)->control; 16620a708f8fSGustavo F. Padovan 1663e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 166418a48e76SMat Martineau control->final = 1; 1665e2ab4353SGustavo F. Padovan 166618a48e76SMat Martineau control->reqseq = chan->buffer_seq; 166718a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 166818a48e76SMat Martineau control->txseq = chan->next_tx_seq; 16690a708f8fSGustavo F. Padovan 167018a48e76SMat Martineau __pack_control(chan, control, skb); 16710a708f8fSGustavo F. Padovan 167247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 167318a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 167418a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 16750a708f8fSGustavo F. Padovan } 16760a708f8fSGustavo F. Padovan 167718a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 167818a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 167918a48e76SMat Martineau */ 168018a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 168118a48e76SMat Martineau 168218a48e76SMat Martineau if (!tx_skb) 168318a48e76SMat Martineau break; 16840a708f8fSGustavo F. Padovan 16851a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 16860a708f8fSGustavo F. Padovan 1687836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 16886a026610SGustavo F. Padovan chan->unacked_frames++; 16896a026610SGustavo F. Padovan chan->frames_sent++; 169018a48e76SMat Martineau sent++; 16910a708f8fSGustavo F. Padovan 169258d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 169358d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 16940a708f8fSGustavo F. Padovan else 169558d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 169618a48e76SMat Martineau 169718a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 169818a48e76SMat Martineau BT_DBG("Sent txseq %d", (int)control->txseq); 16990a708f8fSGustavo F. Padovan } 17000a708f8fSGustavo F. Padovan 170118a48e76SMat Martineau BT_DBG("Sent %d, %d unacked, %d in ERTM queue", sent, 170218a48e76SMat Martineau (int) chan->unacked_frames, skb_queue_len(&chan->tx_q)); 170318a48e76SMat Martineau 170418a48e76SMat Martineau return sent; 17050a708f8fSGustavo F. Padovan } 17060a708f8fSGustavo F. Padovan 1707e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1708e1fbd4c1SMat Martineau { 1709e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1710e1fbd4c1SMat Martineau struct sk_buff *skb; 1711e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1712e1fbd4c1SMat Martineau u16 seq; 1713e1fbd4c1SMat Martineau 1714e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1715e1fbd4c1SMat Martineau 1716e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1717e1fbd4c1SMat Martineau return; 1718e1fbd4c1SMat Martineau 1719e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1720e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1721e1fbd4c1SMat Martineau 1722e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1723e1fbd4c1SMat Martineau if (!skb) { 1724e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1725e1fbd4c1SMat Martineau seq); 1726e1fbd4c1SMat Martineau continue; 1727e1fbd4c1SMat Martineau } 1728e1fbd4c1SMat Martineau 1729e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1730e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1731e1fbd4c1SMat Martineau 1732e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1733e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1734e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 1735e1fbd4c1SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 1736e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1737e1fbd4c1SMat Martineau break; 1738e1fbd4c1SMat Martineau } 1739e1fbd4c1SMat Martineau 1740e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1741e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1742e1fbd4c1SMat Martineau control.final = 1; 1743e1fbd4c1SMat Martineau else 1744e1fbd4c1SMat Martineau control.final = 0; 1745e1fbd4c1SMat Martineau 1746e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1747e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1748e1fbd4c1SMat Martineau * writeable copy 1749e1fbd4c1SMat Martineau */ 1750e1fbd4c1SMat Martineau tx_skb = skb_copy(skb, GFP_ATOMIC); 1751e1fbd4c1SMat Martineau } else { 1752e1fbd4c1SMat Martineau tx_skb = skb_clone(skb, GFP_ATOMIC); 1753e1fbd4c1SMat Martineau } 1754e1fbd4c1SMat Martineau 1755e1fbd4c1SMat Martineau if (!tx_skb) { 1756e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1757e1fbd4c1SMat Martineau break; 1758e1fbd4c1SMat Martineau } 1759e1fbd4c1SMat Martineau 1760e1fbd4c1SMat Martineau /* Update skb contents */ 1761e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1762e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1763e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1764e1fbd4c1SMat Martineau } else { 1765e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1766e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1767e1fbd4c1SMat Martineau } 1768e1fbd4c1SMat Martineau 1769e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1770e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1771e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1772e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1773e1fbd4c1SMat Martineau } 1774e1fbd4c1SMat Martineau 1775e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1776e1fbd4c1SMat Martineau 1777e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 1778e1fbd4c1SMat Martineau 1779e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 1780e1fbd4c1SMat Martineau } 1781e1fbd4c1SMat Martineau } 1782e1fbd4c1SMat Martineau 1783f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 1784f80842a8SMat Martineau struct l2cap_ctrl *control) 1785f80842a8SMat Martineau { 1786f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1787f80842a8SMat Martineau 1788f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 1789f80842a8SMat Martineau l2cap_ertm_resend(chan); 1790f80842a8SMat Martineau } 1791f80842a8SMat Martineau 1792d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 1793d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 1794d2a7ac5dSMat Martineau { 1795e1fbd4c1SMat Martineau struct sk_buff *skb; 1796e1fbd4c1SMat Martineau 1797e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1798e1fbd4c1SMat Martineau 1799e1fbd4c1SMat Martineau if (control->poll) 1800e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 1801e1fbd4c1SMat Martineau 1802e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1803e1fbd4c1SMat Martineau 1804e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1805e1fbd4c1SMat Martineau return; 1806e1fbd4c1SMat Martineau 1807e1fbd4c1SMat Martineau if (chan->unacked_frames) { 1808e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 1809e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 1810e1fbd4c1SMat Martineau skb == chan->tx_send_head) 1811e1fbd4c1SMat Martineau break; 1812e1fbd4c1SMat Martineau } 1813e1fbd4c1SMat Martineau 1814e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 1815e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 1816e1fbd4c1SMat Martineau break; 1817e1fbd4c1SMat Martineau 1818e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 1819e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 1820e1fbd4c1SMat Martineau } 1821e1fbd4c1SMat Martineau 1822e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 1823e1fbd4c1SMat Martineau } 1824d2a7ac5dSMat Martineau } 1825d2a7ac5dSMat Martineau 1826b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 1827b17e73bbSSzymon Janc { 18280a0aba42SMat Martineau struct l2cap_ctrl control; 18290a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 18300a0aba42SMat Martineau chan->last_acked_seq); 18310a0aba42SMat Martineau int threshold; 18320a0aba42SMat Martineau 18330a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 18340a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 18350a0aba42SMat Martineau 18360a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 18370a0aba42SMat Martineau control.sframe = 1; 18380a0aba42SMat Martineau 18390a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 18400a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 1841b17e73bbSSzymon Janc __clear_ack_timer(chan); 18420a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 18430a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18440a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18450a0aba42SMat Martineau } else { 18460a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 18470a0aba42SMat Martineau l2cap_ertm_send(chan); 18480a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 18490a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 18500a0aba42SMat Martineau frames_to_ack = 0; 18510a0aba42SMat Martineau } 18520a0aba42SMat Martineau 18530a0aba42SMat Martineau /* Ack now if the tx window is 3/4ths full. 18540a0aba42SMat Martineau * Calculate without mul or div 18550a0aba42SMat Martineau */ 18560a0aba42SMat Martineau threshold = chan->tx_win; 18570a0aba42SMat Martineau threshold += threshold << 1; 18580a0aba42SMat Martineau threshold >>= 2; 18590a0aba42SMat Martineau 18600a0aba42SMat Martineau BT_DBG("frames_to_ack %d, threshold %d", (int)frames_to_ack, 18610a0aba42SMat Martineau threshold); 18620a0aba42SMat Martineau 18630a0aba42SMat Martineau if (frames_to_ack >= threshold) { 18640a0aba42SMat Martineau __clear_ack_timer(chan); 18650a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 18660a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18670a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18680a0aba42SMat Martineau frames_to_ack = 0; 18690a0aba42SMat Martineau } 18700a0aba42SMat Martineau 18710a0aba42SMat Martineau if (frames_to_ack) 18720a0aba42SMat Martineau __set_ack_timer(chan); 18730a0aba42SMat Martineau } 1874b17e73bbSSzymon Janc } 1875b17e73bbSSzymon Janc 187604124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 187704124681SGustavo F. Padovan struct msghdr *msg, int len, 187804124681SGustavo F. Padovan int count, struct sk_buff *skb) 18790a708f8fSGustavo F. Padovan { 18800952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 18810a708f8fSGustavo F. Padovan struct sk_buff **frag; 188290338947SGustavo Padovan int sent = 0; 18830a708f8fSGustavo F. Padovan 18840a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 18850a708f8fSGustavo F. Padovan return -EFAULT; 18860a708f8fSGustavo F. Padovan 18870a708f8fSGustavo F. Padovan sent += count; 18880a708f8fSGustavo F. Padovan len -= count; 18890a708f8fSGustavo F. Padovan 18900a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 18910a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 18920a708f8fSGustavo F. Padovan while (len) { 1893fbe00700SGustavo Padovan struct sk_buff *tmp; 1894fbe00700SGustavo Padovan 18950a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 18960a708f8fSGustavo F. Padovan 1897fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 189890338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 1899fbe00700SGustavo Padovan if (IS_ERR(tmp)) 1900fbe00700SGustavo Padovan return PTR_ERR(tmp); 19012f7719ceSAndrei Emeltchenko 1902fbe00700SGustavo Padovan *frag = tmp; 1903fbe00700SGustavo Padovan 19040a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 19050a708f8fSGustavo F. Padovan return -EFAULT; 19060a708f8fSGustavo F. Padovan 19075e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 19085e59b791SLuiz Augusto von Dentz 19090a708f8fSGustavo F. Padovan sent += count; 19100a708f8fSGustavo F. Padovan len -= count; 19110a708f8fSGustavo F. Padovan 19122d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 19132d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 19142d0ed3d5SGustavo Padovan 19150a708f8fSGustavo F. Padovan frag = &(*frag)->next; 19160a708f8fSGustavo F. Padovan } 19170a708f8fSGustavo F. Padovan 19180a708f8fSGustavo F. Padovan return sent; 19190a708f8fSGustavo F. Padovan } 19200a708f8fSGustavo F. Padovan 19215e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 19225e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19235e59b791SLuiz Augusto von Dentz u32 priority) 19240a708f8fSGustavo F. Padovan { 19258c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19260a708f8fSGustavo F. Padovan struct sk_buff *skb; 192703a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 19280a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19290a708f8fSGustavo F. Padovan 19306d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d priority %u", chan, (int)len, priority); 19310a708f8fSGustavo F. Padovan 19320a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 19332f7719ceSAndrei Emeltchenko 19342f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 193590338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 193690338947SGustavo Padovan if (IS_ERR(skb)) 193790338947SGustavo Padovan return skb; 19380a708f8fSGustavo F. Padovan 19395e59b791SLuiz Augusto von Dentz skb->priority = priority; 19405e59b791SLuiz Augusto von Dentz 19410a708f8fSGustavo F. Padovan /* Create L2CAP header */ 19420a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 1943fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 1944daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 1945daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 19460a708f8fSGustavo F. Padovan 19470952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 19480a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 19490a708f8fSGustavo F. Padovan kfree_skb(skb); 19500a708f8fSGustavo F. Padovan return ERR_PTR(err); 19510a708f8fSGustavo F. Padovan } 19520a708f8fSGustavo F. Padovan return skb; 19530a708f8fSGustavo F. Padovan } 19540a708f8fSGustavo F. Padovan 19555e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 19565e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19575e59b791SLuiz Augusto von Dentz u32 priority) 19580a708f8fSGustavo F. Padovan { 19598c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19600a708f8fSGustavo F. Padovan struct sk_buff *skb; 1961f2ba7faeSGustavo Padovan int err, count; 19620a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19630a708f8fSGustavo F. Padovan 19646d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d", chan, (int)len); 19650a708f8fSGustavo F. Padovan 1966f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 19672f7719ceSAndrei Emeltchenko 1968f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 196990338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 197090338947SGustavo Padovan if (IS_ERR(skb)) 197190338947SGustavo Padovan return skb; 19720a708f8fSGustavo F. Padovan 19735e59b791SLuiz Augusto von Dentz skb->priority = priority; 19745e59b791SLuiz Augusto von Dentz 19750a708f8fSGustavo F. Padovan /* Create L2CAP header */ 19760a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 1977fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 19786ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 19790a708f8fSGustavo F. Padovan 19800952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 19810a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 19820a708f8fSGustavo F. Padovan kfree_skb(skb); 19830a708f8fSGustavo F. Padovan return ERR_PTR(err); 19840a708f8fSGustavo F. Padovan } 19850a708f8fSGustavo F. Padovan return skb; 19860a708f8fSGustavo F. Padovan } 19870a708f8fSGustavo F. Padovan 1988ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 1989ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 199094122bbeSMat Martineau u16 sdulen) 19910a708f8fSGustavo F. Padovan { 19928c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19930a708f8fSGustavo F. Padovan struct sk_buff *skb; 1994e4ca6d98SAndrei Emeltchenko int err, count, hlen; 19950a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19960a708f8fSGustavo F. Padovan 19976d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d", chan, (int)len); 19980a708f8fSGustavo F. Padovan 19990a708f8fSGustavo F. Padovan if (!conn) 20000a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 20010a708f8fSGustavo F. Padovan 2002e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 2003e4ca6d98SAndrei Emeltchenko hlen = L2CAP_EXT_HDR_SIZE; 2004e4ca6d98SAndrei Emeltchenko else 2005e4ca6d98SAndrei Emeltchenko hlen = L2CAP_ENH_HDR_SIZE; 2006e4ca6d98SAndrei Emeltchenko 20070a708f8fSGustavo F. Padovan if (sdulen) 200803a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 20090a708f8fSGustavo F. Padovan 201047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 201103a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 20120a708f8fSGustavo F. Padovan 20130a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 20142f7719ceSAndrei Emeltchenko 20152f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 201690338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 201790338947SGustavo Padovan if (IS_ERR(skb)) 201890338947SGustavo Padovan return skb; 20190a708f8fSGustavo F. Padovan 20200a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20210a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2022fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 20230a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 202488843ab0SAndrei Emeltchenko 202518a48e76SMat Martineau /* Control header is populated later */ 202618a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 202718a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 202818a48e76SMat Martineau else 202918a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 203088843ab0SAndrei Emeltchenko 20310a708f8fSGustavo F. Padovan if (sdulen) 203203a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 20330a708f8fSGustavo F. Padovan 20340952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20350a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20360a708f8fSGustavo F. Padovan kfree_skb(skb); 20370a708f8fSGustavo F. Padovan return ERR_PTR(err); 20380a708f8fSGustavo F. Padovan } 20390a708f8fSGustavo F. Padovan 204018a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 20413ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 20420a708f8fSGustavo F. Padovan return skb; 20430a708f8fSGustavo F. Padovan } 20440a708f8fSGustavo F. Padovan 204594122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 204694122bbeSMat Martineau struct sk_buff_head *seg_queue, 204794122bbeSMat Martineau struct msghdr *msg, size_t len) 20480a708f8fSGustavo F. Padovan { 20490a708f8fSGustavo F. Padovan struct sk_buff *skb; 205094122bbeSMat Martineau u16 sdu_len; 205194122bbeSMat Martineau size_t pdu_len; 205294122bbeSMat Martineau int err = 0; 205394122bbeSMat Martineau u8 sar; 20540a708f8fSGustavo F. Padovan 205594122bbeSMat Martineau BT_DBG("chan %p, msg %p, len %d", chan, msg, (int)len); 20560a708f8fSGustavo F. Padovan 205794122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 205894122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 205994122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 206094122bbeSMat Martineau */ 206194122bbeSMat Martineau 206294122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 206394122bbeSMat Martineau pdu_len = chan->conn->mtu; 206494122bbeSMat Martineau 206594122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 206694122bbeSMat Martineau 206794122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 206835d401dfSGustavo Padovan if (chan->fcs) 206935d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 207035d401dfSGustavo Padovan 207135d401dfSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 207235d401dfSGustavo Padovan pdu_len -= L2CAP_EXT_HDR_SIZE; 207335d401dfSGustavo Padovan else 207435d401dfSGustavo Padovan pdu_len -= L2CAP_ENH_HDR_SIZE; 207594122bbeSMat Martineau 207694122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 207794122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 207894122bbeSMat Martineau 207994122bbeSMat Martineau if (len <= pdu_len) { 208094122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 208194122bbeSMat Martineau sdu_len = 0; 208294122bbeSMat Martineau pdu_len = len; 208394122bbeSMat Martineau } else { 208494122bbeSMat Martineau sar = L2CAP_SAR_START; 208594122bbeSMat Martineau sdu_len = len; 208694122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 208794122bbeSMat Martineau } 20880a708f8fSGustavo F. Padovan 20890a708f8fSGustavo F. Padovan while (len > 0) { 209094122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 20910a708f8fSGustavo F. Padovan 20920a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 209394122bbeSMat Martineau __skb_queue_purge(seg_queue); 20940a708f8fSGustavo F. Padovan return PTR_ERR(skb); 20950a708f8fSGustavo F. Padovan } 20960a708f8fSGustavo F. Padovan 209794122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 209894122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 20990a708f8fSGustavo F. Padovan 210094122bbeSMat Martineau len -= pdu_len; 210194122bbeSMat Martineau if (sdu_len) { 210294122bbeSMat Martineau sdu_len = 0; 210394122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 210494122bbeSMat Martineau } 210594122bbeSMat Martineau 210694122bbeSMat Martineau if (len <= pdu_len) { 210794122bbeSMat Martineau sar = L2CAP_SAR_END; 210894122bbeSMat Martineau pdu_len = len; 210994122bbeSMat Martineau } else { 211094122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 211194122bbeSMat Martineau } 211294122bbeSMat Martineau } 211394122bbeSMat Martineau 211494122bbeSMat Martineau return err; 21150a708f8fSGustavo F. Padovan } 21160a708f8fSGustavo F. Padovan 21175e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 21185e59b791SLuiz Augusto von Dentz u32 priority) 21199a91a04aSGustavo F. Padovan { 21209a91a04aSGustavo F. Padovan struct sk_buff *skb; 21219a91a04aSGustavo F. Padovan int err; 212294122bbeSMat Martineau struct sk_buff_head seg_queue; 21239a91a04aSGustavo F. Padovan 21249a91a04aSGustavo F. Padovan /* Connectionless channel */ 2125715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 21265e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 21279a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 21289a91a04aSGustavo F. Padovan return PTR_ERR(skb); 21299a91a04aSGustavo F. Padovan 21309a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 21319a91a04aSGustavo F. Padovan return len; 21329a91a04aSGustavo F. Padovan } 21339a91a04aSGustavo F. Padovan 21349a91a04aSGustavo F. Padovan switch (chan->mode) { 21359a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 21369a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 21379a91a04aSGustavo F. Padovan if (len > chan->omtu) 21389a91a04aSGustavo F. Padovan return -EMSGSIZE; 21399a91a04aSGustavo F. Padovan 21409a91a04aSGustavo F. Padovan /* Create a basic PDU */ 21415e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 21429a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 21439a91a04aSGustavo F. Padovan return PTR_ERR(skb); 21449a91a04aSGustavo F. Padovan 21459a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 21469a91a04aSGustavo F. Padovan err = len; 21479a91a04aSGustavo F. Padovan break; 21489a91a04aSGustavo F. Padovan 21499a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 21509a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 215194122bbeSMat Martineau /* Check outgoing MTU */ 215294122bbeSMat Martineau if (len > chan->omtu) { 215394122bbeSMat Martineau err = -EMSGSIZE; 21549a91a04aSGustavo F. Padovan break; 21559a91a04aSGustavo F. Padovan } 21569a91a04aSGustavo F. Padovan 215794122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 215894122bbeSMat Martineau 215994122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 216094122bbeSMat Martineau * since it's possible to block while waiting for memory 216194122bbeSMat Martineau * allocation. 216294122bbeSMat Martineau */ 216394122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 216494122bbeSMat Martineau 216594122bbeSMat Martineau /* The channel could have been closed while segmenting, 216694122bbeSMat Martineau * check that it is still connected. 216794122bbeSMat Martineau */ 216894122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 216994122bbeSMat Martineau __skb_queue_purge(&seg_queue); 217094122bbeSMat Martineau err = -ENOTCONN; 21719a91a04aSGustavo F. Padovan } 21729a91a04aSGustavo F. Padovan 217394122bbeSMat Martineau if (err) 217494122bbeSMat Martineau break; 217594122bbeSMat Martineau 21763733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2177d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 21783733937dSMat Martineau else 2179d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 218094122bbeSMat Martineau 21819a91a04aSGustavo F. Padovan err = len; 21829a91a04aSGustavo F. Padovan 218394122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 218494122bbeSMat Martineau * seg_queue and need to be purged. 218594122bbeSMat Martineau */ 218694122bbeSMat Martineau __skb_queue_purge(&seg_queue); 21879a91a04aSGustavo F. Padovan break; 21889a91a04aSGustavo F. Padovan 21899a91a04aSGustavo F. Padovan default: 21909a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 21919a91a04aSGustavo F. Padovan err = -EBADFD; 21929a91a04aSGustavo F. Padovan } 21939a91a04aSGustavo F. Padovan 21949a91a04aSGustavo F. Padovan return err; 21959a91a04aSGustavo F. Padovan } 21969a91a04aSGustavo F. Padovan 2197d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2198d2a7ac5dSMat Martineau { 2199bed68bdeSMat Martineau struct l2cap_ctrl control; 2200bed68bdeSMat Martineau u16 seq; 2201bed68bdeSMat Martineau 2202bed68bdeSMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 2203bed68bdeSMat Martineau 2204bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2205bed68bdeSMat Martineau control.sframe = 1; 2206bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2207bed68bdeSMat Martineau 2208bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2209bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2210bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2211bed68bdeSMat Martineau control.reqseq = seq; 2212bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2213bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2214bed68bdeSMat Martineau } 2215bed68bdeSMat Martineau } 2216bed68bdeSMat Martineau 2217bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2218d2a7ac5dSMat Martineau } 2219d2a7ac5dSMat Martineau 2220d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2221d2a7ac5dSMat Martineau { 2222bed68bdeSMat Martineau struct l2cap_ctrl control; 2223bed68bdeSMat Martineau 2224bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2225bed68bdeSMat Martineau 2226bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2227bed68bdeSMat Martineau return; 2228bed68bdeSMat Martineau 2229bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2230bed68bdeSMat Martineau control.sframe = 1; 2231bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2232bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2233bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2234d2a7ac5dSMat Martineau } 2235d2a7ac5dSMat Martineau 2236d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2237d2a7ac5dSMat Martineau { 2238bed68bdeSMat Martineau struct l2cap_ctrl control; 2239bed68bdeSMat Martineau u16 initial_head; 2240bed68bdeSMat Martineau u16 seq; 2241bed68bdeSMat Martineau 2242bed68bdeSMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 2243bed68bdeSMat Martineau 2244bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2245bed68bdeSMat Martineau control.sframe = 1; 2246bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2247bed68bdeSMat Martineau 2248bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2249bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2250bed68bdeSMat Martineau 2251bed68bdeSMat Martineau do { 2252bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2253bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2254bed68bdeSMat Martineau break; 2255bed68bdeSMat Martineau 2256bed68bdeSMat Martineau control.reqseq = seq; 2257bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2258bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2259bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2260d2a7ac5dSMat Martineau } 2261d2a7ac5dSMat Martineau 2262608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2263608bcc6dSMat Martineau { 2264608bcc6dSMat Martineau struct sk_buff *acked_skb; 2265608bcc6dSMat Martineau u16 ackseq; 2266608bcc6dSMat Martineau 2267608bcc6dSMat Martineau BT_DBG("chan %p, reqseq %d", chan, reqseq); 2268608bcc6dSMat Martineau 2269608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2270608bcc6dSMat Martineau return; 2271608bcc6dSMat Martineau 2272608bcc6dSMat Martineau BT_DBG("expected_ack_seq %d, unacked_frames %d", 2273608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2274608bcc6dSMat Martineau 2275608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2276608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2277608bcc6dSMat Martineau 2278608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2279608bcc6dSMat Martineau if (acked_skb) { 2280608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2281608bcc6dSMat Martineau kfree_skb(acked_skb); 2282608bcc6dSMat Martineau chan->unacked_frames--; 2283608bcc6dSMat Martineau } 2284608bcc6dSMat Martineau } 2285608bcc6dSMat Martineau 2286608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2287608bcc6dSMat Martineau 2288608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2289608bcc6dSMat Martineau __clear_retrans_timer(chan); 2290608bcc6dSMat Martineau 2291608bcc6dSMat Martineau BT_DBG("unacked_frames %d", (int) chan->unacked_frames); 2292608bcc6dSMat Martineau } 2293608bcc6dSMat Martineau 2294608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2295608bcc6dSMat Martineau { 2296608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2297608bcc6dSMat Martineau 2298608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2299608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2300608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2301608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2302608bcc6dSMat Martineau } 2303608bcc6dSMat Martineau 2304d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2305608bcc6dSMat Martineau struct l2cap_ctrl *control, 2306608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2307608bcc6dSMat Martineau { 2308608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2309608bcc6dSMat Martineau event); 2310608bcc6dSMat Martineau 2311608bcc6dSMat Martineau switch (event) { 2312608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2313608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2314608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2315608bcc6dSMat Martineau 2316608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2317608bcc6dSMat Martineau l2cap_ertm_send(chan); 2318608bcc6dSMat Martineau break; 2319608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2320608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2321608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2322608bcc6dSMat Martineau 2323608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2324608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2325608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2326608bcc6dSMat Martineau */ 2327608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2328608bcc6dSMat Martineau } 2329608bcc6dSMat Martineau 2330608bcc6dSMat Martineau l2cap_send_ack(chan); 2331608bcc6dSMat Martineau 2332608bcc6dSMat Martineau break; 2333608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2334608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2335608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2336608bcc6dSMat Martineau 2337608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2338608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2339608bcc6dSMat Martineau 2340608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2341608bcc6dSMat Martineau local_control.sframe = 1; 2342608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2343608bcc6dSMat Martineau local_control.poll = 1; 2344608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2345a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2346608bcc6dSMat Martineau 2347608bcc6dSMat Martineau chan->retry_count = 1; 2348608bcc6dSMat Martineau __set_monitor_timer(chan); 2349608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2350608bcc6dSMat Martineau } 2351608bcc6dSMat Martineau break; 2352608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2353608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2354608bcc6dSMat Martineau break; 2355608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2356608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2357608bcc6dSMat Martineau chan->retry_count = 1; 2358608bcc6dSMat Martineau __set_monitor_timer(chan); 2359608bcc6dSMat Martineau __clear_ack_timer(chan); 2360608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2361608bcc6dSMat Martineau break; 2362608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2363608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2364608bcc6dSMat Martineau chan->retry_count = 1; 2365608bcc6dSMat Martineau __set_monitor_timer(chan); 2366608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2367608bcc6dSMat Martineau break; 2368608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2369608bcc6dSMat Martineau /* Nothing to process */ 2370608bcc6dSMat Martineau break; 2371608bcc6dSMat Martineau default: 2372608bcc6dSMat Martineau break; 2373608bcc6dSMat Martineau } 2374608bcc6dSMat Martineau } 2375608bcc6dSMat Martineau 2376d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2377608bcc6dSMat Martineau struct l2cap_ctrl *control, 2378608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2379608bcc6dSMat Martineau { 2380608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2381608bcc6dSMat Martineau event); 2382608bcc6dSMat Martineau 2383608bcc6dSMat Martineau switch (event) { 2384608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2385608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2386608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2387608bcc6dSMat Martineau /* Queue data, but don't send. */ 2388608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2389608bcc6dSMat Martineau break; 2390608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2391608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2392608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2393608bcc6dSMat Martineau 2394608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2395608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2396608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2397608bcc6dSMat Martineau */ 2398608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2399608bcc6dSMat Martineau } 2400608bcc6dSMat Martineau 2401608bcc6dSMat Martineau l2cap_send_ack(chan); 2402608bcc6dSMat Martineau 2403608bcc6dSMat Martineau break; 2404608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2405608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2406608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2407608bcc6dSMat Martineau 2408608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2409608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2410608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2411608bcc6dSMat Martineau local_control.sframe = 1; 2412608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2413608bcc6dSMat Martineau local_control.poll = 1; 2414608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2415a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2416608bcc6dSMat Martineau 2417608bcc6dSMat Martineau chan->retry_count = 1; 2418608bcc6dSMat Martineau __set_monitor_timer(chan); 2419608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2420608bcc6dSMat Martineau } 2421608bcc6dSMat Martineau break; 2422608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2423608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2424608bcc6dSMat Martineau 2425608bcc6dSMat Martineau /* Fall through */ 2426608bcc6dSMat Martineau 2427608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2428608bcc6dSMat Martineau if (control && control->final) { 2429608bcc6dSMat Martineau __clear_monitor_timer(chan); 2430608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2431608bcc6dSMat Martineau __set_retrans_timer(chan); 2432608bcc6dSMat Martineau chan->retry_count = 0; 2433608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2434608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2435608bcc6dSMat Martineau } 2436608bcc6dSMat Martineau break; 2437608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2438608bcc6dSMat Martineau /* Ignore */ 2439608bcc6dSMat Martineau break; 2440608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2441608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2442608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2443608bcc6dSMat Martineau __set_monitor_timer(chan); 2444608bcc6dSMat Martineau chan->retry_count++; 2445608bcc6dSMat Martineau } else { 2446608bcc6dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED); 2447608bcc6dSMat Martineau } 2448608bcc6dSMat Martineau break; 2449608bcc6dSMat Martineau default: 2450608bcc6dSMat Martineau break; 2451608bcc6dSMat Martineau } 2452608bcc6dSMat Martineau } 2453608bcc6dSMat Martineau 2454d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2455608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2456608bcc6dSMat Martineau { 2457608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2458608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2459608bcc6dSMat Martineau 2460608bcc6dSMat Martineau switch (chan->tx_state) { 2461608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2462d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2463608bcc6dSMat Martineau break; 2464608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2465d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2466608bcc6dSMat Martineau break; 2467608bcc6dSMat Martineau default: 2468608bcc6dSMat Martineau /* Ignore event */ 2469608bcc6dSMat Martineau break; 2470608bcc6dSMat Martineau } 2471608bcc6dSMat Martineau } 2472608bcc6dSMat Martineau 24734b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 24744b51dae9SMat Martineau struct l2cap_ctrl *control) 24754b51dae9SMat Martineau { 24764b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2477401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 24784b51dae9SMat Martineau } 24794b51dae9SMat Martineau 2480f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2481f80842a8SMat Martineau struct l2cap_ctrl *control) 2482f80842a8SMat Martineau { 2483f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2484401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2485f80842a8SMat Martineau } 2486f80842a8SMat Martineau 24870a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 24880a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 24890a708f8fSGustavo F. Padovan { 24900a708f8fSGustavo F. Padovan struct sk_buff *nskb; 249148454079SGustavo F. Padovan struct l2cap_chan *chan; 24920a708f8fSGustavo F. Padovan 24930a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 24940a708f8fSGustavo F. Padovan 24953df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 24963d57dc68SGustavo F. Padovan 24973df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 249848454079SGustavo F. Padovan struct sock *sk = chan->sk; 2499715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 25000a708f8fSGustavo F. Padovan continue; 25010a708f8fSGustavo F. Padovan 25020a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 25030a708f8fSGustavo F. Padovan if (skb->sk == sk) 25040a708f8fSGustavo F. Padovan continue; 25050a708f8fSGustavo F. Padovan nskb = skb_clone(skb, GFP_ATOMIC); 25060a708f8fSGustavo F. Padovan if (!nskb) 25070a708f8fSGustavo F. Padovan continue; 25080a708f8fSGustavo F. Padovan 250980b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 25100a708f8fSGustavo F. Padovan kfree_skb(nskb); 25110a708f8fSGustavo F. Padovan } 25123d57dc68SGustavo F. Padovan 25133df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 25140a708f8fSGustavo F. Padovan } 25150a708f8fSGustavo F. Padovan 25160a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 25170a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 25180a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data) 25190a708f8fSGustavo F. Padovan { 25200a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 25210a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 25220a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 25230a708f8fSGustavo F. Padovan int len, count; 25240a708f8fSGustavo F. Padovan 25250a708f8fSGustavo F. Padovan BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d", 25260a708f8fSGustavo F. Padovan conn, code, ident, dlen); 25270a708f8fSGustavo F. Padovan 25280a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 25290a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25300a708f8fSGustavo F. Padovan 25310a708f8fSGustavo F. Padovan skb = bt_skb_alloc(count, GFP_ATOMIC); 25320a708f8fSGustavo F. Padovan if (!skb) 25330a708f8fSGustavo F. Padovan return NULL; 25340a708f8fSGustavo F. Padovan 25350a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 25360a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 25373300d9a9SClaudio Takahasi 25383300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2539ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 25403300d9a9SClaudio Takahasi else 2541ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 25420a708f8fSGustavo F. Padovan 25430a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 25440a708f8fSGustavo F. Padovan cmd->code = code; 25450a708f8fSGustavo F. Padovan cmd->ident = ident; 25460a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 25470a708f8fSGustavo F. Padovan 25480a708f8fSGustavo F. Padovan if (dlen) { 25490a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 25500a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 25510a708f8fSGustavo F. Padovan data += count; 25520a708f8fSGustavo F. Padovan } 25530a708f8fSGustavo F. Padovan 25540a708f8fSGustavo F. Padovan len -= skb->len; 25550a708f8fSGustavo F. Padovan 25560a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 25570a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 25580a708f8fSGustavo F. Padovan while (len) { 25590a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25600a708f8fSGustavo F. Padovan 25610a708f8fSGustavo F. Padovan *frag = bt_skb_alloc(count, GFP_ATOMIC); 25620a708f8fSGustavo F. Padovan if (!*frag) 25630a708f8fSGustavo F. Padovan goto fail; 25640a708f8fSGustavo F. Padovan 25650a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 25660a708f8fSGustavo F. Padovan 25670a708f8fSGustavo F. Padovan len -= count; 25680a708f8fSGustavo F. Padovan data += count; 25690a708f8fSGustavo F. Padovan 25700a708f8fSGustavo F. Padovan frag = &(*frag)->next; 25710a708f8fSGustavo F. Padovan } 25720a708f8fSGustavo F. Padovan 25730a708f8fSGustavo F. Padovan return skb; 25740a708f8fSGustavo F. Padovan 25750a708f8fSGustavo F. Padovan fail: 25760a708f8fSGustavo F. Padovan kfree_skb(skb); 25770a708f8fSGustavo F. Padovan return NULL; 25780a708f8fSGustavo F. Padovan } 25790a708f8fSGustavo F. Padovan 25800a708f8fSGustavo F. Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val) 25810a708f8fSGustavo F. Padovan { 25820a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 25830a708f8fSGustavo F. Padovan int len; 25840a708f8fSGustavo F. Padovan 25850a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 25860a708f8fSGustavo F. Padovan *ptr += len; 25870a708f8fSGustavo F. Padovan 25880a708f8fSGustavo F. Padovan *type = opt->type; 25890a708f8fSGustavo F. Padovan *olen = opt->len; 25900a708f8fSGustavo F. Padovan 25910a708f8fSGustavo F. Padovan switch (opt->len) { 25920a708f8fSGustavo F. Padovan case 1: 25930a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 25940a708f8fSGustavo F. Padovan break; 25950a708f8fSGustavo F. Padovan 25960a708f8fSGustavo F. Padovan case 2: 25970a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 25980a708f8fSGustavo F. Padovan break; 25990a708f8fSGustavo F. Padovan 26000a708f8fSGustavo F. Padovan case 4: 26010a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 26020a708f8fSGustavo F. Padovan break; 26030a708f8fSGustavo F. Padovan 26040a708f8fSGustavo F. Padovan default: 26050a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 26060a708f8fSGustavo F. Padovan break; 26070a708f8fSGustavo F. Padovan } 26080a708f8fSGustavo F. Padovan 26090a708f8fSGustavo F. Padovan BT_DBG("type 0x%2.2x len %d val 0x%lx", *type, opt->len, *val); 26100a708f8fSGustavo F. Padovan return len; 26110a708f8fSGustavo F. Padovan } 26120a708f8fSGustavo F. Padovan 26130a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 26140a708f8fSGustavo F. Padovan { 26150a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26160a708f8fSGustavo F. Padovan 26170a708f8fSGustavo F. Padovan BT_DBG("type 0x%2.2x len %d val 0x%lx", type, len, val); 26180a708f8fSGustavo F. Padovan 26190a708f8fSGustavo F. Padovan opt->type = type; 26200a708f8fSGustavo F. Padovan opt->len = len; 26210a708f8fSGustavo F. Padovan 26220a708f8fSGustavo F. Padovan switch (len) { 26230a708f8fSGustavo F. Padovan case 1: 26240a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 26250a708f8fSGustavo F. Padovan break; 26260a708f8fSGustavo F. Padovan 26270a708f8fSGustavo F. Padovan case 2: 26280a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 26290a708f8fSGustavo F. Padovan break; 26300a708f8fSGustavo F. Padovan 26310a708f8fSGustavo F. Padovan case 4: 26320a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 26330a708f8fSGustavo F. Padovan break; 26340a708f8fSGustavo F. Padovan 26350a708f8fSGustavo F. Padovan default: 26360a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 26370a708f8fSGustavo F. Padovan break; 26380a708f8fSGustavo F. Padovan } 26390a708f8fSGustavo F. Padovan 26400a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 26410a708f8fSGustavo F. Padovan } 26420a708f8fSGustavo F. Padovan 2643f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2644f89cef09SAndrei Emeltchenko { 2645f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2646f89cef09SAndrei Emeltchenko 2647f89cef09SAndrei Emeltchenko switch (chan->mode) { 2648f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2649f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2650f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2651f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2652f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2653ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 2654ac73498cSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_DEFAULT_FLUSH_TO); 2655f89cef09SAndrei Emeltchenko break; 2656f89cef09SAndrei Emeltchenko 2657f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2658f89cef09SAndrei Emeltchenko efs.id = 1; 2659f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2660f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2661f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2662f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2663f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2664f89cef09SAndrei Emeltchenko break; 2665f89cef09SAndrei Emeltchenko 2666f89cef09SAndrei Emeltchenko default: 2667f89cef09SAndrei Emeltchenko return; 2668f89cef09SAndrei Emeltchenko } 2669f89cef09SAndrei Emeltchenko 2670f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2671f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2672f89cef09SAndrei Emeltchenko } 2673f89cef09SAndrei Emeltchenko 2674721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 26750a708f8fSGustavo F. Padovan { 2676721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2677721c4181SGustavo F. Padovan ack_timer.work); 26780362520bSMat Martineau u16 frames_to_ack; 26790a708f8fSGustavo F. Padovan 26802fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 26812fb9b3d4SGustavo F. Padovan 26826be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 26836be36555SAndrei Emeltchenko 26840362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 26850362520bSMat Martineau chan->last_acked_seq); 26860362520bSMat Martineau 26870362520bSMat Martineau if (frames_to_ack) 26880362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 26896be36555SAndrei Emeltchenko 26906be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 269109bfb2eeSSzymon Janc l2cap_chan_put(chan); 26920a708f8fSGustavo F. Padovan } 26930a708f8fSGustavo F. Padovan 2694466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 26950a708f8fSGustavo F. Padovan { 26963c588192SMat Martineau int err; 26973c588192SMat Martineau 2698105bdf9eSMat Martineau chan->next_tx_seq = 0; 2699105bdf9eSMat Martineau chan->expected_tx_seq = 0; 270042e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 27016a026610SGustavo F. Padovan chan->unacked_frames = 0; 270242e5c802SGustavo F. Padovan chan->buffer_seq = 0; 27036a026610SGustavo F. Padovan chan->frames_sent = 0; 2704105bdf9eSMat Martineau chan->last_acked_seq = 0; 2705105bdf9eSMat Martineau chan->sdu = NULL; 2706105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2707105bdf9eSMat Martineau chan->sdu_len = 0; 2708105bdf9eSMat Martineau 2709d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2710d34c34fbSMat Martineau 2711105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2712105bdf9eSMat Martineau return 0; 2713105bdf9eSMat Martineau 2714105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2715105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 27160a708f8fSGustavo F. Padovan 2717721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2718721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2719721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 27200a708f8fSGustavo F. Padovan 2721f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 27220a708f8fSGustavo F. Padovan 27233c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 27243c588192SMat Martineau if (err < 0) 27253c588192SMat Martineau return err; 27263c588192SMat Martineau 27279dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 27289dc9affcSMat Martineau if (err < 0) 27299dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 27309dc9affcSMat Martineau 27319dc9affcSMat Martineau return err; 27320a708f8fSGustavo F. Padovan } 27330a708f8fSGustavo F. Padovan 27340a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 27350a708f8fSGustavo F. Padovan { 27360a708f8fSGustavo F. Padovan switch (mode) { 27370a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 27380a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 27390a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 27400a708f8fSGustavo F. Padovan return mode; 27410a708f8fSGustavo F. Padovan /* fall through */ 27420a708f8fSGustavo F. Padovan default: 27430a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 27440a708f8fSGustavo F. Padovan } 27450a708f8fSGustavo F. Padovan } 27460a708f8fSGustavo F. Padovan 27476327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 27486327eb98SAndrei Emeltchenko { 27496327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 27506327eb98SAndrei Emeltchenko } 27516327eb98SAndrei Emeltchenko 2752f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2753f89cef09SAndrei Emeltchenko { 2754f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2755f89cef09SAndrei Emeltchenko } 2756f89cef09SAndrei Emeltchenko 27576327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 27586327eb98SAndrei Emeltchenko { 27596327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 2760836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 27616327eb98SAndrei Emeltchenko /* use extended control field */ 27626327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 2763836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 2764836be934SAndrei Emeltchenko } else { 27656327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 27666327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 2767836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 2768836be934SAndrei Emeltchenko } 27696327eb98SAndrei Emeltchenko } 27706327eb98SAndrei Emeltchenko 2771710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 27720a708f8fSGustavo F. Padovan { 27730a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 27740c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 27750a708f8fSGustavo F. Padovan void *ptr = req->data; 2776c8f79162SAndrei Emeltchenko u16 size; 27770a708f8fSGustavo F. Padovan 277849208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 27790a708f8fSGustavo F. Padovan 278073ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 27810a708f8fSGustavo F. Padovan goto done; 27820a708f8fSGustavo F. Padovan 27830c1bc5c6SGustavo F. Padovan switch (chan->mode) { 27840a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 27850a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2786c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 27870a708f8fSGustavo F. Padovan break; 27880a708f8fSGustavo F. Padovan 2789f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 2790f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 2791f89cef09SAndrei Emeltchenko 27920a708f8fSGustavo F. Padovan /* fall through */ 27930a708f8fSGustavo F. Padovan default: 27948c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 27950a708f8fSGustavo F. Padovan break; 27960a708f8fSGustavo F. Padovan } 27970a708f8fSGustavo F. Padovan 27980a708f8fSGustavo F. Padovan done: 27990c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 28000c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 28010a708f8fSGustavo F. Padovan 28020c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28030a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 28048c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 28058c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 28060a708f8fSGustavo F. Padovan break; 28070a708f8fSGustavo F. Padovan 28080a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 28090a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28100a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28110a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28120a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 28130a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 28140a708f8fSGustavo F. Padovan 28150a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28160a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28170a708f8fSGustavo F. Padovan break; 28180a708f8fSGustavo F. Padovan 28190a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 28200a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 282147d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 28220a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28230a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2824c8f79162SAndrei Emeltchenko 2825c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2826c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2827c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2828c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2829c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28300a708f8fSGustavo F. Padovan 28316327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 28326327eb98SAndrei Emeltchenko 28336327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 28346327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 28350a708f8fSGustavo F. Padovan 28360a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28370a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28380a708f8fSGustavo F. Padovan 2839f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2840f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2841f89cef09SAndrei Emeltchenko 28428c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 28430a708f8fSGustavo F. Padovan break; 28440a708f8fSGustavo F. Padovan 284547d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2846c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 284747d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 284847d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 28490a708f8fSGustavo F. Padovan } 28506327eb98SAndrei Emeltchenko 28516327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 28526327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 28536327eb98SAndrei Emeltchenko chan->tx_win); 28540a708f8fSGustavo F. Padovan break; 28550a708f8fSGustavo F. Padovan 28560a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 2857273759e2SMat Martineau l2cap_txwin_setup(chan); 28580a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 28590a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28600a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28610a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28620a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2863c8f79162SAndrei Emeltchenko 2864c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2865c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2866c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2867c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2868c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28690a708f8fSGustavo F. Padovan 28700a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28710a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28720a708f8fSGustavo F. Padovan 2873f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2874f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2875f89cef09SAndrei Emeltchenko 28768c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 28770a708f8fSGustavo F. Padovan break; 28780a708f8fSGustavo F. Padovan 287947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2880c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 288147d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 288247d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 28830a708f8fSGustavo F. Padovan } 28840a708f8fSGustavo F. Padovan break; 28850a708f8fSGustavo F. Padovan } 28860a708f8fSGustavo F. Padovan 2887fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 288859e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 28890a708f8fSGustavo F. Padovan 28900a708f8fSGustavo F. Padovan return ptr - data; 28910a708f8fSGustavo F. Padovan } 28920a708f8fSGustavo F. Padovan 289373ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 28940a708f8fSGustavo F. Padovan { 28950a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 28960a708f8fSGustavo F. Padovan void *ptr = rsp->data; 289773ffa904SGustavo F. Padovan void *req = chan->conf_req; 289873ffa904SGustavo F. Padovan int len = chan->conf_len; 28990a708f8fSGustavo F. Padovan int type, hint, olen; 29000a708f8fSGustavo F. Padovan unsigned long val; 29010a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 290242dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 290342dceae2SAndrei Emeltchenko u8 remote_efs = 0; 29040a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 29050a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 2906c8f79162SAndrei Emeltchenko u16 size; 29070a708f8fSGustavo F. Padovan 290873ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 29090a708f8fSGustavo F. Padovan 29100a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 29110a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 29120a708f8fSGustavo F. Padovan 29130a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 29140a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 29150a708f8fSGustavo F. Padovan 29160a708f8fSGustavo F. Padovan switch (type) { 29170a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 29180a708f8fSGustavo F. Padovan mtu = val; 29190a708f8fSGustavo F. Padovan break; 29200a708f8fSGustavo F. Padovan 29210a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 29220c1bc5c6SGustavo F. Padovan chan->flush_to = val; 29230a708f8fSGustavo F. Padovan break; 29240a708f8fSGustavo F. Padovan 29250a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 29260a708f8fSGustavo F. Padovan break; 29270a708f8fSGustavo F. Padovan 29280a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 29290a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 29300a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 29310a708f8fSGustavo F. Padovan break; 29320a708f8fSGustavo F. Padovan 29330a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 29340a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 2935c1360a1cSGustavo F. Padovan set_bit(CONF_NO_FCS_RECV, &chan->conf_state); 293642dceae2SAndrei Emeltchenko break; 29370a708f8fSGustavo F. Padovan 293842dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 293942dceae2SAndrei Emeltchenko remote_efs = 1; 294042dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 294142dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 29420a708f8fSGustavo F. Padovan break; 29430a708f8fSGustavo F. Padovan 29446327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 29456327eb98SAndrei Emeltchenko if (!enable_hs) 29466327eb98SAndrei Emeltchenko return -ECONNREFUSED; 29476327eb98SAndrei Emeltchenko 29486327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 29496327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 2950836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 29516327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 29520a708f8fSGustavo F. Padovan break; 29530a708f8fSGustavo F. Padovan 29540a708f8fSGustavo F. Padovan default: 29550a708f8fSGustavo F. Padovan if (hint) 29560a708f8fSGustavo F. Padovan break; 29570a708f8fSGustavo F. Padovan 29580a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 29590a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 29600a708f8fSGustavo F. Padovan break; 29610a708f8fSGustavo F. Padovan } 29620a708f8fSGustavo F. Padovan } 29630a708f8fSGustavo F. Padovan 296473ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 29650a708f8fSGustavo F. Padovan goto done; 29660a708f8fSGustavo F. Padovan 29670c1bc5c6SGustavo F. Padovan switch (chan->mode) { 29680a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 29690a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2970c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 29710c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 29728c1d787bSGustavo F. Padovan chan->conn->feat_mask); 29730a708f8fSGustavo F. Padovan break; 29740a708f8fSGustavo F. Padovan } 29750a708f8fSGustavo F. Padovan 297642dceae2SAndrei Emeltchenko if (remote_efs) { 297742dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 297842dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 297942dceae2SAndrei Emeltchenko else 298042dceae2SAndrei Emeltchenko return -ECONNREFUSED; 298142dceae2SAndrei Emeltchenko } 298242dceae2SAndrei Emeltchenko 29830c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 29840a708f8fSGustavo F. Padovan return -ECONNREFUSED; 29850a708f8fSGustavo F. Padovan 29860a708f8fSGustavo F. Padovan break; 29870a708f8fSGustavo F. Padovan } 29880a708f8fSGustavo F. Padovan 29890a708f8fSGustavo F. Padovan done: 29900c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 29910a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 29920c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 29930a708f8fSGustavo F. Padovan 299473ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 29950a708f8fSGustavo F. Padovan return -ECONNREFUSED; 29960a708f8fSGustavo F. Padovan 29970a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 29980a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 29990a708f8fSGustavo F. Padovan } 30000a708f8fSGustavo F. Padovan 30010a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 30020a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 30030a708f8fSGustavo F. Padovan * which ones we don't like. */ 30040a708f8fSGustavo F. Padovan 30050a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 30060a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30070a708f8fSGustavo F. Padovan else { 30080c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3009c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 30100a708f8fSGustavo F. Padovan } 30110c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 30120a708f8fSGustavo F. Padovan 301342dceae2SAndrei Emeltchenko if (remote_efs) { 301442dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 301542dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 301642dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 301742dceae2SAndrei Emeltchenko 301842dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 301942dceae2SAndrei Emeltchenko 302042dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 302142dceae2SAndrei Emeltchenko return -ECONNREFUSED; 302242dceae2SAndrei Emeltchenko 302342dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 302442dceae2SAndrei Emeltchenko sizeof(efs), 302542dceae2SAndrei Emeltchenko (unsigned long) &efs); 30260e8b207eSAndrei Emeltchenko } else { 30273e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 30280e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 30290e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 303042dceae2SAndrei Emeltchenko } 303142dceae2SAndrei Emeltchenko } 303242dceae2SAndrei Emeltchenko 30330a708f8fSGustavo F. Padovan switch (rfc.mode) { 30340a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 303547d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3036c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30370a708f8fSGustavo F. Padovan break; 30380a708f8fSGustavo F. Padovan 30390a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30406327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 30412c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 30426327eb98SAndrei Emeltchenko else 30436327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 30446327eb98SAndrei Emeltchenko 30452c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 30460a708f8fSGustavo F. Padovan 3047c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3048c8f79162SAndrei Emeltchenko chan->conn->mtu - 3049c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3050c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3051c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3052c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3053c8f79162SAndrei Emeltchenko chan->remote_mps = size; 30540a708f8fSGustavo F. Padovan 30550a708f8fSGustavo F. Padovan rfc.retrans_timeout = 30564fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 30570a708f8fSGustavo F. Padovan rfc.monitor_timeout = 30584fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 30590a708f8fSGustavo F. Padovan 3060c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30610a708f8fSGustavo F. Padovan 30620a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30630a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30640a708f8fSGustavo F. Padovan 306542dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 306642dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 306742dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 306842dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 306942dceae2SAndrei Emeltchenko chan->remote_flush_to = 307042dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 307142dceae2SAndrei Emeltchenko chan->remote_acc_lat = 307242dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 307342dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 307442dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 307542dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 307642dceae2SAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 307742dceae2SAndrei Emeltchenko } 30780a708f8fSGustavo F. Padovan break; 30790a708f8fSGustavo F. Padovan 30800a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3081c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3082c8f79162SAndrei Emeltchenko chan->conn->mtu - 3083c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3084c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3085c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3086c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3087c8f79162SAndrei Emeltchenko chan->remote_mps = size; 30880a708f8fSGustavo F. Padovan 3089c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30900a708f8fSGustavo F. Padovan 30910a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30920a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30930a708f8fSGustavo F. Padovan 30940a708f8fSGustavo F. Padovan break; 30950a708f8fSGustavo F. Padovan 30960a708f8fSGustavo F. Padovan default: 30970a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30980a708f8fSGustavo F. Padovan 30990a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 31000c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 31010a708f8fSGustavo F. Padovan } 31020a708f8fSGustavo F. Padovan 31030a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3104c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 31050a708f8fSGustavo F. Padovan } 3106fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 31070a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 310859e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 31090a708f8fSGustavo F. Padovan 31100a708f8fSGustavo F. Padovan return ptr - data; 31110a708f8fSGustavo F. Padovan } 31120a708f8fSGustavo F. Padovan 3113b4450035SGustavo F. Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, void *data, u16 *result) 31140a708f8fSGustavo F. Padovan { 31150a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 31160a708f8fSGustavo F. Padovan void *ptr = req->data; 31170a708f8fSGustavo F. Padovan int type, olen; 31180a708f8fSGustavo F. Padovan unsigned long val; 311936e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 312066af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 31210a708f8fSGustavo F. Padovan 3122fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 31230a708f8fSGustavo F. Padovan 31240a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 31250a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 31260a708f8fSGustavo F. Padovan 31270a708f8fSGustavo F. Padovan switch (type) { 31280a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 31290a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 31300a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 31310c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 31320a708f8fSGustavo F. Padovan } else 31330c1bc5c6SGustavo F. Padovan chan->imtu = val; 31340c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 31350a708f8fSGustavo F. Padovan break; 31360a708f8fSGustavo F. Padovan 31370a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 31380c1bc5c6SGustavo F. Padovan chan->flush_to = val; 31390a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 31400c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 31410a708f8fSGustavo F. Padovan break; 31420a708f8fSGustavo F. Padovan 31430a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 31440a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 31450a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 31460a708f8fSGustavo F. Padovan 3147c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 31480c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 31490a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31500a708f8fSGustavo F. Padovan 315147d1ec61SGustavo F. Padovan chan->fcs = 0; 31520a708f8fSGustavo F. Padovan 31530a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31540a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31550a708f8fSGustavo F. Padovan break; 31566327eb98SAndrei Emeltchenko 31576327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 31586327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, val, 31596327eb98SAndrei Emeltchenko L2CAP_DEFAULT_EXT_WINDOW); 31603e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 31613e6b3b95SGustavo F. Padovan chan->tx_win); 31626327eb98SAndrei Emeltchenko break; 316366af7aafSAndrei Emeltchenko 316466af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 316566af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 316666af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 316766af7aafSAndrei Emeltchenko 316866af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 316966af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 317066af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 317166af7aafSAndrei Emeltchenko return -ECONNREFUSED; 317266af7aafSAndrei Emeltchenko 317366af7aafSAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 317466af7aafSAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 317566af7aafSAndrei Emeltchenko break; 31760a708f8fSGustavo F. Padovan } 31770a708f8fSGustavo F. Padovan } 31780a708f8fSGustavo F. Padovan 31790c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 31800a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31810a708f8fSGustavo F. Padovan 31820c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 31830a708f8fSGustavo F. Padovan 31840e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 31850a708f8fSGustavo F. Padovan switch (rfc.mode) { 31860a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 318747d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 318847d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 318947d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 319066af7aafSAndrei Emeltchenko 319166af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 319266af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 319366af7aafSAndrei Emeltchenko chan->local_sdu_itime = 319466af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 319566af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 319666af7aafSAndrei Emeltchenko chan->local_flush_to = 319766af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 319866af7aafSAndrei Emeltchenko } 31990a708f8fSGustavo F. Padovan break; 320066af7aafSAndrei Emeltchenko 32010a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 320247d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 32030a708f8fSGustavo F. Padovan } 32040a708f8fSGustavo F. Padovan } 32050a708f8fSGustavo F. Padovan 3206fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 320759e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 32080a708f8fSGustavo F. Padovan 32090a708f8fSGustavo F. Padovan return ptr - data; 32100a708f8fSGustavo F. Padovan } 32110a708f8fSGustavo F. Padovan 3212fe4128e0SGustavo F. Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, u16 result, u16 flags) 32130a708f8fSGustavo F. Padovan { 32140a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 32150a708f8fSGustavo F. Padovan void *ptr = rsp->data; 32160a708f8fSGustavo F. Padovan 3217fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 32180a708f8fSGustavo F. Padovan 3219fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 32200a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 32210a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 32220a708f8fSGustavo F. Padovan 32230a708f8fSGustavo F. Padovan return ptr - data; 32240a708f8fSGustavo F. Padovan } 32250a708f8fSGustavo F. Padovan 32268c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3227710f9b0aSGustavo F. Padovan { 3228710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 32298c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3230710f9b0aSGustavo F. Padovan u8 buf[128]; 3231710f9b0aSGustavo F. Padovan 3232fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3233fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3234ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3235ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3236710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, 3237710f9b0aSGustavo F. Padovan L2CAP_CONN_RSP, sizeof(rsp), &rsp); 3238710f9b0aSGustavo F. Padovan 3239c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3240710f9b0aSGustavo F. Padovan return; 3241710f9b0aSGustavo F. Padovan 3242710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3243710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3244710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3245710f9b0aSGustavo F. Padovan } 3246710f9b0aSGustavo F. Padovan 324747d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 32480a708f8fSGustavo F. Padovan { 32490a708f8fSGustavo F. Padovan int type, olen; 32500a708f8fSGustavo F. Padovan unsigned long val; 32510a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc; 32520a708f8fSGustavo F. Padovan 325347d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 32540a708f8fSGustavo F. Padovan 32550c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 32560a708f8fSGustavo F. Padovan return; 32570a708f8fSGustavo F. Padovan 32580a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32590a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 32600a708f8fSGustavo F. Padovan 32610a708f8fSGustavo F. Padovan switch (type) { 32620a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 32630a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 32640a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 32650a708f8fSGustavo F. Padovan goto done; 32660a708f8fSGustavo F. Padovan } 32670a708f8fSGustavo F. Padovan } 32680a708f8fSGustavo F. Padovan 326936e999a8SMat Martineau /* Use sane default values in case a misbehaving remote device 327036e999a8SMat Martineau * did not send an RFC option. 327136e999a8SMat Martineau */ 327236e999a8SMat Martineau rfc.mode = chan->mode; 3273ac73498cSAndrei Emeltchenko rfc.retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 3274ac73498cSAndrei Emeltchenko rfc.monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 327536e999a8SMat Martineau rfc.max_pdu_size = cpu_to_le16(chan->imtu); 327636e999a8SMat Martineau 327736e999a8SMat Martineau BT_ERR("Expected RFC option was not found, using defaults"); 327836e999a8SMat Martineau 32790a708f8fSGustavo F. Padovan done: 32800a708f8fSGustavo F. Padovan switch (rfc.mode) { 32810a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 328247d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 328347d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 328447d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 32850a708f8fSGustavo F. Padovan break; 32860a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 328747d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 32880a708f8fSGustavo F. Padovan } 32890a708f8fSGustavo F. Padovan } 32900a708f8fSGustavo F. Padovan 32910a708f8fSGustavo F. Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 32920a708f8fSGustavo F. Padovan { 3293e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 32940a708f8fSGustavo F. Padovan 3295e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 32960a708f8fSGustavo F. Padovan return 0; 32970a708f8fSGustavo F. Padovan 32980a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 32990a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 330017cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 33010a708f8fSGustavo F. Padovan 33020a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 33030a708f8fSGustavo F. Padovan conn->info_ident = 0; 33040a708f8fSGustavo F. Padovan 33050a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 33060a708f8fSGustavo F. Padovan } 33070a708f8fSGustavo F. Padovan 33080a708f8fSGustavo F. Padovan return 0; 33090a708f8fSGustavo F. Padovan } 33100a708f8fSGustavo F. Padovan 33110a708f8fSGustavo F. Padovan static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 33120a708f8fSGustavo F. Padovan { 33130a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 33140a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 331523691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 33160a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 33170a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 33180a708f8fSGustavo F. Padovan 33190a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 33200a708f8fSGustavo F. Padovan __le16 psm = req->psm; 33210a708f8fSGustavo F. Padovan 3322097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 33230a708f8fSGustavo F. Padovan 33240a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3325c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 332623691d75SGustavo F. Padovan if (!pchan) { 33270a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 33280a708f8fSGustavo F. Padovan goto sendresp; 33290a708f8fSGustavo F. Padovan } 33300a708f8fSGustavo F. Padovan 333123691d75SGustavo F. Padovan parent = pchan->sk; 333223691d75SGustavo F. Padovan 33333df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3334aa2ac881SGustavo F. Padovan lock_sock(parent); 33350a708f8fSGustavo F. Padovan 33360a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 33372983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 33380a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 33399f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 33400a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 33410a708f8fSGustavo F. Padovan goto response; 33420a708f8fSGustavo F. Padovan } 33430a708f8fSGustavo F. Padovan 33440a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 33450a708f8fSGustavo F. Padovan 33462dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 33472dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 33482dfa1003SGustavo Padovan goto response; 33492dfa1003SGustavo Padovan 335080b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 335180808e43SGustavo F. Padovan if (!chan) 33520a708f8fSGustavo F. Padovan goto response; 33530a708f8fSGustavo F. Padovan 335480808e43SGustavo F. Padovan sk = chan->sk; 335580808e43SGustavo F. Padovan 33560a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 33570a708f8fSGustavo F. Padovan 33580a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 33590a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3360fe4128e0SGustavo F. Padovan chan->psm = psm; 3361fe4128e0SGustavo F. Padovan chan->dcid = scid; 33620a708f8fSGustavo F. Padovan 3363d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 3364d1010240SGustavo F. Padovan 33656be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 336648454079SGustavo F. Padovan 3367fe4128e0SGustavo F. Padovan dcid = chan->scid; 33680a708f8fSGustavo F. Padovan 3369c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 33700a708f8fSGustavo F. Padovan 3371fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 33720a708f8fSGustavo F. Padovan 33730a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3374d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3375c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 33760e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 33770a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 33780a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 33790a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 33800a708f8fSGustavo F. Padovan } else { 33810e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 33820a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 33830a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 33840a708f8fSGustavo F. Padovan } 33850a708f8fSGustavo F. Padovan } else { 33860e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 33870a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 33880a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 33890a708f8fSGustavo F. Padovan } 33900a708f8fSGustavo F. Padovan } else { 33910e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 33920a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 33930a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 33940a708f8fSGustavo F. Padovan } 33950a708f8fSGustavo F. Padovan 33960a708f8fSGustavo F. Padovan response: 3397aa2ac881SGustavo F. Padovan release_sock(parent); 33983df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 33990a708f8fSGustavo F. Padovan 34000a708f8fSGustavo F. Padovan sendresp: 34010a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 34020a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 34030a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 34040a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 34050a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp); 34060a708f8fSGustavo F. Padovan 34070a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 34080a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3409ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 34100a708f8fSGustavo F. Padovan 34110a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 34120a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 34130a708f8fSGustavo F. Padovan 3414ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 34150a708f8fSGustavo F. Padovan 34160a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 34170a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(info), &info); 34180a708f8fSGustavo F. Padovan } 34190a708f8fSGustavo F. Padovan 3420c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 34210a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 34220a708f8fSGustavo F. Padovan u8 buf[128]; 3423c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 34240a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 342573ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 342673ffa904SGustavo F. Padovan chan->num_conf_req++; 34270a708f8fSGustavo F. Padovan } 34280a708f8fSGustavo F. Padovan 34290a708f8fSGustavo F. Padovan return 0; 34300a708f8fSGustavo F. Padovan } 34310a708f8fSGustavo F. Padovan 34320a708f8fSGustavo F. Padovan static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 34330a708f8fSGustavo F. Padovan { 34340a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 34350a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 343648454079SGustavo F. Padovan struct l2cap_chan *chan; 34370a708f8fSGustavo F. Padovan u8 req[128]; 34383df91ea2SAndrei Emeltchenko int err; 34390a708f8fSGustavo F. Padovan 34400a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 34410a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 34420a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 34430a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 34440a708f8fSGustavo F. Padovan 34451b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 34461b009c98SAndrei Emeltchenko dcid, scid, result, status); 34470a708f8fSGustavo F. Padovan 34483df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 34493df91ea2SAndrei Emeltchenko 34500a708f8fSGustavo F. Padovan if (scid) { 34513df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 34523df91ea2SAndrei Emeltchenko if (!chan) { 34533df91ea2SAndrei Emeltchenko err = -EFAULT; 34543df91ea2SAndrei Emeltchenko goto unlock; 34553df91ea2SAndrei Emeltchenko } 34560a708f8fSGustavo F. Padovan } else { 34573df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 34583df91ea2SAndrei Emeltchenko if (!chan) { 34593df91ea2SAndrei Emeltchenko err = -EFAULT; 34603df91ea2SAndrei Emeltchenko goto unlock; 34613df91ea2SAndrei Emeltchenko } 34620a708f8fSGustavo F. Padovan } 34630a708f8fSGustavo F. Padovan 34643df91ea2SAndrei Emeltchenko err = 0; 34653df91ea2SAndrei Emeltchenko 34666be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 346748454079SGustavo F. Padovan 34680a708f8fSGustavo F. Padovan switch (result) { 34690a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 347089bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3471fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3472fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3473c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 34740a708f8fSGustavo F. Padovan 3475c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 34760a708f8fSGustavo F. Padovan break; 34770a708f8fSGustavo F. Padovan 34780a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 347973ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 348073ffa904SGustavo F. Padovan chan->num_conf_req++; 34810a708f8fSGustavo F. Padovan break; 34820a708f8fSGustavo F. Padovan 34830a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3484c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 34850a708f8fSGustavo F. Padovan break; 34860a708f8fSGustavo F. Padovan 34870a708f8fSGustavo F. Padovan default: 348848454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 34890a708f8fSGustavo F. Padovan break; 34900a708f8fSGustavo F. Padovan } 34910a708f8fSGustavo F. Padovan 34926be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 34933df91ea2SAndrei Emeltchenko 34943df91ea2SAndrei Emeltchenko unlock: 34953df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 34963df91ea2SAndrei Emeltchenko 34973df91ea2SAndrei Emeltchenko return err; 34980a708f8fSGustavo F. Padovan } 34990a708f8fSGustavo F. Padovan 350047d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 35010a708f8fSGustavo F. Padovan { 35020a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 35030a708f8fSGustavo F. Padovan * sides request it. 35040a708f8fSGustavo F. Padovan */ 35050c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 350647d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3507c1360a1cSGustavo F. Padovan else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) 350847d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 35090a708f8fSGustavo F. Padovan } 35100a708f8fSGustavo F. Padovan 35110a708f8fSGustavo F. Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 35120a708f8fSGustavo F. Padovan { 35130a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 35140a708f8fSGustavo F. Padovan u16 dcid, flags; 35150a708f8fSGustavo F. Padovan u8 rsp[64]; 351648454079SGustavo F. Padovan struct l2cap_chan *chan; 35173c588192SMat Martineau int len, err = 0; 35180a708f8fSGustavo F. Padovan 35190a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 35200a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 35210a708f8fSGustavo F. Padovan 35220a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 35230a708f8fSGustavo F. Padovan 3524baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 352548454079SGustavo F. Padovan if (!chan) 35260a708f8fSGustavo F. Padovan return -ENOENT; 35270a708f8fSGustavo F. Padovan 3528033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3529e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 35300a708f8fSGustavo F. Padovan 3531ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3532e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3533e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3534e2fd318eSIlia Kolomisnky 35350a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 35360a708f8fSGustavo F. Padovan sizeof(rej), &rej); 35370a708f8fSGustavo F. Padovan goto unlock; 35380a708f8fSGustavo F. Padovan } 35390a708f8fSGustavo F. Padovan 35400a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 35410a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 35427ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 35430a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3544fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35450a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 35460a708f8fSGustavo F. Padovan goto unlock; 35470a708f8fSGustavo F. Padovan } 35480a708f8fSGustavo F. Padovan 35490a708f8fSGustavo F. Padovan /* Store config. */ 355073ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 355173ffa904SGustavo F. Padovan chan->conf_len += len; 35520a708f8fSGustavo F. Padovan 355359e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 35540a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 35550a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3556fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35575325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 35580a708f8fSGustavo F. Padovan goto unlock; 35590a708f8fSGustavo F. Padovan } 35600a708f8fSGustavo F. Padovan 35610a708f8fSGustavo F. Padovan /* Complete config. */ 356273ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 35630a708f8fSGustavo F. Padovan if (len < 0) { 3564e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 35650a708f8fSGustavo F. Padovan goto unlock; 35660a708f8fSGustavo F. Padovan } 35670a708f8fSGustavo F. Padovan 35680a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 356973ffa904SGustavo F. Padovan chan->num_conf_rsp++; 35700a708f8fSGustavo F. Padovan 35710a708f8fSGustavo F. Padovan /* Reset config buffer. */ 357273ffa904SGustavo F. Padovan chan->conf_len = 0; 35730a708f8fSGustavo F. Padovan 3574c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 35750a708f8fSGustavo F. Padovan goto unlock; 35760a708f8fSGustavo F. Padovan 3577c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 357847d1ec61SGustavo F. Padovan set_default_fcs(chan); 35790a708f8fSGustavo F. Padovan 3580105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3581105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 35823c588192SMat Martineau err = l2cap_ertm_init(chan); 35830a708f8fSGustavo F. Padovan 35843c588192SMat Martineau if (err < 0) 35853c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 35863c588192SMat Martineau else 3587cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 35883c588192SMat Martineau 35890a708f8fSGustavo F. Padovan goto unlock; 35900a708f8fSGustavo F. Padovan } 35910a708f8fSGustavo F. Padovan 3592c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 35930a708f8fSGustavo F. Padovan u8 buf[64]; 35940a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 359573ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 359673ffa904SGustavo F. Padovan chan->num_conf_req++; 35970a708f8fSGustavo F. Padovan } 35980a708f8fSGustavo F. Padovan 35990e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 36000e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 36010e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 36020e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36030e8b207eSAndrei Emeltchenko 36040e8b207eSAndrei Emeltchenko /* check compatibility */ 36050e8b207eSAndrei Emeltchenko 36060e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36070e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36080e8b207eSAndrei Emeltchenko 36090e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36100e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, rsp, 36115325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 36120e8b207eSAndrei Emeltchenko } 36130e8b207eSAndrei Emeltchenko 36140a708f8fSGustavo F. Padovan unlock: 36156be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 36163c588192SMat Martineau return err; 36170a708f8fSGustavo F. Padovan } 36180a708f8fSGustavo F. Padovan 36190a708f8fSGustavo F. Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 36200a708f8fSGustavo F. Padovan { 36210a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 36220a708f8fSGustavo F. Padovan u16 scid, flags, result; 362348454079SGustavo F. Padovan struct l2cap_chan *chan; 362461386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 36253c588192SMat Martineau int err = 0; 36260a708f8fSGustavo F. Padovan 36270a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 36280a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 36290a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 36300a708f8fSGustavo F. Padovan 363161386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 363261386cbaSAndrei Emeltchenko result, len); 36330a708f8fSGustavo F. Padovan 3634baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 363548454079SGustavo F. Padovan if (!chan) 36360a708f8fSGustavo F. Padovan return 0; 36370a708f8fSGustavo F. Padovan 36380a708f8fSGustavo F. Padovan switch (result) { 36390a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 364047d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 36410e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36420a708f8fSGustavo F. Padovan break; 36430a708f8fSGustavo F. Padovan 36440e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 36450e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36460e8b207eSAndrei Emeltchenko 36470e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36480e8b207eSAndrei Emeltchenko char buf[64]; 36490e8b207eSAndrei Emeltchenko 36500e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 36510e8b207eSAndrei Emeltchenko buf, &result); 36520e8b207eSAndrei Emeltchenko if (len < 0) { 36530e8b207eSAndrei Emeltchenko l2cap_send_disconn_req(conn, chan, ECONNRESET); 36540e8b207eSAndrei Emeltchenko goto done; 36550e8b207eSAndrei Emeltchenko } 36560e8b207eSAndrei Emeltchenko 36570e8b207eSAndrei Emeltchenko /* check compatibility */ 36580e8b207eSAndrei Emeltchenko 36590e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36600e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36610e8b207eSAndrei Emeltchenko 36620e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36630e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, buf, 36640e8b207eSAndrei Emeltchenko L2CAP_CONF_SUCCESS, 0x0000), buf); 36650e8b207eSAndrei Emeltchenko } 36660e8b207eSAndrei Emeltchenko goto done; 36670e8b207eSAndrei Emeltchenko 36680a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 366973ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 36700a708f8fSGustavo F. Padovan char req[64]; 36710a708f8fSGustavo F. Padovan 36720a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 3673e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 36740a708f8fSGustavo F. Padovan goto done; 36750a708f8fSGustavo F. Padovan } 36760a708f8fSGustavo F. Padovan 36770a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 36780a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 3679b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 3680b4450035SGustavo F. Padovan req, &result); 36810a708f8fSGustavo F. Padovan if (len < 0) { 3682e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 36830a708f8fSGustavo F. Padovan goto done; 36840a708f8fSGustavo F. Padovan } 36850a708f8fSGustavo F. Padovan 36860a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 36870a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 368873ffa904SGustavo F. Padovan chan->num_conf_req++; 36890a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 36900a708f8fSGustavo F. Padovan goto done; 36910a708f8fSGustavo F. Padovan break; 36920a708f8fSGustavo F. Padovan } 36930a708f8fSGustavo F. Padovan 36940a708f8fSGustavo F. Padovan default: 36956be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 36962e0052e4SAndrei Emeltchenko 3697ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 3698e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 36990a708f8fSGustavo F. Padovan goto done; 37000a708f8fSGustavo F. Padovan } 37010a708f8fSGustavo F. Padovan 370259e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 37030a708f8fSGustavo F. Padovan goto done; 37040a708f8fSGustavo F. Padovan 3705c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 37060a708f8fSGustavo F. Padovan 3707c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 370847d1ec61SGustavo F. Padovan set_default_fcs(chan); 37090a708f8fSGustavo F. Padovan 3710105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3711105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 37123c588192SMat Martineau err = l2cap_ertm_init(chan); 37130a708f8fSGustavo F. Padovan 37143c588192SMat Martineau if (err < 0) 37153c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 37163c588192SMat Martineau else 3717cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 37180a708f8fSGustavo F. Padovan } 37190a708f8fSGustavo F. Padovan 37200a708f8fSGustavo F. Padovan done: 37216be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37223c588192SMat Martineau return err; 37230a708f8fSGustavo F. Padovan } 37240a708f8fSGustavo F. Padovan 37250a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 37260a708f8fSGustavo F. Padovan { 37270a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 37280a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 37290a708f8fSGustavo F. Padovan u16 dcid, scid; 373048454079SGustavo F. Padovan struct l2cap_chan *chan; 37310a708f8fSGustavo F. Padovan struct sock *sk; 37320a708f8fSGustavo F. Padovan 37330a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 37340a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 37350a708f8fSGustavo F. Padovan 37360a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 37370a708f8fSGustavo F. Padovan 37383df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37393df91ea2SAndrei Emeltchenko 37403df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 37413df91ea2SAndrei Emeltchenko if (!chan) { 37423df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37430a708f8fSGustavo F. Padovan return 0; 37443df91ea2SAndrei Emeltchenko } 37450a708f8fSGustavo F. Padovan 37466be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 37476be36555SAndrei Emeltchenko 374848454079SGustavo F. Padovan sk = chan->sk; 374948454079SGustavo F. Padovan 3750fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3751fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 37520a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 37530a708f8fSGustavo F. Padovan 37546be36555SAndrei Emeltchenko lock_sock(sk); 37550a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 37566be36555SAndrei Emeltchenko release_sock(sk); 37570a708f8fSGustavo F. Padovan 375861d6ef3eSMat Martineau l2cap_chan_hold(chan); 375948454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 37606be36555SAndrei Emeltchenko 37616be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37620a708f8fSGustavo F. Padovan 376380b98027SGustavo Padovan chan->ops->close(chan); 376461d6ef3eSMat Martineau l2cap_chan_put(chan); 37653df91ea2SAndrei Emeltchenko 37663df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37673df91ea2SAndrei Emeltchenko 37680a708f8fSGustavo F. Padovan return 0; 37690a708f8fSGustavo F. Padovan } 37700a708f8fSGustavo F. Padovan 37710a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 37720a708f8fSGustavo F. Padovan { 37730a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 37740a708f8fSGustavo F. Padovan u16 dcid, scid; 377548454079SGustavo F. Padovan struct l2cap_chan *chan; 37760a708f8fSGustavo F. Padovan 37770a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 37780a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 37790a708f8fSGustavo F. Padovan 37800a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 37810a708f8fSGustavo F. Padovan 37823df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37833df91ea2SAndrei Emeltchenko 37843df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 37853df91ea2SAndrei Emeltchenko if (!chan) { 37863df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37870a708f8fSGustavo F. Padovan return 0; 37883df91ea2SAndrei Emeltchenko } 37890a708f8fSGustavo F. Padovan 37906be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 379148454079SGustavo F. Padovan 379261d6ef3eSMat Martineau l2cap_chan_hold(chan); 379348454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 37946be36555SAndrei Emeltchenko 37956be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37960a708f8fSGustavo F. Padovan 379780b98027SGustavo Padovan chan->ops->close(chan); 379861d6ef3eSMat Martineau l2cap_chan_put(chan); 37993df91ea2SAndrei Emeltchenko 38003df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38013df91ea2SAndrei Emeltchenko 38020a708f8fSGustavo F. Padovan return 0; 38030a708f8fSGustavo F. Padovan } 38040a708f8fSGustavo F. Padovan 38050a708f8fSGustavo F. Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38060a708f8fSGustavo F. Padovan { 38070a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 38080a708f8fSGustavo F. Padovan u16 type; 38090a708f8fSGustavo F. Padovan 38100a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 38110a708f8fSGustavo F. Padovan 38120a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 38130a708f8fSGustavo F. Padovan 38140a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 38150a708f8fSGustavo F. Padovan u8 buf[8]; 38160a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 38170a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 3818ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 3819ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 38200a708f8fSGustavo F. Padovan if (!disable_ertm) 38210a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 38220a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 3823a5fd6f30SAndrei Emeltchenko if (enable_hs) 38246327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 38256327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 3826a5fd6f30SAndrei Emeltchenko 38270a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 38280a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38290a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38300a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 38310a708f8fSGustavo F. Padovan u8 buf[12]; 38320a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 383350a147cdSMat Martineau 383450a147cdSMat Martineau if (enable_hs) 383550a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 383650a147cdSMat Martineau else 383750a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 383850a147cdSMat Martineau 3839ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 3840ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 3841c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 38420a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38430a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38440a708f8fSGustavo F. Padovan } else { 38450a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 38460a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 3847ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 38480a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38490a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(rsp), &rsp); 38500a708f8fSGustavo F. Padovan } 38510a708f8fSGustavo F. Padovan 38520a708f8fSGustavo F. Padovan return 0; 38530a708f8fSGustavo F. Padovan } 38540a708f8fSGustavo F. Padovan 38550a708f8fSGustavo F. Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38560a708f8fSGustavo F. Padovan { 38570a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 38580a708f8fSGustavo F. Padovan u16 type, result; 38590a708f8fSGustavo F. Padovan 38600a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 38610a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 38620a708f8fSGustavo F. Padovan 38630a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 38640a708f8fSGustavo F. Padovan 3865e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 3866e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 3867e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 3868e90165beSAndrei Emeltchenko return 0; 3869e90165beSAndrei Emeltchenko 387017cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 38710a708f8fSGustavo F. Padovan 38720a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 38730a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 38740a708f8fSGustavo F. Padovan conn->info_ident = 0; 38750a708f8fSGustavo F. Padovan 38760a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 38770a708f8fSGustavo F. Padovan 38780a708f8fSGustavo F. Padovan return 0; 38790a708f8fSGustavo F. Padovan } 38800a708f8fSGustavo F. Padovan 3881978c93b9SAndrei Emeltchenko switch (type) { 3882978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 38830a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 38840a708f8fSGustavo F. Padovan 38850a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 38860a708f8fSGustavo F. Padovan struct l2cap_info_req req; 3887ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 38880a708f8fSGustavo F. Padovan 38890a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 38900a708f8fSGustavo F. Padovan 38910a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 38920a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 38930a708f8fSGustavo F. Padovan } else { 38940a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 38950a708f8fSGustavo F. Padovan conn->info_ident = 0; 38960a708f8fSGustavo F. Padovan 38970a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 38980a708f8fSGustavo F. Padovan } 3899978c93b9SAndrei Emeltchenko break; 3900978c93b9SAndrei Emeltchenko 3901978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 3902978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 39030a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39040a708f8fSGustavo F. Padovan conn->info_ident = 0; 39050a708f8fSGustavo F. Padovan 39060a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 3907978c93b9SAndrei Emeltchenko break; 39080a708f8fSGustavo F. Padovan } 39090a708f8fSGustavo F. Padovan 39100a708f8fSGustavo F. Padovan return 0; 39110a708f8fSGustavo F. Padovan } 39120a708f8fSGustavo F. Padovan 3913f94ff6ffSMat Martineau static inline int l2cap_create_channel_req(struct l2cap_conn *conn, 3914f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3915f94ff6ffSMat Martineau void *data) 3916f94ff6ffSMat Martineau { 3917f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 3918f94ff6ffSMat Martineau struct l2cap_create_chan_rsp rsp; 3919f94ff6ffSMat Martineau u16 psm, scid; 3920f94ff6ffSMat Martineau 3921f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 3922f94ff6ffSMat Martineau return -EPROTO; 3923f94ff6ffSMat Martineau 3924f94ff6ffSMat Martineau if (!enable_hs) 3925f94ff6ffSMat Martineau return -EINVAL; 3926f94ff6ffSMat Martineau 3927f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 3928f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 3929f94ff6ffSMat Martineau 3930f94ff6ffSMat Martineau BT_DBG("psm %d, scid %d, amp_id %d", psm, scid, req->amp_id); 3931f94ff6ffSMat Martineau 3932f94ff6ffSMat Martineau /* Placeholder: Always reject */ 3933f94ff6ffSMat Martineau rsp.dcid = 0; 3934f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 39358ce0c498SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_NO_MEM); 39368ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3937f94ff6ffSMat Martineau 3938f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 3939f94ff6ffSMat Martineau sizeof(rsp), &rsp); 3940f94ff6ffSMat Martineau 3941f94ff6ffSMat Martineau return 0; 3942f94ff6ffSMat Martineau } 3943f94ff6ffSMat Martineau 3944f94ff6ffSMat Martineau static inline int l2cap_create_channel_rsp(struct l2cap_conn *conn, 3945f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, void *data) 3946f94ff6ffSMat Martineau { 3947f94ff6ffSMat Martineau BT_DBG("conn %p", conn); 3948f94ff6ffSMat Martineau 3949f94ff6ffSMat Martineau return l2cap_connect_rsp(conn, cmd, data); 3950f94ff6ffSMat Martineau } 3951f94ff6ffSMat Martineau 39528d5a04a1SMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_conn *conn, u8 ident, 39538d5a04a1SMat Martineau u16 icid, u16 result) 39548d5a04a1SMat Martineau { 39558d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 39568d5a04a1SMat Martineau 39578d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 39588d5a04a1SMat Martineau 39598d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 39608d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 39618d5a04a1SMat Martineau 39628d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_RSP, sizeof(rsp), &rsp); 39638d5a04a1SMat Martineau } 39648d5a04a1SMat Martineau 39658d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_conn *conn, 39668d5a04a1SMat Martineau struct l2cap_chan *chan, u16 icid, u16 result) 39678d5a04a1SMat Martineau { 39688d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 39698d5a04a1SMat Martineau u8 ident; 39708d5a04a1SMat Martineau 39718d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 39728d5a04a1SMat Martineau 39738d5a04a1SMat Martineau ident = l2cap_get_ident(conn); 39748d5a04a1SMat Martineau if (chan) 39758d5a04a1SMat Martineau chan->ident = ident; 39768d5a04a1SMat Martineau 39778d5a04a1SMat Martineau cfm.icid = cpu_to_le16(icid); 39788d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 39798d5a04a1SMat Martineau 39808d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM, sizeof(cfm), &cfm); 39818d5a04a1SMat Martineau } 39828d5a04a1SMat Martineau 39838d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 39848d5a04a1SMat Martineau u16 icid) 39858d5a04a1SMat Martineau { 39868d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 39878d5a04a1SMat Martineau 39888d5a04a1SMat Martineau BT_DBG("icid %d", icid); 39898d5a04a1SMat Martineau 39908d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 39918d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 39928d5a04a1SMat Martineau } 39938d5a04a1SMat Martineau 39948d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 39958d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 39968d5a04a1SMat Martineau { 39978d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 39988d5a04a1SMat Martineau u16 icid = 0; 39998d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 40008d5a04a1SMat Martineau 40018d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 40028d5a04a1SMat Martineau return -EPROTO; 40038d5a04a1SMat Martineau 40048d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 40058d5a04a1SMat Martineau 40068d5a04a1SMat Martineau BT_DBG("icid %d, dest_amp_id %d", icid, req->dest_amp_id); 40078d5a04a1SMat Martineau 40088d5a04a1SMat Martineau if (!enable_hs) 40098d5a04a1SMat Martineau return -EINVAL; 40108d5a04a1SMat Martineau 40118d5a04a1SMat Martineau /* Placeholder: Always refuse */ 40128d5a04a1SMat Martineau l2cap_send_move_chan_rsp(conn, cmd->ident, icid, result); 40138d5a04a1SMat Martineau 40148d5a04a1SMat Martineau return 0; 40158d5a04a1SMat Martineau } 40168d5a04a1SMat Martineau 40178d5a04a1SMat Martineau static inline int l2cap_move_channel_rsp(struct l2cap_conn *conn, 40188d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40198d5a04a1SMat Martineau { 40208d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 40218d5a04a1SMat Martineau u16 icid, result; 40228d5a04a1SMat Martineau 40238d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 40248d5a04a1SMat Martineau return -EPROTO; 40258d5a04a1SMat Martineau 40268d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 40278d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 40288d5a04a1SMat Martineau 40298d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 40308d5a04a1SMat Martineau 40318d5a04a1SMat Martineau /* Placeholder: Always unconfirmed */ 40328d5a04a1SMat Martineau l2cap_send_move_chan_cfm(conn, NULL, icid, L2CAP_MC_UNCONFIRMED); 40338d5a04a1SMat Martineau 40348d5a04a1SMat Martineau return 0; 40358d5a04a1SMat Martineau } 40368d5a04a1SMat Martineau 40378d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm(struct l2cap_conn *conn, 40388d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40398d5a04a1SMat Martineau { 40408d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 40418d5a04a1SMat Martineau u16 icid, result; 40428d5a04a1SMat Martineau 40438d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 40448d5a04a1SMat Martineau return -EPROTO; 40458d5a04a1SMat Martineau 40468d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 40478d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 40488d5a04a1SMat Martineau 40498d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 40508d5a04a1SMat Martineau 40518d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 40528d5a04a1SMat Martineau 40538d5a04a1SMat Martineau return 0; 40548d5a04a1SMat Martineau } 40558d5a04a1SMat Martineau 40568d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 40578d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40588d5a04a1SMat Martineau { 40598d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 40608d5a04a1SMat Martineau u16 icid; 40618d5a04a1SMat Martineau 40628d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 40638d5a04a1SMat Martineau return -EPROTO; 40648d5a04a1SMat Martineau 40658d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 40668d5a04a1SMat Martineau 40678d5a04a1SMat Martineau BT_DBG("icid %d", icid); 40688d5a04a1SMat Martineau 40698d5a04a1SMat Martineau return 0; 40708d5a04a1SMat Martineau } 40718d5a04a1SMat Martineau 4072e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4073de73115aSClaudio Takahasi u16 to_multiplier) 4074de73115aSClaudio Takahasi { 4075de73115aSClaudio Takahasi u16 max_latency; 4076de73115aSClaudio Takahasi 4077de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4078de73115aSClaudio Takahasi return -EINVAL; 4079de73115aSClaudio Takahasi 4080de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4081de73115aSClaudio Takahasi return -EINVAL; 4082de73115aSClaudio Takahasi 4083de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4084de73115aSClaudio Takahasi return -EINVAL; 4085de73115aSClaudio Takahasi 4086de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 4087de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 4088de73115aSClaudio Takahasi return -EINVAL; 4089de73115aSClaudio Takahasi 4090de73115aSClaudio Takahasi return 0; 4091de73115aSClaudio Takahasi } 4092de73115aSClaudio Takahasi 4093de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 4094de73115aSClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 4095de73115aSClaudio Takahasi { 4096de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 4097de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 4098de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 4099de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 41002ce603ebSClaudio Takahasi int err; 4101de73115aSClaudio Takahasi 4102de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 4103de73115aSClaudio Takahasi return -EINVAL; 4104de73115aSClaudio Takahasi 4105de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 4106de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 4107de73115aSClaudio Takahasi return -EPROTO; 4108de73115aSClaudio Takahasi 4109de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 4110de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 4111de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 4112de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 4113de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 4114de73115aSClaudio Takahasi 4115de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 4116de73115aSClaudio Takahasi min, max, latency, to_multiplier); 4117de73115aSClaudio Takahasi 4118de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 41192ce603ebSClaudio Takahasi 41202ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 41212ce603ebSClaudio Takahasi if (err) 4122ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 4123de73115aSClaudio Takahasi else 4124ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 4125de73115aSClaudio Takahasi 4126de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 4127de73115aSClaudio Takahasi sizeof(rsp), &rsp); 4128de73115aSClaudio Takahasi 41292ce603ebSClaudio Takahasi if (!err) 41302ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 41312ce603ebSClaudio Takahasi 4132de73115aSClaudio Takahasi return 0; 4133de73115aSClaudio Takahasi } 4134de73115aSClaudio Takahasi 41353300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 41363300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 41373300d9a9SClaudio Takahasi { 41383300d9a9SClaudio Takahasi int err = 0; 41393300d9a9SClaudio Takahasi 41403300d9a9SClaudio Takahasi switch (cmd->code) { 41413300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 41423300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 41433300d9a9SClaudio Takahasi break; 41443300d9a9SClaudio Takahasi 41453300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 41463300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 41473300d9a9SClaudio Takahasi break; 41483300d9a9SClaudio Takahasi 41493300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 41503300d9a9SClaudio Takahasi err = l2cap_connect_rsp(conn, cmd, data); 41513300d9a9SClaudio Takahasi break; 41523300d9a9SClaudio Takahasi 41533300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 41543300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 41553300d9a9SClaudio Takahasi break; 41563300d9a9SClaudio Takahasi 41573300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 41583300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 41593300d9a9SClaudio Takahasi break; 41603300d9a9SClaudio Takahasi 41613300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 41623300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 41633300d9a9SClaudio Takahasi break; 41643300d9a9SClaudio Takahasi 41653300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 41663300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 41673300d9a9SClaudio Takahasi break; 41683300d9a9SClaudio Takahasi 41693300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 41703300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 41713300d9a9SClaudio Takahasi break; 41723300d9a9SClaudio Takahasi 41733300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 41743300d9a9SClaudio Takahasi break; 41753300d9a9SClaudio Takahasi 41763300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 41773300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 41783300d9a9SClaudio Takahasi break; 41793300d9a9SClaudio Takahasi 41803300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 41813300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 41823300d9a9SClaudio Takahasi break; 41833300d9a9SClaudio Takahasi 4184f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 4185f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 4186f94ff6ffSMat Martineau break; 4187f94ff6ffSMat Martineau 4188f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_RSP: 4189f94ff6ffSMat Martineau err = l2cap_create_channel_rsp(conn, cmd, data); 4190f94ff6ffSMat Martineau break; 4191f94ff6ffSMat Martineau 41928d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 41938d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 41948d5a04a1SMat Martineau break; 41958d5a04a1SMat Martineau 41968d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 41978d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 41988d5a04a1SMat Martineau break; 41998d5a04a1SMat Martineau 42008d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 42018d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 42028d5a04a1SMat Martineau break; 42038d5a04a1SMat Martineau 42048d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 42058d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 42068d5a04a1SMat Martineau break; 42078d5a04a1SMat Martineau 42083300d9a9SClaudio Takahasi default: 42093300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 42103300d9a9SClaudio Takahasi err = -EINVAL; 42113300d9a9SClaudio Takahasi break; 42123300d9a9SClaudio Takahasi } 42133300d9a9SClaudio Takahasi 42143300d9a9SClaudio Takahasi return err; 42153300d9a9SClaudio Takahasi } 42163300d9a9SClaudio Takahasi 42173300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 42183300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 42193300d9a9SClaudio Takahasi { 42203300d9a9SClaudio Takahasi switch (cmd->code) { 42213300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 42223300d9a9SClaudio Takahasi return 0; 42233300d9a9SClaudio Takahasi 42243300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 4225de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 42263300d9a9SClaudio Takahasi 42273300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 42283300d9a9SClaudio Takahasi return 0; 42293300d9a9SClaudio Takahasi 42303300d9a9SClaudio Takahasi default: 42313300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 42323300d9a9SClaudio Takahasi return -EINVAL; 42333300d9a9SClaudio Takahasi } 42343300d9a9SClaudio Takahasi } 42353300d9a9SClaudio Takahasi 42363300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 42373300d9a9SClaudio Takahasi struct sk_buff *skb) 42380a708f8fSGustavo F. Padovan { 42390a708f8fSGustavo F. Padovan u8 *data = skb->data; 42400a708f8fSGustavo F. Padovan int len = skb->len; 42410a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 42423300d9a9SClaudio Takahasi int err; 42430a708f8fSGustavo F. Padovan 42440a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 42450a708f8fSGustavo F. Padovan 42460a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 42470a708f8fSGustavo F. Padovan u16 cmd_len; 42480a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 42490a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 42500a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 42510a708f8fSGustavo F. Padovan 42520a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 42530a708f8fSGustavo F. Padovan 42540a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, cmd.ident); 42550a708f8fSGustavo F. Padovan 42560a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 42570a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 42580a708f8fSGustavo F. Padovan break; 42590a708f8fSGustavo F. Padovan } 42600a708f8fSGustavo F. Padovan 42613300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 42623300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 42633300d9a9SClaudio Takahasi else 42643300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 42650a708f8fSGustavo F. Padovan 42660a708f8fSGustavo F. Padovan if (err) { 4267e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 42682c6d1a2eSGustavo F. Padovan 42692c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 42700a708f8fSGustavo F. Padovan 42710a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 4272ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 42730a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej); 42740a708f8fSGustavo F. Padovan } 42750a708f8fSGustavo F. Padovan 42760a708f8fSGustavo F. Padovan data += cmd_len; 42770a708f8fSGustavo F. Padovan len -= cmd_len; 42780a708f8fSGustavo F. Padovan } 42790a708f8fSGustavo F. Padovan 42800a708f8fSGustavo F. Padovan kfree_skb(skb); 42810a708f8fSGustavo F. Padovan } 42820a708f8fSGustavo F. Padovan 428347d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 42840a708f8fSGustavo F. Padovan { 42850a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 4286e4ca6d98SAndrei Emeltchenko int hdr_size; 4287e4ca6d98SAndrei Emeltchenko 4288e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 4289e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 4290e4ca6d98SAndrei Emeltchenko else 4291e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 42920a708f8fSGustavo F. Padovan 429347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 429403a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 42950a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 42960a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 42970a708f8fSGustavo F. Padovan 42980a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 42990a708f8fSGustavo F. Padovan return -EBADMSG; 43000a708f8fSGustavo F. Padovan } 43010a708f8fSGustavo F. Padovan return 0; 43020a708f8fSGustavo F. Padovan } 43030a708f8fSGustavo F. Padovan 43046ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 43050a708f8fSGustavo F. Padovan { 4306e31f7633SMat Martineau struct l2cap_ctrl control; 43070a708f8fSGustavo F. Padovan 4308e31f7633SMat Martineau BT_DBG("chan %p", chan); 43090a708f8fSGustavo F. Padovan 4310e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 4311e31f7633SMat Martineau control.sframe = 1; 4312e31f7633SMat Martineau control.final = 1; 4313e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 4314e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 43150a708f8fSGustavo F. Padovan 4316e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4317e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 4318e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43190a708f8fSGustavo F. Padovan } 43200a708f8fSGustavo F. Padovan 4321e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 4322e31f7633SMat Martineau chan->unacked_frames > 0) 4323e31f7633SMat Martineau __set_retrans_timer(chan); 43240a708f8fSGustavo F. Padovan 4325e31f7633SMat Martineau /* Send pending iframes */ 4326525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 43270a708f8fSGustavo F. Padovan 4328e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 4329e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 4330e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 4331e31f7633SMat Martineau * send it now. 4332e31f7633SMat Martineau */ 4333e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 4334e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43350a708f8fSGustavo F. Padovan } 43360a708f8fSGustavo F. Padovan } 43370a708f8fSGustavo F. Padovan 433884084a31SMat Martineau static void append_skb_frag(struct sk_buff *skb, 433984084a31SMat Martineau struct sk_buff *new_frag, struct sk_buff **last_frag) 43400a708f8fSGustavo F. Padovan { 434184084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 434284084a31SMat Martineau * skb->data_len reflects only data in fragments 434384084a31SMat Martineau */ 434484084a31SMat Martineau if (!skb_has_frag_list(skb)) 434584084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 434684084a31SMat Martineau 434784084a31SMat Martineau new_frag->next = NULL; 434884084a31SMat Martineau 434984084a31SMat Martineau (*last_frag)->next = new_frag; 435084084a31SMat Martineau *last_frag = new_frag; 435184084a31SMat Martineau 435284084a31SMat Martineau skb->len += new_frag->len; 435384084a31SMat Martineau skb->data_len += new_frag->len; 435484084a31SMat Martineau skb->truesize += new_frag->truesize; 435584084a31SMat Martineau } 435684084a31SMat Martineau 43574b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 43584b51dae9SMat Martineau struct l2cap_ctrl *control) 435984084a31SMat Martineau { 436084084a31SMat Martineau int err = -EINVAL; 43610a708f8fSGustavo F. Padovan 43624b51dae9SMat Martineau switch (control->sar) { 43637e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 436484084a31SMat Martineau if (chan->sdu) 436584084a31SMat Martineau break; 43660a708f8fSGustavo F. Padovan 436780b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 436884084a31SMat Martineau break; 43690a708f8fSGustavo F. Padovan 43707e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 437184084a31SMat Martineau if (chan->sdu) 437284084a31SMat Martineau break; 43730a708f8fSGustavo F. Padovan 43746f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 437503a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 43760a708f8fSGustavo F. Padovan 437784084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 437884084a31SMat Martineau err = -EMSGSIZE; 437984084a31SMat Martineau break; 438084084a31SMat Martineau } 43810a708f8fSGustavo F. Padovan 438284084a31SMat Martineau if (skb->len >= chan->sdu_len) 438384084a31SMat Martineau break; 438484084a31SMat Martineau 438584084a31SMat Martineau chan->sdu = skb; 438684084a31SMat Martineau chan->sdu_last_frag = skb; 438784084a31SMat Martineau 438884084a31SMat Martineau skb = NULL; 438984084a31SMat Martineau err = 0; 43900a708f8fSGustavo F. Padovan break; 43910a708f8fSGustavo F. Padovan 43927e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 43936f61fd47SGustavo F. Padovan if (!chan->sdu) 439484084a31SMat Martineau break; 43950a708f8fSGustavo F. Padovan 439684084a31SMat Martineau append_skb_frag(chan->sdu, skb, 439784084a31SMat Martineau &chan->sdu_last_frag); 439884084a31SMat Martineau skb = NULL; 43990a708f8fSGustavo F. Padovan 440084084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 440184084a31SMat Martineau break; 44020a708f8fSGustavo F. Padovan 440384084a31SMat Martineau err = 0; 44040a708f8fSGustavo F. Padovan break; 44050a708f8fSGustavo F. Padovan 44067e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 44076f61fd47SGustavo F. Padovan if (!chan->sdu) 440884084a31SMat Martineau break; 44090a708f8fSGustavo F. Padovan 441084084a31SMat Martineau append_skb_frag(chan->sdu, skb, 441184084a31SMat Martineau &chan->sdu_last_frag); 441284084a31SMat Martineau skb = NULL; 44130a708f8fSGustavo F. Padovan 441484084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 441584084a31SMat Martineau break; 44160a708f8fSGustavo F. Padovan 441780b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 44180a708f8fSGustavo F. Padovan 441984084a31SMat Martineau if (!err) { 442084084a31SMat Martineau /* Reassembly complete */ 442184084a31SMat Martineau chan->sdu = NULL; 442284084a31SMat Martineau chan->sdu_last_frag = NULL; 442384084a31SMat Martineau chan->sdu_len = 0; 44240a708f8fSGustavo F. Padovan } 44250a708f8fSGustavo F. Padovan break; 44260a708f8fSGustavo F. Padovan } 44270a708f8fSGustavo F. Padovan 442884084a31SMat Martineau if (err) { 44290a708f8fSGustavo F. Padovan kfree_skb(skb); 44306f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 44316f61fd47SGustavo F. Padovan chan->sdu = NULL; 443284084a31SMat Martineau chan->sdu_last_frag = NULL; 443384084a31SMat Martineau chan->sdu_len = 0; 443484084a31SMat Martineau } 44350a708f8fSGustavo F. Padovan 443684084a31SMat Martineau return err; 44370a708f8fSGustavo F. Padovan } 44380a708f8fSGustavo F. Padovan 4439e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 44400a708f8fSGustavo F. Padovan { 444161aa4f5bSMat Martineau u8 event; 444261aa4f5bSMat Martineau 444361aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 444461aa4f5bSMat Martineau return; 444561aa4f5bSMat Martineau 444661aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 4447401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 44480a708f8fSGustavo F. Padovan } 44490a708f8fSGustavo F. Padovan 4450d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 4451d2a7ac5dSMat Martineau { 445263838725SMat Martineau int err = 0; 445363838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 445463838725SMat Martineau * until a gap is encountered. 445563838725SMat Martineau */ 445663838725SMat Martineau 445763838725SMat Martineau BT_DBG("chan %p", chan); 445863838725SMat Martineau 445963838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 446063838725SMat Martineau struct sk_buff *skb; 446163838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 446263838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 446363838725SMat Martineau 446463838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 446563838725SMat Martineau 446663838725SMat Martineau if (!skb) 446763838725SMat Martineau break; 446863838725SMat Martineau 446963838725SMat Martineau skb_unlink(skb, &chan->srej_q); 447063838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 447163838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 447263838725SMat Martineau if (err) 447363838725SMat Martineau break; 447463838725SMat Martineau } 447563838725SMat Martineau 447663838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 447763838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 447863838725SMat Martineau l2cap_send_ack(chan); 447963838725SMat Martineau } 448063838725SMat Martineau 448163838725SMat Martineau return err; 4482d2a7ac5dSMat Martineau } 4483d2a7ac5dSMat Martineau 4484d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 4485d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4486d2a7ac5dSMat Martineau { 4487f80842a8SMat Martineau struct sk_buff *skb; 4488f80842a8SMat Martineau 4489f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 4490f80842a8SMat Martineau 4491f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 4492f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4493f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4494f80842a8SMat Martineau return; 4495f80842a8SMat Martineau } 4496f80842a8SMat Martineau 4497f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4498f80842a8SMat Martineau 4499f80842a8SMat Martineau if (skb == NULL) { 4500f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 4501f80842a8SMat Martineau control->reqseq); 4502f80842a8SMat Martineau return; 4503f80842a8SMat Martineau } 4504f80842a8SMat Martineau 4505f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 4506f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4507f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4508f80842a8SMat Martineau return; 4509f80842a8SMat Martineau } 4510f80842a8SMat Martineau 4511f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4512f80842a8SMat Martineau 4513f80842a8SMat Martineau if (control->poll) { 4514f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 4515f80842a8SMat Martineau 4516f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4517f80842a8SMat Martineau l2cap_retransmit(chan, control); 4518f80842a8SMat Martineau l2cap_ertm_send(chan); 4519f80842a8SMat Martineau 4520f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4521f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4522f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4523f80842a8SMat Martineau } 4524f80842a8SMat Martineau } else { 4525f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 4526f80842a8SMat Martineau 4527f80842a8SMat Martineau if (control->final) { 4528f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 4529f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 4530f80842a8SMat Martineau &chan->conn_state)) 4531f80842a8SMat Martineau l2cap_retransmit(chan, control); 4532f80842a8SMat Martineau } else { 4533f80842a8SMat Martineau l2cap_retransmit(chan, control); 4534f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4535f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4536f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4537f80842a8SMat Martineau } 4538f80842a8SMat Martineau } 4539f80842a8SMat Martineau } 4540d2a7ac5dSMat Martineau } 4541d2a7ac5dSMat Martineau 4542d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 4543d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4544d2a7ac5dSMat Martineau { 4545fcd289dfSMat Martineau struct sk_buff *skb; 4546fcd289dfSMat Martineau 4547fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 4548fcd289dfSMat Martineau 4549fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 4550fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4551fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4552fcd289dfSMat Martineau return; 4553fcd289dfSMat Martineau } 4554fcd289dfSMat Martineau 4555fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4556fcd289dfSMat Martineau 4557fcd289dfSMat Martineau if (chan->max_tx && skb && 4558fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 4559fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4560fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4561fcd289dfSMat Martineau return; 4562fcd289dfSMat Martineau } 4563fcd289dfSMat Martineau 4564fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4565fcd289dfSMat Martineau 4566fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 4567fcd289dfSMat Martineau 4568fcd289dfSMat Martineau if (control->final) { 4569fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 4570fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4571fcd289dfSMat Martineau } else { 4572fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4573fcd289dfSMat Martineau l2cap_ertm_send(chan); 4574fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 4575fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 4576fcd289dfSMat Martineau } 4577d2a7ac5dSMat Martineau } 4578d2a7ac5dSMat Martineau 45794b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 45804b51dae9SMat Martineau { 45814b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 45824b51dae9SMat Martineau 45834b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 45844b51dae9SMat Martineau chan->expected_tx_seq); 45854b51dae9SMat Martineau 45864b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 45874b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 45884b51dae9SMat Martineau chan->tx_win) { 45894b51dae9SMat Martineau /* See notes below regarding "double poll" and 45904b51dae9SMat Martineau * invalid packets. 45914b51dae9SMat Martineau */ 45924b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 45934b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 45944b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 45954b51dae9SMat Martineau } else { 45964b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 45974b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 45984b51dae9SMat Martineau } 45994b51dae9SMat Martineau } 46004b51dae9SMat Martineau 46014b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 46024b51dae9SMat Martineau BT_DBG("Expected SREJ"); 46034b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 46044b51dae9SMat Martineau } 46054b51dae9SMat Martineau 46064b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 46074b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 46084b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 46094b51dae9SMat Martineau } 46104b51dae9SMat Martineau 46114b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 46124b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 46134b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 46144b51dae9SMat Martineau } 46154b51dae9SMat Martineau } 46164b51dae9SMat Martineau 46174b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 46184b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 46194b51dae9SMat Martineau chan->tx_win) { 46204b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46214b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46224b51dae9SMat Martineau } else { 46234b51dae9SMat Martineau BT_DBG("Expected"); 46244b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 46254b51dae9SMat Martineau } 46264b51dae9SMat Martineau } 46274b51dae9SMat Martineau 46284b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 46294b51dae9SMat Martineau __seq_offset(chan, chan->expected_tx_seq, 46304b51dae9SMat Martineau chan->last_acked_seq)){ 46314b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 46324b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 46334b51dae9SMat Martineau } 46344b51dae9SMat Martineau 46354b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 46364b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 46374b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 46384b51dae9SMat Martineau * the remote stack receives and processes both polls, 46394b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 46404b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 46414b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 46424b51dae9SMat Martineau * request. 46434b51dae9SMat Martineau * 46444b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 46454b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 46464b51dae9SMat Martineau * invalid frames to be safely ignored. 46474b51dae9SMat Martineau * 46484b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 46494b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 46504b51dae9SMat Martineau * causes a disconnect. 46514b51dae9SMat Martineau */ 46524b51dae9SMat Martineau 46534b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 46544b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 46554b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 46564b51dae9SMat Martineau } else { 46574b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46584b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46594b51dae9SMat Martineau } 46604b51dae9SMat Martineau } else { 46614b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 46624b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 46634b51dae9SMat Martineau } 46644b51dae9SMat Martineau } 46654b51dae9SMat Martineau 4666d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 4667d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4668d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4669d2a7ac5dSMat Martineau { 4670d2a7ac5dSMat Martineau int err = 0; 4671d2a7ac5dSMat Martineau bool skb_in_use = 0; 4672d2a7ac5dSMat Martineau 4673d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4674d2a7ac5dSMat Martineau event); 4675d2a7ac5dSMat Martineau 4676d2a7ac5dSMat Martineau switch (event) { 4677d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4678d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 4679d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4680d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4681d2a7ac5dSMat Martineau 4682d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4683d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 4684d2a7ac5dSMat Martineau control->txseq); 4685d2a7ac5dSMat Martineau break; 4686d2a7ac5dSMat Martineau } 4687d2a7ac5dSMat Martineau 4688d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 4689d2a7ac5dSMat Martineau control->txseq); 4690d2a7ac5dSMat Martineau 4691d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 4692d2a7ac5dSMat Martineau skb_in_use = 1; 4693d2a7ac5dSMat Martineau 4694d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 4695d2a7ac5dSMat Martineau if (err) 4696d2a7ac5dSMat Martineau break; 4697d2a7ac5dSMat Martineau 4698d2a7ac5dSMat Martineau if (control->final) { 4699d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4700d2a7ac5dSMat Martineau &chan->conn_state)) { 4701d2a7ac5dSMat Martineau control->final = 0; 4702d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4703d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4704d2a7ac5dSMat Martineau } 4705d2a7ac5dSMat Martineau } 4706d2a7ac5dSMat Martineau 4707d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 4708d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4709d2a7ac5dSMat Martineau break; 4710d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4711d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4712d2a7ac5dSMat Martineau 4713d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 4714d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 4715d2a7ac5dSMat Martineau * when local busy is exited. 4716d2a7ac5dSMat Martineau */ 4717d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4718d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 4719d2a7ac5dSMat Martineau control->txseq); 4720d2a7ac5dSMat Martineau break; 4721d2a7ac5dSMat Martineau } 4722d2a7ac5dSMat Martineau 4723d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 4724d2a7ac5dSMat Martineau * must be sent for each missing frame. The 4725d2a7ac5dSMat Martineau * current frame is stored for later use. 4726d2a7ac5dSMat Martineau */ 4727d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4728d2a7ac5dSMat Martineau skb_in_use = 1; 4729d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4730d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4731d2a7ac5dSMat Martineau 4732d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 4733d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 4734d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4735d2a7ac5dSMat Martineau 4736d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 4737d2a7ac5dSMat Martineau break; 4738d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4739d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4740d2a7ac5dSMat Martineau break; 4741d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4742d2a7ac5dSMat Martineau break; 4743d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4744d2a7ac5dSMat Martineau default: 4745d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4746d2a7ac5dSMat Martineau ECONNRESET); 4747d2a7ac5dSMat Martineau break; 4748d2a7ac5dSMat Martineau } 4749d2a7ac5dSMat Martineau break; 4750d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4751d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4752d2a7ac5dSMat Martineau if (control->final) { 4753d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4754d2a7ac5dSMat Martineau 4755d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4756d2a7ac5dSMat Martineau &chan->conn_state)) { 4757d2a7ac5dSMat Martineau control->final = 0; 4758d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4759d2a7ac5dSMat Martineau } 4760d2a7ac5dSMat Martineau 4761d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4762d2a7ac5dSMat Martineau } else if (control->poll) { 4763d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 4764d2a7ac5dSMat Martineau } else { 4765d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4766d2a7ac5dSMat Martineau &chan->conn_state) && 4767d2a7ac5dSMat Martineau chan->unacked_frames) 4768d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4769d2a7ac5dSMat Martineau 4770d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4771d2a7ac5dSMat Martineau } 4772d2a7ac5dSMat Martineau break; 4773d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4774d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4775d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4776d2a7ac5dSMat Martineau if (control && control->poll) { 4777d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4778d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 4779d2a7ac5dSMat Martineau } 4780d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 4781d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 4782d2a7ac5dSMat Martineau break; 4783d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4784d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4785d2a7ac5dSMat Martineau break; 4786d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4787d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4788d2a7ac5dSMat Martineau break; 4789d2a7ac5dSMat Martineau default: 4790d2a7ac5dSMat Martineau break; 4791d2a7ac5dSMat Martineau } 4792d2a7ac5dSMat Martineau 4793d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4794d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4795d2a7ac5dSMat Martineau kfree_skb(skb); 4796d2a7ac5dSMat Martineau } 4797d2a7ac5dSMat Martineau 4798d2a7ac5dSMat Martineau return err; 4799d2a7ac5dSMat Martineau } 4800d2a7ac5dSMat Martineau 4801d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 4802d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4803d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4804d2a7ac5dSMat Martineau { 4805d2a7ac5dSMat Martineau int err = 0; 4806d2a7ac5dSMat Martineau u16 txseq = control->txseq; 4807d2a7ac5dSMat Martineau bool skb_in_use = 0; 4808d2a7ac5dSMat Martineau 4809d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4810d2a7ac5dSMat Martineau event); 4811d2a7ac5dSMat Martineau 4812d2a7ac5dSMat Martineau switch (event) { 4813d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4814d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 4815d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4816d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 4817d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4818d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4819d2a7ac5dSMat Martineau skb_in_use = 1; 4820d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4821d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4822d2a7ac5dSMat Martineau 4823d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 4824d2a7ac5dSMat Martineau break; 4825d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 4826d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 4827d2a7ac5dSMat Martineau 4828d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4829d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4830d2a7ac5dSMat Martineau skb_in_use = 1; 4831d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4832d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4833d2a7ac5dSMat Martineau 4834d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 4835d2a7ac5dSMat Martineau if (err) 4836d2a7ac5dSMat Martineau break; 4837d2a7ac5dSMat Martineau 4838d2a7ac5dSMat Martineau break; 4839d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4840d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 4841d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 4842d2a7ac5dSMat Martineau * the missing frames. 4843d2a7ac5dSMat Martineau */ 4844d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4845d2a7ac5dSMat Martineau skb_in_use = 1; 4846d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4847d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4848d2a7ac5dSMat Martineau 4849d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4850d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4851d2a7ac5dSMat Martineau break; 4852d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 4853d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 4854d2a7ac5dSMat Martineau * some expected retransmitted frames are 4855d2a7ac5dSMat Martineau * missing. Request retransmission of missing 4856d2a7ac5dSMat Martineau * SREJ'd frames. 4857d2a7ac5dSMat Martineau */ 4858d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4859d2a7ac5dSMat Martineau skb_in_use = 1; 4860d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4861d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4862d2a7ac5dSMat Martineau 4863d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4864d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 4865d2a7ac5dSMat Martineau break; 4866d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 4867d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 4868d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4869d2a7ac5dSMat Martineau break; 4870d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4871d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 4872d2a7ac5dSMat Martineau * was already received. Ignore it completely. 4873d2a7ac5dSMat Martineau */ 4874d2a7ac5dSMat Martineau break; 4875d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4876d2a7ac5dSMat Martineau break; 4877d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4878d2a7ac5dSMat Martineau default: 4879d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4880d2a7ac5dSMat Martineau ECONNRESET); 4881d2a7ac5dSMat Martineau break; 4882d2a7ac5dSMat Martineau } 4883d2a7ac5dSMat Martineau break; 4884d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4885d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4886d2a7ac5dSMat Martineau if (control->final) { 4887d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4888d2a7ac5dSMat Martineau 4889d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4890d2a7ac5dSMat Martineau &chan->conn_state)) { 4891d2a7ac5dSMat Martineau control->final = 0; 4892d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4893d2a7ac5dSMat Martineau } 4894d2a7ac5dSMat Martineau 4895d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4896d2a7ac5dSMat Martineau } else if (control->poll) { 4897d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4898d2a7ac5dSMat Martineau &chan->conn_state) && 4899d2a7ac5dSMat Martineau chan->unacked_frames) { 4900d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4901d2a7ac5dSMat Martineau } 4902d2a7ac5dSMat Martineau 4903d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4904d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4905d2a7ac5dSMat Martineau } else { 4906d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4907d2a7ac5dSMat Martineau &chan->conn_state) && 4908d2a7ac5dSMat Martineau chan->unacked_frames) 4909d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4910d2a7ac5dSMat Martineau 4911d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4912d2a7ac5dSMat Martineau } 4913d2a7ac5dSMat Martineau break; 4914d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4915d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4916d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4917d2a7ac5dSMat Martineau if (control->poll) { 4918d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4919d2a7ac5dSMat Martineau } else { 4920d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 4921d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 4922d2a7ac5dSMat Martineau rr_control.sframe = 1; 4923d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 4924d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 4925d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 4926d2a7ac5dSMat Martineau } 4927d2a7ac5dSMat Martineau 4928d2a7ac5dSMat Martineau break; 4929d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4930d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4931d2a7ac5dSMat Martineau break; 4932d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4933d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4934d2a7ac5dSMat Martineau break; 4935d2a7ac5dSMat Martineau } 4936d2a7ac5dSMat Martineau 4937d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4938d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4939d2a7ac5dSMat Martineau kfree_skb(skb); 4940d2a7ac5dSMat Martineau } 4941d2a7ac5dSMat Martineau 4942d2a7ac5dSMat Martineau return err; 4943d2a7ac5dSMat Martineau } 4944d2a7ac5dSMat Martineau 4945d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 4946d2a7ac5dSMat Martineau { 4947d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 4948d2a7ac5dSMat Martineau u16 unacked; 4949d2a7ac5dSMat Martineau 4950d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 4951d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 4952d2a7ac5dSMat Martineau } 4953d2a7ac5dSMat Martineau 4954cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 4955cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 49560a708f8fSGustavo F. Padovan { 4957d2a7ac5dSMat Martineau int err = 0; 4958d2a7ac5dSMat Martineau 4959d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 4960d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 4961d2a7ac5dSMat Martineau 4962d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 4963d2a7ac5dSMat Martineau switch (chan->rx_state) { 4964d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 4965d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 4966d2a7ac5dSMat Martineau break; 4967d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 4968d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 4969d2a7ac5dSMat Martineau event); 4970d2a7ac5dSMat Martineau break; 4971d2a7ac5dSMat Martineau default: 4972d2a7ac5dSMat Martineau /* shut it down */ 4973d2a7ac5dSMat Martineau break; 4974d2a7ac5dSMat Martineau } 4975d2a7ac5dSMat Martineau } else { 4976d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 4977d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 4978d2a7ac5dSMat Martineau chan->expected_ack_seq); 4979d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4980d2a7ac5dSMat Martineau } 4981d2a7ac5dSMat Martineau 4982d2a7ac5dSMat Martineau return err; 4983cec8ab6eSMat Martineau } 4984cec8ab6eSMat Martineau 4985cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 4986cec8ab6eSMat Martineau struct sk_buff *skb) 4987cec8ab6eSMat Martineau { 49884b51dae9SMat Martineau int err = 0; 49894b51dae9SMat Martineau 49904b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 49914b51dae9SMat Martineau chan->rx_state); 49924b51dae9SMat Martineau 49934b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 49944b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 49954b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 49964b51dae9SMat Martineau 49974b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 49984b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 49994b51dae9SMat Martineau 50004b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 50014b51dae9SMat Martineau 50024b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 50034b51dae9SMat Martineau } else { 50044b51dae9SMat Martineau if (chan->sdu) { 50054b51dae9SMat Martineau kfree_skb(chan->sdu); 50064b51dae9SMat Martineau chan->sdu = NULL; 50074b51dae9SMat Martineau } 50084b51dae9SMat Martineau chan->sdu_last_frag = NULL; 50094b51dae9SMat Martineau chan->sdu_len = 0; 50104b51dae9SMat Martineau 50114b51dae9SMat Martineau if (skb) { 50124b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 50134b51dae9SMat Martineau kfree_skb(skb); 50144b51dae9SMat Martineau } 50154b51dae9SMat Martineau } 50164b51dae9SMat Martineau 50174b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 50184b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 50194b51dae9SMat Martineau 50204b51dae9SMat Martineau return err; 5021cec8ab6eSMat Martineau } 5022cec8ab6eSMat Martineau 5023cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 5024cec8ab6eSMat Martineau { 5025cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 5026cec8ab6eSMat Martineau u16 len; 5027cec8ab6eSMat Martineau u8 event; 50280a708f8fSGustavo F. Padovan 5029b76bbd66SMat Martineau __unpack_control(chan, skb); 5030b76bbd66SMat Martineau 50310a708f8fSGustavo F. Padovan len = skb->len; 50320a708f8fSGustavo F. Padovan 50330a708f8fSGustavo F. Padovan /* 50340a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 50350a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 5036cec8ab6eSMat Martineau * procedures and ask for retransmission. 50370a708f8fSGustavo F. Padovan */ 503847d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 50390a708f8fSGustavo F. Padovan goto drop; 50400a708f8fSGustavo F. Padovan 5041cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 504203a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 50430a708f8fSGustavo F. Padovan 504447d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 504503a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 50460a708f8fSGustavo F. Padovan 504747d1ec61SGustavo F. Padovan if (len > chan->mps) { 50488c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 50490a708f8fSGustavo F. Padovan goto drop; 50500a708f8fSGustavo F. Padovan } 50510a708f8fSGustavo F. Padovan 5052cec8ab6eSMat Martineau if (!control->sframe) { 5053cec8ab6eSMat Martineau int err; 50540a708f8fSGustavo F. Padovan 5055cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 5056cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 5057cec8ab6eSMat Martineau control->txseq); 5058836be934SAndrei Emeltchenko 5059cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 5060cec8ab6eSMat Martineau * valid in TX WAIT_F 5061cec8ab6eSMat Martineau */ 5062cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 50630a708f8fSGustavo F. Padovan goto drop; 50640a708f8fSGustavo F. Padovan 5065cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 5066cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 5067cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 50680a708f8fSGustavo F. Padovan } else { 5069cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 5070cec8ab6eSMat Martineau } 5071cec8ab6eSMat Martineau 5072cec8ab6eSMat Martineau if (err) 5073cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5074cec8ab6eSMat Martineau ECONNRESET); 5075cec8ab6eSMat Martineau } else { 5076cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 5077cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 5078cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 5079cec8ab6eSMat Martineau }; 5080cec8ab6eSMat Martineau 5081cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 5082cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 5083cec8ab6eSMat Martineau goto drop; 5084cec8ab6eSMat Martineau 5085cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 5086cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 5087cec8ab6eSMat Martineau control->super); 5088cec8ab6eSMat Martineau 50890a708f8fSGustavo F. Padovan if (len != 0) { 50900a708f8fSGustavo F. Padovan BT_ERR("%d", len); 50918c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 50920a708f8fSGustavo F. Padovan goto drop; 50930a708f8fSGustavo F. Padovan } 50940a708f8fSGustavo F. Padovan 5095cec8ab6eSMat Martineau /* Validate F and P bits */ 5096cec8ab6eSMat Martineau if (control->final && (control->poll || 5097cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 5098cec8ab6eSMat Martineau goto drop; 5099cec8ab6eSMat Martineau 5100cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 5101cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 5102cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51030a708f8fSGustavo F. Padovan } 51040a708f8fSGustavo F. Padovan 51050a708f8fSGustavo F. Padovan return 0; 51060a708f8fSGustavo F. Padovan 51070a708f8fSGustavo F. Padovan drop: 51080a708f8fSGustavo F. Padovan kfree_skb(skb); 51090a708f8fSGustavo F. Padovan return 0; 51100a708f8fSGustavo F. Padovan } 51110a708f8fSGustavo F. Padovan 51120a708f8fSGustavo F. Padovan static inline int l2cap_data_channel(struct l2cap_conn *conn, u16 cid, struct sk_buff *skb) 51130a708f8fSGustavo F. Padovan { 511448454079SGustavo F. Padovan struct l2cap_chan *chan; 51150a708f8fSGustavo F. Padovan 5116baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 511748454079SGustavo F. Padovan if (!chan) { 51180a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 51196be36555SAndrei Emeltchenko /* Drop packet and return */ 51203379013bSDan Carpenter kfree_skb(skb); 51216be36555SAndrei Emeltchenko return 0; 51220a708f8fSGustavo F. Padovan } 51230a708f8fSGustavo F. Padovan 512449208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 51250a708f8fSGustavo F. Padovan 512689bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 51270a708f8fSGustavo F. Padovan goto drop; 51280a708f8fSGustavo F. Padovan 51290c1bc5c6SGustavo F. Padovan switch (chan->mode) { 51300a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 51310a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 51320a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 51330a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 51340a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 51350a708f8fSGustavo F. Padovan 51360c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 51370a708f8fSGustavo F. Padovan goto drop; 51380a708f8fSGustavo F. Padovan 513980b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 51400a708f8fSGustavo F. Padovan goto done; 51410a708f8fSGustavo F. Padovan break; 51420a708f8fSGustavo F. Padovan 51430a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 51440a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 5145cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 51460a708f8fSGustavo F. Padovan goto done; 51470a708f8fSGustavo F. Padovan 51480a708f8fSGustavo F. Padovan default: 51490c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 51500a708f8fSGustavo F. Padovan break; 51510a708f8fSGustavo F. Padovan } 51520a708f8fSGustavo F. Padovan 51530a708f8fSGustavo F. Padovan drop: 51540a708f8fSGustavo F. Padovan kfree_skb(skb); 51550a708f8fSGustavo F. Padovan 51560a708f8fSGustavo F. Padovan done: 51576be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 51580a708f8fSGustavo F. Padovan 51590a708f8fSGustavo F. Padovan return 0; 51600a708f8fSGustavo F. Padovan } 51610a708f8fSGustavo F. Padovan 51620a708f8fSGustavo F. Padovan static inline int l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, struct sk_buff *skb) 51630a708f8fSGustavo F. Padovan { 516423691d75SGustavo F. Padovan struct l2cap_chan *chan; 51650a708f8fSGustavo F. Padovan 5166c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 516723691d75SGustavo F. Padovan if (!chan) 51680a708f8fSGustavo F. Padovan goto drop; 51690a708f8fSGustavo F. Padovan 51705b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 51710a708f8fSGustavo F. Padovan 517289bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 51730a708f8fSGustavo F. Padovan goto drop; 51740a708f8fSGustavo F. Padovan 5175e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 51760a708f8fSGustavo F. Padovan goto drop; 51770a708f8fSGustavo F. Padovan 517880b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 51795b4cedaaSAndrei Emeltchenko return 0; 51800a708f8fSGustavo F. Padovan 51810a708f8fSGustavo F. Padovan drop: 51820a708f8fSGustavo F. Padovan kfree_skb(skb); 51830a708f8fSGustavo F. Padovan 51840a708f8fSGustavo F. Padovan return 0; 51850a708f8fSGustavo F. Padovan } 51860a708f8fSGustavo F. Padovan 5187d9b88702SAndrei Emeltchenko static inline int l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 5188d9b88702SAndrei Emeltchenko struct sk_buff *skb) 51899f69bda6SGustavo F. Padovan { 519023691d75SGustavo F. Padovan struct l2cap_chan *chan; 51919f69bda6SGustavo F. Padovan 5192c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 519323691d75SGustavo F. Padovan if (!chan) 51949f69bda6SGustavo F. Padovan goto drop; 51959f69bda6SGustavo F. Padovan 51965b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 51979f69bda6SGustavo F. Padovan 519889bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 51999f69bda6SGustavo F. Padovan goto drop; 52009f69bda6SGustavo F. Padovan 5201e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 52029f69bda6SGustavo F. Padovan goto drop; 52039f69bda6SGustavo F. Padovan 520480b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 52055b4cedaaSAndrei Emeltchenko return 0; 52069f69bda6SGustavo F. Padovan 52079f69bda6SGustavo F. Padovan drop: 52089f69bda6SGustavo F. Padovan kfree_skb(skb); 52099f69bda6SGustavo F. Padovan 52109f69bda6SGustavo F. Padovan return 0; 52119f69bda6SGustavo F. Padovan } 52129f69bda6SGustavo F. Padovan 52130a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 52140a708f8fSGustavo F. Padovan { 52150a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 52160a708f8fSGustavo F. Padovan u16 cid, len; 52170a708f8fSGustavo F. Padovan __le16 psm; 52180a708f8fSGustavo F. Padovan 52190a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 52200a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 52210a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 52220a708f8fSGustavo F. Padovan 52230a708f8fSGustavo F. Padovan if (len != skb->len) { 52240a708f8fSGustavo F. Padovan kfree_skb(skb); 52250a708f8fSGustavo F. Padovan return; 52260a708f8fSGustavo F. Padovan } 52270a708f8fSGustavo F. Padovan 52280a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 52290a708f8fSGustavo F. Padovan 52300a708f8fSGustavo F. Padovan switch (cid) { 52313300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 52320a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 52330a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 52340a708f8fSGustavo F. Padovan break; 52350a708f8fSGustavo F. Padovan 52360a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 5237097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 52380181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 52390a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 52400a708f8fSGustavo F. Padovan break; 52410a708f8fSGustavo F. Padovan 52429f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 52439f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 52449f69bda6SGustavo F. Padovan break; 52459f69bda6SGustavo F. Padovan 5246b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 5247b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 5248b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 5249b501d6a1SAnderson Briglia break; 5250b501d6a1SAnderson Briglia 52510a708f8fSGustavo F. Padovan default: 52520a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 52530a708f8fSGustavo F. Padovan break; 52540a708f8fSGustavo F. Padovan } 52550a708f8fSGustavo F. Padovan } 52560a708f8fSGustavo F. Padovan 52570a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 52580a708f8fSGustavo F. Padovan 5259686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 52600a708f8fSGustavo F. Padovan { 52610a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 526223691d75SGustavo F. Padovan struct l2cap_chan *c; 52630a708f8fSGustavo F. Padovan 52640a708f8fSGustavo F. Padovan BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr)); 52650a708f8fSGustavo F. Padovan 52660a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 526723691d75SGustavo F. Padovan read_lock(&chan_list_lock); 526823691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 526923691d75SGustavo F. Padovan struct sock *sk = c->sk; 52704343478fSGustavo F. Padovan 527189bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 52720a708f8fSGustavo F. Padovan continue; 52730a708f8fSGustavo F. Padovan 52740a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 52750a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 527643bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 52770a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 52780a708f8fSGustavo F. Padovan exact++; 52790a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 52800a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 528143bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 52820a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 52830a708f8fSGustavo F. Padovan } 52840a708f8fSGustavo F. Padovan } 528523691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 52860a708f8fSGustavo F. Padovan 52870a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 52880a708f8fSGustavo F. Padovan } 52890a708f8fSGustavo F. Padovan 5290686ebf28SUlisses Furquim int l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 52910a708f8fSGustavo F. Padovan { 52920a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 52930a708f8fSGustavo F. Padovan 52940a708f8fSGustavo F. Padovan BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status); 52950a708f8fSGustavo F. Padovan 52960a708f8fSGustavo F. Padovan if (!status) { 52970a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 52980a708f8fSGustavo F. Padovan if (conn) 52990a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 53000a708f8fSGustavo F. Padovan } else 5301e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 53020a708f8fSGustavo F. Padovan 53030a708f8fSGustavo F. Padovan return 0; 53040a708f8fSGustavo F. Padovan } 53050a708f8fSGustavo F. Padovan 5306686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 53070a708f8fSGustavo F. Padovan { 53080a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 53090a708f8fSGustavo F. Padovan 53100a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 53110a708f8fSGustavo F. Padovan 5312686ebf28SUlisses Furquim if (!conn) 53139f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 53140a708f8fSGustavo F. Padovan return conn->disc_reason; 53150a708f8fSGustavo F. Padovan } 53160a708f8fSGustavo F. Padovan 5317686ebf28SUlisses Furquim int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 53180a708f8fSGustavo F. Padovan { 53190a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 53200a708f8fSGustavo F. Padovan 5321e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 53220a708f8fSGustavo F. Padovan return 0; 53230a708f8fSGustavo F. Padovan } 53240a708f8fSGustavo F. Padovan 53254343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 53260a708f8fSGustavo F. Padovan { 5327715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 53280a708f8fSGustavo F. Padovan return; 53290a708f8fSGustavo F. Padovan 53300a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 53314343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 5332ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 53334343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 53340f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 53350a708f8fSGustavo F. Padovan } else { 53364343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 5337c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 53380a708f8fSGustavo F. Padovan } 53390a708f8fSGustavo F. Padovan } 53400a708f8fSGustavo F. Padovan 5341686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 53420a708f8fSGustavo F. Padovan { 53430a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 534448454079SGustavo F. Padovan struct l2cap_chan *chan; 53450a708f8fSGustavo F. Padovan 53460a708f8fSGustavo F. Padovan if (!conn) 53470a708f8fSGustavo F. Padovan return 0; 53480a708f8fSGustavo F. Padovan 53490a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 53500a708f8fSGustavo F. Padovan 5351160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 535235d4adccSHemant Gupta if (!status && encrypt) 5353160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 535417cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 5355160dc6acSVinicius Costa Gomes } 5356160dc6acSVinicius Costa Gomes 53573df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 53580a708f8fSGustavo F. Padovan 53593df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 53606be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 53610a708f8fSGustavo F. Padovan 5362f1cb9af5SVinicius Costa Gomes BT_DBG("chan->scid %d", chan->scid); 5363f1cb9af5SVinicius Costa Gomes 5364f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 5365f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 5366f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 5367cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 5368f1cb9af5SVinicius Costa Gomes } 5369f1cb9af5SVinicius Costa Gomes 53706be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 5371f1cb9af5SVinicius Costa Gomes continue; 5372f1cb9af5SVinicius Costa Gomes } 5373f1cb9af5SVinicius Costa Gomes 5374c1360a1cSGustavo F. Padovan if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 53756be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 53760a708f8fSGustavo F. Padovan continue; 53770a708f8fSGustavo F. Padovan } 53780a708f8fSGustavo F. Padovan 537989bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 538089bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 5381a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 5382a7d7723aSGustavo Padovan 5383c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 5384a7d7723aSGustavo Padovan sk->sk_state_change(sk); 5385a7d7723aSGustavo Padovan 53864343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 53876be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 53880a708f8fSGustavo F. Padovan continue; 53890a708f8fSGustavo F. Padovan } 53900a708f8fSGustavo F. Padovan 539189bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 53920a708f8fSGustavo F. Padovan if (!status) { 53939b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 53940a708f8fSGustavo F. Padovan } else { 5395ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 53960a708f8fSGustavo F. Padovan } 539789bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 53986be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 53990a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5400df3c3931SJohan Hedberg __u16 res, stat; 54010a708f8fSGustavo F. Padovan 54026be36555SAndrei Emeltchenko lock_sock(sk); 54036be36555SAndrei Emeltchenko 54040a708f8fSGustavo F. Padovan if (!status) { 5405c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 5406c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 5407df3c3931SJohan Hedberg struct sock *parent = bt_sk(sk)->parent; 5408df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 5409df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 541005e9a2f6SIlia Kolomisnky if (parent) 5411df3c3931SJohan Hedberg parent->sk_data_ready(parent, 0); 5412df3c3931SJohan Hedberg } else { 54130e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 5414df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 5415df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 5416df3c3931SJohan Hedberg } 54170a708f8fSGustavo F. Padovan } else { 54180e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 5419ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 5420df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 5421df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 54220a708f8fSGustavo F. Padovan } 54230a708f8fSGustavo F. Padovan 54246be36555SAndrei Emeltchenko release_sock(sk); 54256be36555SAndrei Emeltchenko 5426fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5427fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5428df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 5429df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 5430fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5431fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 54322d369359SMat Martineau 54332d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 54342d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 54352d369359SMat Martineau char buf[128]; 54362d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 54372d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 54382d369359SMat Martineau L2CAP_CONF_REQ, 54392d369359SMat Martineau l2cap_build_conf_req(chan, buf), 54402d369359SMat Martineau buf); 54412d369359SMat Martineau chan->num_conf_req++; 54422d369359SMat Martineau } 54430a708f8fSGustavo F. Padovan } 54440a708f8fSGustavo F. Padovan 54456be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54460a708f8fSGustavo F. Padovan } 54470a708f8fSGustavo F. Padovan 54483df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 54490a708f8fSGustavo F. Padovan 54500a708f8fSGustavo F. Padovan return 0; 54510a708f8fSGustavo F. Padovan } 54520a708f8fSGustavo F. Padovan 5453686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 54540a708f8fSGustavo F. Padovan { 54550a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 54560a708f8fSGustavo F. Padovan 54570a708f8fSGustavo F. Padovan if (!conn) 54580a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 54590a708f8fSGustavo F. Padovan 54600a708f8fSGustavo F. Padovan if (!conn) 54610a708f8fSGustavo F. Padovan goto drop; 54620a708f8fSGustavo F. Padovan 54630a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 54640a708f8fSGustavo F. Padovan 54650a708f8fSGustavo F. Padovan if (!(flags & ACL_CONT)) { 54660a708f8fSGustavo F. Padovan struct l2cap_hdr *hdr; 54670a708f8fSGustavo F. Padovan int len; 54680a708f8fSGustavo F. Padovan 54690a708f8fSGustavo F. Padovan if (conn->rx_len) { 54700a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 54710a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 54720a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 54730a708f8fSGustavo F. Padovan conn->rx_len = 0; 54740a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 54750a708f8fSGustavo F. Padovan } 54760a708f8fSGustavo F. Padovan 54770a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 54780a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 54790a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 54800a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 54810a708f8fSGustavo F. Padovan goto drop; 54820a708f8fSGustavo F. Padovan } 54830a708f8fSGustavo F. Padovan 54840a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 54850a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 54860a708f8fSGustavo F. Padovan 54870a708f8fSGustavo F. Padovan if (len == skb->len) { 54880a708f8fSGustavo F. Padovan /* Complete frame received */ 54890a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 54900a708f8fSGustavo F. Padovan return 0; 54910a708f8fSGustavo F. Padovan } 54920a708f8fSGustavo F. Padovan 54930a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 54940a708f8fSGustavo F. Padovan 54950a708f8fSGustavo F. Padovan if (skb->len > len) { 54960a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 54970a708f8fSGustavo F. Padovan skb->len, len); 54980a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 54990a708f8fSGustavo F. Padovan goto drop; 55000a708f8fSGustavo F. Padovan } 55010a708f8fSGustavo F. Padovan 55020a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 55030a708f8fSGustavo F. Padovan conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC); 55040a708f8fSGustavo F. Padovan if (!conn->rx_skb) 55050a708f8fSGustavo F. Padovan goto drop; 55060a708f8fSGustavo F. Padovan 55070a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55080a708f8fSGustavo F. Padovan skb->len); 55090a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 55100a708f8fSGustavo F. Padovan } else { 55110a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 55120a708f8fSGustavo F. Padovan 55130a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55140a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 55150a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55160a708f8fSGustavo F. Padovan goto drop; 55170a708f8fSGustavo F. Padovan } 55180a708f8fSGustavo F. Padovan 55190a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 55200a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 55210a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 55220a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 55230a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55240a708f8fSGustavo F. Padovan conn->rx_len = 0; 55250a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55260a708f8fSGustavo F. Padovan goto drop; 55270a708f8fSGustavo F. Padovan } 55280a708f8fSGustavo F. Padovan 55290a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55300a708f8fSGustavo F. Padovan skb->len); 55310a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 55320a708f8fSGustavo F. Padovan 55330a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55340a708f8fSGustavo F. Padovan /* Complete frame received */ 55350a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 55360a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55370a708f8fSGustavo F. Padovan } 55380a708f8fSGustavo F. Padovan } 55390a708f8fSGustavo F. Padovan 55400a708f8fSGustavo F. Padovan drop: 55410a708f8fSGustavo F. Padovan kfree_skb(skb); 55420a708f8fSGustavo F. Padovan return 0; 55430a708f8fSGustavo F. Padovan } 55440a708f8fSGustavo F. Padovan 55450a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 55460a708f8fSGustavo F. Padovan { 554723691d75SGustavo F. Padovan struct l2cap_chan *c; 55480a708f8fSGustavo F. Padovan 5549333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 55500a708f8fSGustavo F. Padovan 555123691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 555223691d75SGustavo F. Padovan struct sock *sk = c->sk; 55530a708f8fSGustavo F. Padovan 5554903d343eSGustavo F. Padovan seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 55550a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->src), 55560a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->dst), 555789bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 555823691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 555923691d75SGustavo F. Padovan c->sec_level, c->mode); 55600a708f8fSGustavo F. Padovan } 55610a708f8fSGustavo F. Padovan 5562333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 55630a708f8fSGustavo F. Padovan 55640a708f8fSGustavo F. Padovan return 0; 55650a708f8fSGustavo F. Padovan } 55660a708f8fSGustavo F. Padovan 55670a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 55680a708f8fSGustavo F. Padovan { 55690a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 55700a708f8fSGustavo F. Padovan } 55710a708f8fSGustavo F. Padovan 55720a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 55730a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 55740a708f8fSGustavo F. Padovan .read = seq_read, 55750a708f8fSGustavo F. Padovan .llseek = seq_lseek, 55760a708f8fSGustavo F. Padovan .release = single_release, 55770a708f8fSGustavo F. Padovan }; 55780a708f8fSGustavo F. Padovan 55790a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 55800a708f8fSGustavo F. Padovan 558164274518SGustavo F. Padovan int __init l2cap_init(void) 55820a708f8fSGustavo F. Padovan { 55830a708f8fSGustavo F. Padovan int err; 55840a708f8fSGustavo F. Padovan 5585bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 55860a708f8fSGustavo F. Padovan if (err < 0) 55870a708f8fSGustavo F. Padovan return err; 55880a708f8fSGustavo F. Padovan 55890a708f8fSGustavo F. Padovan if (bt_debugfs) { 55900a708f8fSGustavo F. Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, 55910a708f8fSGustavo F. Padovan bt_debugfs, NULL, &l2cap_debugfs_fops); 55920a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 55930a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 55940a708f8fSGustavo F. Padovan } 55950a708f8fSGustavo F. Padovan 55960a708f8fSGustavo F. Padovan return 0; 55970a708f8fSGustavo F. Padovan } 55980a708f8fSGustavo F. Padovan 559964274518SGustavo F. Padovan void l2cap_exit(void) 56000a708f8fSGustavo F. Padovan { 56010a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 5602bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 56030a708f8fSGustavo F. Padovan } 56040a708f8fSGustavo F. Padovan 56050a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 56060a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 5607