10a708f8fSGustavo F. Padovan /* 20a708f8fSGustavo F. Padovan BlueZ - Bluetooth protocol stack for Linux 30a708f8fSGustavo F. Padovan Copyright (C) 2000-2001 Qualcomm Incorporated 40a708f8fSGustavo F. Padovan Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org> 50a708f8fSGustavo F. Padovan Copyright (C) 2010 Google Inc. 6590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 7422e925bSMat Martineau Copyright (c) 2012 Code Aurora Forum. All rights reserved. 80a708f8fSGustavo F. Padovan 90a708f8fSGustavo F. Padovan Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 100a708f8fSGustavo F. Padovan 110a708f8fSGustavo F. Padovan This program is free software; you can redistribute it and/or modify 120a708f8fSGustavo F. Padovan it under the terms of the GNU General Public License version 2 as 130a708f8fSGustavo F. Padovan published by the Free Software Foundation; 140a708f8fSGustavo F. Padovan 150a708f8fSGustavo F. Padovan THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 160a708f8fSGustavo F. Padovan OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 170a708f8fSGustavo F. Padovan FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 180a708f8fSGustavo F. Padovan IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 190a708f8fSGustavo F. Padovan CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 200a708f8fSGustavo F. Padovan WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 210a708f8fSGustavo F. Padovan ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 220a708f8fSGustavo F. Padovan OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 230a708f8fSGustavo F. Padovan 240a708f8fSGustavo F. Padovan ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 250a708f8fSGustavo F. Padovan COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 260a708f8fSGustavo F. Padovan SOFTWARE IS DISCLAIMED. 270a708f8fSGustavo F. Padovan */ 280a708f8fSGustavo F. Padovan 29bb58f747SGustavo F. Padovan /* Bluetooth L2CAP core. */ 300a708f8fSGustavo F. Padovan 310a708f8fSGustavo F. Padovan #include <linux/module.h> 320a708f8fSGustavo F. Padovan 330a708f8fSGustavo F. Padovan #include <linux/debugfs.h> 340a708f8fSGustavo F. Padovan #include <linux/crc16.h> 350a708f8fSGustavo F. Padovan 360a708f8fSGustavo F. Padovan #include <net/bluetooth/bluetooth.h> 370a708f8fSGustavo F. Padovan #include <net/bluetooth/hci_core.h> 380a708f8fSGustavo F. Padovan #include <net/bluetooth/l2cap.h> 39b501d6a1SAnderson Briglia #include <net/bluetooth/smp.h> 4097e8e89dSAndrei Emeltchenko #include <net/bluetooth/a2mp.h> 410a708f8fSGustavo F. Padovan 42d1de6d46SMat Martineau bool disable_ertm; 430a708f8fSGustavo F. Padovan 440a708f8fSGustavo F. Padovan static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN; 4550a147cdSMat Martineau static u8 l2cap_fixed_chan[8] = { L2CAP_FC_L2CAP, }; 460a708f8fSGustavo F. Padovan 47b5ad8b7fSJohannes Berg static LIST_HEAD(chan_list); 48b5ad8b7fSJohannes Berg static DEFINE_RWLOCK(chan_list_lock); 490a708f8fSGustavo F. Padovan 500a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 510a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data); 524519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 534519de9aSGustavo F. Padovan void *data); 54710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data); 554519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 564519de9aSGustavo F. Padovan struct l2cap_chan *chan, int err); 570a708f8fSGustavo F. Padovan 58d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 59608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event); 60608bcc6dSMat Martineau 610a708f8fSGustavo F. Padovan /* ---- L2CAP channels ---- */ 6271ba0e56SGustavo F. Padovan 63baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, u16 cid) 640a708f8fSGustavo F. Padovan { 653df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 66baa7e1faSGustavo F. Padovan 673df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 683df91ea2SAndrei Emeltchenko if (c->dcid == cid) 693df91ea2SAndrei Emeltchenko return c; 700a708f8fSGustavo F. Padovan } 713df91ea2SAndrei Emeltchenko return NULL; 72baa7e1faSGustavo F. Padovan } 730a708f8fSGustavo F. Padovan 74baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid) 750a708f8fSGustavo F. Padovan { 763df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 77baa7e1faSGustavo F. Padovan 783df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 793df91ea2SAndrei Emeltchenko if (c->scid == cid) 803df91ea2SAndrei Emeltchenko return c; 810a708f8fSGustavo F. Padovan } 823df91ea2SAndrei Emeltchenko return NULL; 83baa7e1faSGustavo F. Padovan } 840a708f8fSGustavo F. Padovan 850a708f8fSGustavo F. Padovan /* Find channel with given SCID. 86ef191adeSMat Martineau * Returns locked channel. */ 87baa7e1faSGustavo F. Padovan static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid) 880a708f8fSGustavo F. Padovan { 8948454079SGustavo F. Padovan struct l2cap_chan *c; 90baa7e1faSGustavo F. Padovan 913df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 92baa7e1faSGustavo F. Padovan c = __l2cap_get_chan_by_scid(conn, cid); 93ef191adeSMat Martineau if (c) 94ef191adeSMat Martineau l2cap_chan_lock(c); 953df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 963df91ea2SAndrei Emeltchenko 9748454079SGustavo F. Padovan return c; 980a708f8fSGustavo F. Padovan } 990a708f8fSGustavo F. Padovan 100baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident) 1010a708f8fSGustavo F. Padovan { 1023df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 103baa7e1faSGustavo F. Padovan 1043df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 1053df91ea2SAndrei Emeltchenko if (c->ident == ident) 1063df91ea2SAndrei Emeltchenko return c; 1070a708f8fSGustavo F. Padovan } 1083df91ea2SAndrei Emeltchenko return NULL; 109baa7e1faSGustavo F. Padovan } 1100a708f8fSGustavo F. Padovan 11123691d75SGustavo F. Padovan static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src) 1129e4425ffSGustavo F. Padovan { 11323691d75SGustavo F. Padovan struct l2cap_chan *c; 1149e4425ffSGustavo F. Padovan 11523691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 11623691d75SGustavo F. Padovan if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src)) 11723691d75SGustavo F. Padovan return c; 1189e4425ffSGustavo F. Padovan } 119250938cbSSzymon Janc return NULL; 120250938cbSSzymon Janc } 1219e4425ffSGustavo F. Padovan 1229e4425ffSGustavo F. Padovan int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm) 1239e4425ffSGustavo F. Padovan { 12473b2ec18SGustavo F. Padovan int err; 12573b2ec18SGustavo F. Padovan 126333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1279e4425ffSGustavo F. Padovan 12823691d75SGustavo F. Padovan if (psm && __l2cap_global_chan_by_addr(psm, src)) { 12973b2ec18SGustavo F. Padovan err = -EADDRINUSE; 13073b2ec18SGustavo F. Padovan goto done; 1319e4425ffSGustavo F. Padovan } 1329e4425ffSGustavo F. Padovan 13373b2ec18SGustavo F. Padovan if (psm) { 1349e4425ffSGustavo F. Padovan chan->psm = psm; 1359e4425ffSGustavo F. Padovan chan->sport = psm; 13673b2ec18SGustavo F. Padovan err = 0; 13773b2ec18SGustavo F. Padovan } else { 13873b2ec18SGustavo F. Padovan u16 p; 1399e4425ffSGustavo F. Padovan 14073b2ec18SGustavo F. Padovan err = -EINVAL; 14173b2ec18SGustavo F. Padovan for (p = 0x1001; p < 0x1100; p += 2) 14223691d75SGustavo F. Padovan if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) { 14373b2ec18SGustavo F. Padovan chan->psm = cpu_to_le16(p); 14473b2ec18SGustavo F. Padovan chan->sport = cpu_to_le16(p); 14573b2ec18SGustavo F. Padovan err = 0; 14673b2ec18SGustavo F. Padovan break; 14773b2ec18SGustavo F. Padovan } 14873b2ec18SGustavo F. Padovan } 14973b2ec18SGustavo F. Padovan 15073b2ec18SGustavo F. Padovan done: 151333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 15273b2ec18SGustavo F. Padovan return err; 1539e4425ffSGustavo F. Padovan } 1549e4425ffSGustavo F. Padovan 1559e4425ffSGustavo F. Padovan int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid) 1569e4425ffSGustavo F. Padovan { 157333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1589e4425ffSGustavo F. Padovan 1599e4425ffSGustavo F. Padovan chan->scid = scid; 1609e4425ffSGustavo F. Padovan 161333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 1629e4425ffSGustavo F. Padovan 1639e4425ffSGustavo F. Padovan return 0; 1649e4425ffSGustavo F. Padovan } 1659e4425ffSGustavo F. Padovan 166baa7e1faSGustavo F. Padovan static u16 l2cap_alloc_cid(struct l2cap_conn *conn) 1670a708f8fSGustavo F. Padovan { 1680a708f8fSGustavo F. Padovan u16 cid = L2CAP_CID_DYN_START; 1690a708f8fSGustavo F. Padovan 1700a708f8fSGustavo F. Padovan for (; cid < L2CAP_CID_DYN_END; cid++) { 171baa7e1faSGustavo F. Padovan if (!__l2cap_get_chan_by_scid(conn, cid)) 1720a708f8fSGustavo F. Padovan return cid; 1730a708f8fSGustavo F. Padovan } 1740a708f8fSGustavo F. Padovan 1750a708f8fSGustavo F. Padovan return 0; 1760a708f8fSGustavo F. Padovan } 1770a708f8fSGustavo F. Padovan 1780e587be7SAndrei Emeltchenko static void __l2cap_state_change(struct l2cap_chan *chan, int state) 17989bc500eSGustavo F. Padovan { 18042d2d87cSAndrei Emeltchenko BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state), 181badaaa00SGustavo F. Padovan state_to_string(state)); 182badaaa00SGustavo F. Padovan 18389bc500eSGustavo F. Padovan chan->state = state; 18480b98027SGustavo Padovan chan->ops->state_change(chan, state); 18589bc500eSGustavo F. Padovan } 18689bc500eSGustavo F. Padovan 1870e587be7SAndrei Emeltchenko static void l2cap_state_change(struct l2cap_chan *chan, int state) 1880e587be7SAndrei Emeltchenko { 1890e587be7SAndrei Emeltchenko struct sock *sk = chan->sk; 1900e587be7SAndrei Emeltchenko 1910e587be7SAndrei Emeltchenko lock_sock(sk); 1920e587be7SAndrei Emeltchenko __l2cap_state_change(chan, state); 1930e587be7SAndrei Emeltchenko release_sock(sk); 1940e587be7SAndrei Emeltchenko } 1950e587be7SAndrei Emeltchenko 1962e0052e4SAndrei Emeltchenko static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err) 1972e0052e4SAndrei Emeltchenko { 1982e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 1992e0052e4SAndrei Emeltchenko 2002e0052e4SAndrei Emeltchenko sk->sk_err = err; 2012e0052e4SAndrei Emeltchenko } 2022e0052e4SAndrei Emeltchenko 2032e0052e4SAndrei Emeltchenko static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2042e0052e4SAndrei Emeltchenko { 2052e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2062e0052e4SAndrei Emeltchenko 2072e0052e4SAndrei Emeltchenko lock_sock(sk); 2082e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 2092e0052e4SAndrei Emeltchenko release_sock(sk); 2102e0052e4SAndrei Emeltchenko } 2112e0052e4SAndrei Emeltchenko 2124239d16fSMat Martineau static void __set_retrans_timer(struct l2cap_chan *chan) 2134239d16fSMat Martineau { 2144239d16fSMat Martineau if (!delayed_work_pending(&chan->monitor_timer) && 2154239d16fSMat Martineau chan->retrans_timeout) { 2164239d16fSMat Martineau l2cap_set_timer(chan, &chan->retrans_timer, 2174239d16fSMat Martineau msecs_to_jiffies(chan->retrans_timeout)); 2184239d16fSMat Martineau } 2194239d16fSMat Martineau } 2204239d16fSMat Martineau 2214239d16fSMat Martineau static void __set_monitor_timer(struct l2cap_chan *chan) 2224239d16fSMat Martineau { 2234239d16fSMat Martineau __clear_retrans_timer(chan); 2244239d16fSMat Martineau if (chan->monitor_timeout) { 2254239d16fSMat Martineau l2cap_set_timer(chan, &chan->monitor_timer, 2264239d16fSMat Martineau msecs_to_jiffies(chan->monitor_timeout)); 2274239d16fSMat Martineau } 2284239d16fSMat Martineau } 2294239d16fSMat Martineau 230608bcc6dSMat Martineau static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head, 231608bcc6dSMat Martineau u16 seq) 232608bcc6dSMat Martineau { 233608bcc6dSMat Martineau struct sk_buff *skb; 234608bcc6dSMat Martineau 235608bcc6dSMat Martineau skb_queue_walk(head, skb) { 236608bcc6dSMat Martineau if (bt_cb(skb)->control.txseq == seq) 237608bcc6dSMat Martineau return skb; 238608bcc6dSMat Martineau } 239608bcc6dSMat Martineau 240608bcc6dSMat Martineau return NULL; 241608bcc6dSMat Martineau } 242608bcc6dSMat Martineau 2433c588192SMat Martineau /* ---- L2CAP sequence number lists ---- */ 2443c588192SMat Martineau 2453c588192SMat Martineau /* For ERTM, ordered lists of sequence numbers must be tracked for 2463c588192SMat Martineau * SREJ requests that are received and for frames that are to be 2473c588192SMat Martineau * retransmitted. These seq_list functions implement a singly-linked 2483c588192SMat Martineau * list in an array, where membership in the list can also be checked 2493c588192SMat Martineau * in constant time. Items can also be added to the tail of the list 2503c588192SMat Martineau * and removed from the head in constant time, without further memory 2513c588192SMat Martineau * allocs or frees. 2523c588192SMat Martineau */ 2533c588192SMat Martineau 2543c588192SMat Martineau static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) 2553c588192SMat Martineau { 2563c588192SMat Martineau size_t alloc_size, i; 2573c588192SMat Martineau 2583c588192SMat Martineau /* Allocated size is a power of 2 to map sequence numbers 2593c588192SMat Martineau * (which may be up to 14 bits) in to a smaller array that is 2603c588192SMat Martineau * sized for the negotiated ERTM transmit windows. 2613c588192SMat Martineau */ 2623c588192SMat Martineau alloc_size = roundup_pow_of_two(size); 2633c588192SMat Martineau 2643c588192SMat Martineau seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); 2653c588192SMat Martineau if (!seq_list->list) 2663c588192SMat Martineau return -ENOMEM; 2673c588192SMat Martineau 2683c588192SMat Martineau seq_list->mask = alloc_size - 1; 2693c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 2703c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 2713c588192SMat Martineau for (i = 0; i < alloc_size; i++) 2723c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 2733c588192SMat Martineau 2743c588192SMat Martineau return 0; 2753c588192SMat Martineau } 2763c588192SMat Martineau 2773c588192SMat Martineau static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list) 2783c588192SMat Martineau { 2793c588192SMat Martineau kfree(seq_list->list); 2803c588192SMat Martineau } 2813c588192SMat Martineau 2823c588192SMat Martineau static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list, 2833c588192SMat Martineau u16 seq) 2843c588192SMat Martineau { 2853c588192SMat Martineau /* Constant-time check for list membership */ 2863c588192SMat Martineau return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR; 2873c588192SMat Martineau } 2883c588192SMat Martineau 2893c588192SMat Martineau static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq) 2903c588192SMat Martineau { 2913c588192SMat Martineau u16 mask = seq_list->mask; 2923c588192SMat Martineau 2933c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) { 2943c588192SMat Martineau /* In case someone tries to pop the head of an empty list */ 2953c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 2963c588192SMat Martineau } else if (seq_list->head == seq) { 2973c588192SMat Martineau /* Head can be removed in constant time */ 2983c588192SMat Martineau seq_list->head = seq_list->list[seq & mask]; 2993c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3003c588192SMat Martineau 3013c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_TAIL) { 3023c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3033c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3043c588192SMat Martineau } 3053c588192SMat Martineau } else { 3063c588192SMat Martineau /* Walk the list to find the sequence number */ 3073c588192SMat Martineau u16 prev = seq_list->head; 3083c588192SMat Martineau while (seq_list->list[prev & mask] != seq) { 3093c588192SMat Martineau prev = seq_list->list[prev & mask]; 3103c588192SMat Martineau if (prev == L2CAP_SEQ_LIST_TAIL) 3113c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3123c588192SMat Martineau } 3133c588192SMat Martineau 3143c588192SMat Martineau /* Unlink the number from the list and clear it */ 3153c588192SMat Martineau seq_list->list[prev & mask] = seq_list->list[seq & mask]; 3163c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3173c588192SMat Martineau if (seq_list->tail == seq) 3183c588192SMat Martineau seq_list->tail = prev; 3193c588192SMat Martineau } 3203c588192SMat Martineau return seq; 3213c588192SMat Martineau } 3223c588192SMat Martineau 3233c588192SMat Martineau static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list) 3243c588192SMat Martineau { 3253c588192SMat Martineau /* Remove the head in constant time */ 3263c588192SMat Martineau return l2cap_seq_list_remove(seq_list, seq_list->head); 3273c588192SMat Martineau } 3283c588192SMat Martineau 3293c588192SMat Martineau static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list) 3303c588192SMat Martineau { 3313c588192SMat Martineau u16 i; 332f522ae36SGustavo Padovan 333f522ae36SGustavo Padovan if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) 334f522ae36SGustavo Padovan return; 335f522ae36SGustavo Padovan 3363c588192SMat Martineau for (i = 0; i <= seq_list->mask; i++) 3373c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3383c588192SMat Martineau 3393c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3403c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3413c588192SMat Martineau } 3423c588192SMat Martineau 3433c588192SMat Martineau static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq) 3443c588192SMat Martineau { 3453c588192SMat Martineau u16 mask = seq_list->mask; 3463c588192SMat Martineau 3473c588192SMat Martineau /* All appends happen in constant time */ 3483c588192SMat Martineau 349f522ae36SGustavo Padovan if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR) 350f522ae36SGustavo Padovan return; 351f522ae36SGustavo Padovan 3523c588192SMat Martineau if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR) 3533c588192SMat Martineau seq_list->head = seq; 3543c588192SMat Martineau else 3553c588192SMat Martineau seq_list->list[seq_list->tail & mask] = seq; 3563c588192SMat Martineau 3573c588192SMat Martineau seq_list->tail = seq; 3583c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL; 3593c588192SMat Martineau } 3603c588192SMat Martineau 361721c4181SGustavo F. Padovan static void l2cap_chan_timeout(struct work_struct *work) 362ab07801dSGustavo F. Padovan { 363721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 364721c4181SGustavo F. Padovan chan_timer.work); 3653df91ea2SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 366ab07801dSGustavo F. Padovan int reason; 367ab07801dSGustavo F. Padovan 368e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s", chan, state_to_string(chan->state)); 369ab07801dSGustavo F. Padovan 3703df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3716be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 372ab07801dSGustavo F. Padovan 37389bc500eSGustavo F. Padovan if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG) 374ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 37589bc500eSGustavo F. Padovan else if (chan->state == BT_CONNECT && 376ab07801dSGustavo F. Padovan chan->sec_level != BT_SECURITY_SDP) 377ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 378ab07801dSGustavo F. Padovan else 379ab07801dSGustavo F. Padovan reason = ETIMEDOUT; 380ab07801dSGustavo F. Padovan 3810f852724SGustavo F. Padovan l2cap_chan_close(chan, reason); 382ab07801dSGustavo F. Padovan 3836be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 384ab07801dSGustavo F. Padovan 38580b98027SGustavo Padovan chan->ops->close(chan); 3863df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 3873df91ea2SAndrei Emeltchenko 388371fd835SUlisses Furquim l2cap_chan_put(chan); 389ab07801dSGustavo F. Padovan } 390ab07801dSGustavo F. Padovan 391eef1d9b6SGustavo Padovan struct l2cap_chan *l2cap_chan_create(void) 3920a708f8fSGustavo F. Padovan { 39348454079SGustavo F. Padovan struct l2cap_chan *chan; 3940a708f8fSGustavo F. Padovan 39548454079SGustavo F. Padovan chan = kzalloc(sizeof(*chan), GFP_ATOMIC); 39648454079SGustavo F. Padovan if (!chan) 39748454079SGustavo F. Padovan return NULL; 3980a708f8fSGustavo F. Padovan 399c03b355eSAndrei Emeltchenko mutex_init(&chan->lock); 400c03b355eSAndrei Emeltchenko 401333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 40223691d75SGustavo F. Padovan list_add(&chan->global_l, &chan_list); 403333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 40423691d75SGustavo F. Padovan 405721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout); 406ab07801dSGustavo F. Padovan 40789bc500eSGustavo F. Padovan chan->state = BT_OPEN; 40889bc500eSGustavo F. Padovan 40971ba0e56SGustavo F. Padovan atomic_set(&chan->refcnt, 1); 41071ba0e56SGustavo F. Padovan 4112827011fSMat Martineau /* This flag is cleared in l2cap_chan_ready() */ 4122827011fSMat Martineau set_bit(CONF_NOT_COMPLETE, &chan->conf_state); 4132827011fSMat Martineau 414eef1d9b6SGustavo Padovan BT_DBG("chan %p", chan); 415abc545b8SSzymon Janc 41648454079SGustavo F. Padovan return chan; 4170a708f8fSGustavo F. Padovan } 4180a708f8fSGustavo F. Padovan 41923691d75SGustavo F. Padovan void l2cap_chan_destroy(struct l2cap_chan *chan) 4206ff5abbfSGustavo F. Padovan { 421333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 42223691d75SGustavo F. Padovan list_del(&chan->global_l); 423333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 42423691d75SGustavo F. Padovan 425371fd835SUlisses Furquim l2cap_chan_put(chan); 4266ff5abbfSGustavo F. Padovan } 4276ff5abbfSGustavo F. Padovan 428bd4b1653SAndrei Emeltchenko void l2cap_chan_set_defaults(struct l2cap_chan *chan) 429bd4b1653SAndrei Emeltchenko { 430bd4b1653SAndrei Emeltchenko chan->fcs = L2CAP_FCS_CRC16; 431bd4b1653SAndrei Emeltchenko chan->max_tx = L2CAP_DEFAULT_MAX_TX; 432bd4b1653SAndrei Emeltchenko chan->tx_win = L2CAP_DEFAULT_TX_WINDOW; 433bd4b1653SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 434bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 435bd4b1653SAndrei Emeltchenko 436bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 437bd4b1653SAndrei Emeltchenko } 438bd4b1653SAndrei Emeltchenko 43914a28491SAndrei Emeltchenko static void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4400a708f8fSGustavo F. Padovan { 4410a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 442097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4430a708f8fSGustavo F. Padovan 4449f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 4450a708f8fSGustavo F. Padovan 4468c1d787bSGustavo F. Padovan chan->conn = conn; 4470a708f8fSGustavo F. Padovan 4485491120eSAndrei Emeltchenko switch (chan->chan_type) { 4495491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 450b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 451b62f328bSVille Tervo /* LE connection */ 4526fcb06a2SAndre Guedes chan->omtu = L2CAP_DEFAULT_MTU; 453fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 454fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 455b62f328bSVille Tervo } else { 4560a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 457fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 4580c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 459b62f328bSVille Tervo } 4605491120eSAndrei Emeltchenko break; 4615491120eSAndrei Emeltchenko 4625491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 4630a708f8fSGustavo F. Padovan /* Connectionless socket */ 464fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 465fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 4660c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4675491120eSAndrei Emeltchenko break; 4685491120eSAndrei Emeltchenko 469416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 470416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 471416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 472416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 473416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 474416fa752SAndrei Emeltchenko break; 475416fa752SAndrei Emeltchenko 4765491120eSAndrei Emeltchenko default: 4770a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 478fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 479fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 4800c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4810a708f8fSGustavo F. Padovan } 4820a708f8fSGustavo F. Padovan 4838f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 4848f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 4858f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 4868f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 4878f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 4888f7975b1SAndrei Emeltchenko chan->local_flush_to = L2CAP_DEFAULT_FLUSH_TO; 4898f7975b1SAndrei Emeltchenko 490371fd835SUlisses Furquim l2cap_chan_hold(chan); 491baa7e1faSGustavo F. Padovan 4923df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 493643162a8SAndrei Emeltchenko } 494643162a8SAndrei Emeltchenko 495466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 496643162a8SAndrei Emeltchenko { 497643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 498643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 4993df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5000a708f8fSGustavo F. Padovan } 5010a708f8fSGustavo F. Padovan 502466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5030a708f8fSGustavo F. Padovan { 5048c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5050a708f8fSGustavo F. Padovan 506c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5070a708f8fSGustavo F. Padovan 50849208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5090a708f8fSGustavo F. Padovan 5100a708f8fSGustavo F. Padovan if (conn) { 511baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5123df91ea2SAndrei Emeltchenko list_del(&chan->list); 5133d57dc68SGustavo F. Padovan 514371fd835SUlisses Furquim l2cap_chan_put(chan); 515baa7e1faSGustavo F. Padovan 5168c1d787bSGustavo F. Padovan chan->conn = NULL; 5173cabbfdaSAndrei Emeltchenko 5183cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 5190a708f8fSGustavo F. Padovan hci_conn_put(conn->hcon); 5200a708f8fSGustavo F. Padovan } 5210a708f8fSGustavo F. Padovan 522c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 523c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5246be36555SAndrei Emeltchenko 5252827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5266ff5abbfSGustavo F. Padovan return; 5272ead70b8SGustavo F. Padovan 528ee556f66SGustavo Padovan switch(chan->mode) { 529ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 530ee556f66SGustavo Padovan break; 5310a708f8fSGustavo F. Padovan 532ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5331a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5341a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5351a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 5360a708f8fSGustavo F. Padovan 537f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 5380a708f8fSGustavo F. Padovan 5393c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 5403c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 541ee556f66SGustavo Padovan 542ee556f66SGustavo Padovan /* fall through */ 543ee556f66SGustavo Padovan 544ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 545ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 546ee556f66SGustavo Padovan break; 5470a708f8fSGustavo F. Padovan } 548ee556f66SGustavo Padovan 549ee556f66SGustavo Padovan return; 5500a708f8fSGustavo F. Padovan } 5510a708f8fSGustavo F. Padovan 5520f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 5534519de9aSGustavo F. Padovan { 5544519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5554519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 5564519de9aSGustavo F. Padovan 557e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s sk %p", chan, 558e05dcc32SAndrei Emeltchenko state_to_string(chan->state), sk); 5594519de9aSGustavo F. Padovan 56089bc500eSGustavo F. Padovan switch (chan->state) { 5614519de9aSGustavo F. Padovan case BT_LISTEN: 562c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 563c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 5644519de9aSGustavo F. Padovan break; 5654519de9aSGustavo F. Padovan 5664519de9aSGustavo F. Padovan case BT_CONNECTED: 5674519de9aSGustavo F. Padovan case BT_CONFIG: 568715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5694519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 570c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 5714519de9aSGustavo F. Padovan l2cap_send_disconn_req(conn, chan, reason); 5724519de9aSGustavo F. Padovan } else 5734519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5744519de9aSGustavo F. Padovan break; 5754519de9aSGustavo F. Padovan 5764519de9aSGustavo F. Padovan case BT_CONNECT2: 577715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5784519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 5794519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5804519de9aSGustavo F. Padovan __u16 result; 5814519de9aSGustavo F. Padovan 582c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 5834519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 5844519de9aSGustavo F. Padovan else 5854519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 58689bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 5874519de9aSGustavo F. Padovan 5884519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5894519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5904519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 591ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 5924519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5934519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 5944519de9aSGustavo F. Padovan } 5954519de9aSGustavo F. Padovan 5964519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5974519de9aSGustavo F. Padovan break; 5984519de9aSGustavo F. Padovan 5994519de9aSGustavo F. Padovan case BT_CONNECT: 6004519de9aSGustavo F. Padovan case BT_DISCONN: 6014519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6024519de9aSGustavo F. Padovan break; 6034519de9aSGustavo F. Padovan 6044519de9aSGustavo F. Padovan default: 605c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 606c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6074519de9aSGustavo F. Padovan break; 6084519de9aSGustavo F. Padovan } 6094519de9aSGustavo F. Padovan } 6104519de9aSGustavo F. Padovan 6114343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6120a708f8fSGustavo F. Padovan { 613715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6144343478fSGustavo F. Padovan switch (chan->sec_level) { 6150a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6160a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6170a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6180a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6190a708f8fSGustavo F. Padovan default: 6200a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6210a708f8fSGustavo F. Padovan } 6222983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6234343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6244343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6250a708f8fSGustavo F. Padovan 6264343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6270a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6280a708f8fSGustavo F. Padovan else 6290a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6300a708f8fSGustavo F. Padovan } else { 6314343478fSGustavo F. Padovan switch (chan->sec_level) { 6320a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6330a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6340a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6350a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6360a708f8fSGustavo F. Padovan default: 6370a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6380a708f8fSGustavo F. Padovan } 6390a708f8fSGustavo F. Padovan } 6400a708f8fSGustavo F. Padovan } 6410a708f8fSGustavo F. Padovan 6420a708f8fSGustavo F. Padovan /* Service level security */ 643d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 6440a708f8fSGustavo F. Padovan { 6458c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6460a708f8fSGustavo F. Padovan __u8 auth_type; 6470a708f8fSGustavo F. Padovan 6484343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 6490a708f8fSGustavo F. Padovan 6504343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 6510a708f8fSGustavo F. Padovan } 6520a708f8fSGustavo F. Padovan 653b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 6540a708f8fSGustavo F. Padovan { 6550a708f8fSGustavo F. Padovan u8 id; 6560a708f8fSGustavo F. Padovan 6570a708f8fSGustavo F. Padovan /* Get next available identificator. 6580a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 6590a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 6600a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 6610a708f8fSGustavo F. Padovan */ 6620a708f8fSGustavo F. Padovan 663333055f2SGustavo F. Padovan spin_lock(&conn->lock); 6640a708f8fSGustavo F. Padovan 6650a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 6660a708f8fSGustavo F. Padovan conn->tx_ident = 1; 6670a708f8fSGustavo F. Padovan 6680a708f8fSGustavo F. Padovan id = conn->tx_ident; 6690a708f8fSGustavo F. Padovan 670333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 6710a708f8fSGustavo F. Padovan 6720a708f8fSGustavo F. Padovan return id; 6730a708f8fSGustavo F. Padovan } 6740a708f8fSGustavo F. Padovan 6754519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data) 6760a708f8fSGustavo F. Padovan { 6770a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 6780a708f8fSGustavo F. Padovan u8 flags; 6790a708f8fSGustavo F. Padovan 6800a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 6810a708f8fSGustavo F. Padovan 6820a708f8fSGustavo F. Padovan if (!skb) 6830a708f8fSGustavo F. Padovan return; 6840a708f8fSGustavo F. Padovan 6850a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 6860a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 6870a708f8fSGustavo F. Padovan else 6880a708f8fSGustavo F. Padovan flags = ACL_START; 6890a708f8fSGustavo F. Padovan 69014b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 6915e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 69214b12d0bSJaikumar Ganesh 69373d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 6940a708f8fSGustavo F. Padovan } 6950a708f8fSGustavo F. Padovan 69673d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 69773d80debSLuiz Augusto von Dentz { 69873d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 69973d80debSLuiz Augusto von Dentz u16 flags; 70073d80debSLuiz Augusto von Dentz 70173d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 70273d80debSLuiz Augusto von Dentz skb->priority); 70373d80debSLuiz Augusto von Dentz 70473d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 70573d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 70673d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 70773d80debSLuiz Augusto von Dentz else 70873d80debSLuiz Augusto von Dentz flags = ACL_START; 70973d80debSLuiz Augusto von Dentz 71073d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 71173d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7120a708f8fSGustavo F. Padovan } 7130a708f8fSGustavo F. Padovan 714b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 715b5c6aaedSMat Martineau { 716b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 717b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 718b5c6aaedSMat Martineau 719b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 720b5c6aaedSMat Martineau /* S-Frame */ 721b5c6aaedSMat Martineau control->sframe = 1; 722b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 723b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 724b5c6aaedSMat Martineau 725b5c6aaedSMat Martineau control->sar = 0; 726b5c6aaedSMat Martineau control->txseq = 0; 727b5c6aaedSMat Martineau } else { 728b5c6aaedSMat Martineau /* I-Frame */ 729b5c6aaedSMat Martineau control->sframe = 0; 730b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 731b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 732b5c6aaedSMat Martineau 733b5c6aaedSMat Martineau control->poll = 0; 734b5c6aaedSMat Martineau control->super = 0; 735b5c6aaedSMat Martineau } 736b5c6aaedSMat Martineau } 737b5c6aaedSMat Martineau 738b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 739b5c6aaedSMat Martineau { 740b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 741b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 742b5c6aaedSMat Martineau 743b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 744b5c6aaedSMat Martineau /* S-Frame */ 745b5c6aaedSMat Martineau control->sframe = 1; 746b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 747b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 748b5c6aaedSMat Martineau 749b5c6aaedSMat Martineau control->sar = 0; 750b5c6aaedSMat Martineau control->txseq = 0; 751b5c6aaedSMat Martineau } else { 752b5c6aaedSMat Martineau /* I-Frame */ 753b5c6aaedSMat Martineau control->sframe = 0; 754b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 755b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 756b5c6aaedSMat Martineau 757b5c6aaedSMat Martineau control->poll = 0; 758b5c6aaedSMat Martineau control->super = 0; 759b5c6aaedSMat Martineau } 760b5c6aaedSMat Martineau } 761b5c6aaedSMat Martineau 762b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 763b5c6aaedSMat Martineau struct sk_buff *skb) 764b5c6aaedSMat Martineau { 765b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 766b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 767b5c6aaedSMat Martineau &bt_cb(skb)->control); 768cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 769b5c6aaedSMat Martineau } else { 770b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 771b5c6aaedSMat Martineau &bt_cb(skb)->control); 772cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 773b5c6aaedSMat Martineau } 774b5c6aaedSMat Martineau } 775b5c6aaedSMat Martineau 776b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 777b5c6aaedSMat Martineau { 778b5c6aaedSMat Martineau u32 packed; 779b5c6aaedSMat Martineau 780b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 781b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 782b5c6aaedSMat Martineau 783b5c6aaedSMat Martineau if (control->sframe) { 784b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 785b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 786b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 787b5c6aaedSMat Martineau } else { 788b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 789b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 790b5c6aaedSMat Martineau } 791b5c6aaedSMat Martineau 792b5c6aaedSMat Martineau return packed; 793b5c6aaedSMat Martineau } 794b5c6aaedSMat Martineau 795b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 796b5c6aaedSMat Martineau { 797b5c6aaedSMat Martineau u16 packed; 798b5c6aaedSMat Martineau 799b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 800b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 801b5c6aaedSMat Martineau 802b5c6aaedSMat Martineau if (control->sframe) { 803b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 804b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 805b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 806b5c6aaedSMat Martineau } else { 807b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 808b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 809b5c6aaedSMat Martineau } 810b5c6aaedSMat Martineau 811b5c6aaedSMat Martineau return packed; 812b5c6aaedSMat Martineau } 813b5c6aaedSMat Martineau 814b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 815b5c6aaedSMat Martineau struct l2cap_ctrl *control, 816b5c6aaedSMat Martineau struct sk_buff *skb) 817b5c6aaedSMat Martineau { 818b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 819b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 820b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 821b5c6aaedSMat Martineau } else { 822b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 823b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 824b5c6aaedSMat Martineau } 825b5c6aaedSMat Martineau } 826b5c6aaedSMat Martineau 827ba7aa64fSGustavo Padovan static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan) 828ba7aa64fSGustavo Padovan { 829ba7aa64fSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 830ba7aa64fSGustavo Padovan return L2CAP_EXT_HDR_SIZE; 831ba7aa64fSGustavo Padovan else 832ba7aa64fSGustavo Padovan return L2CAP_ENH_HDR_SIZE; 833ba7aa64fSGustavo Padovan } 834ba7aa64fSGustavo Padovan 835a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 836a67d7f6fSMat Martineau u32 control) 8370a708f8fSGustavo F. Padovan { 8380a708f8fSGustavo F. Padovan struct sk_buff *skb; 8390a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 840ba7aa64fSGustavo Padovan int hlen = __ertm_hdr_size(chan); 8410a708f8fSGustavo F. Padovan 8420a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 84303a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 8440a708f8fSGustavo F. Padovan 845a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 8460a708f8fSGustavo F. Padovan 8470a708f8fSGustavo F. Padovan if (!skb) 848a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 8490a708f8fSGustavo F. Padovan 8500a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 8510a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 852fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 85388843ab0SAndrei Emeltchenko 854a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 855a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 856a67d7f6fSMat Martineau else 857a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 8580a708f8fSGustavo F. Padovan 85947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 860a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 86103a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 8620a708f8fSGustavo F. Padovan } 8630a708f8fSGustavo F. Padovan 86473d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 865a67d7f6fSMat Martineau return skb; 866a67d7f6fSMat Martineau } 867a67d7f6fSMat Martineau 868a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 869a67d7f6fSMat Martineau struct l2cap_ctrl *control) 870a67d7f6fSMat Martineau { 871a67d7f6fSMat Martineau struct sk_buff *skb; 872a67d7f6fSMat Martineau u32 control_field; 873a67d7f6fSMat Martineau 874a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 875a67d7f6fSMat Martineau 876a67d7f6fSMat Martineau if (!control->sframe) 877a67d7f6fSMat Martineau return; 878a67d7f6fSMat Martineau 879a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 880a67d7f6fSMat Martineau !control->poll) 881a67d7f6fSMat Martineau control->final = 1; 882a67d7f6fSMat Martineau 883a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 884a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 885a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 886a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 887a67d7f6fSMat Martineau 888a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 889a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 890a67d7f6fSMat Martineau __clear_ack_timer(chan); 891a67d7f6fSMat Martineau } 892a67d7f6fSMat Martineau 893a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 894a67d7f6fSMat Martineau control->final, control->poll, control->super); 895a67d7f6fSMat Martineau 896a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 897a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 898a67d7f6fSMat Martineau else 899a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 900a67d7f6fSMat Martineau 901a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 902a67d7f6fSMat Martineau if (!IS_ERR(skb)) 90373d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9040a708f8fSGustavo F. Padovan } 9050a708f8fSGustavo F. Padovan 906c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9070a708f8fSGustavo F. Padovan { 908c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9090a708f8fSGustavo F. Padovan 910c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 911c9e3d5e0SMat Martineau 912c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 913c9e3d5e0SMat Martineau control.sframe = 1; 914c9e3d5e0SMat Martineau control.poll = poll; 915c9e3d5e0SMat Martineau 916c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 917c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 918c9e3d5e0SMat Martineau else 919c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 920c9e3d5e0SMat Martineau 921c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 922c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 9230a708f8fSGustavo F. Padovan } 9240a708f8fSGustavo F. Padovan 925b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 9260a708f8fSGustavo F. Padovan { 927c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 9280a708f8fSGustavo F. Padovan } 9290a708f8fSGustavo F. Padovan 9309b27f350SAndrei Emeltchenko static void l2cap_send_conn_req(struct l2cap_chan *chan) 9319b27f350SAndrei Emeltchenko { 9329b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 9339b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 9349b27f350SAndrei Emeltchenko 9359b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 9369b27f350SAndrei Emeltchenko req.psm = chan->psm; 9379b27f350SAndrei Emeltchenko 9389b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 9399b27f350SAndrei Emeltchenko 9409b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 9419b27f350SAndrei Emeltchenko 9429b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 9439b27f350SAndrei Emeltchenko } 9449b27f350SAndrei Emeltchenko 9459f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 9469f0caeb1SVinicius Costa Gomes { 9472827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 9489f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 9499f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 9509f0caeb1SVinicius Costa Gomes 95154a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 9529f0caeb1SVinicius Costa Gomes 95354a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 9549f0caeb1SVinicius Costa Gomes } 9559f0caeb1SVinicius Costa Gomes 956fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 9570a708f8fSGustavo F. Padovan { 9588c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 9590a708f8fSGustavo F. Padovan 9609f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 9619f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 9629f0caeb1SVinicius Costa Gomes return; 9639f0caeb1SVinicius Costa Gomes } 9649f0caeb1SVinicius Costa Gomes 9650a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 9660a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 9670a708f8fSGustavo F. Padovan return; 9680a708f8fSGustavo F. Padovan 969d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 9709b27f350SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) 9719b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 9720a708f8fSGustavo F. Padovan } else { 9730a708f8fSGustavo F. Padovan struct l2cap_info_req req; 974ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 9750a708f8fSGustavo F. Padovan 9760a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 9770a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 9780a708f8fSGustavo F. Padovan 979ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 9800a708f8fSGustavo F. Padovan 9810a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 9820a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 9830a708f8fSGustavo F. Padovan } 9840a708f8fSGustavo F. Padovan } 9850a708f8fSGustavo F. Padovan 9860a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 9870a708f8fSGustavo F. Padovan { 9880a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 9890a708f8fSGustavo F. Padovan if (!disable_ertm) 9900a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 9910a708f8fSGustavo F. Padovan 9920a708f8fSGustavo F. Padovan switch (mode) { 9930a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 9940a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 9950a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 9960a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 9970a708f8fSGustavo F. Padovan default: 9980a708f8fSGustavo F. Padovan return 0x00; 9990a708f8fSGustavo F. Padovan } 10000a708f8fSGustavo F. Padovan } 10010a708f8fSGustavo F. Padovan 10024519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err) 10030a708f8fSGustavo F. Padovan { 10046be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 10050a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 10060a708f8fSGustavo F. Padovan 10070a708f8fSGustavo F. Padovan if (!conn) 10080a708f8fSGustavo F. Padovan return; 10090a708f8fSGustavo F. Padovan 10100c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_ERTM) { 10111a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 10121a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 10131a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 10140a708f8fSGustavo F. Padovan } 10150a708f8fSGustavo F. Padovan 1016416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1017416fa752SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 1018416fa752SAndrei Emeltchenko return; 1019416fa752SAndrei Emeltchenko } 1020416fa752SAndrei Emeltchenko 1021fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1022fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 10230a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 10240a708f8fSGustavo F. Padovan L2CAP_DISCONN_REQ, sizeof(req), &req); 10250a708f8fSGustavo F. Padovan 10266be36555SAndrei Emeltchenko lock_sock(sk); 10270e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 10282e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 10296be36555SAndrei Emeltchenko release_sock(sk); 10300a708f8fSGustavo F. Padovan } 10310a708f8fSGustavo F. Padovan 10320a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 10330a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 10340a708f8fSGustavo F. Padovan { 10353df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 10360a708f8fSGustavo F. Padovan 10370a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 10380a708f8fSGustavo F. Padovan 10393df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 10400a708f8fSGustavo F. Padovan 10413df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 104248454079SGustavo F. Padovan struct sock *sk = chan->sk; 1043baa7e1faSGustavo F. Padovan 10446be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 10450a708f8fSGustavo F. Padovan 1046715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 10476be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10480a708f8fSGustavo F. Padovan continue; 10490a708f8fSGustavo F. Padovan } 10500a708f8fSGustavo F. Padovan 105189bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1052d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1053b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 10546be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10550a708f8fSGustavo F. Padovan continue; 10560a708f8fSGustavo F. Padovan } 10570a708f8fSGustavo F. Padovan 1058c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1059c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1060c1360a1cSGustavo F. Padovan &chan->conf_state)) { 10610f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 10626be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10630a708f8fSGustavo F. Padovan continue; 10640a708f8fSGustavo F. Padovan } 10650a708f8fSGustavo F. Padovan 10669b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 10670a708f8fSGustavo F. Padovan 106889bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 10690a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 10700a708f8fSGustavo F. Padovan char buf[128]; 1071fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1072fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 10730a708f8fSGustavo F. Padovan 1074d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 10756be36555SAndrei Emeltchenko lock_sock(sk); 1076c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1077c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 10780a708f8fSGustavo F. Padovan struct sock *parent = bt_sk(sk)->parent; 1079ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1080ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 108105e9a2f6SIlia Kolomisnky if (parent) 10820a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 10830a708f8fSGustavo F. Padovan 10840a708f8fSGustavo F. Padovan } else { 10850e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1086ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1087ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 10880a708f8fSGustavo F. Padovan } 10896be36555SAndrei Emeltchenko release_sock(sk); 10900a708f8fSGustavo F. Padovan } else { 1091ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1092ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 10930a708f8fSGustavo F. Padovan } 10940a708f8fSGustavo F. Padovan 1095fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1096fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 10970a708f8fSGustavo F. Padovan 1098c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 10990a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 11006be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11010a708f8fSGustavo F. Padovan continue; 11020a708f8fSGustavo F. Padovan } 11030a708f8fSGustavo F. Padovan 1104c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 11050a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 110673ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 110773ffa904SGustavo F. Padovan chan->num_conf_req++; 11080a708f8fSGustavo F. Padovan } 11090a708f8fSGustavo F. Padovan 11106be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11110a708f8fSGustavo F. Padovan } 11120a708f8fSGustavo F. Padovan 11133df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 11140a708f8fSGustavo F. Padovan } 11150a708f8fSGustavo F. Padovan 1116c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1117b62f328bSVille Tervo * Returns closest match, locked. 1118b62f328bSVille Tervo */ 1119d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1120c2287681SIdo Yariv bdaddr_t *src, 1121c2287681SIdo Yariv bdaddr_t *dst) 1122b62f328bSVille Tervo { 112323691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1124b62f328bSVille Tervo 112523691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1126b62f328bSVille Tervo 112723691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 112823691d75SGustavo F. Padovan struct sock *sk = c->sk; 1129fe4128e0SGustavo F. Padovan 113089bc500eSGustavo F. Padovan if (state && c->state != state) 1131b62f328bSVille Tervo continue; 1132b62f328bSVille Tervo 113323691d75SGustavo F. Padovan if (c->scid == cid) { 1134c2287681SIdo Yariv int src_match, dst_match; 1135c2287681SIdo Yariv int src_any, dst_any; 1136c2287681SIdo Yariv 1137b62f328bSVille Tervo /* Exact match. */ 1138c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1139c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1140c2287681SIdo Yariv if (src_match && dst_match) { 114123691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 114223691d75SGustavo F. Padovan return c; 114323691d75SGustavo F. Padovan } 1144b62f328bSVille Tervo 1145b62f328bSVille Tervo /* Closest match */ 1146c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1147c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1148c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1149c2287681SIdo Yariv (src_any && dst_any)) 115023691d75SGustavo F. Padovan c1 = c; 1151b62f328bSVille Tervo } 1152b62f328bSVille Tervo } 1153280f294fSGustavo F. Padovan 115423691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1155b62f328bSVille Tervo 115623691d75SGustavo F. Padovan return c1; 1157b62f328bSVille Tervo } 1158b62f328bSVille Tervo 1159b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1160b62f328bSVille Tervo { 1161c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 116223691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1163b62f328bSVille Tervo 1164b62f328bSVille Tervo BT_DBG(""); 1165b62f328bSVille Tervo 1166b62f328bSVille Tervo /* Check if we have socket listening on cid */ 116723691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1168c2287681SIdo Yariv conn->src, conn->dst); 116923691d75SGustavo F. Padovan if (!pchan) 1170b62f328bSVille Tervo return; 1171b62f328bSVille Tervo 117223691d75SGustavo F. Padovan parent = pchan->sk; 117323691d75SGustavo F. Padovan 1174aa2ac881SGustavo F. Padovan lock_sock(parent); 117562f3a2cfSGustavo F. Padovan 117680b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 117780808e43SGustavo F. Padovan if (!chan) 1178b62f328bSVille Tervo goto clean; 1179b62f328bSVille Tervo 118080808e43SGustavo F. Padovan sk = chan->sk; 11815d41ce1dSGustavo F. Padovan 1182b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1183b62f328bSVille Tervo 1184b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1185b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1186b62f328bSVille Tervo 1187d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 1188d1010240SGustavo F. Padovan 11893d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 119048454079SGustavo F. Padovan 11916754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1192b62f328bSVille Tervo 1193b62f328bSVille Tervo clean: 1194aa2ac881SGustavo F. Padovan release_sock(parent); 1195b62f328bSVille Tervo } 1196b62f328bSVille Tervo 11970a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 11980a708f8fSGustavo F. Padovan { 119948454079SGustavo F. Padovan struct l2cap_chan *chan; 12000a708f8fSGustavo F. Padovan 12010a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12020a708f8fSGustavo F. Padovan 1203b62f328bSVille Tervo if (!conn->hcon->out && conn->hcon->type == LE_LINK) 1204b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1205b62f328bSVille Tervo 1206160dc6acSVinicius Costa Gomes if (conn->hcon->out && conn->hcon->type == LE_LINK) 1207160dc6acSVinicius Costa Gomes smp_conn_security(conn, conn->hcon->pending_sec_level); 1208160dc6acSVinicius Costa Gomes 12093df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12100a708f8fSGustavo F. Padovan 12113df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1212baa7e1faSGustavo F. Padovan 12136be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12140a708f8fSGustavo F. Padovan 1215416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1216416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1217416fa752SAndrei Emeltchenko continue; 1218416fa752SAndrei Emeltchenko } 1219416fa752SAndrei Emeltchenko 122063128451SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 1221b501d6a1SAnderson Briglia if (smp_conn_security(conn, chan->sec_level)) 1222cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1223acd7d370SVille Tervo 122463128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12256be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1226c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 12276be36555SAndrei Emeltchenko lock_sock(sk); 12280e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 12290a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 12306be36555SAndrei Emeltchenko release_sock(sk); 1231b501d6a1SAnderson Briglia 123289bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1233fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 12340a708f8fSGustavo F. Padovan 12356be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12360a708f8fSGustavo F. Padovan } 12370a708f8fSGustavo F. Padovan 12383df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12390a708f8fSGustavo F. Padovan } 12400a708f8fSGustavo F. Padovan 12410a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 12420a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 12430a708f8fSGustavo F. Padovan { 124448454079SGustavo F. Padovan struct l2cap_chan *chan; 12450a708f8fSGustavo F. Padovan 12460a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12470a708f8fSGustavo F. Padovan 12483df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12490a708f8fSGustavo F. Padovan 12503df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1251ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 12522e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 12530a708f8fSGustavo F. Padovan } 12540a708f8fSGustavo F. Padovan 12553df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12560a708f8fSGustavo F. Padovan } 12570a708f8fSGustavo F. Padovan 1258f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 12590a708f8fSGustavo F. Padovan { 1260f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1261030013d8SGustavo F. Padovan info_timer.work); 12620a708f8fSGustavo F. Padovan 12630a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 12640a708f8fSGustavo F. Padovan conn->info_ident = 0; 12650a708f8fSGustavo F. Padovan 12660a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 12670a708f8fSGustavo F. Padovan } 12680a708f8fSGustavo F. Padovan 12695d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 12705d3de7dfSVinicius Costa Gomes { 12715d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 12725d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 12735d3de7dfSVinicius Costa Gomes 12745d3de7dfSVinicius Costa Gomes if (!conn) 12755d3de7dfSVinicius Costa Gomes return; 12765d3de7dfSVinicius Costa Gomes 12775d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 12785d3de7dfSVinicius Costa Gomes 12795d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 12805d3de7dfSVinicius Costa Gomes 12813df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12823df91ea2SAndrei Emeltchenko 12835d3de7dfSVinicius Costa Gomes /* Kill channels */ 12845d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 128561d6ef3eSMat Martineau l2cap_chan_hold(chan); 12866be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12876be36555SAndrei Emeltchenko 12885d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 12896be36555SAndrei Emeltchenko 12906be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12916be36555SAndrei Emeltchenko 129280b98027SGustavo Padovan chan->ops->close(chan); 129361d6ef3eSMat Martineau l2cap_chan_put(chan); 12945d3de7dfSVinicius Costa Gomes } 12955d3de7dfSVinicius Costa Gomes 12963df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12973df91ea2SAndrei Emeltchenko 129873d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 129973d80debSLuiz Augusto von Dentz 13005d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1301127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 13025d3de7dfSVinicius Costa Gomes 130351a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1304127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 13058aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1306d26a2345SVinicius Costa Gomes } 13075d3de7dfSVinicius Costa Gomes 13085d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 13095d3de7dfSVinicius Costa Gomes kfree(conn); 13105d3de7dfSVinicius Costa Gomes } 13115d3de7dfSVinicius Costa Gomes 13126c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 13135d3de7dfSVinicius Costa Gomes { 13146c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 13156c9d42a1SGustavo F. Padovan security_timer.work); 13165d3de7dfSVinicius Costa Gomes 13175d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 13185d3de7dfSVinicius Costa Gomes } 13195d3de7dfSVinicius Costa Gomes 13200a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 13210a708f8fSGustavo F. Padovan { 13220a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 132373d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 13240a708f8fSGustavo F. Padovan 13250a708f8fSGustavo F. Padovan if (conn || status) 13260a708f8fSGustavo F. Padovan return conn; 13270a708f8fSGustavo F. Padovan 132873d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 132973d80debSLuiz Augusto von Dentz if (!hchan) 13300a708f8fSGustavo F. Padovan return NULL; 13310a708f8fSGustavo F. Padovan 133273d80debSLuiz Augusto von Dentz conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC); 133373d80debSLuiz Augusto von Dentz if (!conn) { 133473d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 133573d80debSLuiz Augusto von Dentz return NULL; 133673d80debSLuiz Augusto von Dentz } 133773d80debSLuiz Augusto von Dentz 13380a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 13390a708f8fSGustavo F. Padovan conn->hcon = hcon; 134073d80debSLuiz Augusto von Dentz conn->hchan = hchan; 13410a708f8fSGustavo F. Padovan 134273d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 13430a708f8fSGustavo F. Padovan 1344acd7d370SVille Tervo if (hcon->hdev->le_mtu && hcon->type == LE_LINK) 1345acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1346acd7d370SVille Tervo else 13470a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1348acd7d370SVille Tervo 13490a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 13500a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 13510a708f8fSGustavo F. Padovan 13520a708f8fSGustavo F. Padovan conn->feat_mask = 0; 13530a708f8fSGustavo F. Padovan 13540a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 13553df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1356baa7e1faSGustavo F. Padovan 1357baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 13580a708f8fSGustavo F. Padovan 13595d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 13606c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 13615d3de7dfSVinicius Costa Gomes else 1362030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 13630a708f8fSGustavo F. Padovan 13649f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 13650a708f8fSGustavo F. Padovan 13660a708f8fSGustavo F. Padovan return conn; 13670a708f8fSGustavo F. Padovan } 13680a708f8fSGustavo F. Padovan 13690a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 13700a708f8fSGustavo F. Padovan 1371c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 13720a708f8fSGustavo F. Padovan * Returns closest match. 13730a708f8fSGustavo F. Padovan */ 1374c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1375c2287681SIdo Yariv bdaddr_t *src, 1376c2287681SIdo Yariv bdaddr_t *dst) 13770a708f8fSGustavo F. Padovan { 137823691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 13790a708f8fSGustavo F. Padovan 138023691d75SGustavo F. Padovan read_lock(&chan_list_lock); 13810a708f8fSGustavo F. Padovan 138223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 138323691d75SGustavo F. Padovan struct sock *sk = c->sk; 1384fe4128e0SGustavo F. Padovan 138589bc500eSGustavo F. Padovan if (state && c->state != state) 13860a708f8fSGustavo F. Padovan continue; 13870a708f8fSGustavo F. Padovan 138823691d75SGustavo F. Padovan if (c->psm == psm) { 1389c2287681SIdo Yariv int src_match, dst_match; 1390c2287681SIdo Yariv int src_any, dst_any; 1391c2287681SIdo Yariv 13920a708f8fSGustavo F. Padovan /* Exact match. */ 1393c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1394c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1395c2287681SIdo Yariv if (src_match && dst_match) { 1396a7567b20SJohannes Berg read_unlock(&chan_list_lock); 139723691d75SGustavo F. Padovan return c; 139823691d75SGustavo F. Padovan } 13990a708f8fSGustavo F. Padovan 14000a708f8fSGustavo F. Padovan /* Closest match */ 1401c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1402c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1403c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1404c2287681SIdo Yariv (src_any && dst_any)) 140523691d75SGustavo F. Padovan c1 = c; 14060a708f8fSGustavo F. Padovan } 14070a708f8fSGustavo F. Padovan } 14080a708f8fSGustavo F. Padovan 140923691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 14100a708f8fSGustavo F. Padovan 141123691d75SGustavo F. Padovan return c1; 14120a708f8fSGustavo F. Padovan } 14130a708f8fSGustavo F. Padovan 14148e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 14158e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 14160a708f8fSGustavo F. Padovan { 14175d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 14180a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 14190a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 14200a708f8fSGustavo F. Padovan struct hci_conn *hcon; 14210a708f8fSGustavo F. Padovan struct hci_dev *hdev; 14220a708f8fSGustavo F. Padovan __u8 auth_type; 14230a708f8fSGustavo F. Padovan int err; 14240a708f8fSGustavo F. Padovan 14258e9f9892SAndre Guedes BT_DBG("%s -> %s (type %u) psm 0x%2.2x", batostr(src), batostr(dst), 14268e9f9892SAndre Guedes dst_type, __le16_to_cpu(chan->psm)); 14270a708f8fSGustavo F. Padovan 14280a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 14290a708f8fSGustavo F. Padovan if (!hdev) 14300a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 14310a708f8fSGustavo F. Padovan 143209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14330a708f8fSGustavo F. Padovan 14346be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 143503a00194SGustavo F. Padovan 143603a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 143703a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 143803a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 143903a00194SGustavo F. Padovan err = -EINVAL; 144003a00194SGustavo F. Padovan goto done; 144103a00194SGustavo F. Padovan } 144203a00194SGustavo F. Padovan 144303a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 144403a00194SGustavo F. Padovan err = -EINVAL; 144503a00194SGustavo F. Padovan goto done; 144603a00194SGustavo F. Padovan } 144703a00194SGustavo F. Padovan 144803a00194SGustavo F. Padovan switch (chan->mode) { 144903a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 145003a00194SGustavo F. Padovan break; 145103a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 145203a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 145303a00194SGustavo F. Padovan if (!disable_ertm) 145403a00194SGustavo F. Padovan break; 145503a00194SGustavo F. Padovan /* fall through */ 145603a00194SGustavo F. Padovan default: 145703a00194SGustavo F. Padovan err = -ENOTSUPP; 145803a00194SGustavo F. Padovan goto done; 145903a00194SGustavo F. Padovan } 146003a00194SGustavo F. Padovan 14610797e01dSGustavo Padovan switch (chan->state) { 146203a00194SGustavo F. Padovan case BT_CONNECT: 146303a00194SGustavo F. Padovan case BT_CONNECT2: 146403a00194SGustavo F. Padovan case BT_CONFIG: 146503a00194SGustavo F. Padovan /* Already connecting */ 146603a00194SGustavo F. Padovan err = 0; 146703a00194SGustavo F. Padovan goto done; 146803a00194SGustavo F. Padovan 146903a00194SGustavo F. Padovan case BT_CONNECTED: 147003a00194SGustavo F. Padovan /* Already connected */ 147103a00194SGustavo F. Padovan err = -EISCONN; 147203a00194SGustavo F. Padovan goto done; 147303a00194SGustavo F. Padovan 147403a00194SGustavo F. Padovan case BT_OPEN: 147503a00194SGustavo F. Padovan case BT_BOUND: 147603a00194SGustavo F. Padovan /* Can connect */ 147703a00194SGustavo F. Padovan break; 147803a00194SGustavo F. Padovan 147903a00194SGustavo F. Padovan default: 148003a00194SGustavo F. Padovan err = -EBADFD; 148103a00194SGustavo F. Padovan goto done; 148203a00194SGustavo F. Padovan } 148303a00194SGustavo F. Padovan 148403a00194SGustavo F. Padovan /* Set destination address and psm */ 14850797e01dSGustavo Padovan lock_sock(sk); 14869219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 14876be36555SAndrei Emeltchenko release_sock(sk); 14886be36555SAndrei Emeltchenko 148903a00194SGustavo F. Padovan chan->psm = psm; 149003a00194SGustavo F. Padovan chan->dcid = cid; 14910a708f8fSGustavo F. Padovan 14924343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 14930a708f8fSGustavo F. Padovan 1494fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 14958e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 14964343478fSGustavo F. Padovan chan->sec_level, auth_type); 1497acd7d370SVille Tervo else 14988e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 14994343478fSGustavo F. Padovan chan->sec_level, auth_type); 1500acd7d370SVille Tervo 150130e76272SVille Tervo if (IS_ERR(hcon)) { 150230e76272SVille Tervo err = PTR_ERR(hcon); 15030a708f8fSGustavo F. Padovan goto done; 150430e76272SVille Tervo } 15050a708f8fSGustavo F. Padovan 15060a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 15070a708f8fSGustavo F. Padovan if (!conn) { 15080a708f8fSGustavo F. Padovan hci_conn_put(hcon); 150930e76272SVille Tervo err = -ENOMEM; 15100a708f8fSGustavo F. Padovan goto done; 15110a708f8fSGustavo F. Padovan } 15120a708f8fSGustavo F. Padovan 15139f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 15149f0caeb1SVinicius Costa Gomes err = 0; 15159f0caeb1SVinicius Costa Gomes 15169f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 15179f0caeb1SVinicius Costa Gomes err = -EBUSY; 15189f0caeb1SVinicius Costa Gomes hci_conn_put(hcon); 15199f0caeb1SVinicius Costa Gomes } 15209f0caeb1SVinicius Costa Gomes 15219f0caeb1SVinicius Costa Gomes if (err) 15229f0caeb1SVinicius Costa Gomes goto done; 15239f0caeb1SVinicius Costa Gomes } 15249f0caeb1SVinicius Costa Gomes 15250a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 15260a708f8fSGustavo F. Padovan bacpy(src, conn->src); 15270a708f8fSGustavo F. Padovan 15286be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 152948454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 15306be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 153148454079SGustavo F. Padovan 15326be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1533c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 15340a708f8fSGustavo F. Padovan 15350a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1536715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1537c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1538d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 15396be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 15400a708f8fSGustavo F. Padovan } else 1541fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 15420a708f8fSGustavo F. Padovan } 15430a708f8fSGustavo F. Padovan 154430e76272SVille Tervo err = 0; 154530e76272SVille Tervo 15460a708f8fSGustavo F. Padovan done: 15476be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 154809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15490a708f8fSGustavo F. Padovan hci_dev_put(hdev); 15500a708f8fSGustavo F. Padovan return err; 15510a708f8fSGustavo F. Padovan } 15520a708f8fSGustavo F. Padovan 1553dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 15540a708f8fSGustavo F. Padovan { 15558c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 15560a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 15570a708f8fSGustavo F. Padovan int err = 0; 15580a708f8fSGustavo F. Padovan int timeo = HZ/5; 15590a708f8fSGustavo F. Padovan 15600a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 15610a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1562a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 15630a708f8fSGustavo F. Padovan if (!timeo) 15640a708f8fSGustavo F. Padovan timeo = HZ/5; 15650a708f8fSGustavo F. Padovan 15660a708f8fSGustavo F. Padovan if (signal_pending(current)) { 15670a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 15680a708f8fSGustavo F. Padovan break; 15690a708f8fSGustavo F. Padovan } 15700a708f8fSGustavo F. Padovan 15710a708f8fSGustavo F. Padovan release_sock(sk); 15720a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 15730a708f8fSGustavo F. Padovan lock_sock(sk); 1574a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 15750a708f8fSGustavo F. Padovan 15760a708f8fSGustavo F. Padovan err = sock_error(sk); 15770a708f8fSGustavo F. Padovan if (err) 15780a708f8fSGustavo F. Padovan break; 15790a708f8fSGustavo F. Padovan } 15800a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 15810a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 15820a708f8fSGustavo F. Padovan return err; 15830a708f8fSGustavo F. Padovan } 15840a708f8fSGustavo F. Padovan 1585721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 15860a708f8fSGustavo F. Padovan { 1587721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1588721c4181SGustavo F. Padovan monitor_timer.work); 15890a708f8fSGustavo F. Padovan 1590525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 15910a708f8fSGustavo F. Padovan 15926be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 15936be36555SAndrei Emeltchenko 159480909e04SMat Martineau if (!chan->conn) { 15956be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 15968d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 15970a708f8fSGustavo F. Padovan return; 15980a708f8fSGustavo F. Padovan } 15990a708f8fSGustavo F. Padovan 1600401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 16010a708f8fSGustavo F. Padovan 16026be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16038d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16040a708f8fSGustavo F. Padovan } 16050a708f8fSGustavo F. Padovan 1606721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 16070a708f8fSGustavo F. Padovan { 1608721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1609721c4181SGustavo F. Padovan retrans_timer.work); 16100a708f8fSGustavo F. Padovan 161149208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 16120a708f8fSGustavo F. Padovan 16136be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 16146be36555SAndrei Emeltchenko 161580909e04SMat Martineau if (!chan->conn) { 161680909e04SMat Martineau l2cap_chan_unlock(chan); 161780909e04SMat Martineau l2cap_chan_put(chan); 161880909e04SMat Martineau return; 161980909e04SMat Martineau } 16200a708f8fSGustavo F. Padovan 1621401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 16226be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16238d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16240a708f8fSGustavo F. Padovan } 16250a708f8fSGustavo F. Padovan 1626d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 16273733937dSMat Martineau struct sk_buff_head *skbs) 16280a708f8fSGustavo F. Padovan { 16290a708f8fSGustavo F. Padovan struct sk_buff *skb; 16303733937dSMat Martineau struct l2cap_ctrl *control; 16310a708f8fSGustavo F. Padovan 16323733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 16333733937dSMat Martineau 16343733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 16353733937dSMat Martineau 16363733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 16373733937dSMat Martineau 16383733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 16393733937dSMat Martineau 16403733937dSMat Martineau bt_cb(skb)->control.retries = 1; 16413733937dSMat Martineau control = &bt_cb(skb)->control; 16423733937dSMat Martineau 16433733937dSMat Martineau control->reqseq = 0; 16443733937dSMat Martineau control->txseq = chan->next_tx_seq; 16453733937dSMat Martineau 16463733937dSMat Martineau __pack_control(chan, control, skb); 16470a708f8fSGustavo F. Padovan 164847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 16493733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 16503733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 16510a708f8fSGustavo F. Padovan } 16520a708f8fSGustavo F. Padovan 16534343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 16540a708f8fSGustavo F. Padovan 16553733937dSMat Martineau BT_DBG("Sent txseq %d", (int)control->txseq); 16563733937dSMat Martineau 1657836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 16583733937dSMat Martineau chan->frames_sent++; 16590a708f8fSGustavo F. Padovan } 16600a708f8fSGustavo F. Padovan } 16610a708f8fSGustavo F. Padovan 166267c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 16630a708f8fSGustavo F. Padovan { 16640a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 166518a48e76SMat Martineau struct l2cap_ctrl *control; 166618a48e76SMat Martineau int sent = 0; 166718a48e76SMat Martineau 166818a48e76SMat Martineau BT_DBG("chan %p", chan); 16690a708f8fSGustavo F. Padovan 167089bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 16710a708f8fSGustavo F. Padovan return -ENOTCONN; 16720a708f8fSGustavo F. Padovan 167394122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 167494122bbeSMat Martineau return 0; 167594122bbeSMat Martineau 167618a48e76SMat Martineau while (chan->tx_send_head && 167718a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 167818a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 16790a708f8fSGustavo F. Padovan 168018a48e76SMat Martineau skb = chan->tx_send_head; 16810a708f8fSGustavo F. Padovan 168218a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 168318a48e76SMat Martineau control = &bt_cb(skb)->control; 16840a708f8fSGustavo F. Padovan 1685e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 168618a48e76SMat Martineau control->final = 1; 1687e2ab4353SGustavo F. Padovan 168818a48e76SMat Martineau control->reqseq = chan->buffer_seq; 168918a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 169018a48e76SMat Martineau control->txseq = chan->next_tx_seq; 16910a708f8fSGustavo F. Padovan 169218a48e76SMat Martineau __pack_control(chan, control, skb); 16930a708f8fSGustavo F. Padovan 169447d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 169518a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 169618a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 16970a708f8fSGustavo F. Padovan } 16980a708f8fSGustavo F. Padovan 169918a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 170018a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 170118a48e76SMat Martineau */ 170218a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 170318a48e76SMat Martineau 170418a48e76SMat Martineau if (!tx_skb) 170518a48e76SMat Martineau break; 17060a708f8fSGustavo F. Padovan 17071a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 17080a708f8fSGustavo F. Padovan 1709836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 17106a026610SGustavo F. Padovan chan->unacked_frames++; 17116a026610SGustavo F. Padovan chan->frames_sent++; 171218a48e76SMat Martineau sent++; 17130a708f8fSGustavo F. Padovan 171458d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 171558d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 17160a708f8fSGustavo F. Padovan else 171758d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 171818a48e76SMat Martineau 171918a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 172018a48e76SMat Martineau BT_DBG("Sent txseq %d", (int)control->txseq); 17210a708f8fSGustavo F. Padovan } 17220a708f8fSGustavo F. Padovan 172318a48e76SMat Martineau BT_DBG("Sent %d, %d unacked, %d in ERTM queue", sent, 172418a48e76SMat Martineau (int) chan->unacked_frames, skb_queue_len(&chan->tx_q)); 172518a48e76SMat Martineau 172618a48e76SMat Martineau return sent; 17270a708f8fSGustavo F. Padovan } 17280a708f8fSGustavo F. Padovan 1729e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1730e1fbd4c1SMat Martineau { 1731e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1732e1fbd4c1SMat Martineau struct sk_buff *skb; 1733e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1734e1fbd4c1SMat Martineau u16 seq; 1735e1fbd4c1SMat Martineau 1736e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1737e1fbd4c1SMat Martineau 1738e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1739e1fbd4c1SMat Martineau return; 1740e1fbd4c1SMat Martineau 1741e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1742e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1743e1fbd4c1SMat Martineau 1744e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1745e1fbd4c1SMat Martineau if (!skb) { 1746e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1747e1fbd4c1SMat Martineau seq); 1748e1fbd4c1SMat Martineau continue; 1749e1fbd4c1SMat Martineau } 1750e1fbd4c1SMat Martineau 1751e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1752e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1753e1fbd4c1SMat Martineau 1754e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1755e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1756e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 1757e1fbd4c1SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 1758e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1759e1fbd4c1SMat Martineau break; 1760e1fbd4c1SMat Martineau } 1761e1fbd4c1SMat Martineau 1762e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1763e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1764e1fbd4c1SMat Martineau control.final = 1; 1765e1fbd4c1SMat Martineau else 1766e1fbd4c1SMat Martineau control.final = 0; 1767e1fbd4c1SMat Martineau 1768e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1769e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1770e1fbd4c1SMat Martineau * writeable copy 1771e1fbd4c1SMat Martineau */ 1772e1fbd4c1SMat Martineau tx_skb = skb_copy(skb, GFP_ATOMIC); 1773e1fbd4c1SMat Martineau } else { 1774e1fbd4c1SMat Martineau tx_skb = skb_clone(skb, GFP_ATOMIC); 1775e1fbd4c1SMat Martineau } 1776e1fbd4c1SMat Martineau 1777e1fbd4c1SMat Martineau if (!tx_skb) { 1778e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1779e1fbd4c1SMat Martineau break; 1780e1fbd4c1SMat Martineau } 1781e1fbd4c1SMat Martineau 1782e1fbd4c1SMat Martineau /* Update skb contents */ 1783e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1784e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1785e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1786e1fbd4c1SMat Martineau } else { 1787e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1788e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1789e1fbd4c1SMat Martineau } 1790e1fbd4c1SMat Martineau 1791e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1792e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1793e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1794e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1795e1fbd4c1SMat Martineau } 1796e1fbd4c1SMat Martineau 1797e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1798e1fbd4c1SMat Martineau 1799e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 1800e1fbd4c1SMat Martineau 1801e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 1802e1fbd4c1SMat Martineau } 1803e1fbd4c1SMat Martineau } 1804e1fbd4c1SMat Martineau 1805f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 1806f80842a8SMat Martineau struct l2cap_ctrl *control) 1807f80842a8SMat Martineau { 1808f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1809f80842a8SMat Martineau 1810f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 1811f80842a8SMat Martineau l2cap_ertm_resend(chan); 1812f80842a8SMat Martineau } 1813f80842a8SMat Martineau 1814d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 1815d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 1816d2a7ac5dSMat Martineau { 1817e1fbd4c1SMat Martineau struct sk_buff *skb; 1818e1fbd4c1SMat Martineau 1819e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1820e1fbd4c1SMat Martineau 1821e1fbd4c1SMat Martineau if (control->poll) 1822e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 1823e1fbd4c1SMat Martineau 1824e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1825e1fbd4c1SMat Martineau 1826e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1827e1fbd4c1SMat Martineau return; 1828e1fbd4c1SMat Martineau 1829e1fbd4c1SMat Martineau if (chan->unacked_frames) { 1830e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 1831e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 1832e1fbd4c1SMat Martineau skb == chan->tx_send_head) 1833e1fbd4c1SMat Martineau break; 1834e1fbd4c1SMat Martineau } 1835e1fbd4c1SMat Martineau 1836e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 1837e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 1838e1fbd4c1SMat Martineau break; 1839e1fbd4c1SMat Martineau 1840e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 1841e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 1842e1fbd4c1SMat Martineau } 1843e1fbd4c1SMat Martineau 1844e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 1845e1fbd4c1SMat Martineau } 1846d2a7ac5dSMat Martineau } 1847d2a7ac5dSMat Martineau 1848b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 1849b17e73bbSSzymon Janc { 18500a0aba42SMat Martineau struct l2cap_ctrl control; 18510a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 18520a0aba42SMat Martineau chan->last_acked_seq); 18530a0aba42SMat Martineau int threshold; 18540a0aba42SMat Martineau 18550a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 18560a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 18570a0aba42SMat Martineau 18580a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 18590a0aba42SMat Martineau control.sframe = 1; 18600a0aba42SMat Martineau 18610a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 18620a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 1863b17e73bbSSzymon Janc __clear_ack_timer(chan); 18640a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 18650a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18660a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18670a0aba42SMat Martineau } else { 18680a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 18690a0aba42SMat Martineau l2cap_ertm_send(chan); 18700a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 18710a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 18720a0aba42SMat Martineau frames_to_ack = 0; 18730a0aba42SMat Martineau } 18740a0aba42SMat Martineau 18750a0aba42SMat Martineau /* Ack now if the tx window is 3/4ths full. 18760a0aba42SMat Martineau * Calculate without mul or div 18770a0aba42SMat Martineau */ 18780a0aba42SMat Martineau threshold = chan->tx_win; 18790a0aba42SMat Martineau threshold += threshold << 1; 18800a0aba42SMat Martineau threshold >>= 2; 18810a0aba42SMat Martineau 18820a0aba42SMat Martineau BT_DBG("frames_to_ack %d, threshold %d", (int)frames_to_ack, 18830a0aba42SMat Martineau threshold); 18840a0aba42SMat Martineau 18850a0aba42SMat Martineau if (frames_to_ack >= threshold) { 18860a0aba42SMat Martineau __clear_ack_timer(chan); 18870a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 18880a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18890a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18900a0aba42SMat Martineau frames_to_ack = 0; 18910a0aba42SMat Martineau } 18920a0aba42SMat Martineau 18930a0aba42SMat Martineau if (frames_to_ack) 18940a0aba42SMat Martineau __set_ack_timer(chan); 18950a0aba42SMat Martineau } 1896b17e73bbSSzymon Janc } 1897b17e73bbSSzymon Janc 189804124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 189904124681SGustavo F. Padovan struct msghdr *msg, int len, 190004124681SGustavo F. Padovan int count, struct sk_buff *skb) 19010a708f8fSGustavo F. Padovan { 19020952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 19030a708f8fSGustavo F. Padovan struct sk_buff **frag; 190490338947SGustavo Padovan int sent = 0; 19050a708f8fSGustavo F. Padovan 19060a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 19070a708f8fSGustavo F. Padovan return -EFAULT; 19080a708f8fSGustavo F. Padovan 19090a708f8fSGustavo F. Padovan sent += count; 19100a708f8fSGustavo F. Padovan len -= count; 19110a708f8fSGustavo F. Padovan 19120a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 19130a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 19140a708f8fSGustavo F. Padovan while (len) { 1915fbe00700SGustavo Padovan struct sk_buff *tmp; 1916fbe00700SGustavo Padovan 19170a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 19180a708f8fSGustavo F. Padovan 1919fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 192090338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 1921fbe00700SGustavo Padovan if (IS_ERR(tmp)) 1922fbe00700SGustavo Padovan return PTR_ERR(tmp); 19232f7719ceSAndrei Emeltchenko 1924fbe00700SGustavo Padovan *frag = tmp; 1925fbe00700SGustavo Padovan 19260a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 19270a708f8fSGustavo F. Padovan return -EFAULT; 19280a708f8fSGustavo F. Padovan 19295e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 19305e59b791SLuiz Augusto von Dentz 19310a708f8fSGustavo F. Padovan sent += count; 19320a708f8fSGustavo F. Padovan len -= count; 19330a708f8fSGustavo F. Padovan 19342d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 19352d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 19362d0ed3d5SGustavo Padovan 19370a708f8fSGustavo F. Padovan frag = &(*frag)->next; 19380a708f8fSGustavo F. Padovan } 19390a708f8fSGustavo F. Padovan 19400a708f8fSGustavo F. Padovan return sent; 19410a708f8fSGustavo F. Padovan } 19420a708f8fSGustavo F. Padovan 19435e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 19445e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19455e59b791SLuiz Augusto von Dentz u32 priority) 19460a708f8fSGustavo F. Padovan { 19478c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19480a708f8fSGustavo F. Padovan struct sk_buff *skb; 194903a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 19500a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19510a708f8fSGustavo F. Padovan 19526d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d priority %u", chan, (int)len, priority); 19530a708f8fSGustavo F. Padovan 19540a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 19552f7719ceSAndrei Emeltchenko 19562f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 195790338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 195890338947SGustavo Padovan if (IS_ERR(skb)) 195990338947SGustavo Padovan return skb; 19600a708f8fSGustavo F. Padovan 19615e59b791SLuiz Augusto von Dentz skb->priority = priority; 19625e59b791SLuiz Augusto von Dentz 19630a708f8fSGustavo F. Padovan /* Create L2CAP header */ 19640a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 1965fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 1966daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 1967daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 19680a708f8fSGustavo F. Padovan 19690952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 19700a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 19710a708f8fSGustavo F. Padovan kfree_skb(skb); 19720a708f8fSGustavo F. Padovan return ERR_PTR(err); 19730a708f8fSGustavo F. Padovan } 19740a708f8fSGustavo F. Padovan return skb; 19750a708f8fSGustavo F. Padovan } 19760a708f8fSGustavo F. Padovan 19775e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 19785e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19795e59b791SLuiz Augusto von Dentz u32 priority) 19800a708f8fSGustavo F. Padovan { 19818c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19820a708f8fSGustavo F. Padovan struct sk_buff *skb; 1983f2ba7faeSGustavo Padovan int err, count; 19840a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19850a708f8fSGustavo F. Padovan 19866d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d", chan, (int)len); 19870a708f8fSGustavo F. Padovan 1988f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 19892f7719ceSAndrei Emeltchenko 1990f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 199190338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 199290338947SGustavo Padovan if (IS_ERR(skb)) 199390338947SGustavo Padovan return skb; 19940a708f8fSGustavo F. Padovan 19955e59b791SLuiz Augusto von Dentz skb->priority = priority; 19965e59b791SLuiz Augusto von Dentz 19970a708f8fSGustavo F. Padovan /* Create L2CAP header */ 19980a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 1999fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 20006ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 20010a708f8fSGustavo F. Padovan 20020952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20030a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20040a708f8fSGustavo F. Padovan kfree_skb(skb); 20050a708f8fSGustavo F. Padovan return ERR_PTR(err); 20060a708f8fSGustavo F. Padovan } 20070a708f8fSGustavo F. Padovan return skb; 20080a708f8fSGustavo F. Padovan } 20090a708f8fSGustavo F. Padovan 2010ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2011ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 201294122bbeSMat Martineau u16 sdulen) 20130a708f8fSGustavo F. Padovan { 20148c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 20150a708f8fSGustavo F. Padovan struct sk_buff *skb; 2016e4ca6d98SAndrei Emeltchenko int err, count, hlen; 20170a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 20180a708f8fSGustavo F. Padovan 20196d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d", chan, (int)len); 20200a708f8fSGustavo F. Padovan 20210a708f8fSGustavo F. Padovan if (!conn) 20220a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 20230a708f8fSGustavo F. Padovan 2024ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2025e4ca6d98SAndrei Emeltchenko 20260a708f8fSGustavo F. Padovan if (sdulen) 202703a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 20280a708f8fSGustavo F. Padovan 202947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 203003a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 20310a708f8fSGustavo F. Padovan 20320a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 20332f7719ceSAndrei Emeltchenko 20342f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 203590338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 203690338947SGustavo Padovan if (IS_ERR(skb)) 203790338947SGustavo Padovan return skb; 20380a708f8fSGustavo F. Padovan 20390a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20400a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2041fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 20420a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 204388843ab0SAndrei Emeltchenko 204418a48e76SMat Martineau /* Control header is populated later */ 204518a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 204618a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 204718a48e76SMat Martineau else 204818a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 204988843ab0SAndrei Emeltchenko 20500a708f8fSGustavo F. Padovan if (sdulen) 205103a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 20520a708f8fSGustavo F. Padovan 20530952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20540a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20550a708f8fSGustavo F. Padovan kfree_skb(skb); 20560a708f8fSGustavo F. Padovan return ERR_PTR(err); 20570a708f8fSGustavo F. Padovan } 20580a708f8fSGustavo F. Padovan 205918a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 20603ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 20610a708f8fSGustavo F. Padovan return skb; 20620a708f8fSGustavo F. Padovan } 20630a708f8fSGustavo F. Padovan 206494122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 206594122bbeSMat Martineau struct sk_buff_head *seg_queue, 206694122bbeSMat Martineau struct msghdr *msg, size_t len) 20670a708f8fSGustavo F. Padovan { 20680a708f8fSGustavo F. Padovan struct sk_buff *skb; 206994122bbeSMat Martineau u16 sdu_len; 207094122bbeSMat Martineau size_t pdu_len; 207194122bbeSMat Martineau u8 sar; 20720a708f8fSGustavo F. Padovan 207394122bbeSMat Martineau BT_DBG("chan %p, msg %p, len %d", chan, msg, (int)len); 20740a708f8fSGustavo F. Padovan 207594122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 207694122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 207794122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 207894122bbeSMat Martineau */ 207994122bbeSMat Martineau 208094122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 208194122bbeSMat Martineau pdu_len = chan->conn->mtu; 208294122bbeSMat Martineau 208394122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 208494122bbeSMat Martineau 208594122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 208635d401dfSGustavo Padovan if (chan->fcs) 208735d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 208835d401dfSGustavo Padovan 2089ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 209094122bbeSMat Martineau 209194122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 209294122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 209394122bbeSMat Martineau 209494122bbeSMat Martineau if (len <= pdu_len) { 209594122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 209694122bbeSMat Martineau sdu_len = 0; 209794122bbeSMat Martineau pdu_len = len; 209894122bbeSMat Martineau } else { 209994122bbeSMat Martineau sar = L2CAP_SAR_START; 210094122bbeSMat Martineau sdu_len = len; 210194122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 210294122bbeSMat Martineau } 21030a708f8fSGustavo F. Padovan 21040a708f8fSGustavo F. Padovan while (len > 0) { 210594122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 21060a708f8fSGustavo F. Padovan 21070a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 210894122bbeSMat Martineau __skb_queue_purge(seg_queue); 21090a708f8fSGustavo F. Padovan return PTR_ERR(skb); 21100a708f8fSGustavo F. Padovan } 21110a708f8fSGustavo F. Padovan 211294122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 211394122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 21140a708f8fSGustavo F. Padovan 211594122bbeSMat Martineau len -= pdu_len; 211694122bbeSMat Martineau if (sdu_len) { 211794122bbeSMat Martineau sdu_len = 0; 211894122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 211994122bbeSMat Martineau } 212094122bbeSMat Martineau 212194122bbeSMat Martineau if (len <= pdu_len) { 212294122bbeSMat Martineau sar = L2CAP_SAR_END; 212394122bbeSMat Martineau pdu_len = len; 212494122bbeSMat Martineau } else { 212594122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 212694122bbeSMat Martineau } 212794122bbeSMat Martineau } 212894122bbeSMat Martineau 2129f0f62799SGustavo Padovan return 0; 21300a708f8fSGustavo F. Padovan } 21310a708f8fSGustavo F. Padovan 21325e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 21335e59b791SLuiz Augusto von Dentz u32 priority) 21349a91a04aSGustavo F. Padovan { 21359a91a04aSGustavo F. Padovan struct sk_buff *skb; 21369a91a04aSGustavo F. Padovan int err; 213794122bbeSMat Martineau struct sk_buff_head seg_queue; 21389a91a04aSGustavo F. Padovan 21399a91a04aSGustavo F. Padovan /* Connectionless channel */ 2140715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 21415e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_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 return len; 21479a91a04aSGustavo F. Padovan } 21489a91a04aSGustavo F. Padovan 21499a91a04aSGustavo F. Padovan switch (chan->mode) { 21509a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 21519a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 21529a91a04aSGustavo F. Padovan if (len > chan->omtu) 21539a91a04aSGustavo F. Padovan return -EMSGSIZE; 21549a91a04aSGustavo F. Padovan 21559a91a04aSGustavo F. Padovan /* Create a basic PDU */ 21565e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 21579a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 21589a91a04aSGustavo F. Padovan return PTR_ERR(skb); 21599a91a04aSGustavo F. Padovan 21609a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 21619a91a04aSGustavo F. Padovan err = len; 21629a91a04aSGustavo F. Padovan break; 21639a91a04aSGustavo F. Padovan 21649a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 21659a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 216694122bbeSMat Martineau /* Check outgoing MTU */ 216794122bbeSMat Martineau if (len > chan->omtu) { 216894122bbeSMat Martineau err = -EMSGSIZE; 21699a91a04aSGustavo F. Padovan break; 21709a91a04aSGustavo F. Padovan } 21719a91a04aSGustavo F. Padovan 217294122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 217394122bbeSMat Martineau 217494122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 217594122bbeSMat Martineau * since it's possible to block while waiting for memory 217694122bbeSMat Martineau * allocation. 217794122bbeSMat Martineau */ 217894122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 217994122bbeSMat Martineau 218094122bbeSMat Martineau /* The channel could have been closed while segmenting, 218194122bbeSMat Martineau * check that it is still connected. 218294122bbeSMat Martineau */ 218394122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 218494122bbeSMat Martineau __skb_queue_purge(&seg_queue); 218594122bbeSMat Martineau err = -ENOTCONN; 21869a91a04aSGustavo F. Padovan } 21879a91a04aSGustavo F. Padovan 218894122bbeSMat Martineau if (err) 218994122bbeSMat Martineau break; 219094122bbeSMat Martineau 21913733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2192d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 21933733937dSMat Martineau else 2194d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 219594122bbeSMat Martineau 21969a91a04aSGustavo F. Padovan err = len; 21979a91a04aSGustavo F. Padovan 219894122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 219994122bbeSMat Martineau * seg_queue and need to be purged. 220094122bbeSMat Martineau */ 220194122bbeSMat Martineau __skb_queue_purge(&seg_queue); 22029a91a04aSGustavo F. Padovan break; 22039a91a04aSGustavo F. Padovan 22049a91a04aSGustavo F. Padovan default: 22059a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 22069a91a04aSGustavo F. Padovan err = -EBADFD; 22079a91a04aSGustavo F. Padovan } 22089a91a04aSGustavo F. Padovan 22099a91a04aSGustavo F. Padovan return err; 22109a91a04aSGustavo F. Padovan } 22119a91a04aSGustavo F. Padovan 2212d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2213d2a7ac5dSMat Martineau { 2214bed68bdeSMat Martineau struct l2cap_ctrl control; 2215bed68bdeSMat Martineau u16 seq; 2216bed68bdeSMat Martineau 2217bed68bdeSMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 2218bed68bdeSMat Martineau 2219bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2220bed68bdeSMat Martineau control.sframe = 1; 2221bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2222bed68bdeSMat Martineau 2223bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2224bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2225bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2226bed68bdeSMat Martineau control.reqseq = seq; 2227bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2228bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2229bed68bdeSMat Martineau } 2230bed68bdeSMat Martineau } 2231bed68bdeSMat Martineau 2232bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2233d2a7ac5dSMat Martineau } 2234d2a7ac5dSMat Martineau 2235d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2236d2a7ac5dSMat Martineau { 2237bed68bdeSMat Martineau struct l2cap_ctrl control; 2238bed68bdeSMat Martineau 2239bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2240bed68bdeSMat Martineau 2241bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2242bed68bdeSMat Martineau return; 2243bed68bdeSMat Martineau 2244bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2245bed68bdeSMat Martineau control.sframe = 1; 2246bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2247bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2248bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2249d2a7ac5dSMat Martineau } 2250d2a7ac5dSMat Martineau 2251d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2252d2a7ac5dSMat Martineau { 2253bed68bdeSMat Martineau struct l2cap_ctrl control; 2254bed68bdeSMat Martineau u16 initial_head; 2255bed68bdeSMat Martineau u16 seq; 2256bed68bdeSMat Martineau 2257bed68bdeSMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 2258bed68bdeSMat Martineau 2259bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2260bed68bdeSMat Martineau control.sframe = 1; 2261bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2262bed68bdeSMat Martineau 2263bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2264bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2265bed68bdeSMat Martineau 2266bed68bdeSMat Martineau do { 2267bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2268bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2269bed68bdeSMat Martineau break; 2270bed68bdeSMat Martineau 2271bed68bdeSMat Martineau control.reqseq = seq; 2272bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2273bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2274bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2275d2a7ac5dSMat Martineau } 2276d2a7ac5dSMat Martineau 2277608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2278608bcc6dSMat Martineau { 2279608bcc6dSMat Martineau struct sk_buff *acked_skb; 2280608bcc6dSMat Martineau u16 ackseq; 2281608bcc6dSMat Martineau 2282608bcc6dSMat Martineau BT_DBG("chan %p, reqseq %d", chan, reqseq); 2283608bcc6dSMat Martineau 2284608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2285608bcc6dSMat Martineau return; 2286608bcc6dSMat Martineau 2287608bcc6dSMat Martineau BT_DBG("expected_ack_seq %d, unacked_frames %d", 2288608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2289608bcc6dSMat Martineau 2290608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2291608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2292608bcc6dSMat Martineau 2293608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2294608bcc6dSMat Martineau if (acked_skb) { 2295608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2296608bcc6dSMat Martineau kfree_skb(acked_skb); 2297608bcc6dSMat Martineau chan->unacked_frames--; 2298608bcc6dSMat Martineau } 2299608bcc6dSMat Martineau } 2300608bcc6dSMat Martineau 2301608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2302608bcc6dSMat Martineau 2303608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2304608bcc6dSMat Martineau __clear_retrans_timer(chan); 2305608bcc6dSMat Martineau 2306608bcc6dSMat Martineau BT_DBG("unacked_frames %d", (int) chan->unacked_frames); 2307608bcc6dSMat Martineau } 2308608bcc6dSMat Martineau 2309608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2310608bcc6dSMat Martineau { 2311608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2312608bcc6dSMat Martineau 2313608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2314608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2315608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2316608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2317608bcc6dSMat Martineau } 2318608bcc6dSMat Martineau 2319d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2320608bcc6dSMat Martineau struct l2cap_ctrl *control, 2321608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2322608bcc6dSMat Martineau { 2323608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2324608bcc6dSMat Martineau event); 2325608bcc6dSMat Martineau 2326608bcc6dSMat Martineau switch (event) { 2327608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2328608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2329608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2330608bcc6dSMat Martineau 2331608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2332608bcc6dSMat Martineau l2cap_ertm_send(chan); 2333608bcc6dSMat Martineau break; 2334608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2335608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2336608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2337608bcc6dSMat Martineau 2338608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2339608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2340608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2341608bcc6dSMat Martineau */ 2342608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2343608bcc6dSMat Martineau } 2344608bcc6dSMat Martineau 2345608bcc6dSMat Martineau l2cap_send_ack(chan); 2346608bcc6dSMat Martineau 2347608bcc6dSMat Martineau break; 2348608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2349608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2350608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2351608bcc6dSMat Martineau 2352608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2353608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2354608bcc6dSMat Martineau 2355608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2356608bcc6dSMat Martineau local_control.sframe = 1; 2357608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2358608bcc6dSMat Martineau local_control.poll = 1; 2359608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2360a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2361608bcc6dSMat Martineau 2362608bcc6dSMat Martineau chan->retry_count = 1; 2363608bcc6dSMat Martineau __set_monitor_timer(chan); 2364608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2365608bcc6dSMat Martineau } 2366608bcc6dSMat Martineau break; 2367608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2368608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2369608bcc6dSMat Martineau break; 2370608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2371608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2372608bcc6dSMat Martineau chan->retry_count = 1; 2373608bcc6dSMat Martineau __set_monitor_timer(chan); 2374608bcc6dSMat Martineau __clear_ack_timer(chan); 2375608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2376608bcc6dSMat Martineau break; 2377608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2378608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2379608bcc6dSMat Martineau chan->retry_count = 1; 2380608bcc6dSMat Martineau __set_monitor_timer(chan); 2381608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2382608bcc6dSMat Martineau break; 2383608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2384608bcc6dSMat Martineau /* Nothing to process */ 2385608bcc6dSMat Martineau break; 2386608bcc6dSMat Martineau default: 2387608bcc6dSMat Martineau break; 2388608bcc6dSMat Martineau } 2389608bcc6dSMat Martineau } 2390608bcc6dSMat Martineau 2391d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2392608bcc6dSMat Martineau struct l2cap_ctrl *control, 2393608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2394608bcc6dSMat Martineau { 2395608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2396608bcc6dSMat Martineau event); 2397608bcc6dSMat Martineau 2398608bcc6dSMat Martineau switch (event) { 2399608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2400608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2401608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2402608bcc6dSMat Martineau /* Queue data, but don't send. */ 2403608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2404608bcc6dSMat Martineau break; 2405608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2406608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2407608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2408608bcc6dSMat Martineau 2409608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2410608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2411608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2412608bcc6dSMat Martineau */ 2413608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2414608bcc6dSMat Martineau } 2415608bcc6dSMat Martineau 2416608bcc6dSMat Martineau l2cap_send_ack(chan); 2417608bcc6dSMat Martineau 2418608bcc6dSMat Martineau break; 2419608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2420608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2421608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2422608bcc6dSMat Martineau 2423608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2424608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2425608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2426608bcc6dSMat Martineau local_control.sframe = 1; 2427608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2428608bcc6dSMat Martineau local_control.poll = 1; 2429608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2430a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2431608bcc6dSMat Martineau 2432608bcc6dSMat Martineau chan->retry_count = 1; 2433608bcc6dSMat Martineau __set_monitor_timer(chan); 2434608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2435608bcc6dSMat Martineau } 2436608bcc6dSMat Martineau break; 2437608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2438608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2439608bcc6dSMat Martineau 2440608bcc6dSMat Martineau /* Fall through */ 2441608bcc6dSMat Martineau 2442608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2443608bcc6dSMat Martineau if (control && control->final) { 2444608bcc6dSMat Martineau __clear_monitor_timer(chan); 2445608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2446608bcc6dSMat Martineau __set_retrans_timer(chan); 2447608bcc6dSMat Martineau chan->retry_count = 0; 2448608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2449608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2450608bcc6dSMat Martineau } 2451608bcc6dSMat Martineau break; 2452608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2453608bcc6dSMat Martineau /* Ignore */ 2454608bcc6dSMat Martineau break; 2455608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2456608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2457608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2458608bcc6dSMat Martineau __set_monitor_timer(chan); 2459608bcc6dSMat Martineau chan->retry_count++; 2460608bcc6dSMat Martineau } else { 2461608bcc6dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED); 2462608bcc6dSMat Martineau } 2463608bcc6dSMat Martineau break; 2464608bcc6dSMat Martineau default: 2465608bcc6dSMat Martineau break; 2466608bcc6dSMat Martineau } 2467608bcc6dSMat Martineau } 2468608bcc6dSMat Martineau 2469d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2470608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2471608bcc6dSMat Martineau { 2472608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2473608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2474608bcc6dSMat Martineau 2475608bcc6dSMat Martineau switch (chan->tx_state) { 2476608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2477d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2478608bcc6dSMat Martineau break; 2479608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2480d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2481608bcc6dSMat Martineau break; 2482608bcc6dSMat Martineau default: 2483608bcc6dSMat Martineau /* Ignore event */ 2484608bcc6dSMat Martineau break; 2485608bcc6dSMat Martineau } 2486608bcc6dSMat Martineau } 2487608bcc6dSMat Martineau 24884b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 24894b51dae9SMat Martineau struct l2cap_ctrl *control) 24904b51dae9SMat Martineau { 24914b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2492401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 24934b51dae9SMat Martineau } 24944b51dae9SMat Martineau 2495f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2496f80842a8SMat Martineau struct l2cap_ctrl *control) 2497f80842a8SMat Martineau { 2498f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2499401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2500f80842a8SMat Martineau } 2501f80842a8SMat Martineau 25020a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 25030a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 25040a708f8fSGustavo F. Padovan { 25050a708f8fSGustavo F. Padovan struct sk_buff *nskb; 250648454079SGustavo F. Padovan struct l2cap_chan *chan; 25070a708f8fSGustavo F. Padovan 25080a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 25090a708f8fSGustavo F. Padovan 25103df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 25113d57dc68SGustavo F. Padovan 25123df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 251348454079SGustavo F. Padovan struct sock *sk = chan->sk; 2514715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 25150a708f8fSGustavo F. Padovan continue; 25160a708f8fSGustavo F. Padovan 25170a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 25180a708f8fSGustavo F. Padovan if (skb->sk == sk) 25190a708f8fSGustavo F. Padovan continue; 25200a708f8fSGustavo F. Padovan nskb = skb_clone(skb, GFP_ATOMIC); 25210a708f8fSGustavo F. Padovan if (!nskb) 25220a708f8fSGustavo F. Padovan continue; 25230a708f8fSGustavo F. Padovan 252480b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 25250a708f8fSGustavo F. Padovan kfree_skb(nskb); 25260a708f8fSGustavo F. Padovan } 25273d57dc68SGustavo F. Padovan 25283df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 25290a708f8fSGustavo F. Padovan } 25300a708f8fSGustavo F. Padovan 25310a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 25320a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 25330a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data) 25340a708f8fSGustavo F. Padovan { 25350a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 25360a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 25370a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 25380a708f8fSGustavo F. Padovan int len, count; 25390a708f8fSGustavo F. Padovan 25400a708f8fSGustavo F. Padovan BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d", 25410a708f8fSGustavo F. Padovan conn, code, ident, dlen); 25420a708f8fSGustavo F. Padovan 25430a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 25440a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25450a708f8fSGustavo F. Padovan 25460a708f8fSGustavo F. Padovan skb = bt_skb_alloc(count, GFP_ATOMIC); 25470a708f8fSGustavo F. Padovan if (!skb) 25480a708f8fSGustavo F. Padovan return NULL; 25490a708f8fSGustavo F. Padovan 25500a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 25510a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 25523300d9a9SClaudio Takahasi 25533300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2554ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 25553300d9a9SClaudio Takahasi else 2556ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 25570a708f8fSGustavo F. Padovan 25580a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 25590a708f8fSGustavo F. Padovan cmd->code = code; 25600a708f8fSGustavo F. Padovan cmd->ident = ident; 25610a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 25620a708f8fSGustavo F. Padovan 25630a708f8fSGustavo F. Padovan if (dlen) { 25640a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 25650a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 25660a708f8fSGustavo F. Padovan data += count; 25670a708f8fSGustavo F. Padovan } 25680a708f8fSGustavo F. Padovan 25690a708f8fSGustavo F. Padovan len -= skb->len; 25700a708f8fSGustavo F. Padovan 25710a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 25720a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 25730a708f8fSGustavo F. Padovan while (len) { 25740a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25750a708f8fSGustavo F. Padovan 25760a708f8fSGustavo F. Padovan *frag = bt_skb_alloc(count, GFP_ATOMIC); 25770a708f8fSGustavo F. Padovan if (!*frag) 25780a708f8fSGustavo F. Padovan goto fail; 25790a708f8fSGustavo F. Padovan 25800a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 25810a708f8fSGustavo F. Padovan 25820a708f8fSGustavo F. Padovan len -= count; 25830a708f8fSGustavo F. Padovan data += count; 25840a708f8fSGustavo F. Padovan 25850a708f8fSGustavo F. Padovan frag = &(*frag)->next; 25860a708f8fSGustavo F. Padovan } 25870a708f8fSGustavo F. Padovan 25880a708f8fSGustavo F. Padovan return skb; 25890a708f8fSGustavo F. Padovan 25900a708f8fSGustavo F. Padovan fail: 25910a708f8fSGustavo F. Padovan kfree_skb(skb); 25920a708f8fSGustavo F. Padovan return NULL; 25930a708f8fSGustavo F. Padovan } 25940a708f8fSGustavo F. Padovan 25950a708f8fSGustavo F. Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val) 25960a708f8fSGustavo F. Padovan { 25970a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 25980a708f8fSGustavo F. Padovan int len; 25990a708f8fSGustavo F. Padovan 26000a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 26010a708f8fSGustavo F. Padovan *ptr += len; 26020a708f8fSGustavo F. Padovan 26030a708f8fSGustavo F. Padovan *type = opt->type; 26040a708f8fSGustavo F. Padovan *olen = opt->len; 26050a708f8fSGustavo F. Padovan 26060a708f8fSGustavo F. Padovan switch (opt->len) { 26070a708f8fSGustavo F. Padovan case 1: 26080a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 26090a708f8fSGustavo F. Padovan break; 26100a708f8fSGustavo F. Padovan 26110a708f8fSGustavo F. Padovan case 2: 26120a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 26130a708f8fSGustavo F. Padovan break; 26140a708f8fSGustavo F. Padovan 26150a708f8fSGustavo F. Padovan case 4: 26160a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 26170a708f8fSGustavo F. Padovan break; 26180a708f8fSGustavo F. Padovan 26190a708f8fSGustavo F. Padovan default: 26200a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 26210a708f8fSGustavo F. Padovan break; 26220a708f8fSGustavo F. Padovan } 26230a708f8fSGustavo F. Padovan 26240a708f8fSGustavo F. Padovan BT_DBG("type 0x%2.2x len %d val 0x%lx", *type, opt->len, *val); 26250a708f8fSGustavo F. Padovan return len; 26260a708f8fSGustavo F. Padovan } 26270a708f8fSGustavo F. Padovan 26280a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 26290a708f8fSGustavo F. Padovan { 26300a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26310a708f8fSGustavo F. Padovan 26320a708f8fSGustavo F. Padovan BT_DBG("type 0x%2.2x len %d val 0x%lx", type, len, val); 26330a708f8fSGustavo F. Padovan 26340a708f8fSGustavo F. Padovan opt->type = type; 26350a708f8fSGustavo F. Padovan opt->len = len; 26360a708f8fSGustavo F. Padovan 26370a708f8fSGustavo F. Padovan switch (len) { 26380a708f8fSGustavo F. Padovan case 1: 26390a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 26400a708f8fSGustavo F. Padovan break; 26410a708f8fSGustavo F. Padovan 26420a708f8fSGustavo F. Padovan case 2: 26430a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 26440a708f8fSGustavo F. Padovan break; 26450a708f8fSGustavo F. Padovan 26460a708f8fSGustavo F. Padovan case 4: 26470a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 26480a708f8fSGustavo F. Padovan break; 26490a708f8fSGustavo F. Padovan 26500a708f8fSGustavo F. Padovan default: 26510a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 26520a708f8fSGustavo F. Padovan break; 26530a708f8fSGustavo F. Padovan } 26540a708f8fSGustavo F. Padovan 26550a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 26560a708f8fSGustavo F. Padovan } 26570a708f8fSGustavo F. Padovan 2658f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2659f89cef09SAndrei Emeltchenko { 2660f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2661f89cef09SAndrei Emeltchenko 2662f89cef09SAndrei Emeltchenko switch (chan->mode) { 2663f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2664f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2665f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2666f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2667f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2668ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 2669ac73498cSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_DEFAULT_FLUSH_TO); 2670f89cef09SAndrei Emeltchenko break; 2671f89cef09SAndrei Emeltchenko 2672f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2673f89cef09SAndrei Emeltchenko efs.id = 1; 2674f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2675f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2676f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2677f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2678f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2679f89cef09SAndrei Emeltchenko break; 2680f89cef09SAndrei Emeltchenko 2681f89cef09SAndrei Emeltchenko default: 2682f89cef09SAndrei Emeltchenko return; 2683f89cef09SAndrei Emeltchenko } 2684f89cef09SAndrei Emeltchenko 2685f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2686f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2687f89cef09SAndrei Emeltchenko } 2688f89cef09SAndrei Emeltchenko 2689721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 26900a708f8fSGustavo F. Padovan { 2691721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2692721c4181SGustavo F. Padovan ack_timer.work); 26930362520bSMat Martineau u16 frames_to_ack; 26940a708f8fSGustavo F. Padovan 26952fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 26962fb9b3d4SGustavo F. Padovan 26976be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 26986be36555SAndrei Emeltchenko 26990362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 27000362520bSMat Martineau chan->last_acked_seq); 27010362520bSMat Martineau 27020362520bSMat Martineau if (frames_to_ack) 27030362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 27046be36555SAndrei Emeltchenko 27056be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 270609bfb2eeSSzymon Janc l2cap_chan_put(chan); 27070a708f8fSGustavo F. Padovan } 27080a708f8fSGustavo F. Padovan 2709466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 27100a708f8fSGustavo F. Padovan { 27113c588192SMat Martineau int err; 27123c588192SMat Martineau 2713105bdf9eSMat Martineau chan->next_tx_seq = 0; 2714105bdf9eSMat Martineau chan->expected_tx_seq = 0; 271542e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 27166a026610SGustavo F. Padovan chan->unacked_frames = 0; 271742e5c802SGustavo F. Padovan chan->buffer_seq = 0; 27186a026610SGustavo F. Padovan chan->frames_sent = 0; 2719105bdf9eSMat Martineau chan->last_acked_seq = 0; 2720105bdf9eSMat Martineau chan->sdu = NULL; 2721105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2722105bdf9eSMat Martineau chan->sdu_len = 0; 2723105bdf9eSMat Martineau 2724d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2725d34c34fbSMat Martineau 2726105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2727105bdf9eSMat Martineau return 0; 2728105bdf9eSMat Martineau 2729105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2730105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 27310a708f8fSGustavo F. Padovan 2732721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2733721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2734721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 27350a708f8fSGustavo F. Padovan 2736f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 27370a708f8fSGustavo F. Padovan 27383c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 27393c588192SMat Martineau if (err < 0) 27403c588192SMat Martineau return err; 27413c588192SMat Martineau 27429dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 27439dc9affcSMat Martineau if (err < 0) 27449dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 27459dc9affcSMat Martineau 27469dc9affcSMat Martineau return err; 27470a708f8fSGustavo F. Padovan } 27480a708f8fSGustavo F. Padovan 27490a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 27500a708f8fSGustavo F. Padovan { 27510a708f8fSGustavo F. Padovan switch (mode) { 27520a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 27530a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 27540a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 27550a708f8fSGustavo F. Padovan return mode; 27560a708f8fSGustavo F. Padovan /* fall through */ 27570a708f8fSGustavo F. Padovan default: 27580a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 27590a708f8fSGustavo F. Padovan } 27600a708f8fSGustavo F. Padovan } 27610a708f8fSGustavo F. Padovan 27626327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 27636327eb98SAndrei Emeltchenko { 27646327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 27656327eb98SAndrei Emeltchenko } 27666327eb98SAndrei Emeltchenko 2767f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2768f89cef09SAndrei Emeltchenko { 2769f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2770f89cef09SAndrei Emeltchenko } 2771f89cef09SAndrei Emeltchenko 27726327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 27736327eb98SAndrei Emeltchenko { 27746327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 2775836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 27766327eb98SAndrei Emeltchenko /* use extended control field */ 27776327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 2778836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 2779836be934SAndrei Emeltchenko } else { 27806327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 27816327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 2782836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 2783836be934SAndrei Emeltchenko } 27846327eb98SAndrei Emeltchenko } 27856327eb98SAndrei Emeltchenko 2786710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 27870a708f8fSGustavo F. Padovan { 27880a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 27890c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 27900a708f8fSGustavo F. Padovan void *ptr = req->data; 2791c8f79162SAndrei Emeltchenko u16 size; 27920a708f8fSGustavo F. Padovan 279349208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 27940a708f8fSGustavo F. Padovan 279573ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 27960a708f8fSGustavo F. Padovan goto done; 27970a708f8fSGustavo F. Padovan 27980c1bc5c6SGustavo F. Padovan switch (chan->mode) { 27990a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 28000a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2801c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 28020a708f8fSGustavo F. Padovan break; 28030a708f8fSGustavo F. Padovan 2804f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 2805f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 2806f89cef09SAndrei Emeltchenko 28070a708f8fSGustavo F. Padovan /* fall through */ 28080a708f8fSGustavo F. Padovan default: 28098c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 28100a708f8fSGustavo F. Padovan break; 28110a708f8fSGustavo F. Padovan } 28120a708f8fSGustavo F. Padovan 28130a708f8fSGustavo F. Padovan done: 28140c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 28150c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 28160a708f8fSGustavo F. Padovan 28170c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28180a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 28198c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 28208c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 28210a708f8fSGustavo F. Padovan break; 28220a708f8fSGustavo F. Padovan 28230a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 28240a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28250a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28260a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28270a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 28280a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 28290a708f8fSGustavo F. Padovan 28300a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28310a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28320a708f8fSGustavo F. Padovan break; 28330a708f8fSGustavo F. Padovan 28340a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 28350a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 283647d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 28370a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28380a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2839c8f79162SAndrei Emeltchenko 2840c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2841c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2842c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2843c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2844c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28450a708f8fSGustavo F. Padovan 28466327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 28476327eb98SAndrei Emeltchenko 28486327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 28496327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 28500a708f8fSGustavo F. Padovan 28510a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28520a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28530a708f8fSGustavo F. Padovan 2854f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2855f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2856f89cef09SAndrei Emeltchenko 28578c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 28580a708f8fSGustavo F. Padovan break; 28590a708f8fSGustavo F. Padovan 286047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2861c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 286247d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 286347d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 28640a708f8fSGustavo F. Padovan } 28656327eb98SAndrei Emeltchenko 28666327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 28676327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 28686327eb98SAndrei Emeltchenko chan->tx_win); 28690a708f8fSGustavo F. Padovan break; 28700a708f8fSGustavo F. Padovan 28710a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 2872273759e2SMat Martineau l2cap_txwin_setup(chan); 28730a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 28740a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28750a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28760a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28770a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2878c8f79162SAndrei Emeltchenko 2879c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2880c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2881c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2882c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2883c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28840a708f8fSGustavo F. Padovan 28850a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28860a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28870a708f8fSGustavo F. Padovan 2888f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2889f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2890f89cef09SAndrei Emeltchenko 28918c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 28920a708f8fSGustavo F. Padovan break; 28930a708f8fSGustavo F. Padovan 289447d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2895c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 289647d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 289747d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 28980a708f8fSGustavo F. Padovan } 28990a708f8fSGustavo F. Padovan break; 29000a708f8fSGustavo F. Padovan } 29010a708f8fSGustavo F. Padovan 2902fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 290359e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 29040a708f8fSGustavo F. Padovan 29050a708f8fSGustavo F. Padovan return ptr - data; 29060a708f8fSGustavo F. Padovan } 29070a708f8fSGustavo F. Padovan 290873ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 29090a708f8fSGustavo F. Padovan { 29100a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 29110a708f8fSGustavo F. Padovan void *ptr = rsp->data; 291273ffa904SGustavo F. Padovan void *req = chan->conf_req; 291373ffa904SGustavo F. Padovan int len = chan->conf_len; 29140a708f8fSGustavo F. Padovan int type, hint, olen; 29150a708f8fSGustavo F. Padovan unsigned long val; 29160a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 291742dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 291842dceae2SAndrei Emeltchenko u8 remote_efs = 0; 29190a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 29200a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 2921c8f79162SAndrei Emeltchenko u16 size; 29220a708f8fSGustavo F. Padovan 292373ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 29240a708f8fSGustavo F. Padovan 29250a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 29260a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 29270a708f8fSGustavo F. Padovan 29280a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 29290a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 29300a708f8fSGustavo F. Padovan 29310a708f8fSGustavo F. Padovan switch (type) { 29320a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 29330a708f8fSGustavo F. Padovan mtu = val; 29340a708f8fSGustavo F. Padovan break; 29350a708f8fSGustavo F. Padovan 29360a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 29370c1bc5c6SGustavo F. Padovan chan->flush_to = val; 29380a708f8fSGustavo F. Padovan break; 29390a708f8fSGustavo F. Padovan 29400a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 29410a708f8fSGustavo F. Padovan break; 29420a708f8fSGustavo F. Padovan 29430a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 29440a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 29450a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 29460a708f8fSGustavo F. Padovan break; 29470a708f8fSGustavo F. Padovan 29480a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 29490a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 2950c1360a1cSGustavo F. Padovan set_bit(CONF_NO_FCS_RECV, &chan->conf_state); 295142dceae2SAndrei Emeltchenko break; 29520a708f8fSGustavo F. Padovan 295342dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 295442dceae2SAndrei Emeltchenko remote_efs = 1; 295542dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 295642dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 29570a708f8fSGustavo F. Padovan break; 29580a708f8fSGustavo F. Padovan 29596327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 29606327eb98SAndrei Emeltchenko if (!enable_hs) 29616327eb98SAndrei Emeltchenko return -ECONNREFUSED; 29626327eb98SAndrei Emeltchenko 29636327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 29646327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 2965836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 29666327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 29670a708f8fSGustavo F. Padovan break; 29680a708f8fSGustavo F. Padovan 29690a708f8fSGustavo F. Padovan default: 29700a708f8fSGustavo F. Padovan if (hint) 29710a708f8fSGustavo F. Padovan break; 29720a708f8fSGustavo F. Padovan 29730a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 29740a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 29750a708f8fSGustavo F. Padovan break; 29760a708f8fSGustavo F. Padovan } 29770a708f8fSGustavo F. Padovan } 29780a708f8fSGustavo F. Padovan 297973ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 29800a708f8fSGustavo F. Padovan goto done; 29810a708f8fSGustavo F. Padovan 29820c1bc5c6SGustavo F. Padovan switch (chan->mode) { 29830a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 29840a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2985c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 29860c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 29878c1d787bSGustavo F. Padovan chan->conn->feat_mask); 29880a708f8fSGustavo F. Padovan break; 29890a708f8fSGustavo F. Padovan } 29900a708f8fSGustavo F. Padovan 299142dceae2SAndrei Emeltchenko if (remote_efs) { 299242dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 299342dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 299442dceae2SAndrei Emeltchenko else 299542dceae2SAndrei Emeltchenko return -ECONNREFUSED; 299642dceae2SAndrei Emeltchenko } 299742dceae2SAndrei Emeltchenko 29980c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 29990a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30000a708f8fSGustavo F. Padovan 30010a708f8fSGustavo F. Padovan break; 30020a708f8fSGustavo F. Padovan } 30030a708f8fSGustavo F. Padovan 30040a708f8fSGustavo F. Padovan done: 30050c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 30060a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30070c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 30080a708f8fSGustavo F. Padovan 300973ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 30100a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30110a708f8fSGustavo F. Padovan 30120a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30130a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30140a708f8fSGustavo F. Padovan } 30150a708f8fSGustavo F. Padovan 30160a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 30170a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 30180a708f8fSGustavo F. Padovan * which ones we don't like. */ 30190a708f8fSGustavo F. Padovan 30200a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 30210a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30220a708f8fSGustavo F. Padovan else { 30230c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3024c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 30250a708f8fSGustavo F. Padovan } 30260c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 30270a708f8fSGustavo F. Padovan 302842dceae2SAndrei Emeltchenko if (remote_efs) { 302942dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 303042dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 303142dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 303242dceae2SAndrei Emeltchenko 303342dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 303442dceae2SAndrei Emeltchenko 303542dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 303642dceae2SAndrei Emeltchenko return -ECONNREFUSED; 303742dceae2SAndrei Emeltchenko 303842dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 303942dceae2SAndrei Emeltchenko sizeof(efs), 304042dceae2SAndrei Emeltchenko (unsigned long) &efs); 30410e8b207eSAndrei Emeltchenko } else { 30423e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 30430e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 30440e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 304542dceae2SAndrei Emeltchenko } 304642dceae2SAndrei Emeltchenko } 304742dceae2SAndrei Emeltchenko 30480a708f8fSGustavo F. Padovan switch (rfc.mode) { 30490a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 305047d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3051c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30520a708f8fSGustavo F. Padovan break; 30530a708f8fSGustavo F. Padovan 30540a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30556327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 30562c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 30576327eb98SAndrei Emeltchenko else 30586327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 30596327eb98SAndrei Emeltchenko 30602c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 30610a708f8fSGustavo F. Padovan 3062c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3063c8f79162SAndrei Emeltchenko chan->conn->mtu - 3064c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3065c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3066c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3067c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3068c8f79162SAndrei Emeltchenko chan->remote_mps = size; 30690a708f8fSGustavo F. Padovan 30700a708f8fSGustavo F. Padovan rfc.retrans_timeout = 30714fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 30720a708f8fSGustavo F. Padovan rfc.monitor_timeout = 30734fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 30740a708f8fSGustavo F. Padovan 3075c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30760a708f8fSGustavo F. Padovan 30770a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30780a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30790a708f8fSGustavo F. Padovan 308042dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 308142dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 308242dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 308342dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 308442dceae2SAndrei Emeltchenko chan->remote_flush_to = 308542dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 308642dceae2SAndrei Emeltchenko chan->remote_acc_lat = 308742dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 308842dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 308942dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 309042dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 309142dceae2SAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 309242dceae2SAndrei Emeltchenko } 30930a708f8fSGustavo F. Padovan break; 30940a708f8fSGustavo F. Padovan 30950a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3096c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3097c8f79162SAndrei Emeltchenko chan->conn->mtu - 3098c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3099c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3100c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3101c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3102c8f79162SAndrei Emeltchenko chan->remote_mps = size; 31030a708f8fSGustavo F. Padovan 3104c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 31050a708f8fSGustavo F. Padovan 31060a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31070a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31080a708f8fSGustavo F. Padovan 31090a708f8fSGustavo F. Padovan break; 31100a708f8fSGustavo F. Padovan 31110a708f8fSGustavo F. Padovan default: 31120a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 31130a708f8fSGustavo F. Padovan 31140a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 31150c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 31160a708f8fSGustavo F. Padovan } 31170a708f8fSGustavo F. Padovan 31180a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3119c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 31200a708f8fSGustavo F. Padovan } 3121fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 31220a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 312359e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 31240a708f8fSGustavo F. Padovan 31250a708f8fSGustavo F. Padovan return ptr - data; 31260a708f8fSGustavo F. Padovan } 31270a708f8fSGustavo F. Padovan 3128b4450035SGustavo F. Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, void *data, u16 *result) 31290a708f8fSGustavo F. Padovan { 31300a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 31310a708f8fSGustavo F. Padovan void *ptr = req->data; 31320a708f8fSGustavo F. Padovan int type, olen; 31330a708f8fSGustavo F. Padovan unsigned long val; 313436e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 313566af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 31360a708f8fSGustavo F. Padovan 3137fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 31380a708f8fSGustavo F. Padovan 31390a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 31400a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 31410a708f8fSGustavo F. Padovan 31420a708f8fSGustavo F. Padovan switch (type) { 31430a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 31440a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 31450a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 31460c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 31470a708f8fSGustavo F. Padovan } else 31480c1bc5c6SGustavo F. Padovan chan->imtu = val; 31490c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 31500a708f8fSGustavo F. Padovan break; 31510a708f8fSGustavo F. Padovan 31520a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 31530c1bc5c6SGustavo F. Padovan chan->flush_to = val; 31540a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 31550c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 31560a708f8fSGustavo F. Padovan break; 31570a708f8fSGustavo F. Padovan 31580a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 31590a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 31600a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 31610a708f8fSGustavo F. Padovan 3162c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 31630c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 31640a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31650a708f8fSGustavo F. Padovan 316647d1ec61SGustavo F. Padovan chan->fcs = 0; 31670a708f8fSGustavo F. Padovan 31680a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31690a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31700a708f8fSGustavo F. Padovan break; 31716327eb98SAndrei Emeltchenko 31726327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 31736327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, val, 31746327eb98SAndrei Emeltchenko L2CAP_DEFAULT_EXT_WINDOW); 31753e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 31763e6b3b95SGustavo F. Padovan chan->tx_win); 31776327eb98SAndrei Emeltchenko break; 317866af7aafSAndrei Emeltchenko 317966af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 318066af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 318166af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 318266af7aafSAndrei Emeltchenko 318366af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 318466af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 318566af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 318666af7aafSAndrei Emeltchenko return -ECONNREFUSED; 318766af7aafSAndrei Emeltchenko 318866af7aafSAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 318966af7aafSAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 319066af7aafSAndrei Emeltchenko break; 31910a708f8fSGustavo F. Padovan } 31920a708f8fSGustavo F. Padovan } 31930a708f8fSGustavo F. Padovan 31940c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 31950a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31960a708f8fSGustavo F. Padovan 31970c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 31980a708f8fSGustavo F. Padovan 31990e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 32000a708f8fSGustavo F. Padovan switch (rfc.mode) { 32010a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 320247d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 320347d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 320447d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 320566af7aafSAndrei Emeltchenko 320666af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 320766af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 320866af7aafSAndrei Emeltchenko chan->local_sdu_itime = 320966af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 321066af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 321166af7aafSAndrei Emeltchenko chan->local_flush_to = 321266af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 321366af7aafSAndrei Emeltchenko } 32140a708f8fSGustavo F. Padovan break; 321566af7aafSAndrei Emeltchenko 32160a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 321747d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 32180a708f8fSGustavo F. Padovan } 32190a708f8fSGustavo F. Padovan } 32200a708f8fSGustavo F. Padovan 3221fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 322259e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 32230a708f8fSGustavo F. Padovan 32240a708f8fSGustavo F. Padovan return ptr - data; 32250a708f8fSGustavo F. Padovan } 32260a708f8fSGustavo F. Padovan 3227fe4128e0SGustavo F. Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, u16 result, u16 flags) 32280a708f8fSGustavo F. Padovan { 32290a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 32300a708f8fSGustavo F. Padovan void *ptr = rsp->data; 32310a708f8fSGustavo F. Padovan 3232fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 32330a708f8fSGustavo F. Padovan 3234fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 32350a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 32360a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 32370a708f8fSGustavo F. Padovan 32380a708f8fSGustavo F. Padovan return ptr - data; 32390a708f8fSGustavo F. Padovan } 32400a708f8fSGustavo F. Padovan 32418c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3242710f9b0aSGustavo F. Padovan { 3243710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 32448c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3245710f9b0aSGustavo F. Padovan u8 buf[128]; 3246710f9b0aSGustavo F. Padovan 3247fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3248fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3249ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3250ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3251710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, 3252710f9b0aSGustavo F. Padovan L2CAP_CONN_RSP, sizeof(rsp), &rsp); 3253710f9b0aSGustavo F. Padovan 3254c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3255710f9b0aSGustavo F. Padovan return; 3256710f9b0aSGustavo F. Padovan 3257710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3258710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3259710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3260710f9b0aSGustavo F. Padovan } 3261710f9b0aSGustavo F. Padovan 326247d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 32630a708f8fSGustavo F. Padovan { 32640a708f8fSGustavo F. Padovan int type, olen; 32650a708f8fSGustavo F. Padovan unsigned long val; 32660a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc; 32670a708f8fSGustavo F. Padovan 326847d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 32690a708f8fSGustavo F. Padovan 32700c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 32710a708f8fSGustavo F. Padovan return; 32720a708f8fSGustavo F. Padovan 32730a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32740a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 32750a708f8fSGustavo F. Padovan 32760a708f8fSGustavo F. Padovan switch (type) { 32770a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 32780a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 32790a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 32800a708f8fSGustavo F. Padovan goto done; 32810a708f8fSGustavo F. Padovan } 32820a708f8fSGustavo F. Padovan } 32830a708f8fSGustavo F. Padovan 328436e999a8SMat Martineau /* Use sane default values in case a misbehaving remote device 328536e999a8SMat Martineau * did not send an RFC option. 328636e999a8SMat Martineau */ 328736e999a8SMat Martineau rfc.mode = chan->mode; 3288ac73498cSAndrei Emeltchenko rfc.retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 3289ac73498cSAndrei Emeltchenko rfc.monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 329036e999a8SMat Martineau rfc.max_pdu_size = cpu_to_le16(chan->imtu); 329136e999a8SMat Martineau 329236e999a8SMat Martineau BT_ERR("Expected RFC option was not found, using defaults"); 329336e999a8SMat Martineau 32940a708f8fSGustavo F. Padovan done: 32950a708f8fSGustavo F. Padovan switch (rfc.mode) { 32960a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 329747d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 329847d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 329947d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 33000a708f8fSGustavo F. Padovan break; 33010a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 330247d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 33030a708f8fSGustavo F. Padovan } 33040a708f8fSGustavo F. Padovan } 33050a708f8fSGustavo F. Padovan 33060a708f8fSGustavo F. Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 33070a708f8fSGustavo F. Padovan { 3308e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 33090a708f8fSGustavo F. Padovan 3310e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 33110a708f8fSGustavo F. Padovan return 0; 33120a708f8fSGustavo F. Padovan 33130a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 33140a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 331517cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 33160a708f8fSGustavo F. Padovan 33170a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 33180a708f8fSGustavo F. Padovan conn->info_ident = 0; 33190a708f8fSGustavo F. Padovan 33200a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 33210a708f8fSGustavo F. Padovan } 33220a708f8fSGustavo F. Padovan 33230a708f8fSGustavo F. Padovan return 0; 33240a708f8fSGustavo F. Padovan } 33250a708f8fSGustavo F. Padovan 33260a708f8fSGustavo F. Padovan static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 33270a708f8fSGustavo F. Padovan { 33280a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 33290a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 333023691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 33310a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 33320a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 33330a708f8fSGustavo F. Padovan 33340a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 33350a708f8fSGustavo F. Padovan __le16 psm = req->psm; 33360a708f8fSGustavo F. Padovan 3337097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 33380a708f8fSGustavo F. Padovan 33390a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3340c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 334123691d75SGustavo F. Padovan if (!pchan) { 33420a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 33430a708f8fSGustavo F. Padovan goto sendresp; 33440a708f8fSGustavo F. Padovan } 33450a708f8fSGustavo F. Padovan 334623691d75SGustavo F. Padovan parent = pchan->sk; 334723691d75SGustavo F. Padovan 33483df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3349aa2ac881SGustavo F. Padovan lock_sock(parent); 33500a708f8fSGustavo F. Padovan 33510a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 33522983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 33530a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 33549f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 33550a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 33560a708f8fSGustavo F. Padovan goto response; 33570a708f8fSGustavo F. Padovan } 33580a708f8fSGustavo F. Padovan 33590a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 33600a708f8fSGustavo F. Padovan 33612dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 33622dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 33632dfa1003SGustavo Padovan goto response; 33642dfa1003SGustavo Padovan 336580b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 336680808e43SGustavo F. Padovan if (!chan) 33670a708f8fSGustavo F. Padovan goto response; 33680a708f8fSGustavo F. Padovan 336980808e43SGustavo F. Padovan sk = chan->sk; 337080808e43SGustavo F. Padovan 33710a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 33720a708f8fSGustavo F. Padovan 33730a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 33740a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3375fe4128e0SGustavo F. Padovan chan->psm = psm; 3376fe4128e0SGustavo F. Padovan chan->dcid = scid; 33770a708f8fSGustavo F. Padovan 3378d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 3379d1010240SGustavo F. Padovan 33806be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 338148454079SGustavo F. Padovan 3382fe4128e0SGustavo F. Padovan dcid = chan->scid; 33830a708f8fSGustavo F. Padovan 3384c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 33850a708f8fSGustavo F. Padovan 3386fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 33870a708f8fSGustavo F. Padovan 33880a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3389d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3390c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 33910e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 33920a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 33930a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 33940a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 33950a708f8fSGustavo F. Padovan } else { 33960e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 33970a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 33980a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 33990a708f8fSGustavo F. Padovan } 34000a708f8fSGustavo F. Padovan } else { 34010e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34020a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34030a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 34040a708f8fSGustavo F. Padovan } 34050a708f8fSGustavo F. Padovan } else { 34060e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34070a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34080a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 34090a708f8fSGustavo F. Padovan } 34100a708f8fSGustavo F. Padovan 34110a708f8fSGustavo F. Padovan response: 3412aa2ac881SGustavo F. Padovan release_sock(parent); 34133df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 34140a708f8fSGustavo F. Padovan 34150a708f8fSGustavo F. Padovan sendresp: 34160a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 34170a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 34180a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 34190a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 34200a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp); 34210a708f8fSGustavo F. Padovan 34220a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 34230a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3424ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 34250a708f8fSGustavo F. Padovan 34260a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 34270a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 34280a708f8fSGustavo F. Padovan 3429ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 34300a708f8fSGustavo F. Padovan 34310a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 34320a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(info), &info); 34330a708f8fSGustavo F. Padovan } 34340a708f8fSGustavo F. Padovan 3435c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 34360a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 34370a708f8fSGustavo F. Padovan u8 buf[128]; 3438c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 34390a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 344073ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 344173ffa904SGustavo F. Padovan chan->num_conf_req++; 34420a708f8fSGustavo F. Padovan } 34430a708f8fSGustavo F. Padovan 34440a708f8fSGustavo F. Padovan return 0; 34450a708f8fSGustavo F. Padovan } 34460a708f8fSGustavo F. Padovan 34470a708f8fSGustavo F. Padovan static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 34480a708f8fSGustavo F. Padovan { 34490a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 34500a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 345148454079SGustavo F. Padovan struct l2cap_chan *chan; 34520a708f8fSGustavo F. Padovan u8 req[128]; 34533df91ea2SAndrei Emeltchenko int err; 34540a708f8fSGustavo F. Padovan 34550a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 34560a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 34570a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 34580a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 34590a708f8fSGustavo F. Padovan 34601b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 34611b009c98SAndrei Emeltchenko dcid, scid, result, status); 34620a708f8fSGustavo F. Padovan 34633df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 34643df91ea2SAndrei Emeltchenko 34650a708f8fSGustavo F. Padovan if (scid) { 34663df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 34673df91ea2SAndrei Emeltchenko if (!chan) { 34683df91ea2SAndrei Emeltchenko err = -EFAULT; 34693df91ea2SAndrei Emeltchenko goto unlock; 34703df91ea2SAndrei Emeltchenko } 34710a708f8fSGustavo F. Padovan } else { 34723df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 34733df91ea2SAndrei Emeltchenko if (!chan) { 34743df91ea2SAndrei Emeltchenko err = -EFAULT; 34753df91ea2SAndrei Emeltchenko goto unlock; 34763df91ea2SAndrei Emeltchenko } 34770a708f8fSGustavo F. Padovan } 34780a708f8fSGustavo F. Padovan 34793df91ea2SAndrei Emeltchenko err = 0; 34803df91ea2SAndrei Emeltchenko 34816be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 348248454079SGustavo F. Padovan 34830a708f8fSGustavo F. Padovan switch (result) { 34840a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 348589bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3486fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3487fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3488c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 34890a708f8fSGustavo F. Padovan 3490c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 34910a708f8fSGustavo F. Padovan break; 34920a708f8fSGustavo F. Padovan 34930a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 349473ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 349573ffa904SGustavo F. Padovan chan->num_conf_req++; 34960a708f8fSGustavo F. Padovan break; 34970a708f8fSGustavo F. Padovan 34980a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3499c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 35000a708f8fSGustavo F. Padovan break; 35010a708f8fSGustavo F. Padovan 35020a708f8fSGustavo F. Padovan default: 350348454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 35040a708f8fSGustavo F. Padovan break; 35050a708f8fSGustavo F. Padovan } 35060a708f8fSGustavo F. Padovan 35076be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 35083df91ea2SAndrei Emeltchenko 35093df91ea2SAndrei Emeltchenko unlock: 35103df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 35113df91ea2SAndrei Emeltchenko 35123df91ea2SAndrei Emeltchenko return err; 35130a708f8fSGustavo F. Padovan } 35140a708f8fSGustavo F. Padovan 351547d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 35160a708f8fSGustavo F. Padovan { 35170a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 35180a708f8fSGustavo F. Padovan * sides request it. 35190a708f8fSGustavo F. Padovan */ 35200c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 352147d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3522c1360a1cSGustavo F. Padovan else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) 352347d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 35240a708f8fSGustavo F. Padovan } 35250a708f8fSGustavo F. Padovan 35260a708f8fSGustavo F. Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 35270a708f8fSGustavo F. Padovan { 35280a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 35290a708f8fSGustavo F. Padovan u16 dcid, flags; 35300a708f8fSGustavo F. Padovan u8 rsp[64]; 353148454079SGustavo F. Padovan struct l2cap_chan *chan; 35323c588192SMat Martineau int len, err = 0; 35330a708f8fSGustavo F. Padovan 35340a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 35350a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 35360a708f8fSGustavo F. Padovan 35370a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 35380a708f8fSGustavo F. Padovan 3539baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 354048454079SGustavo F. Padovan if (!chan) 35410a708f8fSGustavo F. Padovan return -ENOENT; 35420a708f8fSGustavo F. Padovan 3543033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3544e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 35450a708f8fSGustavo F. Padovan 3546ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3547e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3548e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3549e2fd318eSIlia Kolomisnky 35500a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 35510a708f8fSGustavo F. Padovan sizeof(rej), &rej); 35520a708f8fSGustavo F. Padovan goto unlock; 35530a708f8fSGustavo F. Padovan } 35540a708f8fSGustavo F. Padovan 35550a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 35560a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 35577ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 35580a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3559fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35600a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 35610a708f8fSGustavo F. Padovan goto unlock; 35620a708f8fSGustavo F. Padovan } 35630a708f8fSGustavo F. Padovan 35640a708f8fSGustavo F. Padovan /* Store config. */ 356573ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 356673ffa904SGustavo F. Padovan chan->conf_len += len; 35670a708f8fSGustavo F. Padovan 356859e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 35690a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 35700a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3571fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35725325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 35730a708f8fSGustavo F. Padovan goto unlock; 35740a708f8fSGustavo F. Padovan } 35750a708f8fSGustavo F. Padovan 35760a708f8fSGustavo F. Padovan /* Complete config. */ 357773ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 35780a708f8fSGustavo F. Padovan if (len < 0) { 3579e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 35800a708f8fSGustavo F. Padovan goto unlock; 35810a708f8fSGustavo F. Padovan } 35820a708f8fSGustavo F. Padovan 35830a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 358473ffa904SGustavo F. Padovan chan->num_conf_rsp++; 35850a708f8fSGustavo F. Padovan 35860a708f8fSGustavo F. Padovan /* Reset config buffer. */ 358773ffa904SGustavo F. Padovan chan->conf_len = 0; 35880a708f8fSGustavo F. Padovan 3589c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 35900a708f8fSGustavo F. Padovan goto unlock; 35910a708f8fSGustavo F. Padovan 3592c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 359347d1ec61SGustavo F. Padovan set_default_fcs(chan); 35940a708f8fSGustavo F. Padovan 3595105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3596105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 35973c588192SMat Martineau err = l2cap_ertm_init(chan); 35980a708f8fSGustavo F. Padovan 35993c588192SMat Martineau if (err < 0) 36003c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 36013c588192SMat Martineau else 3602cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 36033c588192SMat Martineau 36040a708f8fSGustavo F. Padovan goto unlock; 36050a708f8fSGustavo F. Padovan } 36060a708f8fSGustavo F. Padovan 3607c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 36080a708f8fSGustavo F. Padovan u8 buf[64]; 36090a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 361073ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 361173ffa904SGustavo F. Padovan chan->num_conf_req++; 36120a708f8fSGustavo F. Padovan } 36130a708f8fSGustavo F. Padovan 36140e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 36150e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 36160e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 36170e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36180e8b207eSAndrei Emeltchenko 36190e8b207eSAndrei Emeltchenko /* check compatibility */ 36200e8b207eSAndrei Emeltchenko 36210e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36220e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36230e8b207eSAndrei Emeltchenko 36240e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36250e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, rsp, 36265325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 36270e8b207eSAndrei Emeltchenko } 36280e8b207eSAndrei Emeltchenko 36290a708f8fSGustavo F. Padovan unlock: 36306be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 36313c588192SMat Martineau return err; 36320a708f8fSGustavo F. Padovan } 36330a708f8fSGustavo F. Padovan 36340a708f8fSGustavo F. Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 36350a708f8fSGustavo F. Padovan { 36360a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 36370a708f8fSGustavo F. Padovan u16 scid, flags, result; 363848454079SGustavo F. Padovan struct l2cap_chan *chan; 363961386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 36403c588192SMat Martineau int err = 0; 36410a708f8fSGustavo F. Padovan 36420a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 36430a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 36440a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 36450a708f8fSGustavo F. Padovan 364661386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 364761386cbaSAndrei Emeltchenko result, len); 36480a708f8fSGustavo F. Padovan 3649baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 365048454079SGustavo F. Padovan if (!chan) 36510a708f8fSGustavo F. Padovan return 0; 36520a708f8fSGustavo F. Padovan 36530a708f8fSGustavo F. Padovan switch (result) { 36540a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 365547d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 36560e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36570a708f8fSGustavo F. Padovan break; 36580a708f8fSGustavo F. Padovan 36590e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 36600e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36610e8b207eSAndrei Emeltchenko 36620e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36630e8b207eSAndrei Emeltchenko char buf[64]; 36640e8b207eSAndrei Emeltchenko 36650e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 36660e8b207eSAndrei Emeltchenko buf, &result); 36670e8b207eSAndrei Emeltchenko if (len < 0) { 36680e8b207eSAndrei Emeltchenko l2cap_send_disconn_req(conn, chan, ECONNRESET); 36690e8b207eSAndrei Emeltchenko goto done; 36700e8b207eSAndrei Emeltchenko } 36710e8b207eSAndrei Emeltchenko 36720e8b207eSAndrei Emeltchenko /* check compatibility */ 36730e8b207eSAndrei Emeltchenko 36740e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36750e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36760e8b207eSAndrei Emeltchenko 36770e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36780e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, buf, 36790e8b207eSAndrei Emeltchenko L2CAP_CONF_SUCCESS, 0x0000), buf); 36800e8b207eSAndrei Emeltchenko } 36810e8b207eSAndrei Emeltchenko goto done; 36820e8b207eSAndrei Emeltchenko 36830a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 368473ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 36850a708f8fSGustavo F. Padovan char req[64]; 36860a708f8fSGustavo F. Padovan 36870a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 3688e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 36890a708f8fSGustavo F. Padovan goto done; 36900a708f8fSGustavo F. Padovan } 36910a708f8fSGustavo F. Padovan 36920a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 36930a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 3694b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 3695b4450035SGustavo F. Padovan req, &result); 36960a708f8fSGustavo F. Padovan if (len < 0) { 3697e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 36980a708f8fSGustavo F. Padovan goto done; 36990a708f8fSGustavo F. Padovan } 37000a708f8fSGustavo F. Padovan 37010a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 37020a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 370373ffa904SGustavo F. Padovan chan->num_conf_req++; 37040a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 37050a708f8fSGustavo F. Padovan goto done; 37060a708f8fSGustavo F. Padovan break; 37070a708f8fSGustavo F. Padovan } 37080a708f8fSGustavo F. Padovan 37090a708f8fSGustavo F. Padovan default: 37106be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 37112e0052e4SAndrei Emeltchenko 3712ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 3713e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 37140a708f8fSGustavo F. Padovan goto done; 37150a708f8fSGustavo F. Padovan } 37160a708f8fSGustavo F. Padovan 371759e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 37180a708f8fSGustavo F. Padovan goto done; 37190a708f8fSGustavo F. Padovan 3720c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 37210a708f8fSGustavo F. Padovan 3722c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 372347d1ec61SGustavo F. Padovan set_default_fcs(chan); 37240a708f8fSGustavo F. Padovan 3725105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3726105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 37273c588192SMat Martineau err = l2cap_ertm_init(chan); 37280a708f8fSGustavo F. Padovan 37293c588192SMat Martineau if (err < 0) 37303c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 37313c588192SMat Martineau else 3732cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 37330a708f8fSGustavo F. Padovan } 37340a708f8fSGustavo F. Padovan 37350a708f8fSGustavo F. Padovan done: 37366be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37373c588192SMat Martineau return err; 37380a708f8fSGustavo F. Padovan } 37390a708f8fSGustavo F. Padovan 37400a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 37410a708f8fSGustavo F. Padovan { 37420a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 37430a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 37440a708f8fSGustavo F. Padovan u16 dcid, scid; 374548454079SGustavo F. Padovan struct l2cap_chan *chan; 37460a708f8fSGustavo F. Padovan struct sock *sk; 37470a708f8fSGustavo F. Padovan 37480a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 37490a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 37500a708f8fSGustavo F. Padovan 37510a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 37520a708f8fSGustavo F. Padovan 37533df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37543df91ea2SAndrei Emeltchenko 37553df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 37563df91ea2SAndrei Emeltchenko if (!chan) { 37573df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37580a708f8fSGustavo F. Padovan return 0; 37593df91ea2SAndrei Emeltchenko } 37600a708f8fSGustavo F. Padovan 37616be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 37626be36555SAndrei Emeltchenko 376348454079SGustavo F. Padovan sk = chan->sk; 376448454079SGustavo F. Padovan 3765fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3766fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 37670a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 37680a708f8fSGustavo F. Padovan 37696be36555SAndrei Emeltchenko lock_sock(sk); 37700a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 37716be36555SAndrei Emeltchenko release_sock(sk); 37720a708f8fSGustavo F. Padovan 377361d6ef3eSMat Martineau l2cap_chan_hold(chan); 377448454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 37756be36555SAndrei Emeltchenko 37766be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37770a708f8fSGustavo F. Padovan 377880b98027SGustavo Padovan chan->ops->close(chan); 377961d6ef3eSMat Martineau l2cap_chan_put(chan); 37803df91ea2SAndrei Emeltchenko 37813df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37823df91ea2SAndrei Emeltchenko 37830a708f8fSGustavo F. Padovan return 0; 37840a708f8fSGustavo F. Padovan } 37850a708f8fSGustavo F. Padovan 37860a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 37870a708f8fSGustavo F. Padovan { 37880a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 37890a708f8fSGustavo F. Padovan u16 dcid, scid; 379048454079SGustavo F. Padovan struct l2cap_chan *chan; 37910a708f8fSGustavo F. Padovan 37920a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 37930a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 37940a708f8fSGustavo F. Padovan 37950a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 37960a708f8fSGustavo F. Padovan 37973df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37983df91ea2SAndrei Emeltchenko 37993df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 38003df91ea2SAndrei Emeltchenko if (!chan) { 38013df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38020a708f8fSGustavo F. Padovan return 0; 38033df91ea2SAndrei Emeltchenko } 38040a708f8fSGustavo F. Padovan 38056be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 380648454079SGustavo F. Padovan 380761d6ef3eSMat Martineau l2cap_chan_hold(chan); 380848454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 38096be36555SAndrei Emeltchenko 38106be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 38110a708f8fSGustavo F. Padovan 381280b98027SGustavo Padovan chan->ops->close(chan); 381361d6ef3eSMat Martineau l2cap_chan_put(chan); 38143df91ea2SAndrei Emeltchenko 38153df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38163df91ea2SAndrei Emeltchenko 38170a708f8fSGustavo F. Padovan return 0; 38180a708f8fSGustavo F. Padovan } 38190a708f8fSGustavo F. Padovan 38200a708f8fSGustavo F. Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38210a708f8fSGustavo F. Padovan { 38220a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 38230a708f8fSGustavo F. Padovan u16 type; 38240a708f8fSGustavo F. Padovan 38250a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 38260a708f8fSGustavo F. Padovan 38270a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 38280a708f8fSGustavo F. Padovan 38290a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 38300a708f8fSGustavo F. Padovan u8 buf[8]; 38310a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 38320a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 3833ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 3834ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 38350a708f8fSGustavo F. Padovan if (!disable_ertm) 38360a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 38370a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 3838a5fd6f30SAndrei Emeltchenko if (enable_hs) 38396327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 38406327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 3841a5fd6f30SAndrei Emeltchenko 38420a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 38430a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38440a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38450a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 38460a708f8fSGustavo F. Padovan u8 buf[12]; 38470a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 384850a147cdSMat Martineau 384950a147cdSMat Martineau if (enable_hs) 385050a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 385150a147cdSMat Martineau else 385250a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 385350a147cdSMat Martineau 3854ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 3855ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 3856c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 38570a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38580a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38590a708f8fSGustavo F. Padovan } else { 38600a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 38610a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 3862ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 38630a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38640a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(rsp), &rsp); 38650a708f8fSGustavo F. Padovan } 38660a708f8fSGustavo F. Padovan 38670a708f8fSGustavo F. Padovan return 0; 38680a708f8fSGustavo F. Padovan } 38690a708f8fSGustavo F. Padovan 38700a708f8fSGustavo F. Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38710a708f8fSGustavo F. Padovan { 38720a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 38730a708f8fSGustavo F. Padovan u16 type, result; 38740a708f8fSGustavo F. Padovan 38750a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 38760a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 38770a708f8fSGustavo F. Padovan 38780a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 38790a708f8fSGustavo F. Padovan 3880e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 3881e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 3882e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 3883e90165beSAndrei Emeltchenko return 0; 3884e90165beSAndrei Emeltchenko 388517cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 38860a708f8fSGustavo F. Padovan 38870a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 38880a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 38890a708f8fSGustavo F. Padovan conn->info_ident = 0; 38900a708f8fSGustavo F. Padovan 38910a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 38920a708f8fSGustavo F. Padovan 38930a708f8fSGustavo F. Padovan return 0; 38940a708f8fSGustavo F. Padovan } 38950a708f8fSGustavo F. Padovan 3896978c93b9SAndrei Emeltchenko switch (type) { 3897978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 38980a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 38990a708f8fSGustavo F. Padovan 39000a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 39010a708f8fSGustavo F. Padovan struct l2cap_info_req req; 3902ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 39030a708f8fSGustavo F. Padovan 39040a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 39050a708f8fSGustavo F. Padovan 39060a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 39070a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 39080a708f8fSGustavo F. Padovan } else { 39090a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39100a708f8fSGustavo F. Padovan conn->info_ident = 0; 39110a708f8fSGustavo F. Padovan 39120a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 39130a708f8fSGustavo F. Padovan } 3914978c93b9SAndrei Emeltchenko break; 3915978c93b9SAndrei Emeltchenko 3916978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 3917978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 39180a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39190a708f8fSGustavo F. Padovan conn->info_ident = 0; 39200a708f8fSGustavo F. Padovan 39210a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 3922978c93b9SAndrei Emeltchenko break; 39230a708f8fSGustavo F. Padovan } 39240a708f8fSGustavo F. Padovan 39250a708f8fSGustavo F. Padovan return 0; 39260a708f8fSGustavo F. Padovan } 39270a708f8fSGustavo F. Padovan 3928f94ff6ffSMat Martineau static inline int l2cap_create_channel_req(struct l2cap_conn *conn, 3929f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3930f94ff6ffSMat Martineau void *data) 3931f94ff6ffSMat Martineau { 3932f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 3933f94ff6ffSMat Martineau struct l2cap_create_chan_rsp rsp; 3934f94ff6ffSMat Martineau u16 psm, scid; 3935f94ff6ffSMat Martineau 3936f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 3937f94ff6ffSMat Martineau return -EPROTO; 3938f94ff6ffSMat Martineau 3939f94ff6ffSMat Martineau if (!enable_hs) 3940f94ff6ffSMat Martineau return -EINVAL; 3941f94ff6ffSMat Martineau 3942f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 3943f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 3944f94ff6ffSMat Martineau 3945f94ff6ffSMat Martineau BT_DBG("psm %d, scid %d, amp_id %d", psm, scid, req->amp_id); 3946f94ff6ffSMat Martineau 3947f94ff6ffSMat Martineau /* Placeholder: Always reject */ 3948f94ff6ffSMat Martineau rsp.dcid = 0; 3949f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 39508ce0c498SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_NO_MEM); 39518ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3952f94ff6ffSMat Martineau 3953f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 3954f94ff6ffSMat Martineau sizeof(rsp), &rsp); 3955f94ff6ffSMat Martineau 3956f94ff6ffSMat Martineau return 0; 3957f94ff6ffSMat Martineau } 3958f94ff6ffSMat Martineau 3959f94ff6ffSMat Martineau static inline int l2cap_create_channel_rsp(struct l2cap_conn *conn, 3960f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, void *data) 3961f94ff6ffSMat Martineau { 3962f94ff6ffSMat Martineau BT_DBG("conn %p", conn); 3963f94ff6ffSMat Martineau 3964f94ff6ffSMat Martineau return l2cap_connect_rsp(conn, cmd, data); 3965f94ff6ffSMat Martineau } 3966f94ff6ffSMat Martineau 39678d5a04a1SMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_conn *conn, u8 ident, 39688d5a04a1SMat Martineau u16 icid, u16 result) 39698d5a04a1SMat Martineau { 39708d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 39718d5a04a1SMat Martineau 39728d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 39738d5a04a1SMat Martineau 39748d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 39758d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 39768d5a04a1SMat Martineau 39778d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_RSP, sizeof(rsp), &rsp); 39788d5a04a1SMat Martineau } 39798d5a04a1SMat Martineau 39808d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_conn *conn, 39818d5a04a1SMat Martineau struct l2cap_chan *chan, u16 icid, u16 result) 39828d5a04a1SMat Martineau { 39838d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 39848d5a04a1SMat Martineau u8 ident; 39858d5a04a1SMat Martineau 39868d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 39878d5a04a1SMat Martineau 39888d5a04a1SMat Martineau ident = l2cap_get_ident(conn); 39898d5a04a1SMat Martineau if (chan) 39908d5a04a1SMat Martineau chan->ident = ident; 39918d5a04a1SMat Martineau 39928d5a04a1SMat Martineau cfm.icid = cpu_to_le16(icid); 39938d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 39948d5a04a1SMat Martineau 39958d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM, sizeof(cfm), &cfm); 39968d5a04a1SMat Martineau } 39978d5a04a1SMat Martineau 39988d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 39998d5a04a1SMat Martineau u16 icid) 40008d5a04a1SMat Martineau { 40018d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 40028d5a04a1SMat Martineau 40038d5a04a1SMat Martineau BT_DBG("icid %d", icid); 40048d5a04a1SMat Martineau 40058d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 40068d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 40078d5a04a1SMat Martineau } 40088d5a04a1SMat Martineau 40098d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 40108d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40118d5a04a1SMat Martineau { 40128d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 40138d5a04a1SMat Martineau u16 icid = 0; 40148d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 40158d5a04a1SMat Martineau 40168d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 40178d5a04a1SMat Martineau return -EPROTO; 40188d5a04a1SMat Martineau 40198d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 40208d5a04a1SMat Martineau 40218d5a04a1SMat Martineau BT_DBG("icid %d, dest_amp_id %d", icid, req->dest_amp_id); 40228d5a04a1SMat Martineau 40238d5a04a1SMat Martineau if (!enable_hs) 40248d5a04a1SMat Martineau return -EINVAL; 40258d5a04a1SMat Martineau 40268d5a04a1SMat Martineau /* Placeholder: Always refuse */ 40278d5a04a1SMat Martineau l2cap_send_move_chan_rsp(conn, cmd->ident, icid, result); 40288d5a04a1SMat Martineau 40298d5a04a1SMat Martineau return 0; 40308d5a04a1SMat Martineau } 40318d5a04a1SMat Martineau 40328d5a04a1SMat Martineau static inline int l2cap_move_channel_rsp(struct l2cap_conn *conn, 40338d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40348d5a04a1SMat Martineau { 40358d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 40368d5a04a1SMat Martineau u16 icid, result; 40378d5a04a1SMat Martineau 40388d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 40398d5a04a1SMat Martineau return -EPROTO; 40408d5a04a1SMat Martineau 40418d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 40428d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 40438d5a04a1SMat Martineau 40448d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 40458d5a04a1SMat Martineau 40468d5a04a1SMat Martineau /* Placeholder: Always unconfirmed */ 40478d5a04a1SMat Martineau l2cap_send_move_chan_cfm(conn, NULL, icid, L2CAP_MC_UNCONFIRMED); 40488d5a04a1SMat Martineau 40498d5a04a1SMat Martineau return 0; 40508d5a04a1SMat Martineau } 40518d5a04a1SMat Martineau 40528d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm(struct l2cap_conn *conn, 40538d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40548d5a04a1SMat Martineau { 40558d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 40568d5a04a1SMat Martineau u16 icid, result; 40578d5a04a1SMat Martineau 40588d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 40598d5a04a1SMat Martineau return -EPROTO; 40608d5a04a1SMat Martineau 40618d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 40628d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 40638d5a04a1SMat Martineau 40648d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 40658d5a04a1SMat Martineau 40668d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 40678d5a04a1SMat Martineau 40688d5a04a1SMat Martineau return 0; 40698d5a04a1SMat Martineau } 40708d5a04a1SMat Martineau 40718d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 40728d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40738d5a04a1SMat Martineau { 40748d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 40758d5a04a1SMat Martineau u16 icid; 40768d5a04a1SMat Martineau 40778d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 40788d5a04a1SMat Martineau return -EPROTO; 40798d5a04a1SMat Martineau 40808d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 40818d5a04a1SMat Martineau 40828d5a04a1SMat Martineau BT_DBG("icid %d", icid); 40838d5a04a1SMat Martineau 40848d5a04a1SMat Martineau return 0; 40858d5a04a1SMat Martineau } 40868d5a04a1SMat Martineau 4087e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4088de73115aSClaudio Takahasi u16 to_multiplier) 4089de73115aSClaudio Takahasi { 4090de73115aSClaudio Takahasi u16 max_latency; 4091de73115aSClaudio Takahasi 4092de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4093de73115aSClaudio Takahasi return -EINVAL; 4094de73115aSClaudio Takahasi 4095de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4096de73115aSClaudio Takahasi return -EINVAL; 4097de73115aSClaudio Takahasi 4098de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4099de73115aSClaudio Takahasi return -EINVAL; 4100de73115aSClaudio Takahasi 4101de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 4102de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 4103de73115aSClaudio Takahasi return -EINVAL; 4104de73115aSClaudio Takahasi 4105de73115aSClaudio Takahasi return 0; 4106de73115aSClaudio Takahasi } 4107de73115aSClaudio Takahasi 4108de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 4109de73115aSClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 4110de73115aSClaudio Takahasi { 4111de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 4112de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 4113de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 4114de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 41152ce603ebSClaudio Takahasi int err; 4116de73115aSClaudio Takahasi 4117de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 4118de73115aSClaudio Takahasi return -EINVAL; 4119de73115aSClaudio Takahasi 4120de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 4121de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 4122de73115aSClaudio Takahasi return -EPROTO; 4123de73115aSClaudio Takahasi 4124de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 4125de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 4126de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 4127de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 4128de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 4129de73115aSClaudio Takahasi 4130de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 4131de73115aSClaudio Takahasi min, max, latency, to_multiplier); 4132de73115aSClaudio Takahasi 4133de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 41342ce603ebSClaudio Takahasi 41352ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 41362ce603ebSClaudio Takahasi if (err) 4137ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 4138de73115aSClaudio Takahasi else 4139ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 4140de73115aSClaudio Takahasi 4141de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 4142de73115aSClaudio Takahasi sizeof(rsp), &rsp); 4143de73115aSClaudio Takahasi 41442ce603ebSClaudio Takahasi if (!err) 41452ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 41462ce603ebSClaudio Takahasi 4147de73115aSClaudio Takahasi return 0; 4148de73115aSClaudio Takahasi } 4149de73115aSClaudio Takahasi 41503300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 41513300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 41523300d9a9SClaudio Takahasi { 41533300d9a9SClaudio Takahasi int err = 0; 41543300d9a9SClaudio Takahasi 41553300d9a9SClaudio Takahasi switch (cmd->code) { 41563300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 41573300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 41583300d9a9SClaudio Takahasi break; 41593300d9a9SClaudio Takahasi 41603300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 41613300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 41623300d9a9SClaudio Takahasi break; 41633300d9a9SClaudio Takahasi 41643300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 41653300d9a9SClaudio Takahasi err = l2cap_connect_rsp(conn, cmd, data); 41663300d9a9SClaudio Takahasi break; 41673300d9a9SClaudio Takahasi 41683300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 41693300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 41703300d9a9SClaudio Takahasi break; 41713300d9a9SClaudio Takahasi 41723300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 41733300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 41743300d9a9SClaudio Takahasi break; 41753300d9a9SClaudio Takahasi 41763300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 41773300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 41783300d9a9SClaudio Takahasi break; 41793300d9a9SClaudio Takahasi 41803300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 41813300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 41823300d9a9SClaudio Takahasi break; 41833300d9a9SClaudio Takahasi 41843300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 41853300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 41863300d9a9SClaudio Takahasi break; 41873300d9a9SClaudio Takahasi 41883300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 41893300d9a9SClaudio Takahasi break; 41903300d9a9SClaudio Takahasi 41913300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 41923300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 41933300d9a9SClaudio Takahasi break; 41943300d9a9SClaudio Takahasi 41953300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 41963300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 41973300d9a9SClaudio Takahasi break; 41983300d9a9SClaudio Takahasi 4199f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 4200f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 4201f94ff6ffSMat Martineau break; 4202f94ff6ffSMat Martineau 4203f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_RSP: 4204f94ff6ffSMat Martineau err = l2cap_create_channel_rsp(conn, cmd, data); 4205f94ff6ffSMat Martineau break; 4206f94ff6ffSMat Martineau 42078d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 42088d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 42098d5a04a1SMat Martineau break; 42108d5a04a1SMat Martineau 42118d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 42128d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 42138d5a04a1SMat Martineau break; 42148d5a04a1SMat Martineau 42158d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 42168d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 42178d5a04a1SMat Martineau break; 42188d5a04a1SMat Martineau 42198d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 42208d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 42218d5a04a1SMat Martineau break; 42228d5a04a1SMat Martineau 42233300d9a9SClaudio Takahasi default: 42243300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 42253300d9a9SClaudio Takahasi err = -EINVAL; 42263300d9a9SClaudio Takahasi break; 42273300d9a9SClaudio Takahasi } 42283300d9a9SClaudio Takahasi 42293300d9a9SClaudio Takahasi return err; 42303300d9a9SClaudio Takahasi } 42313300d9a9SClaudio Takahasi 42323300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 42333300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 42343300d9a9SClaudio Takahasi { 42353300d9a9SClaudio Takahasi switch (cmd->code) { 42363300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 42373300d9a9SClaudio Takahasi return 0; 42383300d9a9SClaudio Takahasi 42393300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 4240de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 42413300d9a9SClaudio Takahasi 42423300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 42433300d9a9SClaudio Takahasi return 0; 42443300d9a9SClaudio Takahasi 42453300d9a9SClaudio Takahasi default: 42463300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 42473300d9a9SClaudio Takahasi return -EINVAL; 42483300d9a9SClaudio Takahasi } 42493300d9a9SClaudio Takahasi } 42503300d9a9SClaudio Takahasi 42513300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 42523300d9a9SClaudio Takahasi struct sk_buff *skb) 42530a708f8fSGustavo F. Padovan { 42540a708f8fSGustavo F. Padovan u8 *data = skb->data; 42550a708f8fSGustavo F. Padovan int len = skb->len; 42560a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 42573300d9a9SClaudio Takahasi int err; 42580a708f8fSGustavo F. Padovan 42590a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 42600a708f8fSGustavo F. Padovan 42610a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 42620a708f8fSGustavo F. Padovan u16 cmd_len; 42630a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 42640a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 42650a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 42660a708f8fSGustavo F. Padovan 42670a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 42680a708f8fSGustavo F. Padovan 42690a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, cmd.ident); 42700a708f8fSGustavo F. Padovan 42710a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 42720a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 42730a708f8fSGustavo F. Padovan break; 42740a708f8fSGustavo F. Padovan } 42750a708f8fSGustavo F. Padovan 42763300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 42773300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 42783300d9a9SClaudio Takahasi else 42793300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 42800a708f8fSGustavo F. Padovan 42810a708f8fSGustavo F. Padovan if (err) { 4282e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 42832c6d1a2eSGustavo F. Padovan 42842c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 42850a708f8fSGustavo F. Padovan 42860a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 4287ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 42880a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej); 42890a708f8fSGustavo F. Padovan } 42900a708f8fSGustavo F. Padovan 42910a708f8fSGustavo F. Padovan data += cmd_len; 42920a708f8fSGustavo F. Padovan len -= cmd_len; 42930a708f8fSGustavo F. Padovan } 42940a708f8fSGustavo F. Padovan 42950a708f8fSGustavo F. Padovan kfree_skb(skb); 42960a708f8fSGustavo F. Padovan } 42970a708f8fSGustavo F. Padovan 429847d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 42990a708f8fSGustavo F. Padovan { 43000a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 4301e4ca6d98SAndrei Emeltchenko int hdr_size; 4302e4ca6d98SAndrei Emeltchenko 4303e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 4304e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 4305e4ca6d98SAndrei Emeltchenko else 4306e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 43070a708f8fSGustavo F. Padovan 430847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 430903a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 43100a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 43110a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 43120a708f8fSGustavo F. Padovan 43130a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 43140a708f8fSGustavo F. Padovan return -EBADMSG; 43150a708f8fSGustavo F. Padovan } 43160a708f8fSGustavo F. Padovan return 0; 43170a708f8fSGustavo F. Padovan } 43180a708f8fSGustavo F. Padovan 43196ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 43200a708f8fSGustavo F. Padovan { 4321e31f7633SMat Martineau struct l2cap_ctrl control; 43220a708f8fSGustavo F. Padovan 4323e31f7633SMat Martineau BT_DBG("chan %p", chan); 43240a708f8fSGustavo F. Padovan 4325e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 4326e31f7633SMat Martineau control.sframe = 1; 4327e31f7633SMat Martineau control.final = 1; 4328e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 4329e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 43300a708f8fSGustavo F. Padovan 4331e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4332e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 4333e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43340a708f8fSGustavo F. Padovan } 43350a708f8fSGustavo F. Padovan 4336e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 4337e31f7633SMat Martineau chan->unacked_frames > 0) 4338e31f7633SMat Martineau __set_retrans_timer(chan); 43390a708f8fSGustavo F. Padovan 4340e31f7633SMat Martineau /* Send pending iframes */ 4341525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 43420a708f8fSGustavo F. Padovan 4343e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 4344e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 4345e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 4346e31f7633SMat Martineau * send it now. 4347e31f7633SMat Martineau */ 4348e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 4349e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43500a708f8fSGustavo F. Padovan } 43510a708f8fSGustavo F. Padovan } 43520a708f8fSGustavo F. Padovan 435384084a31SMat Martineau static void append_skb_frag(struct sk_buff *skb, 435484084a31SMat Martineau struct sk_buff *new_frag, struct sk_buff **last_frag) 43550a708f8fSGustavo F. Padovan { 435684084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 435784084a31SMat Martineau * skb->data_len reflects only data in fragments 435884084a31SMat Martineau */ 435984084a31SMat Martineau if (!skb_has_frag_list(skb)) 436084084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 436184084a31SMat Martineau 436284084a31SMat Martineau new_frag->next = NULL; 436384084a31SMat Martineau 436484084a31SMat Martineau (*last_frag)->next = new_frag; 436584084a31SMat Martineau *last_frag = new_frag; 436684084a31SMat Martineau 436784084a31SMat Martineau skb->len += new_frag->len; 436884084a31SMat Martineau skb->data_len += new_frag->len; 436984084a31SMat Martineau skb->truesize += new_frag->truesize; 437084084a31SMat Martineau } 437184084a31SMat Martineau 43724b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 43734b51dae9SMat Martineau struct l2cap_ctrl *control) 437484084a31SMat Martineau { 437584084a31SMat Martineau int err = -EINVAL; 43760a708f8fSGustavo F. Padovan 43774b51dae9SMat Martineau switch (control->sar) { 43787e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 437984084a31SMat Martineau if (chan->sdu) 438084084a31SMat Martineau break; 43810a708f8fSGustavo F. Padovan 438280b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 438384084a31SMat Martineau break; 43840a708f8fSGustavo F. Padovan 43857e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 438684084a31SMat Martineau if (chan->sdu) 438784084a31SMat Martineau break; 43880a708f8fSGustavo F. Padovan 43896f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 439003a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 43910a708f8fSGustavo F. Padovan 439284084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 439384084a31SMat Martineau err = -EMSGSIZE; 439484084a31SMat Martineau break; 439584084a31SMat Martineau } 43960a708f8fSGustavo F. Padovan 439784084a31SMat Martineau if (skb->len >= chan->sdu_len) 439884084a31SMat Martineau break; 439984084a31SMat Martineau 440084084a31SMat Martineau chan->sdu = skb; 440184084a31SMat Martineau chan->sdu_last_frag = skb; 440284084a31SMat Martineau 440384084a31SMat Martineau skb = NULL; 440484084a31SMat Martineau err = 0; 44050a708f8fSGustavo F. Padovan break; 44060a708f8fSGustavo F. Padovan 44077e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 44086f61fd47SGustavo F. Padovan if (!chan->sdu) 440984084a31SMat Martineau break; 44100a708f8fSGustavo F. Padovan 441184084a31SMat Martineau append_skb_frag(chan->sdu, skb, 441284084a31SMat Martineau &chan->sdu_last_frag); 441384084a31SMat Martineau skb = NULL; 44140a708f8fSGustavo F. Padovan 441584084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 441684084a31SMat Martineau break; 44170a708f8fSGustavo F. Padovan 441884084a31SMat Martineau err = 0; 44190a708f8fSGustavo F. Padovan break; 44200a708f8fSGustavo F. Padovan 44217e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 44226f61fd47SGustavo F. Padovan if (!chan->sdu) 442384084a31SMat Martineau break; 44240a708f8fSGustavo F. Padovan 442584084a31SMat Martineau append_skb_frag(chan->sdu, skb, 442684084a31SMat Martineau &chan->sdu_last_frag); 442784084a31SMat Martineau skb = NULL; 44280a708f8fSGustavo F. Padovan 442984084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 443084084a31SMat Martineau break; 44310a708f8fSGustavo F. Padovan 443280b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 44330a708f8fSGustavo F. Padovan 443484084a31SMat Martineau if (!err) { 443584084a31SMat Martineau /* Reassembly complete */ 443684084a31SMat Martineau chan->sdu = NULL; 443784084a31SMat Martineau chan->sdu_last_frag = NULL; 443884084a31SMat Martineau chan->sdu_len = 0; 44390a708f8fSGustavo F. Padovan } 44400a708f8fSGustavo F. Padovan break; 44410a708f8fSGustavo F. Padovan } 44420a708f8fSGustavo F. Padovan 444384084a31SMat Martineau if (err) { 44440a708f8fSGustavo F. Padovan kfree_skb(skb); 44456f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 44466f61fd47SGustavo F. Padovan chan->sdu = NULL; 444784084a31SMat Martineau chan->sdu_last_frag = NULL; 444884084a31SMat Martineau chan->sdu_len = 0; 444984084a31SMat Martineau } 44500a708f8fSGustavo F. Padovan 445184084a31SMat Martineau return err; 44520a708f8fSGustavo F. Padovan } 44530a708f8fSGustavo F. Padovan 4454e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 44550a708f8fSGustavo F. Padovan { 445661aa4f5bSMat Martineau u8 event; 445761aa4f5bSMat Martineau 445861aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 445961aa4f5bSMat Martineau return; 446061aa4f5bSMat Martineau 446161aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 4462401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 44630a708f8fSGustavo F. Padovan } 44640a708f8fSGustavo F. Padovan 4465d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 4466d2a7ac5dSMat Martineau { 446763838725SMat Martineau int err = 0; 446863838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 446963838725SMat Martineau * until a gap is encountered. 447063838725SMat Martineau */ 447163838725SMat Martineau 447263838725SMat Martineau BT_DBG("chan %p", chan); 447363838725SMat Martineau 447463838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 447563838725SMat Martineau struct sk_buff *skb; 447663838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 447763838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 447863838725SMat Martineau 447963838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 448063838725SMat Martineau 448163838725SMat Martineau if (!skb) 448263838725SMat Martineau break; 448363838725SMat Martineau 448463838725SMat Martineau skb_unlink(skb, &chan->srej_q); 448563838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 448663838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 448763838725SMat Martineau if (err) 448863838725SMat Martineau break; 448963838725SMat Martineau } 449063838725SMat Martineau 449163838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 449263838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 449363838725SMat Martineau l2cap_send_ack(chan); 449463838725SMat Martineau } 449563838725SMat Martineau 449663838725SMat Martineau return err; 4497d2a7ac5dSMat Martineau } 4498d2a7ac5dSMat Martineau 4499d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 4500d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4501d2a7ac5dSMat Martineau { 4502f80842a8SMat Martineau struct sk_buff *skb; 4503f80842a8SMat Martineau 4504f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 4505f80842a8SMat Martineau 4506f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 4507f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4508f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4509f80842a8SMat Martineau return; 4510f80842a8SMat Martineau } 4511f80842a8SMat Martineau 4512f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4513f80842a8SMat Martineau 4514f80842a8SMat Martineau if (skb == NULL) { 4515f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 4516f80842a8SMat Martineau control->reqseq); 4517f80842a8SMat Martineau return; 4518f80842a8SMat Martineau } 4519f80842a8SMat Martineau 4520f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 4521f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4522f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4523f80842a8SMat Martineau return; 4524f80842a8SMat Martineau } 4525f80842a8SMat Martineau 4526f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4527f80842a8SMat Martineau 4528f80842a8SMat Martineau if (control->poll) { 4529f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 4530f80842a8SMat Martineau 4531f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4532f80842a8SMat Martineau l2cap_retransmit(chan, control); 4533f80842a8SMat Martineau l2cap_ertm_send(chan); 4534f80842a8SMat Martineau 4535f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4536f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4537f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4538f80842a8SMat Martineau } 4539f80842a8SMat Martineau } else { 4540f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 4541f80842a8SMat Martineau 4542f80842a8SMat Martineau if (control->final) { 4543f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 4544f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 4545f80842a8SMat Martineau &chan->conn_state)) 4546f80842a8SMat Martineau l2cap_retransmit(chan, control); 4547f80842a8SMat Martineau } else { 4548f80842a8SMat Martineau l2cap_retransmit(chan, control); 4549f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4550f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4551f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4552f80842a8SMat Martineau } 4553f80842a8SMat Martineau } 4554f80842a8SMat Martineau } 4555d2a7ac5dSMat Martineau } 4556d2a7ac5dSMat Martineau 4557d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 4558d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4559d2a7ac5dSMat Martineau { 4560fcd289dfSMat Martineau struct sk_buff *skb; 4561fcd289dfSMat Martineau 4562fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 4563fcd289dfSMat Martineau 4564fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 4565fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4566fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4567fcd289dfSMat Martineau return; 4568fcd289dfSMat Martineau } 4569fcd289dfSMat Martineau 4570fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4571fcd289dfSMat Martineau 4572fcd289dfSMat Martineau if (chan->max_tx && skb && 4573fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 4574fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4575fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4576fcd289dfSMat Martineau return; 4577fcd289dfSMat Martineau } 4578fcd289dfSMat Martineau 4579fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4580fcd289dfSMat Martineau 4581fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 4582fcd289dfSMat Martineau 4583fcd289dfSMat Martineau if (control->final) { 4584fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 4585fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4586fcd289dfSMat Martineau } else { 4587fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4588fcd289dfSMat Martineau l2cap_ertm_send(chan); 4589fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 4590fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 4591fcd289dfSMat Martineau } 4592d2a7ac5dSMat Martineau } 4593d2a7ac5dSMat Martineau 45944b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 45954b51dae9SMat Martineau { 45964b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 45974b51dae9SMat Martineau 45984b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 45994b51dae9SMat Martineau chan->expected_tx_seq); 46004b51dae9SMat Martineau 46014b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 46024b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 46034b51dae9SMat Martineau chan->tx_win) { 46044b51dae9SMat Martineau /* See notes below regarding "double poll" and 46054b51dae9SMat Martineau * invalid packets. 46064b51dae9SMat Martineau */ 46074b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 46084b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 46094b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 46104b51dae9SMat Martineau } else { 46114b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 46124b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46134b51dae9SMat Martineau } 46144b51dae9SMat Martineau } 46154b51dae9SMat Martineau 46164b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 46174b51dae9SMat Martineau BT_DBG("Expected SREJ"); 46184b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 46194b51dae9SMat Martineau } 46204b51dae9SMat Martineau 46214b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 46224b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 46234b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 46244b51dae9SMat Martineau } 46254b51dae9SMat Martineau 46264b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 46274b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 46284b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 46294b51dae9SMat Martineau } 46304b51dae9SMat Martineau } 46314b51dae9SMat Martineau 46324b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 46334b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 46344b51dae9SMat Martineau chan->tx_win) { 46354b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46364b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46374b51dae9SMat Martineau } else { 46384b51dae9SMat Martineau BT_DBG("Expected"); 46394b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 46404b51dae9SMat Martineau } 46414b51dae9SMat Martineau } 46424b51dae9SMat Martineau 46434b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 46444b51dae9SMat Martineau __seq_offset(chan, chan->expected_tx_seq, 46454b51dae9SMat Martineau chan->last_acked_seq)){ 46464b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 46474b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 46484b51dae9SMat Martineau } 46494b51dae9SMat Martineau 46504b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 46514b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 46524b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 46534b51dae9SMat Martineau * the remote stack receives and processes both polls, 46544b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 46554b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 46564b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 46574b51dae9SMat Martineau * request. 46584b51dae9SMat Martineau * 46594b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 46604b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 46614b51dae9SMat Martineau * invalid frames to be safely ignored. 46624b51dae9SMat Martineau * 46634b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 46644b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 46654b51dae9SMat Martineau * causes a disconnect. 46664b51dae9SMat Martineau */ 46674b51dae9SMat Martineau 46684b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 46694b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 46704b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 46714b51dae9SMat Martineau } else { 46724b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46734b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46744b51dae9SMat Martineau } 46754b51dae9SMat Martineau } else { 46764b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 46774b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 46784b51dae9SMat Martineau } 46794b51dae9SMat Martineau } 46804b51dae9SMat Martineau 4681d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 4682d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4683d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4684d2a7ac5dSMat Martineau { 4685d2a7ac5dSMat Martineau int err = 0; 4686d2a7ac5dSMat Martineau bool skb_in_use = 0; 4687d2a7ac5dSMat Martineau 4688d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4689d2a7ac5dSMat Martineau event); 4690d2a7ac5dSMat Martineau 4691d2a7ac5dSMat Martineau switch (event) { 4692d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4693d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 4694d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4695d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4696d2a7ac5dSMat Martineau 4697d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4698d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 4699d2a7ac5dSMat Martineau control->txseq); 4700d2a7ac5dSMat Martineau break; 4701d2a7ac5dSMat Martineau } 4702d2a7ac5dSMat Martineau 4703d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 4704d2a7ac5dSMat Martineau control->txseq); 4705d2a7ac5dSMat Martineau 4706d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 4707d2a7ac5dSMat Martineau skb_in_use = 1; 4708d2a7ac5dSMat Martineau 4709d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 4710d2a7ac5dSMat Martineau if (err) 4711d2a7ac5dSMat Martineau break; 4712d2a7ac5dSMat Martineau 4713d2a7ac5dSMat Martineau if (control->final) { 4714d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4715d2a7ac5dSMat Martineau &chan->conn_state)) { 4716d2a7ac5dSMat Martineau control->final = 0; 4717d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4718d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4719d2a7ac5dSMat Martineau } 4720d2a7ac5dSMat Martineau } 4721d2a7ac5dSMat Martineau 4722d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 4723d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4724d2a7ac5dSMat Martineau break; 4725d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4726d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4727d2a7ac5dSMat Martineau 4728d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 4729d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 4730d2a7ac5dSMat Martineau * when local busy is exited. 4731d2a7ac5dSMat Martineau */ 4732d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4733d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 4734d2a7ac5dSMat Martineau control->txseq); 4735d2a7ac5dSMat Martineau break; 4736d2a7ac5dSMat Martineau } 4737d2a7ac5dSMat Martineau 4738d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 4739d2a7ac5dSMat Martineau * must be sent for each missing frame. The 4740d2a7ac5dSMat Martineau * current frame is stored for later use. 4741d2a7ac5dSMat Martineau */ 4742d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4743d2a7ac5dSMat Martineau skb_in_use = 1; 4744d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4745d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4746d2a7ac5dSMat Martineau 4747d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 4748d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 4749d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4750d2a7ac5dSMat Martineau 4751d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 4752d2a7ac5dSMat Martineau break; 4753d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4754d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4755d2a7ac5dSMat Martineau break; 4756d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4757d2a7ac5dSMat Martineau break; 4758d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4759d2a7ac5dSMat Martineau default: 4760d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4761d2a7ac5dSMat Martineau ECONNRESET); 4762d2a7ac5dSMat Martineau break; 4763d2a7ac5dSMat Martineau } 4764d2a7ac5dSMat Martineau break; 4765d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4766d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4767d2a7ac5dSMat Martineau if (control->final) { 4768d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4769d2a7ac5dSMat Martineau 4770d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4771d2a7ac5dSMat Martineau &chan->conn_state)) { 4772d2a7ac5dSMat Martineau control->final = 0; 4773d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4774d2a7ac5dSMat Martineau } 4775d2a7ac5dSMat Martineau 4776d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4777d2a7ac5dSMat Martineau } else if (control->poll) { 4778d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 4779d2a7ac5dSMat Martineau } else { 4780d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4781d2a7ac5dSMat Martineau &chan->conn_state) && 4782d2a7ac5dSMat Martineau chan->unacked_frames) 4783d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4784d2a7ac5dSMat Martineau 4785d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4786d2a7ac5dSMat Martineau } 4787d2a7ac5dSMat Martineau break; 4788d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4789d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4790d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4791d2a7ac5dSMat Martineau if (control && control->poll) { 4792d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4793d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 4794d2a7ac5dSMat Martineau } 4795d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 4796d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 4797d2a7ac5dSMat Martineau break; 4798d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4799d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4800d2a7ac5dSMat Martineau break; 4801d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4802d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4803d2a7ac5dSMat Martineau break; 4804d2a7ac5dSMat Martineau default: 4805d2a7ac5dSMat Martineau break; 4806d2a7ac5dSMat Martineau } 4807d2a7ac5dSMat Martineau 4808d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4809d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4810d2a7ac5dSMat Martineau kfree_skb(skb); 4811d2a7ac5dSMat Martineau } 4812d2a7ac5dSMat Martineau 4813d2a7ac5dSMat Martineau return err; 4814d2a7ac5dSMat Martineau } 4815d2a7ac5dSMat Martineau 4816d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 4817d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4818d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4819d2a7ac5dSMat Martineau { 4820d2a7ac5dSMat Martineau int err = 0; 4821d2a7ac5dSMat Martineau u16 txseq = control->txseq; 4822d2a7ac5dSMat Martineau bool skb_in_use = 0; 4823d2a7ac5dSMat Martineau 4824d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4825d2a7ac5dSMat Martineau event); 4826d2a7ac5dSMat Martineau 4827d2a7ac5dSMat Martineau switch (event) { 4828d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4829d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 4830d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4831d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 4832d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4833d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4834d2a7ac5dSMat Martineau skb_in_use = 1; 4835d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4836d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4837d2a7ac5dSMat Martineau 4838d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 4839d2a7ac5dSMat Martineau break; 4840d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 4841d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 4842d2a7ac5dSMat Martineau 4843d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 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 err = l2cap_rx_queued_iframes(chan); 4850d2a7ac5dSMat Martineau if (err) 4851d2a7ac5dSMat Martineau break; 4852d2a7ac5dSMat Martineau 4853d2a7ac5dSMat Martineau break; 4854d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4855d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 4856d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 4857d2a7ac5dSMat Martineau * the missing frames. 4858d2a7ac5dSMat Martineau */ 4859d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4860d2a7ac5dSMat Martineau skb_in_use = 1; 4861d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4862d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4863d2a7ac5dSMat Martineau 4864d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4865d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4866d2a7ac5dSMat Martineau break; 4867d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 4868d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 4869d2a7ac5dSMat Martineau * some expected retransmitted frames are 4870d2a7ac5dSMat Martineau * missing. Request retransmission of missing 4871d2a7ac5dSMat Martineau * SREJ'd frames. 4872d2a7ac5dSMat Martineau */ 4873d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4874d2a7ac5dSMat Martineau skb_in_use = 1; 4875d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4876d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4877d2a7ac5dSMat Martineau 4878d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4879d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 4880d2a7ac5dSMat Martineau break; 4881d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 4882d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 4883d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4884d2a7ac5dSMat Martineau break; 4885d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4886d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 4887d2a7ac5dSMat Martineau * was already received. Ignore it completely. 4888d2a7ac5dSMat Martineau */ 4889d2a7ac5dSMat Martineau break; 4890d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4891d2a7ac5dSMat Martineau break; 4892d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4893d2a7ac5dSMat Martineau default: 4894d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4895d2a7ac5dSMat Martineau ECONNRESET); 4896d2a7ac5dSMat Martineau break; 4897d2a7ac5dSMat Martineau } 4898d2a7ac5dSMat Martineau break; 4899d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4900d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4901d2a7ac5dSMat Martineau if (control->final) { 4902d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4903d2a7ac5dSMat Martineau 4904d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4905d2a7ac5dSMat Martineau &chan->conn_state)) { 4906d2a7ac5dSMat Martineau control->final = 0; 4907d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4908d2a7ac5dSMat Martineau } 4909d2a7ac5dSMat Martineau 4910d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4911d2a7ac5dSMat Martineau } else if (control->poll) { 4912d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4913d2a7ac5dSMat Martineau &chan->conn_state) && 4914d2a7ac5dSMat Martineau chan->unacked_frames) { 4915d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4916d2a7ac5dSMat Martineau } 4917d2a7ac5dSMat Martineau 4918d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4919d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4920d2a7ac5dSMat Martineau } else { 4921d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4922d2a7ac5dSMat Martineau &chan->conn_state) && 4923d2a7ac5dSMat Martineau chan->unacked_frames) 4924d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4925d2a7ac5dSMat Martineau 4926d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4927d2a7ac5dSMat Martineau } 4928d2a7ac5dSMat Martineau break; 4929d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4930d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4931d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4932d2a7ac5dSMat Martineau if (control->poll) { 4933d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4934d2a7ac5dSMat Martineau } else { 4935d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 4936d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 4937d2a7ac5dSMat Martineau rr_control.sframe = 1; 4938d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 4939d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 4940d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 4941d2a7ac5dSMat Martineau } 4942d2a7ac5dSMat Martineau 4943d2a7ac5dSMat Martineau break; 4944d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4945d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4946d2a7ac5dSMat Martineau break; 4947d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4948d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4949d2a7ac5dSMat Martineau break; 4950d2a7ac5dSMat Martineau } 4951d2a7ac5dSMat Martineau 4952d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4953d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4954d2a7ac5dSMat Martineau kfree_skb(skb); 4955d2a7ac5dSMat Martineau } 4956d2a7ac5dSMat Martineau 4957d2a7ac5dSMat Martineau return err; 4958d2a7ac5dSMat Martineau } 4959d2a7ac5dSMat Martineau 4960d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 4961d2a7ac5dSMat Martineau { 4962d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 4963d2a7ac5dSMat Martineau u16 unacked; 4964d2a7ac5dSMat Martineau 4965d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 4966d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 4967d2a7ac5dSMat Martineau } 4968d2a7ac5dSMat Martineau 4969cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 4970cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 49710a708f8fSGustavo F. Padovan { 4972d2a7ac5dSMat Martineau int err = 0; 4973d2a7ac5dSMat Martineau 4974d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 4975d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 4976d2a7ac5dSMat Martineau 4977d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 4978d2a7ac5dSMat Martineau switch (chan->rx_state) { 4979d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 4980d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 4981d2a7ac5dSMat Martineau break; 4982d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 4983d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 4984d2a7ac5dSMat Martineau event); 4985d2a7ac5dSMat Martineau break; 4986d2a7ac5dSMat Martineau default: 4987d2a7ac5dSMat Martineau /* shut it down */ 4988d2a7ac5dSMat Martineau break; 4989d2a7ac5dSMat Martineau } 4990d2a7ac5dSMat Martineau } else { 4991d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 4992d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 4993d2a7ac5dSMat Martineau chan->expected_ack_seq); 4994d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4995d2a7ac5dSMat Martineau } 4996d2a7ac5dSMat Martineau 4997d2a7ac5dSMat Martineau return err; 4998cec8ab6eSMat Martineau } 4999cec8ab6eSMat Martineau 5000cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5001cec8ab6eSMat Martineau struct sk_buff *skb) 5002cec8ab6eSMat Martineau { 50034b51dae9SMat Martineau int err = 0; 50044b51dae9SMat Martineau 50054b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 50064b51dae9SMat Martineau chan->rx_state); 50074b51dae9SMat Martineau 50084b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 50094b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 50104b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 50114b51dae9SMat Martineau 50124b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 50134b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 50144b51dae9SMat Martineau 50154b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 50164b51dae9SMat Martineau 50174b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 50184b51dae9SMat Martineau } else { 50194b51dae9SMat Martineau if (chan->sdu) { 50204b51dae9SMat Martineau kfree_skb(chan->sdu); 50214b51dae9SMat Martineau chan->sdu = NULL; 50224b51dae9SMat Martineau } 50234b51dae9SMat Martineau chan->sdu_last_frag = NULL; 50244b51dae9SMat Martineau chan->sdu_len = 0; 50254b51dae9SMat Martineau 50264b51dae9SMat Martineau if (skb) { 50274b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 50284b51dae9SMat Martineau kfree_skb(skb); 50294b51dae9SMat Martineau } 50304b51dae9SMat Martineau } 50314b51dae9SMat Martineau 50324b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 50334b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 50344b51dae9SMat Martineau 50354b51dae9SMat Martineau return err; 5036cec8ab6eSMat Martineau } 5037cec8ab6eSMat Martineau 5038cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 5039cec8ab6eSMat Martineau { 5040cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 5041cec8ab6eSMat Martineau u16 len; 5042cec8ab6eSMat Martineau u8 event; 50430a708f8fSGustavo F. Padovan 5044b76bbd66SMat Martineau __unpack_control(chan, skb); 5045b76bbd66SMat Martineau 50460a708f8fSGustavo F. Padovan len = skb->len; 50470a708f8fSGustavo F. Padovan 50480a708f8fSGustavo F. Padovan /* 50490a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 50500a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 5051cec8ab6eSMat Martineau * procedures and ask for retransmission. 50520a708f8fSGustavo F. Padovan */ 505347d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 50540a708f8fSGustavo F. Padovan goto drop; 50550a708f8fSGustavo F. Padovan 5056cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 505703a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 50580a708f8fSGustavo F. Padovan 505947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 506003a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 50610a708f8fSGustavo F. Padovan 506247d1ec61SGustavo F. Padovan if (len > chan->mps) { 50638c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 50640a708f8fSGustavo F. Padovan goto drop; 50650a708f8fSGustavo F. Padovan } 50660a708f8fSGustavo F. Padovan 5067cec8ab6eSMat Martineau if (!control->sframe) { 5068cec8ab6eSMat Martineau int err; 50690a708f8fSGustavo F. Padovan 5070cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 5071cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 5072cec8ab6eSMat Martineau control->txseq); 5073836be934SAndrei Emeltchenko 5074cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 5075cec8ab6eSMat Martineau * valid in TX WAIT_F 5076cec8ab6eSMat Martineau */ 5077cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 50780a708f8fSGustavo F. Padovan goto drop; 50790a708f8fSGustavo F. Padovan 5080cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 5081cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 5082cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 50830a708f8fSGustavo F. Padovan } else { 5084cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 5085cec8ab6eSMat Martineau } 5086cec8ab6eSMat Martineau 5087cec8ab6eSMat Martineau if (err) 5088cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5089cec8ab6eSMat Martineau ECONNRESET); 5090cec8ab6eSMat Martineau } else { 5091cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 5092cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 5093cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 5094cec8ab6eSMat Martineau }; 5095cec8ab6eSMat Martineau 5096cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 5097cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 5098cec8ab6eSMat Martineau goto drop; 5099cec8ab6eSMat Martineau 5100cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 5101cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 5102cec8ab6eSMat Martineau control->super); 5103cec8ab6eSMat Martineau 51040a708f8fSGustavo F. Padovan if (len != 0) { 51050a708f8fSGustavo F. Padovan BT_ERR("%d", len); 51068c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51070a708f8fSGustavo F. Padovan goto drop; 51080a708f8fSGustavo F. Padovan } 51090a708f8fSGustavo F. Padovan 5110cec8ab6eSMat Martineau /* Validate F and P bits */ 5111cec8ab6eSMat Martineau if (control->final && (control->poll || 5112cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 5113cec8ab6eSMat Martineau goto drop; 5114cec8ab6eSMat Martineau 5115cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 5116cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 5117cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51180a708f8fSGustavo F. Padovan } 51190a708f8fSGustavo F. Padovan 51200a708f8fSGustavo F. Padovan return 0; 51210a708f8fSGustavo F. Padovan 51220a708f8fSGustavo F. Padovan drop: 51230a708f8fSGustavo F. Padovan kfree_skb(skb); 51240a708f8fSGustavo F. Padovan return 0; 51250a708f8fSGustavo F. Padovan } 51260a708f8fSGustavo F. Padovan 512713ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 512813ca56e0SAndrei Emeltchenko struct sk_buff *skb) 51290a708f8fSGustavo F. Padovan { 513048454079SGustavo F. Padovan struct l2cap_chan *chan; 51310a708f8fSGustavo F. Padovan 5132baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 513348454079SGustavo F. Padovan if (!chan) { 513497e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 513597e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 513697e8e89dSAndrei Emeltchenko if (!chan) { 513797e8e89dSAndrei Emeltchenko kfree_skb(skb); 513813ca56e0SAndrei Emeltchenko return; 513997e8e89dSAndrei Emeltchenko } 514097e8e89dSAndrei Emeltchenko 514197e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 514297e8e89dSAndrei Emeltchenko } else { 51430a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 51446be36555SAndrei Emeltchenko /* Drop packet and return */ 51453379013bSDan Carpenter kfree_skb(skb); 514613ca56e0SAndrei Emeltchenko return; 51470a708f8fSGustavo F. Padovan } 514897e8e89dSAndrei Emeltchenko } 51490a708f8fSGustavo F. Padovan 515049208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 51510a708f8fSGustavo F. Padovan 515289bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 51530a708f8fSGustavo F. Padovan goto drop; 51540a708f8fSGustavo F. Padovan 51550c1bc5c6SGustavo F. Padovan switch (chan->mode) { 51560a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 51570a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 51580a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 51590a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 51600a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 51610a708f8fSGustavo F. Padovan 51620c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 51630a708f8fSGustavo F. Padovan goto drop; 51640a708f8fSGustavo F. Padovan 516580b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 51660a708f8fSGustavo F. Padovan goto done; 51670a708f8fSGustavo F. Padovan break; 51680a708f8fSGustavo F. Padovan 51690a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 51700a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 5171cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 51720a708f8fSGustavo F. Padovan goto done; 51730a708f8fSGustavo F. Padovan 51740a708f8fSGustavo F. Padovan default: 51750c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 51760a708f8fSGustavo F. Padovan break; 51770a708f8fSGustavo F. Padovan } 51780a708f8fSGustavo F. Padovan 51790a708f8fSGustavo F. Padovan drop: 51800a708f8fSGustavo F. Padovan kfree_skb(skb); 51810a708f8fSGustavo F. Padovan 51820a708f8fSGustavo F. Padovan done: 51836be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 51840a708f8fSGustavo F. Padovan } 51850a708f8fSGustavo F. Padovan 518684104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 518784104b24SAndrei Emeltchenko struct sk_buff *skb) 51880a708f8fSGustavo F. Padovan { 518923691d75SGustavo F. Padovan struct l2cap_chan *chan; 51900a708f8fSGustavo F. Padovan 5191c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 519223691d75SGustavo F. Padovan if (!chan) 51930a708f8fSGustavo F. Padovan goto drop; 51940a708f8fSGustavo F. Padovan 51955b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 51960a708f8fSGustavo F. Padovan 519789bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 51980a708f8fSGustavo F. Padovan goto drop; 51990a708f8fSGustavo F. Padovan 5200e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 52010a708f8fSGustavo F. Padovan goto drop; 52020a708f8fSGustavo F. Padovan 520380b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 520484104b24SAndrei Emeltchenko return; 52050a708f8fSGustavo F. Padovan 52060a708f8fSGustavo F. Padovan drop: 52070a708f8fSGustavo F. Padovan kfree_skb(skb); 52080a708f8fSGustavo F. Padovan } 52090a708f8fSGustavo F. Padovan 52106810fca7SAndrei Emeltchenko static void l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 5211d9b88702SAndrei Emeltchenko struct sk_buff *skb) 52129f69bda6SGustavo F. Padovan { 521323691d75SGustavo F. Padovan struct l2cap_chan *chan; 52149f69bda6SGustavo F. Padovan 5215c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 521623691d75SGustavo F. Padovan if (!chan) 52179f69bda6SGustavo F. Padovan goto drop; 52189f69bda6SGustavo F. Padovan 52195b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 52209f69bda6SGustavo F. Padovan 522189bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 52229f69bda6SGustavo F. Padovan goto drop; 52239f69bda6SGustavo F. Padovan 5224e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 52259f69bda6SGustavo F. Padovan goto drop; 52269f69bda6SGustavo F. Padovan 522780b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 52286810fca7SAndrei Emeltchenko return; 52299f69bda6SGustavo F. Padovan 52309f69bda6SGustavo F. Padovan drop: 52319f69bda6SGustavo F. Padovan kfree_skb(skb); 52329f69bda6SGustavo F. Padovan } 52339f69bda6SGustavo F. Padovan 52340a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 52350a708f8fSGustavo F. Padovan { 52360a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 52370a708f8fSGustavo F. Padovan u16 cid, len; 52380a708f8fSGustavo F. Padovan __le16 psm; 52390a708f8fSGustavo F. Padovan 52400a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 52410a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 52420a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 52430a708f8fSGustavo F. Padovan 52440a708f8fSGustavo F. Padovan if (len != skb->len) { 52450a708f8fSGustavo F. Padovan kfree_skb(skb); 52460a708f8fSGustavo F. Padovan return; 52470a708f8fSGustavo F. Padovan } 52480a708f8fSGustavo F. Padovan 52490a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 52500a708f8fSGustavo F. Padovan 52510a708f8fSGustavo F. Padovan switch (cid) { 52523300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 52530a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 52540a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 52550a708f8fSGustavo F. Padovan break; 52560a708f8fSGustavo F. Padovan 52570a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 5258097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 52590181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 52600a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 52610a708f8fSGustavo F. Padovan break; 52620a708f8fSGustavo F. Padovan 52639f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 52649f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 52659f69bda6SGustavo F. Padovan break; 52669f69bda6SGustavo F. Padovan 5267b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 5268b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 5269b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 5270b501d6a1SAnderson Briglia break; 5271b501d6a1SAnderson Briglia 52720a708f8fSGustavo F. Padovan default: 52730a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 52740a708f8fSGustavo F. Padovan break; 52750a708f8fSGustavo F. Padovan } 52760a708f8fSGustavo F. Padovan } 52770a708f8fSGustavo F. Padovan 52780a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 52790a708f8fSGustavo F. Padovan 5280686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 52810a708f8fSGustavo F. Padovan { 52820a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 528323691d75SGustavo F. Padovan struct l2cap_chan *c; 52840a708f8fSGustavo F. Padovan 52850a708f8fSGustavo F. Padovan BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr)); 52860a708f8fSGustavo F. Padovan 52870a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 528823691d75SGustavo F. Padovan read_lock(&chan_list_lock); 528923691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 529023691d75SGustavo F. Padovan struct sock *sk = c->sk; 52914343478fSGustavo F. Padovan 529289bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 52930a708f8fSGustavo F. Padovan continue; 52940a708f8fSGustavo F. Padovan 52950a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 52960a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 529743bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 52980a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 52990a708f8fSGustavo F. Padovan exact++; 53000a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 53010a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 530243bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 53030a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 53040a708f8fSGustavo F. Padovan } 53050a708f8fSGustavo F. Padovan } 530623691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 53070a708f8fSGustavo F. Padovan 53080a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 53090a708f8fSGustavo F. Padovan } 53100a708f8fSGustavo F. Padovan 5311686ebf28SUlisses Furquim int l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 53120a708f8fSGustavo F. Padovan { 53130a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 53140a708f8fSGustavo F. Padovan 53150a708f8fSGustavo F. Padovan BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status); 53160a708f8fSGustavo F. Padovan 53170a708f8fSGustavo F. Padovan if (!status) { 53180a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 53190a708f8fSGustavo F. Padovan if (conn) 53200a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 53210a708f8fSGustavo F. Padovan } else 5322e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 53230a708f8fSGustavo F. Padovan 53240a708f8fSGustavo F. Padovan return 0; 53250a708f8fSGustavo F. Padovan } 53260a708f8fSGustavo F. Padovan 5327686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 53280a708f8fSGustavo F. Padovan { 53290a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 53300a708f8fSGustavo F. Padovan 53310a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 53320a708f8fSGustavo F. Padovan 5333686ebf28SUlisses Furquim if (!conn) 53349f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 53350a708f8fSGustavo F. Padovan return conn->disc_reason; 53360a708f8fSGustavo F. Padovan } 53370a708f8fSGustavo F. Padovan 5338686ebf28SUlisses Furquim int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 53390a708f8fSGustavo F. Padovan { 53400a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 53410a708f8fSGustavo F. Padovan 5342e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 53430a708f8fSGustavo F. Padovan return 0; 53440a708f8fSGustavo F. Padovan } 53450a708f8fSGustavo F. Padovan 53464343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 53470a708f8fSGustavo F. Padovan { 5348715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 53490a708f8fSGustavo F. Padovan return; 53500a708f8fSGustavo F. Padovan 53510a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 53524343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 5353ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 53544343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 53550f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 53560a708f8fSGustavo F. Padovan } else { 53574343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 5358c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 53590a708f8fSGustavo F. Padovan } 53600a708f8fSGustavo F. Padovan } 53610a708f8fSGustavo F. Padovan 5362686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 53630a708f8fSGustavo F. Padovan { 53640a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 536548454079SGustavo F. Padovan struct l2cap_chan *chan; 53660a708f8fSGustavo F. Padovan 53670a708f8fSGustavo F. Padovan if (!conn) 53680a708f8fSGustavo F. Padovan return 0; 53690a708f8fSGustavo F. Padovan 53700a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 53710a708f8fSGustavo F. Padovan 5372160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 537335d4adccSHemant Gupta if (!status && encrypt) 5374160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 537517cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 5376160dc6acSVinicius Costa Gomes } 5377160dc6acSVinicius Costa Gomes 53783df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 53790a708f8fSGustavo F. Padovan 53803df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 53816be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 53820a708f8fSGustavo F. Padovan 5383f1cb9af5SVinicius Costa Gomes BT_DBG("chan->scid %d", chan->scid); 5384f1cb9af5SVinicius Costa Gomes 5385f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 5386f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 5387f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 5388cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 5389f1cb9af5SVinicius Costa Gomes } 5390f1cb9af5SVinicius Costa Gomes 53916be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 5392f1cb9af5SVinicius Costa Gomes continue; 5393f1cb9af5SVinicius Costa Gomes } 5394f1cb9af5SVinicius Costa Gomes 5395c1360a1cSGustavo F. Padovan if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 53966be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 53970a708f8fSGustavo F. Padovan continue; 53980a708f8fSGustavo F. Padovan } 53990a708f8fSGustavo F. Padovan 540089bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 540189bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 5402a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 5403a7d7723aSGustavo Padovan 5404c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 5405a7d7723aSGustavo Padovan sk->sk_state_change(sk); 5406a7d7723aSGustavo Padovan 54074343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 54086be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54090a708f8fSGustavo F. Padovan continue; 54100a708f8fSGustavo F. Padovan } 54110a708f8fSGustavo F. Padovan 541289bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 54130a708f8fSGustavo F. Padovan if (!status) { 54149b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 54150a708f8fSGustavo F. Padovan } else { 5416ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 54170a708f8fSGustavo F. Padovan } 541889bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 54196be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 54200a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5421df3c3931SJohan Hedberg __u16 res, stat; 54220a708f8fSGustavo F. Padovan 54236be36555SAndrei Emeltchenko lock_sock(sk); 54246be36555SAndrei Emeltchenko 54250a708f8fSGustavo F. Padovan if (!status) { 5426c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 5427c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 5428df3c3931SJohan Hedberg struct sock *parent = bt_sk(sk)->parent; 5429df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 5430df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 543105e9a2f6SIlia Kolomisnky if (parent) 5432df3c3931SJohan Hedberg parent->sk_data_ready(parent, 0); 5433df3c3931SJohan Hedberg } else { 54340e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 5435df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 5436df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 5437df3c3931SJohan Hedberg } 54380a708f8fSGustavo F. Padovan } else { 54390e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 5440ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 5441df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 5442df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 54430a708f8fSGustavo F. Padovan } 54440a708f8fSGustavo F. Padovan 54456be36555SAndrei Emeltchenko release_sock(sk); 54466be36555SAndrei Emeltchenko 5447fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5448fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5449df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 5450df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 5451fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5452fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 54532d369359SMat Martineau 54542d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 54552d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 54562d369359SMat Martineau char buf[128]; 54572d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 54582d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 54592d369359SMat Martineau L2CAP_CONF_REQ, 54602d369359SMat Martineau l2cap_build_conf_req(chan, buf), 54612d369359SMat Martineau buf); 54622d369359SMat Martineau chan->num_conf_req++; 54632d369359SMat Martineau } 54640a708f8fSGustavo F. Padovan } 54650a708f8fSGustavo F. Padovan 54666be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54670a708f8fSGustavo F. Padovan } 54680a708f8fSGustavo F. Padovan 54693df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 54700a708f8fSGustavo F. Padovan 54710a708f8fSGustavo F. Padovan return 0; 54720a708f8fSGustavo F. Padovan } 54730a708f8fSGustavo F. Padovan 5474686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 54750a708f8fSGustavo F. Padovan { 54760a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 54770a708f8fSGustavo F. Padovan 54780a708f8fSGustavo F. Padovan if (!conn) 54790a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 54800a708f8fSGustavo F. Padovan 54810a708f8fSGustavo F. Padovan if (!conn) 54820a708f8fSGustavo F. Padovan goto drop; 54830a708f8fSGustavo F. Padovan 54840a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 54850a708f8fSGustavo F. Padovan 54860a708f8fSGustavo F. Padovan if (!(flags & ACL_CONT)) { 54870a708f8fSGustavo F. Padovan struct l2cap_hdr *hdr; 54880a708f8fSGustavo F. Padovan int len; 54890a708f8fSGustavo F. Padovan 54900a708f8fSGustavo F. Padovan if (conn->rx_len) { 54910a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 54920a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 54930a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 54940a708f8fSGustavo F. Padovan conn->rx_len = 0; 54950a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 54960a708f8fSGustavo F. Padovan } 54970a708f8fSGustavo F. Padovan 54980a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 54990a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 55000a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 55010a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55020a708f8fSGustavo F. Padovan goto drop; 55030a708f8fSGustavo F. Padovan } 55040a708f8fSGustavo F. Padovan 55050a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 55060a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 55070a708f8fSGustavo F. Padovan 55080a708f8fSGustavo F. Padovan if (len == skb->len) { 55090a708f8fSGustavo F. Padovan /* Complete frame received */ 55100a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 55110a708f8fSGustavo F. Padovan return 0; 55120a708f8fSGustavo F. Padovan } 55130a708f8fSGustavo F. Padovan 55140a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 55150a708f8fSGustavo F. Padovan 55160a708f8fSGustavo F. Padovan if (skb->len > len) { 55170a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 55180a708f8fSGustavo F. Padovan skb->len, len); 55190a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55200a708f8fSGustavo F. Padovan goto drop; 55210a708f8fSGustavo F. Padovan } 55220a708f8fSGustavo F. Padovan 55230a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 55240a708f8fSGustavo F. Padovan conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC); 55250a708f8fSGustavo F. Padovan if (!conn->rx_skb) 55260a708f8fSGustavo F. Padovan goto drop; 55270a708f8fSGustavo F. Padovan 55280a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55290a708f8fSGustavo F. Padovan skb->len); 55300a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 55310a708f8fSGustavo F. Padovan } else { 55320a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 55330a708f8fSGustavo F. Padovan 55340a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55350a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 55360a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55370a708f8fSGustavo F. Padovan goto drop; 55380a708f8fSGustavo F. Padovan } 55390a708f8fSGustavo F. Padovan 55400a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 55410a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 55420a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 55430a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 55440a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55450a708f8fSGustavo F. Padovan conn->rx_len = 0; 55460a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55470a708f8fSGustavo F. Padovan goto drop; 55480a708f8fSGustavo F. Padovan } 55490a708f8fSGustavo F. Padovan 55500a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55510a708f8fSGustavo F. Padovan skb->len); 55520a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 55530a708f8fSGustavo F. Padovan 55540a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55550a708f8fSGustavo F. Padovan /* Complete frame received */ 55560a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 55570a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55580a708f8fSGustavo F. Padovan } 55590a708f8fSGustavo F. Padovan } 55600a708f8fSGustavo F. Padovan 55610a708f8fSGustavo F. Padovan drop: 55620a708f8fSGustavo F. Padovan kfree_skb(skb); 55630a708f8fSGustavo F. Padovan return 0; 55640a708f8fSGustavo F. Padovan } 55650a708f8fSGustavo F. Padovan 55660a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 55670a708f8fSGustavo F. Padovan { 556823691d75SGustavo F. Padovan struct l2cap_chan *c; 55690a708f8fSGustavo F. Padovan 5570333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 55710a708f8fSGustavo F. Padovan 557223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 557323691d75SGustavo F. Padovan struct sock *sk = c->sk; 55740a708f8fSGustavo F. Padovan 5575903d343eSGustavo F. Padovan seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 55760a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->src), 55770a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->dst), 557889bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 557923691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 558023691d75SGustavo F. Padovan c->sec_level, c->mode); 55810a708f8fSGustavo F. Padovan } 55820a708f8fSGustavo F. Padovan 5583333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 55840a708f8fSGustavo F. Padovan 55850a708f8fSGustavo F. Padovan return 0; 55860a708f8fSGustavo F. Padovan } 55870a708f8fSGustavo F. Padovan 55880a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 55890a708f8fSGustavo F. Padovan { 55900a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 55910a708f8fSGustavo F. Padovan } 55920a708f8fSGustavo F. Padovan 55930a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 55940a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 55950a708f8fSGustavo F. Padovan .read = seq_read, 55960a708f8fSGustavo F. Padovan .llseek = seq_lseek, 55970a708f8fSGustavo F. Padovan .release = single_release, 55980a708f8fSGustavo F. Padovan }; 55990a708f8fSGustavo F. Padovan 56000a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 56010a708f8fSGustavo F. Padovan 560264274518SGustavo F. Padovan int __init l2cap_init(void) 56030a708f8fSGustavo F. Padovan { 56040a708f8fSGustavo F. Padovan int err; 56050a708f8fSGustavo F. Padovan 5606bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 56070a708f8fSGustavo F. Padovan if (err < 0) 56080a708f8fSGustavo F. Padovan return err; 56090a708f8fSGustavo F. Padovan 56100a708f8fSGustavo F. Padovan if (bt_debugfs) { 56110a708f8fSGustavo F. Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, 56120a708f8fSGustavo F. Padovan bt_debugfs, NULL, &l2cap_debugfs_fops); 56130a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 56140a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 56150a708f8fSGustavo F. Padovan } 56160a708f8fSGustavo F. Padovan 56170a708f8fSGustavo F. Padovan return 0; 56180a708f8fSGustavo F. Padovan } 56190a708f8fSGustavo F. Padovan 562064274518SGustavo F. Padovan void l2cap_exit(void) 56210a708f8fSGustavo F. Padovan { 56220a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 5623bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 56240a708f8fSGustavo F. Padovan } 56250a708f8fSGustavo F. Padovan 56260a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 56270a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 5628