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; 434c20f8e35SMat Martineau chan->ack_win = L2CAP_DEFAULT_TX_WINDOW; 435bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 436bd4b1653SAndrei Emeltchenko 437bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 438bd4b1653SAndrei Emeltchenko } 439bd4b1653SAndrei Emeltchenko 44014a28491SAndrei Emeltchenko static void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4410a708f8fSGustavo F. Padovan { 4420a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 443097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4440a708f8fSGustavo F. Padovan 4459f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 4460a708f8fSGustavo F. Padovan 4478c1d787bSGustavo F. Padovan chan->conn = conn; 4480a708f8fSGustavo F. Padovan 4495491120eSAndrei Emeltchenko switch (chan->chan_type) { 4505491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 451b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 452b62f328bSVille Tervo /* LE connection */ 4536fcb06a2SAndre Guedes chan->omtu = L2CAP_DEFAULT_MTU; 454fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 455fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 456b62f328bSVille Tervo } else { 4570a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 458fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 4590c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 460b62f328bSVille Tervo } 4615491120eSAndrei Emeltchenko break; 4625491120eSAndrei Emeltchenko 4635491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 4640a708f8fSGustavo F. Padovan /* Connectionless socket */ 465fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 466fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 4670c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4685491120eSAndrei Emeltchenko break; 4695491120eSAndrei Emeltchenko 470416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 471416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 472416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 473416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 474416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 475416fa752SAndrei Emeltchenko break; 476416fa752SAndrei Emeltchenko 4775491120eSAndrei Emeltchenko default: 4780a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 479fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 480fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 4810c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4820a708f8fSGustavo F. Padovan } 4830a708f8fSGustavo F. Padovan 4848f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 4858f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 4868f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 4878f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 4888f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 4898f7975b1SAndrei Emeltchenko chan->local_flush_to = L2CAP_DEFAULT_FLUSH_TO; 4908f7975b1SAndrei Emeltchenko 491371fd835SUlisses Furquim l2cap_chan_hold(chan); 492baa7e1faSGustavo F. Padovan 4933df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 494643162a8SAndrei Emeltchenko } 495643162a8SAndrei Emeltchenko 496466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 497643162a8SAndrei Emeltchenko { 498643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 499643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 5003df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5010a708f8fSGustavo F. Padovan } 5020a708f8fSGustavo F. Padovan 503466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5040a708f8fSGustavo F. Padovan { 5058c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5060a708f8fSGustavo F. Padovan 507c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5080a708f8fSGustavo F. Padovan 50949208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5100a708f8fSGustavo F. Padovan 5110a708f8fSGustavo F. Padovan if (conn) { 512baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5133df91ea2SAndrei Emeltchenko list_del(&chan->list); 5143d57dc68SGustavo F. Padovan 515371fd835SUlisses Furquim l2cap_chan_put(chan); 516baa7e1faSGustavo F. Padovan 5178c1d787bSGustavo F. Padovan chan->conn = NULL; 5183cabbfdaSAndrei Emeltchenko 5193cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 5200a708f8fSGustavo F. Padovan hci_conn_put(conn->hcon); 5210a708f8fSGustavo F. Padovan } 5220a708f8fSGustavo F. Padovan 523c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 524c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5256be36555SAndrei Emeltchenko 5262827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5276ff5abbfSGustavo F. Padovan return; 5282ead70b8SGustavo F. Padovan 529ee556f66SGustavo Padovan switch(chan->mode) { 530ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 531ee556f66SGustavo Padovan break; 5320a708f8fSGustavo F. Padovan 533ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5341a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5351a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5361a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 5370a708f8fSGustavo F. Padovan 538f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 5390a708f8fSGustavo F. Padovan 5403c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 5413c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 542ee556f66SGustavo Padovan 543ee556f66SGustavo Padovan /* fall through */ 544ee556f66SGustavo Padovan 545ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 546ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 547ee556f66SGustavo Padovan break; 5480a708f8fSGustavo F. Padovan } 549ee556f66SGustavo Padovan 550ee556f66SGustavo Padovan return; 5510a708f8fSGustavo F. Padovan } 5520a708f8fSGustavo F. Padovan 5530f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 5544519de9aSGustavo F. Padovan { 5554519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5564519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 5574519de9aSGustavo F. Padovan 558e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s sk %p", chan, 559e05dcc32SAndrei Emeltchenko state_to_string(chan->state), sk); 5604519de9aSGustavo F. Padovan 56189bc500eSGustavo F. Padovan switch (chan->state) { 5624519de9aSGustavo F. Padovan case BT_LISTEN: 563c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 564c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 5654519de9aSGustavo F. Padovan break; 5664519de9aSGustavo F. Padovan 5674519de9aSGustavo F. Padovan case BT_CONNECTED: 5684519de9aSGustavo F. Padovan case BT_CONFIG: 569715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5704519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 571c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 5724519de9aSGustavo F. Padovan l2cap_send_disconn_req(conn, chan, reason); 5734519de9aSGustavo F. Padovan } else 5744519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5754519de9aSGustavo F. Padovan break; 5764519de9aSGustavo F. Padovan 5774519de9aSGustavo F. Padovan case BT_CONNECT2: 578715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5794519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 5804519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5814519de9aSGustavo F. Padovan __u16 result; 5824519de9aSGustavo F. Padovan 583c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 5844519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 5854519de9aSGustavo F. Padovan else 5864519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 58789bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 5884519de9aSGustavo F. Padovan 5894519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5904519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5914519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 592ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 5934519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5944519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 5954519de9aSGustavo F. Padovan } 5964519de9aSGustavo F. Padovan 5974519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5984519de9aSGustavo F. Padovan break; 5994519de9aSGustavo F. Padovan 6004519de9aSGustavo F. Padovan case BT_CONNECT: 6014519de9aSGustavo F. Padovan case BT_DISCONN: 6024519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6034519de9aSGustavo F. Padovan break; 6044519de9aSGustavo F. Padovan 6054519de9aSGustavo F. Padovan default: 606c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 607c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6084519de9aSGustavo F. Padovan break; 6094519de9aSGustavo F. Padovan } 6104519de9aSGustavo F. Padovan } 6114519de9aSGustavo F. Padovan 6124343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6130a708f8fSGustavo F. Padovan { 614715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6154343478fSGustavo F. Padovan switch (chan->sec_level) { 6160a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6170a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6180a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6190a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6200a708f8fSGustavo F. Padovan default: 6210a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6220a708f8fSGustavo F. Padovan } 6232983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6244343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6254343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6260a708f8fSGustavo F. Padovan 6274343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6280a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6290a708f8fSGustavo F. Padovan else 6300a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6310a708f8fSGustavo F. Padovan } else { 6324343478fSGustavo F. Padovan switch (chan->sec_level) { 6330a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6340a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6350a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6360a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6370a708f8fSGustavo F. Padovan default: 6380a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6390a708f8fSGustavo F. Padovan } 6400a708f8fSGustavo F. Padovan } 6410a708f8fSGustavo F. Padovan } 6420a708f8fSGustavo F. Padovan 6430a708f8fSGustavo F. Padovan /* Service level security */ 644d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 6450a708f8fSGustavo F. Padovan { 6468c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6470a708f8fSGustavo F. Padovan __u8 auth_type; 6480a708f8fSGustavo F. Padovan 6494343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 6500a708f8fSGustavo F. Padovan 6514343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 6520a708f8fSGustavo F. Padovan } 6530a708f8fSGustavo F. Padovan 654b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 6550a708f8fSGustavo F. Padovan { 6560a708f8fSGustavo F. Padovan u8 id; 6570a708f8fSGustavo F. Padovan 6580a708f8fSGustavo F. Padovan /* Get next available identificator. 6590a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 6600a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 6610a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 6620a708f8fSGustavo F. Padovan */ 6630a708f8fSGustavo F. Padovan 664333055f2SGustavo F. Padovan spin_lock(&conn->lock); 6650a708f8fSGustavo F. Padovan 6660a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 6670a708f8fSGustavo F. Padovan conn->tx_ident = 1; 6680a708f8fSGustavo F. Padovan 6690a708f8fSGustavo F. Padovan id = conn->tx_ident; 6700a708f8fSGustavo F. Padovan 671333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 6720a708f8fSGustavo F. Padovan 6730a708f8fSGustavo F. Padovan return id; 6740a708f8fSGustavo F. Padovan } 6750a708f8fSGustavo F. Padovan 6764519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data) 6770a708f8fSGustavo F. Padovan { 6780a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 6790a708f8fSGustavo F. Padovan u8 flags; 6800a708f8fSGustavo F. Padovan 6810a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 6820a708f8fSGustavo F. Padovan 6830a708f8fSGustavo F. Padovan if (!skb) 6840a708f8fSGustavo F. Padovan return; 6850a708f8fSGustavo F. Padovan 6860a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 6870a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 6880a708f8fSGustavo F. Padovan else 6890a708f8fSGustavo F. Padovan flags = ACL_START; 6900a708f8fSGustavo F. Padovan 69114b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 6925e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 69314b12d0bSJaikumar Ganesh 69473d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 6950a708f8fSGustavo F. Padovan } 6960a708f8fSGustavo F. Padovan 69773d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 69873d80debSLuiz Augusto von Dentz { 69973d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 70073d80debSLuiz Augusto von Dentz u16 flags; 70173d80debSLuiz Augusto von Dentz 70273d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 70373d80debSLuiz Augusto von Dentz skb->priority); 70473d80debSLuiz Augusto von Dentz 70573d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 70673d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 70773d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 70873d80debSLuiz Augusto von Dentz else 70973d80debSLuiz Augusto von Dentz flags = ACL_START; 71073d80debSLuiz Augusto von Dentz 71173d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 71273d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7130a708f8fSGustavo F. Padovan } 7140a708f8fSGustavo F. Padovan 715b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 716b5c6aaedSMat Martineau { 717b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 718b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 719b5c6aaedSMat Martineau 720b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 721b5c6aaedSMat Martineau /* S-Frame */ 722b5c6aaedSMat Martineau control->sframe = 1; 723b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 724b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 725b5c6aaedSMat Martineau 726b5c6aaedSMat Martineau control->sar = 0; 727b5c6aaedSMat Martineau control->txseq = 0; 728b5c6aaedSMat Martineau } else { 729b5c6aaedSMat Martineau /* I-Frame */ 730b5c6aaedSMat Martineau control->sframe = 0; 731b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 732b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 733b5c6aaedSMat Martineau 734b5c6aaedSMat Martineau control->poll = 0; 735b5c6aaedSMat Martineau control->super = 0; 736b5c6aaedSMat Martineau } 737b5c6aaedSMat Martineau } 738b5c6aaedSMat Martineau 739b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 740b5c6aaedSMat Martineau { 741b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 742b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 743b5c6aaedSMat Martineau 744b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 745b5c6aaedSMat Martineau /* S-Frame */ 746b5c6aaedSMat Martineau control->sframe = 1; 747b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 748b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 749b5c6aaedSMat Martineau 750b5c6aaedSMat Martineau control->sar = 0; 751b5c6aaedSMat Martineau control->txseq = 0; 752b5c6aaedSMat Martineau } else { 753b5c6aaedSMat Martineau /* I-Frame */ 754b5c6aaedSMat Martineau control->sframe = 0; 755b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 756b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 757b5c6aaedSMat Martineau 758b5c6aaedSMat Martineau control->poll = 0; 759b5c6aaedSMat Martineau control->super = 0; 760b5c6aaedSMat Martineau } 761b5c6aaedSMat Martineau } 762b5c6aaedSMat Martineau 763b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 764b5c6aaedSMat Martineau struct sk_buff *skb) 765b5c6aaedSMat Martineau { 766b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 767b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 768b5c6aaedSMat Martineau &bt_cb(skb)->control); 769cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 770b5c6aaedSMat Martineau } else { 771b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 772b5c6aaedSMat Martineau &bt_cb(skb)->control); 773cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 774b5c6aaedSMat Martineau } 775b5c6aaedSMat Martineau } 776b5c6aaedSMat Martineau 777b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 778b5c6aaedSMat Martineau { 779b5c6aaedSMat Martineau u32 packed; 780b5c6aaedSMat Martineau 781b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 782b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 783b5c6aaedSMat Martineau 784b5c6aaedSMat Martineau if (control->sframe) { 785b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 786b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 787b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 788b5c6aaedSMat Martineau } else { 789b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 790b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 791b5c6aaedSMat Martineau } 792b5c6aaedSMat Martineau 793b5c6aaedSMat Martineau return packed; 794b5c6aaedSMat Martineau } 795b5c6aaedSMat Martineau 796b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 797b5c6aaedSMat Martineau { 798b5c6aaedSMat Martineau u16 packed; 799b5c6aaedSMat Martineau 800b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 801b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 802b5c6aaedSMat Martineau 803b5c6aaedSMat Martineau if (control->sframe) { 804b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 805b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 806b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 807b5c6aaedSMat Martineau } else { 808b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 809b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 810b5c6aaedSMat Martineau } 811b5c6aaedSMat Martineau 812b5c6aaedSMat Martineau return packed; 813b5c6aaedSMat Martineau } 814b5c6aaedSMat Martineau 815b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 816b5c6aaedSMat Martineau struct l2cap_ctrl *control, 817b5c6aaedSMat Martineau struct sk_buff *skb) 818b5c6aaedSMat Martineau { 819b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 820b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 821b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 822b5c6aaedSMat Martineau } else { 823b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 824b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 825b5c6aaedSMat Martineau } 826b5c6aaedSMat Martineau } 827b5c6aaedSMat Martineau 828ba7aa64fSGustavo Padovan static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan) 829ba7aa64fSGustavo Padovan { 830ba7aa64fSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 831ba7aa64fSGustavo Padovan return L2CAP_EXT_HDR_SIZE; 832ba7aa64fSGustavo Padovan else 833ba7aa64fSGustavo Padovan return L2CAP_ENH_HDR_SIZE; 834ba7aa64fSGustavo Padovan } 835ba7aa64fSGustavo Padovan 836a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 837a67d7f6fSMat Martineau u32 control) 8380a708f8fSGustavo F. Padovan { 8390a708f8fSGustavo F. Padovan struct sk_buff *skb; 8400a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 841ba7aa64fSGustavo Padovan int hlen = __ertm_hdr_size(chan); 8420a708f8fSGustavo F. Padovan 8430a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 84403a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 8450a708f8fSGustavo F. Padovan 846a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 8470a708f8fSGustavo F. Padovan 8480a708f8fSGustavo F. Padovan if (!skb) 849a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 8500a708f8fSGustavo F. Padovan 8510a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 8520a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 853fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 85488843ab0SAndrei Emeltchenko 855a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 856a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 857a67d7f6fSMat Martineau else 858a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 8590a708f8fSGustavo F. Padovan 86047d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 861a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 86203a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 8630a708f8fSGustavo F. Padovan } 8640a708f8fSGustavo F. Padovan 86573d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 866a67d7f6fSMat Martineau return skb; 867a67d7f6fSMat Martineau } 868a67d7f6fSMat Martineau 869a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 870a67d7f6fSMat Martineau struct l2cap_ctrl *control) 871a67d7f6fSMat Martineau { 872a67d7f6fSMat Martineau struct sk_buff *skb; 873a67d7f6fSMat Martineau u32 control_field; 874a67d7f6fSMat Martineau 875a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 876a67d7f6fSMat Martineau 877a67d7f6fSMat Martineau if (!control->sframe) 878a67d7f6fSMat Martineau return; 879a67d7f6fSMat Martineau 880a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 881a67d7f6fSMat Martineau !control->poll) 882a67d7f6fSMat Martineau control->final = 1; 883a67d7f6fSMat Martineau 884a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 885a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 886a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 887a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 888a67d7f6fSMat Martineau 889a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 890a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 891a67d7f6fSMat Martineau __clear_ack_timer(chan); 892a67d7f6fSMat Martineau } 893a67d7f6fSMat Martineau 894a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 895a67d7f6fSMat Martineau control->final, control->poll, control->super); 896a67d7f6fSMat Martineau 897a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 898a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 899a67d7f6fSMat Martineau else 900a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 901a67d7f6fSMat Martineau 902a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 903a67d7f6fSMat Martineau if (!IS_ERR(skb)) 90473d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9050a708f8fSGustavo F. Padovan } 9060a708f8fSGustavo F. Padovan 907c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9080a708f8fSGustavo F. Padovan { 909c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9100a708f8fSGustavo F. Padovan 911c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 912c9e3d5e0SMat Martineau 913c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 914c9e3d5e0SMat Martineau control.sframe = 1; 915c9e3d5e0SMat Martineau control.poll = poll; 916c9e3d5e0SMat Martineau 917c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 918c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 919c9e3d5e0SMat Martineau else 920c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 921c9e3d5e0SMat Martineau 922c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 923c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 9240a708f8fSGustavo F. Padovan } 9250a708f8fSGustavo F. Padovan 926b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 9270a708f8fSGustavo F. Padovan { 928c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 9290a708f8fSGustavo F. Padovan } 9300a708f8fSGustavo F. Padovan 9319b27f350SAndrei Emeltchenko static void l2cap_send_conn_req(struct l2cap_chan *chan) 9329b27f350SAndrei Emeltchenko { 9339b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 9349b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 9359b27f350SAndrei Emeltchenko 9369b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 9379b27f350SAndrei Emeltchenko req.psm = chan->psm; 9389b27f350SAndrei Emeltchenko 9399b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 9409b27f350SAndrei Emeltchenko 9419b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 9429b27f350SAndrei Emeltchenko 9439b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 9449b27f350SAndrei Emeltchenko } 9459b27f350SAndrei Emeltchenko 9469f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 9479f0caeb1SVinicius Costa Gomes { 9482827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 9499f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 9509f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 9519f0caeb1SVinicius Costa Gomes 95254a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 9539f0caeb1SVinicius Costa Gomes 95454a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 9559f0caeb1SVinicius Costa Gomes } 9569f0caeb1SVinicius Costa Gomes 957fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 9580a708f8fSGustavo F. Padovan { 9598c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 9600a708f8fSGustavo F. Padovan 9619f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 9629f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 9639f0caeb1SVinicius Costa Gomes return; 9649f0caeb1SVinicius Costa Gomes } 9659f0caeb1SVinicius Costa Gomes 9660a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 9670a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 9680a708f8fSGustavo F. Padovan return; 9690a708f8fSGustavo F. Padovan 970d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 9719b27f350SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) 9729b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 9730a708f8fSGustavo F. Padovan } else { 9740a708f8fSGustavo F. Padovan struct l2cap_info_req req; 975ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 9760a708f8fSGustavo F. Padovan 9770a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 9780a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 9790a708f8fSGustavo F. Padovan 980ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 9810a708f8fSGustavo F. Padovan 9820a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 9830a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 9840a708f8fSGustavo F. Padovan } 9850a708f8fSGustavo F. Padovan } 9860a708f8fSGustavo F. Padovan 9870a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 9880a708f8fSGustavo F. Padovan { 9890a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 9900a708f8fSGustavo F. Padovan if (!disable_ertm) 9910a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 9920a708f8fSGustavo F. Padovan 9930a708f8fSGustavo F. Padovan switch (mode) { 9940a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 9950a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 9960a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 9970a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 9980a708f8fSGustavo F. Padovan default: 9990a708f8fSGustavo F. Padovan return 0x00; 10000a708f8fSGustavo F. Padovan } 10010a708f8fSGustavo F. Padovan } 10020a708f8fSGustavo F. Padovan 10034519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err) 10040a708f8fSGustavo F. Padovan { 10056be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 10060a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 10070a708f8fSGustavo F. Padovan 10080a708f8fSGustavo F. Padovan if (!conn) 10090a708f8fSGustavo F. Padovan return; 10100a708f8fSGustavo F. Padovan 10110c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_ERTM) { 10121a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 10131a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 10141a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 10150a708f8fSGustavo F. Padovan } 10160a708f8fSGustavo F. Padovan 1017416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1018416fa752SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 1019416fa752SAndrei Emeltchenko return; 1020416fa752SAndrei Emeltchenko } 1021416fa752SAndrei Emeltchenko 1022fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1023fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 10240a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 10250a708f8fSGustavo F. Padovan L2CAP_DISCONN_REQ, sizeof(req), &req); 10260a708f8fSGustavo F. Padovan 10276be36555SAndrei Emeltchenko lock_sock(sk); 10280e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 10292e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 10306be36555SAndrei Emeltchenko release_sock(sk); 10310a708f8fSGustavo F. Padovan } 10320a708f8fSGustavo F. Padovan 10330a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 10340a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 10350a708f8fSGustavo F. Padovan { 10363df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 10370a708f8fSGustavo F. Padovan 10380a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 10390a708f8fSGustavo F. Padovan 10403df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 10410a708f8fSGustavo F. Padovan 10423df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 104348454079SGustavo F. Padovan struct sock *sk = chan->sk; 1044baa7e1faSGustavo F. Padovan 10456be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 10460a708f8fSGustavo F. Padovan 1047715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 10486be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10490a708f8fSGustavo F. Padovan continue; 10500a708f8fSGustavo F. Padovan } 10510a708f8fSGustavo F. Padovan 105289bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1053d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1054b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 10556be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10560a708f8fSGustavo F. Padovan continue; 10570a708f8fSGustavo F. Padovan } 10580a708f8fSGustavo F. Padovan 1059c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1060c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1061c1360a1cSGustavo F. Padovan &chan->conf_state)) { 10620f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 10636be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10640a708f8fSGustavo F. Padovan continue; 10650a708f8fSGustavo F. Padovan } 10660a708f8fSGustavo F. Padovan 10679b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 10680a708f8fSGustavo F. Padovan 106989bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 10700a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 10710a708f8fSGustavo F. Padovan char buf[128]; 1072fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1073fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 10740a708f8fSGustavo F. Padovan 1075d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 10766be36555SAndrei Emeltchenko lock_sock(sk); 1077c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1078c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 10790a708f8fSGustavo F. Padovan struct sock *parent = bt_sk(sk)->parent; 1080ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1081ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 108205e9a2f6SIlia Kolomisnky if (parent) 10830a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 10840a708f8fSGustavo F. Padovan 10850a708f8fSGustavo F. Padovan } else { 10860e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1087ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1088ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 10890a708f8fSGustavo F. Padovan } 10906be36555SAndrei Emeltchenko release_sock(sk); 10910a708f8fSGustavo F. Padovan } else { 1092ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1093ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 10940a708f8fSGustavo F. Padovan } 10950a708f8fSGustavo F. Padovan 1096fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1097fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 10980a708f8fSGustavo F. Padovan 1099c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 11000a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 11016be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11020a708f8fSGustavo F. Padovan continue; 11030a708f8fSGustavo F. Padovan } 11040a708f8fSGustavo F. Padovan 1105c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 11060a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 110773ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 110873ffa904SGustavo F. Padovan chan->num_conf_req++; 11090a708f8fSGustavo F. Padovan } 11100a708f8fSGustavo F. Padovan 11116be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11120a708f8fSGustavo F. Padovan } 11130a708f8fSGustavo F. Padovan 11143df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 11150a708f8fSGustavo F. Padovan } 11160a708f8fSGustavo F. Padovan 1117c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1118b62f328bSVille Tervo * Returns closest match, locked. 1119b62f328bSVille Tervo */ 1120d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1121c2287681SIdo Yariv bdaddr_t *src, 1122c2287681SIdo Yariv bdaddr_t *dst) 1123b62f328bSVille Tervo { 112423691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1125b62f328bSVille Tervo 112623691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1127b62f328bSVille Tervo 112823691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 112923691d75SGustavo F. Padovan struct sock *sk = c->sk; 1130fe4128e0SGustavo F. Padovan 113189bc500eSGustavo F. Padovan if (state && c->state != state) 1132b62f328bSVille Tervo continue; 1133b62f328bSVille Tervo 113423691d75SGustavo F. Padovan if (c->scid == cid) { 1135c2287681SIdo Yariv int src_match, dst_match; 1136c2287681SIdo Yariv int src_any, dst_any; 1137c2287681SIdo Yariv 1138b62f328bSVille Tervo /* Exact match. */ 1139c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1140c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1141c2287681SIdo Yariv if (src_match && dst_match) { 114223691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 114323691d75SGustavo F. Padovan return c; 114423691d75SGustavo F. Padovan } 1145b62f328bSVille Tervo 1146b62f328bSVille Tervo /* Closest match */ 1147c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1148c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1149c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1150c2287681SIdo Yariv (src_any && dst_any)) 115123691d75SGustavo F. Padovan c1 = c; 1152b62f328bSVille Tervo } 1153b62f328bSVille Tervo } 1154280f294fSGustavo F. Padovan 115523691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1156b62f328bSVille Tervo 115723691d75SGustavo F. Padovan return c1; 1158b62f328bSVille Tervo } 1159b62f328bSVille Tervo 1160b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1161b62f328bSVille Tervo { 1162c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 116323691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1164b62f328bSVille Tervo 1165b62f328bSVille Tervo BT_DBG(""); 1166b62f328bSVille Tervo 1167b62f328bSVille Tervo /* Check if we have socket listening on cid */ 116823691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1169c2287681SIdo Yariv conn->src, conn->dst); 117023691d75SGustavo F. Padovan if (!pchan) 1171b62f328bSVille Tervo return; 1172b62f328bSVille Tervo 117323691d75SGustavo F. Padovan parent = pchan->sk; 117423691d75SGustavo F. Padovan 1175aa2ac881SGustavo F. Padovan lock_sock(parent); 117662f3a2cfSGustavo F. Padovan 117780b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 117880808e43SGustavo F. Padovan if (!chan) 1179b62f328bSVille Tervo goto clean; 1180b62f328bSVille Tervo 118180808e43SGustavo F. Padovan sk = chan->sk; 11825d41ce1dSGustavo F. Padovan 1183b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1184a9ea3ed9SSzymon Janc conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT; 1185b62f328bSVille Tervo 1186b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1187b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1188b62f328bSVille Tervo 1189d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 1190d1010240SGustavo F. Padovan 11913d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 119248454079SGustavo F. Padovan 11936754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1194b62f328bSVille Tervo 1195b62f328bSVille Tervo clean: 1196aa2ac881SGustavo F. Padovan release_sock(parent); 1197b62f328bSVille Tervo } 1198b62f328bSVille Tervo 11990a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 12000a708f8fSGustavo F. Padovan { 120148454079SGustavo F. Padovan struct l2cap_chan *chan; 1202cc110922SVinicius Costa Gomes struct hci_conn *hcon = conn->hcon; 12030a708f8fSGustavo F. Padovan 12040a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12050a708f8fSGustavo F. Padovan 1206cc110922SVinicius Costa Gomes if (!hcon->out && hcon->type == LE_LINK) 1207b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1208b62f328bSVille Tervo 1209cc110922SVinicius Costa Gomes if (hcon->out && hcon->type == LE_LINK) 1210cc110922SVinicius Costa Gomes smp_conn_security(hcon, hcon->pending_sec_level); 1211160dc6acSVinicius Costa Gomes 12123df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12130a708f8fSGustavo F. Padovan 12143df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1215baa7e1faSGustavo F. Padovan 12166be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12170a708f8fSGustavo F. Padovan 1218416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1219416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1220416fa752SAndrei Emeltchenko continue; 1221416fa752SAndrei Emeltchenko } 1222416fa752SAndrei Emeltchenko 1223cc110922SVinicius Costa Gomes if (hcon->type == LE_LINK) { 1224cc110922SVinicius Costa Gomes if (smp_conn_security(hcon, chan->sec_level)) 1225cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1226acd7d370SVille Tervo 122763128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12286be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1229c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 12306be36555SAndrei Emeltchenko lock_sock(sk); 12310e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 12320a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 12336be36555SAndrei Emeltchenko release_sock(sk); 1234b501d6a1SAnderson Briglia 123589bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1236fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 12370a708f8fSGustavo F. Padovan 12386be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12390a708f8fSGustavo F. Padovan } 12400a708f8fSGustavo F. Padovan 12413df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12420a708f8fSGustavo F. Padovan } 12430a708f8fSGustavo F. Padovan 12440a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 12450a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 12460a708f8fSGustavo F. Padovan { 124748454079SGustavo F. Padovan struct l2cap_chan *chan; 12480a708f8fSGustavo F. Padovan 12490a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12500a708f8fSGustavo F. Padovan 12513df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12520a708f8fSGustavo F. Padovan 12533df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1254ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 12552e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 12560a708f8fSGustavo F. Padovan } 12570a708f8fSGustavo F. Padovan 12583df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12590a708f8fSGustavo F. Padovan } 12600a708f8fSGustavo F. Padovan 1261f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 12620a708f8fSGustavo F. Padovan { 1263f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1264030013d8SGustavo F. Padovan info_timer.work); 12650a708f8fSGustavo F. Padovan 12660a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 12670a708f8fSGustavo F. Padovan conn->info_ident = 0; 12680a708f8fSGustavo F. Padovan 12690a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 12700a708f8fSGustavo F. Padovan } 12710a708f8fSGustavo F. Padovan 12725d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 12735d3de7dfSVinicius Costa Gomes { 12745d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 12755d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 12765d3de7dfSVinicius Costa Gomes 12775d3de7dfSVinicius Costa Gomes if (!conn) 12785d3de7dfSVinicius Costa Gomes return; 12795d3de7dfSVinicius Costa Gomes 12805d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 12815d3de7dfSVinicius Costa Gomes 12825d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 12835d3de7dfSVinicius Costa Gomes 12843df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12853df91ea2SAndrei Emeltchenko 12865d3de7dfSVinicius Costa Gomes /* Kill channels */ 12875d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 128861d6ef3eSMat Martineau l2cap_chan_hold(chan); 12896be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12906be36555SAndrei Emeltchenko 12915d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 12926be36555SAndrei Emeltchenko 12936be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12946be36555SAndrei Emeltchenko 129580b98027SGustavo Padovan chan->ops->close(chan); 129661d6ef3eSMat Martineau l2cap_chan_put(chan); 12975d3de7dfSVinicius Costa Gomes } 12985d3de7dfSVinicius Costa Gomes 12993df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 13003df91ea2SAndrei Emeltchenko 130173d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 130273d80debSLuiz Augusto von Dentz 13035d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1304127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 13055d3de7dfSVinicius Costa Gomes 130651a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1307127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 13088aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1309d26a2345SVinicius Costa Gomes } 13105d3de7dfSVinicius Costa Gomes 13115d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 13125d3de7dfSVinicius Costa Gomes kfree(conn); 13135d3de7dfSVinicius Costa Gomes } 13145d3de7dfSVinicius Costa Gomes 13156c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 13165d3de7dfSVinicius Costa Gomes { 13176c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 13186c9d42a1SGustavo F. Padovan security_timer.work); 13195d3de7dfSVinicius Costa Gomes 1320d06cc416SJohan Hedberg BT_DBG("conn %p", conn); 1321d06cc416SJohan Hedberg 1322d06cc416SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags)) { 1323d06cc416SJohan Hedberg smp_chan_destroy(conn); 13245d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 13255d3de7dfSVinicius Costa Gomes } 1326d06cc416SJohan Hedberg } 13275d3de7dfSVinicius Costa Gomes 13280a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 13290a708f8fSGustavo F. Padovan { 13300a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 133173d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 13320a708f8fSGustavo F. Padovan 13330a708f8fSGustavo F. Padovan if (conn || status) 13340a708f8fSGustavo F. Padovan return conn; 13350a708f8fSGustavo F. Padovan 133673d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 133773d80debSLuiz Augusto von Dentz if (!hchan) 13380a708f8fSGustavo F. Padovan return NULL; 13390a708f8fSGustavo F. Padovan 134073d80debSLuiz Augusto von Dentz conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC); 134173d80debSLuiz Augusto von Dentz if (!conn) { 134273d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 134373d80debSLuiz Augusto von Dentz return NULL; 134473d80debSLuiz Augusto von Dentz } 134573d80debSLuiz Augusto von Dentz 13460a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 13470a708f8fSGustavo F. Padovan conn->hcon = hcon; 134873d80debSLuiz Augusto von Dentz conn->hchan = hchan; 13490a708f8fSGustavo F. Padovan 135073d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 13510a708f8fSGustavo F. Padovan 1352acd7d370SVille Tervo if (hcon->hdev->le_mtu && hcon->type == LE_LINK) 1353acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1354acd7d370SVille Tervo else 13550a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1356acd7d370SVille Tervo 13570a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 13580a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 13590a708f8fSGustavo F. Padovan 13600a708f8fSGustavo F. Padovan conn->feat_mask = 0; 13610a708f8fSGustavo F. Padovan 13620a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 13633df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1364baa7e1faSGustavo F. Padovan 1365baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 13660a708f8fSGustavo F. Padovan 13675d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 13686c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 13695d3de7dfSVinicius Costa Gomes else 1370030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 13710a708f8fSGustavo F. Padovan 13729f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 13730a708f8fSGustavo F. Padovan 13740a708f8fSGustavo F. Padovan return conn; 13750a708f8fSGustavo F. Padovan } 13760a708f8fSGustavo F. Padovan 13770a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 13780a708f8fSGustavo F. Padovan 1379c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 13800a708f8fSGustavo F. Padovan * Returns closest match. 13810a708f8fSGustavo F. Padovan */ 1382c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1383c2287681SIdo Yariv bdaddr_t *src, 1384c2287681SIdo Yariv bdaddr_t *dst) 13850a708f8fSGustavo F. Padovan { 138623691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 13870a708f8fSGustavo F. Padovan 138823691d75SGustavo F. Padovan read_lock(&chan_list_lock); 13890a708f8fSGustavo F. Padovan 139023691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 139123691d75SGustavo F. Padovan struct sock *sk = c->sk; 1392fe4128e0SGustavo F. Padovan 139389bc500eSGustavo F. Padovan if (state && c->state != state) 13940a708f8fSGustavo F. Padovan continue; 13950a708f8fSGustavo F. Padovan 139623691d75SGustavo F. Padovan if (c->psm == psm) { 1397c2287681SIdo Yariv int src_match, dst_match; 1398c2287681SIdo Yariv int src_any, dst_any; 1399c2287681SIdo Yariv 14000a708f8fSGustavo F. Padovan /* Exact match. */ 1401c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1402c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1403c2287681SIdo Yariv if (src_match && dst_match) { 1404a7567b20SJohannes Berg read_unlock(&chan_list_lock); 140523691d75SGustavo F. Padovan return c; 140623691d75SGustavo F. Padovan } 14070a708f8fSGustavo F. Padovan 14080a708f8fSGustavo F. Padovan /* Closest match */ 1409c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1410c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1411c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1412c2287681SIdo Yariv (src_any && dst_any)) 141323691d75SGustavo F. Padovan c1 = c; 14140a708f8fSGustavo F. Padovan } 14150a708f8fSGustavo F. Padovan } 14160a708f8fSGustavo F. Padovan 141723691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 14180a708f8fSGustavo F. Padovan 141923691d75SGustavo F. Padovan return c1; 14200a708f8fSGustavo F. Padovan } 14210a708f8fSGustavo F. Padovan 14228e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 14238e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 14240a708f8fSGustavo F. Padovan { 14255d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 14260a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 14270a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 14280a708f8fSGustavo F. Padovan struct hci_conn *hcon; 14290a708f8fSGustavo F. Padovan struct hci_dev *hdev; 14300a708f8fSGustavo F. Padovan __u8 auth_type; 14310a708f8fSGustavo F. Padovan int err; 14320a708f8fSGustavo F. Padovan 14338e9f9892SAndre Guedes BT_DBG("%s -> %s (type %u) psm 0x%2.2x", batostr(src), batostr(dst), 14348e9f9892SAndre Guedes dst_type, __le16_to_cpu(chan->psm)); 14350a708f8fSGustavo F. Padovan 14360a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 14370a708f8fSGustavo F. Padovan if (!hdev) 14380a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 14390a708f8fSGustavo F. Padovan 144009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14410a708f8fSGustavo F. Padovan 14426be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 144303a00194SGustavo F. Padovan 144403a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 144503a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 144603a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 144703a00194SGustavo F. Padovan err = -EINVAL; 144803a00194SGustavo F. Padovan goto done; 144903a00194SGustavo F. Padovan } 145003a00194SGustavo F. Padovan 145103a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 145203a00194SGustavo F. Padovan err = -EINVAL; 145303a00194SGustavo F. Padovan goto done; 145403a00194SGustavo F. Padovan } 145503a00194SGustavo F. Padovan 145603a00194SGustavo F. Padovan switch (chan->mode) { 145703a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 145803a00194SGustavo F. Padovan break; 145903a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 146003a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 146103a00194SGustavo F. Padovan if (!disable_ertm) 146203a00194SGustavo F. Padovan break; 146303a00194SGustavo F. Padovan /* fall through */ 146403a00194SGustavo F. Padovan default: 146503a00194SGustavo F. Padovan err = -ENOTSUPP; 146603a00194SGustavo F. Padovan goto done; 146703a00194SGustavo F. Padovan } 146803a00194SGustavo F. Padovan 14690797e01dSGustavo Padovan switch (chan->state) { 147003a00194SGustavo F. Padovan case BT_CONNECT: 147103a00194SGustavo F. Padovan case BT_CONNECT2: 147203a00194SGustavo F. Padovan case BT_CONFIG: 147303a00194SGustavo F. Padovan /* Already connecting */ 147403a00194SGustavo F. Padovan err = 0; 147503a00194SGustavo F. Padovan goto done; 147603a00194SGustavo F. Padovan 147703a00194SGustavo F. Padovan case BT_CONNECTED: 147803a00194SGustavo F. Padovan /* Already connected */ 147903a00194SGustavo F. Padovan err = -EISCONN; 148003a00194SGustavo F. Padovan goto done; 148103a00194SGustavo F. Padovan 148203a00194SGustavo F. Padovan case BT_OPEN: 148303a00194SGustavo F. Padovan case BT_BOUND: 148403a00194SGustavo F. Padovan /* Can connect */ 148503a00194SGustavo F. Padovan break; 148603a00194SGustavo F. Padovan 148703a00194SGustavo F. Padovan default: 148803a00194SGustavo F. Padovan err = -EBADFD; 148903a00194SGustavo F. Padovan goto done; 149003a00194SGustavo F. Padovan } 149103a00194SGustavo F. Padovan 149203a00194SGustavo F. Padovan /* Set destination address and psm */ 14930797e01dSGustavo Padovan lock_sock(sk); 14949219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 14956be36555SAndrei Emeltchenko release_sock(sk); 14966be36555SAndrei Emeltchenko 149703a00194SGustavo F. Padovan chan->psm = psm; 149803a00194SGustavo F. Padovan chan->dcid = cid; 14990a708f8fSGustavo F. Padovan 15004343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 15010a708f8fSGustavo F. Padovan 1502fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 15038e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 15044343478fSGustavo F. Padovan chan->sec_level, auth_type); 1505acd7d370SVille Tervo else 15068e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 15074343478fSGustavo F. Padovan chan->sec_level, auth_type); 1508acd7d370SVille Tervo 150930e76272SVille Tervo if (IS_ERR(hcon)) { 151030e76272SVille Tervo err = PTR_ERR(hcon); 15110a708f8fSGustavo F. Padovan goto done; 151230e76272SVille Tervo } 15130a708f8fSGustavo F. Padovan 15140a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 15150a708f8fSGustavo F. Padovan if (!conn) { 15160a708f8fSGustavo F. Padovan hci_conn_put(hcon); 151730e76272SVille Tervo err = -ENOMEM; 15180a708f8fSGustavo F. Padovan goto done; 15190a708f8fSGustavo F. Padovan } 15200a708f8fSGustavo F. Padovan 15219f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 15229f0caeb1SVinicius Costa Gomes err = 0; 15239f0caeb1SVinicius Costa Gomes 15249f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 15259f0caeb1SVinicius Costa Gomes err = -EBUSY; 15269f0caeb1SVinicius Costa Gomes hci_conn_put(hcon); 15279f0caeb1SVinicius Costa Gomes } 15289f0caeb1SVinicius Costa Gomes 15299f0caeb1SVinicius Costa Gomes if (err) 15309f0caeb1SVinicius Costa Gomes goto done; 15319f0caeb1SVinicius Costa Gomes } 15329f0caeb1SVinicius Costa Gomes 15330a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 15340a708f8fSGustavo F. Padovan bacpy(src, conn->src); 15350a708f8fSGustavo F. Padovan 15366be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 153748454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 15386be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 153948454079SGustavo F. Padovan 15406be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1541c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 15420a708f8fSGustavo F. Padovan 15430a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1544715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1545c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1546d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 15476be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 15480a708f8fSGustavo F. Padovan } else 1549fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 15500a708f8fSGustavo F. Padovan } 15510a708f8fSGustavo F. Padovan 155230e76272SVille Tervo err = 0; 155330e76272SVille Tervo 15540a708f8fSGustavo F. Padovan done: 15556be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 155609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15570a708f8fSGustavo F. Padovan hci_dev_put(hdev); 15580a708f8fSGustavo F. Padovan return err; 15590a708f8fSGustavo F. Padovan } 15600a708f8fSGustavo F. Padovan 1561dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 15620a708f8fSGustavo F. Padovan { 15638c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 15640a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 15650a708f8fSGustavo F. Padovan int err = 0; 15660a708f8fSGustavo F. Padovan int timeo = HZ/5; 15670a708f8fSGustavo F. Padovan 15680a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 15690a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1570a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 15710a708f8fSGustavo F. Padovan if (!timeo) 15720a708f8fSGustavo F. Padovan timeo = HZ/5; 15730a708f8fSGustavo F. Padovan 15740a708f8fSGustavo F. Padovan if (signal_pending(current)) { 15750a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 15760a708f8fSGustavo F. Padovan break; 15770a708f8fSGustavo F. Padovan } 15780a708f8fSGustavo F. Padovan 15790a708f8fSGustavo F. Padovan release_sock(sk); 15800a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 15810a708f8fSGustavo F. Padovan lock_sock(sk); 1582a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 15830a708f8fSGustavo F. Padovan 15840a708f8fSGustavo F. Padovan err = sock_error(sk); 15850a708f8fSGustavo F. Padovan if (err) 15860a708f8fSGustavo F. Padovan break; 15870a708f8fSGustavo F. Padovan } 15880a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 15890a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 15900a708f8fSGustavo F. Padovan return err; 15910a708f8fSGustavo F. Padovan } 15920a708f8fSGustavo F. Padovan 1593721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 15940a708f8fSGustavo F. Padovan { 1595721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1596721c4181SGustavo F. Padovan monitor_timer.work); 15970a708f8fSGustavo F. Padovan 1598525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 15990a708f8fSGustavo F. Padovan 16006be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 16016be36555SAndrei Emeltchenko 160280909e04SMat Martineau if (!chan->conn) { 16036be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16048d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16050a708f8fSGustavo F. Padovan return; 16060a708f8fSGustavo F. Padovan } 16070a708f8fSGustavo F. Padovan 1608401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 16090a708f8fSGustavo F. Padovan 16106be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16118d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16120a708f8fSGustavo F. Padovan } 16130a708f8fSGustavo F. Padovan 1614721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 16150a708f8fSGustavo F. Padovan { 1616721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1617721c4181SGustavo F. Padovan retrans_timer.work); 16180a708f8fSGustavo F. Padovan 161949208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 16200a708f8fSGustavo F. Padovan 16216be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 16226be36555SAndrei Emeltchenko 162380909e04SMat Martineau if (!chan->conn) { 162480909e04SMat Martineau l2cap_chan_unlock(chan); 162580909e04SMat Martineau l2cap_chan_put(chan); 162680909e04SMat Martineau return; 162780909e04SMat Martineau } 16280a708f8fSGustavo F. Padovan 1629401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 16306be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16318d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16320a708f8fSGustavo F. Padovan } 16330a708f8fSGustavo F. Padovan 1634d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 16353733937dSMat Martineau struct sk_buff_head *skbs) 16360a708f8fSGustavo F. Padovan { 16370a708f8fSGustavo F. Padovan struct sk_buff *skb; 16383733937dSMat Martineau struct l2cap_ctrl *control; 16390a708f8fSGustavo F. Padovan 16403733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 16413733937dSMat Martineau 16423733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 16433733937dSMat Martineau 16443733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 16453733937dSMat Martineau 16463733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 16473733937dSMat Martineau 16483733937dSMat Martineau bt_cb(skb)->control.retries = 1; 16493733937dSMat Martineau control = &bt_cb(skb)->control; 16503733937dSMat Martineau 16513733937dSMat Martineau control->reqseq = 0; 16523733937dSMat Martineau control->txseq = chan->next_tx_seq; 16533733937dSMat Martineau 16543733937dSMat Martineau __pack_control(chan, control, skb); 16550a708f8fSGustavo F. Padovan 165647d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 16573733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 16583733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 16590a708f8fSGustavo F. Padovan } 16600a708f8fSGustavo F. Padovan 16614343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 16620a708f8fSGustavo F. Padovan 1663b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 16643733937dSMat Martineau 1665836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 16663733937dSMat Martineau chan->frames_sent++; 16670a708f8fSGustavo F. Padovan } 16680a708f8fSGustavo F. Padovan } 16690a708f8fSGustavo F. Padovan 167067c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 16710a708f8fSGustavo F. Padovan { 16720a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 167318a48e76SMat Martineau struct l2cap_ctrl *control; 167418a48e76SMat Martineau int sent = 0; 167518a48e76SMat Martineau 167618a48e76SMat Martineau BT_DBG("chan %p", chan); 16770a708f8fSGustavo F. Padovan 167889bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 16790a708f8fSGustavo F. Padovan return -ENOTCONN; 16800a708f8fSGustavo F. Padovan 168194122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 168294122bbeSMat Martineau return 0; 168394122bbeSMat Martineau 168418a48e76SMat Martineau while (chan->tx_send_head && 168518a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 168618a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 16870a708f8fSGustavo F. Padovan 168818a48e76SMat Martineau skb = chan->tx_send_head; 16890a708f8fSGustavo F. Padovan 169018a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 169118a48e76SMat Martineau control = &bt_cb(skb)->control; 16920a708f8fSGustavo F. Padovan 1693e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 169418a48e76SMat Martineau control->final = 1; 1695e2ab4353SGustavo F. Padovan 169618a48e76SMat Martineau control->reqseq = chan->buffer_seq; 169718a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 169818a48e76SMat Martineau control->txseq = chan->next_tx_seq; 16990a708f8fSGustavo F. Padovan 170018a48e76SMat Martineau __pack_control(chan, control, skb); 17010a708f8fSGustavo F. Padovan 170247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 170318a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 170418a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 17050a708f8fSGustavo F. Padovan } 17060a708f8fSGustavo F. Padovan 170718a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 170818a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 170918a48e76SMat Martineau */ 171018a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 171118a48e76SMat Martineau 171218a48e76SMat Martineau if (!tx_skb) 171318a48e76SMat Martineau break; 17140a708f8fSGustavo F. Padovan 17151a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 17160a708f8fSGustavo F. Padovan 1717836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 17186a026610SGustavo F. Padovan chan->unacked_frames++; 17196a026610SGustavo F. Padovan chan->frames_sent++; 172018a48e76SMat Martineau sent++; 17210a708f8fSGustavo F. Padovan 172258d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 172358d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 17240a708f8fSGustavo F. Padovan else 172558d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 172618a48e76SMat Martineau 172718a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 1728b4400672SAndrei Emeltchenko BT_DBG("Sent txseq %u", control->txseq); 17290a708f8fSGustavo F. Padovan } 17300a708f8fSGustavo F. Padovan 1731b4400672SAndrei Emeltchenko BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent, 1732b4400672SAndrei Emeltchenko chan->unacked_frames, skb_queue_len(&chan->tx_q)); 173318a48e76SMat Martineau 173418a48e76SMat Martineau return sent; 17350a708f8fSGustavo F. Padovan } 17360a708f8fSGustavo F. Padovan 1737e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1738e1fbd4c1SMat Martineau { 1739e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1740e1fbd4c1SMat Martineau struct sk_buff *skb; 1741e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1742e1fbd4c1SMat Martineau u16 seq; 1743e1fbd4c1SMat Martineau 1744e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1745e1fbd4c1SMat Martineau 1746e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1747e1fbd4c1SMat Martineau return; 1748e1fbd4c1SMat Martineau 1749e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1750e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1751e1fbd4c1SMat Martineau 1752e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1753e1fbd4c1SMat Martineau if (!skb) { 1754e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1755e1fbd4c1SMat Martineau seq); 1756e1fbd4c1SMat Martineau continue; 1757e1fbd4c1SMat Martineau } 1758e1fbd4c1SMat Martineau 1759e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1760e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1761e1fbd4c1SMat Martineau 1762e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1763e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1764e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 1765e1fbd4c1SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 1766e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1767e1fbd4c1SMat Martineau break; 1768e1fbd4c1SMat Martineau } 1769e1fbd4c1SMat Martineau 1770e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1771e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1772e1fbd4c1SMat Martineau control.final = 1; 1773e1fbd4c1SMat Martineau else 1774e1fbd4c1SMat Martineau control.final = 0; 1775e1fbd4c1SMat Martineau 1776e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1777e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1778e1fbd4c1SMat Martineau * writeable copy 1779e1fbd4c1SMat Martineau */ 1780e1fbd4c1SMat Martineau tx_skb = skb_copy(skb, GFP_ATOMIC); 1781e1fbd4c1SMat Martineau } else { 1782e1fbd4c1SMat Martineau tx_skb = skb_clone(skb, GFP_ATOMIC); 1783e1fbd4c1SMat Martineau } 1784e1fbd4c1SMat Martineau 1785e1fbd4c1SMat Martineau if (!tx_skb) { 1786e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1787e1fbd4c1SMat Martineau break; 1788e1fbd4c1SMat Martineau } 1789e1fbd4c1SMat Martineau 1790e1fbd4c1SMat Martineau /* Update skb contents */ 1791e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1792e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1793e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1794e1fbd4c1SMat Martineau } else { 1795e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1796e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1797e1fbd4c1SMat Martineau } 1798e1fbd4c1SMat Martineau 1799e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1800e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1801e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1802e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1803e1fbd4c1SMat Martineau } 1804e1fbd4c1SMat Martineau 1805e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1806e1fbd4c1SMat Martineau 1807e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 1808e1fbd4c1SMat Martineau 1809e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 1810e1fbd4c1SMat Martineau } 1811e1fbd4c1SMat Martineau } 1812e1fbd4c1SMat Martineau 1813f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 1814f80842a8SMat Martineau struct l2cap_ctrl *control) 1815f80842a8SMat Martineau { 1816f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1817f80842a8SMat Martineau 1818f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 1819f80842a8SMat Martineau l2cap_ertm_resend(chan); 1820f80842a8SMat Martineau } 1821f80842a8SMat Martineau 1822d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 1823d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 1824d2a7ac5dSMat Martineau { 1825e1fbd4c1SMat Martineau struct sk_buff *skb; 1826e1fbd4c1SMat Martineau 1827e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1828e1fbd4c1SMat Martineau 1829e1fbd4c1SMat Martineau if (control->poll) 1830e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 1831e1fbd4c1SMat Martineau 1832e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1833e1fbd4c1SMat Martineau 1834e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1835e1fbd4c1SMat Martineau return; 1836e1fbd4c1SMat Martineau 1837e1fbd4c1SMat Martineau if (chan->unacked_frames) { 1838e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 1839e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 1840e1fbd4c1SMat Martineau skb == chan->tx_send_head) 1841e1fbd4c1SMat Martineau break; 1842e1fbd4c1SMat Martineau } 1843e1fbd4c1SMat Martineau 1844e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 1845e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 1846e1fbd4c1SMat Martineau break; 1847e1fbd4c1SMat Martineau 1848e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 1849e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 1850e1fbd4c1SMat Martineau } 1851e1fbd4c1SMat Martineau 1852e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 1853e1fbd4c1SMat Martineau } 1854d2a7ac5dSMat Martineau } 1855d2a7ac5dSMat Martineau 1856b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 1857b17e73bbSSzymon Janc { 18580a0aba42SMat Martineau struct l2cap_ctrl control; 18590a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 18600a0aba42SMat Martineau chan->last_acked_seq); 18610a0aba42SMat Martineau int threshold; 18620a0aba42SMat Martineau 18630a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 18640a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 18650a0aba42SMat Martineau 18660a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 18670a0aba42SMat Martineau control.sframe = 1; 18680a0aba42SMat Martineau 18690a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 18700a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 1871b17e73bbSSzymon Janc __clear_ack_timer(chan); 18720a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 18730a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18740a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18750a0aba42SMat Martineau } else { 18760a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 18770a0aba42SMat Martineau l2cap_ertm_send(chan); 18780a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 18790a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 18800a0aba42SMat Martineau frames_to_ack = 0; 18810a0aba42SMat Martineau } 18820a0aba42SMat Martineau 1883c20f8e35SMat Martineau /* Ack now if the window is 3/4ths full. 18840a0aba42SMat Martineau * Calculate without mul or div 18850a0aba42SMat Martineau */ 1886c20f8e35SMat Martineau threshold = chan->ack_win; 18870a0aba42SMat Martineau threshold += threshold << 1; 18880a0aba42SMat Martineau threshold >>= 2; 18890a0aba42SMat Martineau 1890b4400672SAndrei Emeltchenko BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack, 18910a0aba42SMat Martineau threshold); 18920a0aba42SMat Martineau 18930a0aba42SMat Martineau if (frames_to_ack >= threshold) { 18940a0aba42SMat Martineau __clear_ack_timer(chan); 18950a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 18960a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18970a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18980a0aba42SMat Martineau frames_to_ack = 0; 18990a0aba42SMat Martineau } 19000a0aba42SMat Martineau 19010a0aba42SMat Martineau if (frames_to_ack) 19020a0aba42SMat Martineau __set_ack_timer(chan); 19030a0aba42SMat Martineau } 1904b17e73bbSSzymon Janc } 1905b17e73bbSSzymon Janc 190604124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 190704124681SGustavo F. Padovan struct msghdr *msg, int len, 190804124681SGustavo F. Padovan int count, struct sk_buff *skb) 19090a708f8fSGustavo F. Padovan { 19100952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 19110a708f8fSGustavo F. Padovan struct sk_buff **frag; 191290338947SGustavo Padovan int sent = 0; 19130a708f8fSGustavo F. Padovan 19140a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 19150a708f8fSGustavo F. Padovan return -EFAULT; 19160a708f8fSGustavo F. Padovan 19170a708f8fSGustavo F. Padovan sent += count; 19180a708f8fSGustavo F. Padovan len -= count; 19190a708f8fSGustavo F. Padovan 19200a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 19210a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 19220a708f8fSGustavo F. Padovan while (len) { 1923fbe00700SGustavo Padovan struct sk_buff *tmp; 1924fbe00700SGustavo Padovan 19250a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 19260a708f8fSGustavo F. Padovan 1927fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 192890338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 1929fbe00700SGustavo Padovan if (IS_ERR(tmp)) 1930fbe00700SGustavo Padovan return PTR_ERR(tmp); 19312f7719ceSAndrei Emeltchenko 1932fbe00700SGustavo Padovan *frag = tmp; 1933fbe00700SGustavo Padovan 19340a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 19350a708f8fSGustavo F. Padovan return -EFAULT; 19360a708f8fSGustavo F. Padovan 19375e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 19385e59b791SLuiz Augusto von Dentz 19390a708f8fSGustavo F. Padovan sent += count; 19400a708f8fSGustavo F. Padovan len -= count; 19410a708f8fSGustavo F. Padovan 19422d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 19432d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 19442d0ed3d5SGustavo Padovan 19450a708f8fSGustavo F. Padovan frag = &(*frag)->next; 19460a708f8fSGustavo F. Padovan } 19470a708f8fSGustavo F. Padovan 19480a708f8fSGustavo F. Padovan return sent; 19490a708f8fSGustavo F. Padovan } 19500a708f8fSGustavo F. Padovan 19515e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 19525e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19535e59b791SLuiz Augusto von Dentz u32 priority) 19540a708f8fSGustavo F. Padovan { 19558c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19560a708f8fSGustavo F. Padovan struct sk_buff *skb; 195703a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 19580a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19590a708f8fSGustavo F. Padovan 1960b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu priority %u", chan, len, priority); 19610a708f8fSGustavo F. Padovan 19620a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 19632f7719ceSAndrei Emeltchenko 19642f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 196590338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 196690338947SGustavo Padovan if (IS_ERR(skb)) 196790338947SGustavo Padovan return skb; 19680a708f8fSGustavo F. Padovan 19695e59b791SLuiz Augusto von Dentz skb->priority = priority; 19705e59b791SLuiz Augusto von Dentz 19710a708f8fSGustavo F. Padovan /* Create L2CAP header */ 19720a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 1973fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 1974daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 1975daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 19760a708f8fSGustavo F. Padovan 19770952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 19780a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 19790a708f8fSGustavo F. Padovan kfree_skb(skb); 19800a708f8fSGustavo F. Padovan return ERR_PTR(err); 19810a708f8fSGustavo F. Padovan } 19820a708f8fSGustavo F. Padovan return skb; 19830a708f8fSGustavo F. Padovan } 19840a708f8fSGustavo F. Padovan 19855e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 19865e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19875e59b791SLuiz Augusto von Dentz u32 priority) 19880a708f8fSGustavo F. Padovan { 19898c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19900a708f8fSGustavo F. Padovan struct sk_buff *skb; 1991f2ba7faeSGustavo Padovan int err, count; 19920a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19930a708f8fSGustavo F. Padovan 1994b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 19950a708f8fSGustavo F. Padovan 1996f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 19972f7719ceSAndrei Emeltchenko 1998f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 199990338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 200090338947SGustavo Padovan if (IS_ERR(skb)) 200190338947SGustavo Padovan return skb; 20020a708f8fSGustavo F. Padovan 20035e59b791SLuiz Augusto von Dentz skb->priority = priority; 20045e59b791SLuiz Augusto von Dentz 20050a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20060a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2007fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 20086ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 20090a708f8fSGustavo F. Padovan 20100952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20110a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20120a708f8fSGustavo F. Padovan kfree_skb(skb); 20130a708f8fSGustavo F. Padovan return ERR_PTR(err); 20140a708f8fSGustavo F. Padovan } 20150a708f8fSGustavo F. Padovan return skb; 20160a708f8fSGustavo F. Padovan } 20170a708f8fSGustavo F. Padovan 2018ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2019ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 202094122bbeSMat Martineau u16 sdulen) 20210a708f8fSGustavo F. Padovan { 20228c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 20230a708f8fSGustavo F. Padovan struct sk_buff *skb; 2024e4ca6d98SAndrei Emeltchenko int err, count, hlen; 20250a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 20260a708f8fSGustavo F. Padovan 2027b4400672SAndrei Emeltchenko BT_DBG("chan %p len %zu", chan, len); 20280a708f8fSGustavo F. Padovan 20290a708f8fSGustavo F. Padovan if (!conn) 20300a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 20310a708f8fSGustavo F. Padovan 2032ba7aa64fSGustavo Padovan hlen = __ertm_hdr_size(chan); 2033e4ca6d98SAndrei Emeltchenko 20340a708f8fSGustavo F. Padovan if (sdulen) 203503a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 20360a708f8fSGustavo F. Padovan 203747d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 203803a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 20390a708f8fSGustavo F. Padovan 20400a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 20412f7719ceSAndrei Emeltchenko 20422f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 204390338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 204490338947SGustavo Padovan if (IS_ERR(skb)) 204590338947SGustavo Padovan return skb; 20460a708f8fSGustavo F. Padovan 20470a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20480a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2049fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 20500a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 205188843ab0SAndrei Emeltchenko 205218a48e76SMat Martineau /* Control header is populated later */ 205318a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 205418a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 205518a48e76SMat Martineau else 205618a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 205788843ab0SAndrei Emeltchenko 20580a708f8fSGustavo F. Padovan if (sdulen) 205903a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 20600a708f8fSGustavo F. Padovan 20610952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20620a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20630a708f8fSGustavo F. Padovan kfree_skb(skb); 20640a708f8fSGustavo F. Padovan return ERR_PTR(err); 20650a708f8fSGustavo F. Padovan } 20660a708f8fSGustavo F. Padovan 206718a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 20683ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 20690a708f8fSGustavo F. Padovan return skb; 20700a708f8fSGustavo F. Padovan } 20710a708f8fSGustavo F. Padovan 207294122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 207394122bbeSMat Martineau struct sk_buff_head *seg_queue, 207494122bbeSMat Martineau struct msghdr *msg, size_t len) 20750a708f8fSGustavo F. Padovan { 20760a708f8fSGustavo F. Padovan struct sk_buff *skb; 207794122bbeSMat Martineau u16 sdu_len; 207894122bbeSMat Martineau size_t pdu_len; 207994122bbeSMat Martineau u8 sar; 20800a708f8fSGustavo F. Padovan 2081b4400672SAndrei Emeltchenko BT_DBG("chan %p, msg %p, len %zu", chan, msg, len); 20820a708f8fSGustavo F. Padovan 208394122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 208494122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 208594122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 208694122bbeSMat Martineau */ 208794122bbeSMat Martineau 208894122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 208994122bbeSMat Martineau pdu_len = chan->conn->mtu; 209094122bbeSMat Martineau 209194122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 209294122bbeSMat Martineau 209394122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 209435d401dfSGustavo Padovan if (chan->fcs) 209535d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 209635d401dfSGustavo Padovan 2097ba7aa64fSGustavo Padovan pdu_len -= __ertm_hdr_size(chan); 209894122bbeSMat Martineau 209994122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 210094122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 210194122bbeSMat Martineau 210294122bbeSMat Martineau if (len <= pdu_len) { 210394122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 210494122bbeSMat Martineau sdu_len = 0; 210594122bbeSMat Martineau pdu_len = len; 210694122bbeSMat Martineau } else { 210794122bbeSMat Martineau sar = L2CAP_SAR_START; 210894122bbeSMat Martineau sdu_len = len; 210994122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 211094122bbeSMat Martineau } 21110a708f8fSGustavo F. Padovan 21120a708f8fSGustavo F. Padovan while (len > 0) { 211394122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 21140a708f8fSGustavo F. Padovan 21150a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 211694122bbeSMat Martineau __skb_queue_purge(seg_queue); 21170a708f8fSGustavo F. Padovan return PTR_ERR(skb); 21180a708f8fSGustavo F. Padovan } 21190a708f8fSGustavo F. Padovan 212094122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 212194122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 21220a708f8fSGustavo F. Padovan 212394122bbeSMat Martineau len -= pdu_len; 212494122bbeSMat Martineau if (sdu_len) { 212594122bbeSMat Martineau sdu_len = 0; 212694122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 212794122bbeSMat Martineau } 212894122bbeSMat Martineau 212994122bbeSMat Martineau if (len <= pdu_len) { 213094122bbeSMat Martineau sar = L2CAP_SAR_END; 213194122bbeSMat Martineau pdu_len = len; 213294122bbeSMat Martineau } else { 213394122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 213494122bbeSMat Martineau } 213594122bbeSMat Martineau } 213694122bbeSMat Martineau 2137f0f62799SGustavo Padovan return 0; 21380a708f8fSGustavo F. Padovan } 21390a708f8fSGustavo F. Padovan 21405e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 21415e59b791SLuiz Augusto von Dentz u32 priority) 21429a91a04aSGustavo F. Padovan { 21439a91a04aSGustavo F. Padovan struct sk_buff *skb; 21449a91a04aSGustavo F. Padovan int err; 214594122bbeSMat Martineau struct sk_buff_head seg_queue; 21469a91a04aSGustavo F. Padovan 21479a91a04aSGustavo F. Padovan /* Connectionless channel */ 2148715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 21495e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 21509a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 21519a91a04aSGustavo F. Padovan return PTR_ERR(skb); 21529a91a04aSGustavo F. Padovan 21539a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 21549a91a04aSGustavo F. Padovan return len; 21559a91a04aSGustavo F. Padovan } 21569a91a04aSGustavo F. Padovan 21579a91a04aSGustavo F. Padovan switch (chan->mode) { 21589a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 21599a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 21609a91a04aSGustavo F. Padovan if (len > chan->omtu) 21619a91a04aSGustavo F. Padovan return -EMSGSIZE; 21629a91a04aSGustavo F. Padovan 21639a91a04aSGustavo F. Padovan /* Create a basic PDU */ 21645e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 21659a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 21669a91a04aSGustavo F. Padovan return PTR_ERR(skb); 21679a91a04aSGustavo F. Padovan 21689a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 21699a91a04aSGustavo F. Padovan err = len; 21709a91a04aSGustavo F. Padovan break; 21719a91a04aSGustavo F. Padovan 21729a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 21739a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 217494122bbeSMat Martineau /* Check outgoing MTU */ 217594122bbeSMat Martineau if (len > chan->omtu) { 217694122bbeSMat Martineau err = -EMSGSIZE; 21779a91a04aSGustavo F. Padovan break; 21789a91a04aSGustavo F. Padovan } 21799a91a04aSGustavo F. Padovan 218094122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 218194122bbeSMat Martineau 218294122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 218394122bbeSMat Martineau * since it's possible to block while waiting for memory 218494122bbeSMat Martineau * allocation. 218594122bbeSMat Martineau */ 218694122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 218794122bbeSMat Martineau 218894122bbeSMat Martineau /* The channel could have been closed while segmenting, 218994122bbeSMat Martineau * check that it is still connected. 219094122bbeSMat Martineau */ 219194122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 219294122bbeSMat Martineau __skb_queue_purge(&seg_queue); 219394122bbeSMat Martineau err = -ENOTCONN; 21949a91a04aSGustavo F. Padovan } 21959a91a04aSGustavo F. Padovan 219694122bbeSMat Martineau if (err) 219794122bbeSMat Martineau break; 219894122bbeSMat Martineau 21993733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2200d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 22013733937dSMat Martineau else 2202d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 220394122bbeSMat Martineau 22049a91a04aSGustavo F. Padovan err = len; 22059a91a04aSGustavo F. Padovan 220694122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 220794122bbeSMat Martineau * seg_queue and need to be purged. 220894122bbeSMat Martineau */ 220994122bbeSMat Martineau __skb_queue_purge(&seg_queue); 22109a91a04aSGustavo F. Padovan break; 22119a91a04aSGustavo F. Padovan 22129a91a04aSGustavo F. Padovan default: 22139a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 22149a91a04aSGustavo F. Padovan err = -EBADFD; 22159a91a04aSGustavo F. Padovan } 22169a91a04aSGustavo F. Padovan 22179a91a04aSGustavo F. Padovan return err; 22189a91a04aSGustavo F. Padovan } 22199a91a04aSGustavo F. Padovan 2220d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2221d2a7ac5dSMat Martineau { 2222bed68bdeSMat Martineau struct l2cap_ctrl control; 2223bed68bdeSMat Martineau u16 seq; 2224bed68bdeSMat Martineau 2225b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2226bed68bdeSMat Martineau 2227bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2228bed68bdeSMat Martineau control.sframe = 1; 2229bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2230bed68bdeSMat Martineau 2231bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2232bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2233bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2234bed68bdeSMat Martineau control.reqseq = seq; 2235bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2236bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2237bed68bdeSMat Martineau } 2238bed68bdeSMat Martineau } 2239bed68bdeSMat Martineau 2240bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2241d2a7ac5dSMat Martineau } 2242d2a7ac5dSMat Martineau 2243d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2244d2a7ac5dSMat Martineau { 2245bed68bdeSMat Martineau struct l2cap_ctrl control; 2246bed68bdeSMat Martineau 2247bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2248bed68bdeSMat Martineau 2249bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2250bed68bdeSMat Martineau return; 2251bed68bdeSMat Martineau 2252bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2253bed68bdeSMat Martineau control.sframe = 1; 2254bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2255bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2256bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2257d2a7ac5dSMat Martineau } 2258d2a7ac5dSMat Martineau 2259d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2260d2a7ac5dSMat Martineau { 2261bed68bdeSMat Martineau struct l2cap_ctrl control; 2262bed68bdeSMat Martineau u16 initial_head; 2263bed68bdeSMat Martineau u16 seq; 2264bed68bdeSMat Martineau 2265b4400672SAndrei Emeltchenko BT_DBG("chan %p, txseq %u", chan, txseq); 2266bed68bdeSMat Martineau 2267bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2268bed68bdeSMat Martineau control.sframe = 1; 2269bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2270bed68bdeSMat Martineau 2271bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2272bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2273bed68bdeSMat Martineau 2274bed68bdeSMat Martineau do { 2275bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2276bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2277bed68bdeSMat Martineau break; 2278bed68bdeSMat Martineau 2279bed68bdeSMat Martineau control.reqseq = seq; 2280bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2281bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2282bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2283d2a7ac5dSMat Martineau } 2284d2a7ac5dSMat Martineau 2285608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2286608bcc6dSMat Martineau { 2287608bcc6dSMat Martineau struct sk_buff *acked_skb; 2288608bcc6dSMat Martineau u16 ackseq; 2289608bcc6dSMat Martineau 2290b4400672SAndrei Emeltchenko BT_DBG("chan %p, reqseq %u", chan, reqseq); 2291608bcc6dSMat Martineau 2292608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2293608bcc6dSMat Martineau return; 2294608bcc6dSMat Martineau 2295b4400672SAndrei Emeltchenko BT_DBG("expected_ack_seq %u, unacked_frames %u", 2296608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2297608bcc6dSMat Martineau 2298608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2299608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2300608bcc6dSMat Martineau 2301608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2302608bcc6dSMat Martineau if (acked_skb) { 2303608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2304608bcc6dSMat Martineau kfree_skb(acked_skb); 2305608bcc6dSMat Martineau chan->unacked_frames--; 2306608bcc6dSMat Martineau } 2307608bcc6dSMat Martineau } 2308608bcc6dSMat Martineau 2309608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2310608bcc6dSMat Martineau 2311608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2312608bcc6dSMat Martineau __clear_retrans_timer(chan); 2313608bcc6dSMat Martineau 2314b4400672SAndrei Emeltchenko BT_DBG("unacked_frames %u", chan->unacked_frames); 2315608bcc6dSMat Martineau } 2316608bcc6dSMat Martineau 2317608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2318608bcc6dSMat Martineau { 2319608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2320608bcc6dSMat Martineau 2321608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2322608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2323608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2324608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2325608bcc6dSMat Martineau } 2326608bcc6dSMat Martineau 2327d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2328608bcc6dSMat Martineau struct l2cap_ctrl *control, 2329608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2330608bcc6dSMat Martineau { 2331608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2332608bcc6dSMat Martineau event); 2333608bcc6dSMat Martineau 2334608bcc6dSMat Martineau switch (event) { 2335608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2336608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2337608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2338608bcc6dSMat Martineau 2339608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2340608bcc6dSMat Martineau l2cap_ertm_send(chan); 2341608bcc6dSMat Martineau break; 2342608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2343608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2344608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2345608bcc6dSMat Martineau 2346608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2347608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2348608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2349608bcc6dSMat Martineau */ 2350608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2351608bcc6dSMat Martineau } 2352608bcc6dSMat Martineau 2353608bcc6dSMat Martineau l2cap_send_ack(chan); 2354608bcc6dSMat Martineau 2355608bcc6dSMat Martineau break; 2356608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2357608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2358608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2359608bcc6dSMat Martineau 2360608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2361608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2362608bcc6dSMat Martineau 2363608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2364608bcc6dSMat Martineau local_control.sframe = 1; 2365608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2366608bcc6dSMat Martineau local_control.poll = 1; 2367608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2368a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2369608bcc6dSMat Martineau 2370608bcc6dSMat Martineau chan->retry_count = 1; 2371608bcc6dSMat Martineau __set_monitor_timer(chan); 2372608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2373608bcc6dSMat Martineau } 2374608bcc6dSMat Martineau break; 2375608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2376608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2377608bcc6dSMat Martineau break; 2378608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2379608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2380608bcc6dSMat Martineau chan->retry_count = 1; 2381608bcc6dSMat Martineau __set_monitor_timer(chan); 2382608bcc6dSMat Martineau __clear_ack_timer(chan); 2383608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2384608bcc6dSMat Martineau break; 2385608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2386608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2387608bcc6dSMat Martineau chan->retry_count = 1; 2388608bcc6dSMat Martineau __set_monitor_timer(chan); 2389608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2390608bcc6dSMat Martineau break; 2391608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2392608bcc6dSMat Martineau /* Nothing to process */ 2393608bcc6dSMat Martineau break; 2394608bcc6dSMat Martineau default: 2395608bcc6dSMat Martineau break; 2396608bcc6dSMat Martineau } 2397608bcc6dSMat Martineau } 2398608bcc6dSMat Martineau 2399d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2400608bcc6dSMat Martineau struct l2cap_ctrl *control, 2401608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2402608bcc6dSMat Martineau { 2403608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2404608bcc6dSMat Martineau event); 2405608bcc6dSMat Martineau 2406608bcc6dSMat Martineau switch (event) { 2407608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2408608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2409608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2410608bcc6dSMat Martineau /* Queue data, but don't send. */ 2411608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2412608bcc6dSMat Martineau break; 2413608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2414608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2415608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2416608bcc6dSMat Martineau 2417608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2418608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2419608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2420608bcc6dSMat Martineau */ 2421608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2422608bcc6dSMat Martineau } 2423608bcc6dSMat Martineau 2424608bcc6dSMat Martineau l2cap_send_ack(chan); 2425608bcc6dSMat Martineau 2426608bcc6dSMat Martineau break; 2427608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2428608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2429608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2430608bcc6dSMat Martineau 2431608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2432608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2433608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2434608bcc6dSMat Martineau local_control.sframe = 1; 2435608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2436608bcc6dSMat Martineau local_control.poll = 1; 2437608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2438a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2439608bcc6dSMat Martineau 2440608bcc6dSMat Martineau chan->retry_count = 1; 2441608bcc6dSMat Martineau __set_monitor_timer(chan); 2442608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2443608bcc6dSMat Martineau } 2444608bcc6dSMat Martineau break; 2445608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2446608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2447608bcc6dSMat Martineau 2448608bcc6dSMat Martineau /* Fall through */ 2449608bcc6dSMat Martineau 2450608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2451608bcc6dSMat Martineau if (control && control->final) { 2452608bcc6dSMat Martineau __clear_monitor_timer(chan); 2453608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2454608bcc6dSMat Martineau __set_retrans_timer(chan); 2455608bcc6dSMat Martineau chan->retry_count = 0; 2456608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2457608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2458608bcc6dSMat Martineau } 2459608bcc6dSMat Martineau break; 2460608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2461608bcc6dSMat Martineau /* Ignore */ 2462608bcc6dSMat Martineau break; 2463608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2464608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2465608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2466608bcc6dSMat Martineau __set_monitor_timer(chan); 2467608bcc6dSMat Martineau chan->retry_count++; 2468608bcc6dSMat Martineau } else { 2469608bcc6dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED); 2470608bcc6dSMat Martineau } 2471608bcc6dSMat Martineau break; 2472608bcc6dSMat Martineau default: 2473608bcc6dSMat Martineau break; 2474608bcc6dSMat Martineau } 2475608bcc6dSMat Martineau } 2476608bcc6dSMat Martineau 2477d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2478608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2479608bcc6dSMat Martineau { 2480608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2481608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2482608bcc6dSMat Martineau 2483608bcc6dSMat Martineau switch (chan->tx_state) { 2484608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2485d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2486608bcc6dSMat Martineau break; 2487608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2488d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2489608bcc6dSMat Martineau break; 2490608bcc6dSMat Martineau default: 2491608bcc6dSMat Martineau /* Ignore event */ 2492608bcc6dSMat Martineau break; 2493608bcc6dSMat Martineau } 2494608bcc6dSMat Martineau } 2495608bcc6dSMat Martineau 24964b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 24974b51dae9SMat Martineau struct l2cap_ctrl *control) 24984b51dae9SMat Martineau { 24994b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2500401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 25014b51dae9SMat Martineau } 25024b51dae9SMat Martineau 2503f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2504f80842a8SMat Martineau struct l2cap_ctrl *control) 2505f80842a8SMat Martineau { 2506f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2507401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2508f80842a8SMat Martineau } 2509f80842a8SMat Martineau 25100a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 25110a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 25120a708f8fSGustavo F. Padovan { 25130a708f8fSGustavo F. Padovan struct sk_buff *nskb; 251448454079SGustavo F. Padovan struct l2cap_chan *chan; 25150a708f8fSGustavo F. Padovan 25160a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 25170a708f8fSGustavo F. Padovan 25183df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 25193d57dc68SGustavo F. Padovan 25203df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 252148454079SGustavo F. Padovan struct sock *sk = chan->sk; 2522715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 25230a708f8fSGustavo F. Padovan continue; 25240a708f8fSGustavo F. Padovan 25250a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 25260a708f8fSGustavo F. Padovan if (skb->sk == sk) 25270a708f8fSGustavo F. Padovan continue; 25280a708f8fSGustavo F. Padovan nskb = skb_clone(skb, GFP_ATOMIC); 25290a708f8fSGustavo F. Padovan if (!nskb) 25300a708f8fSGustavo F. Padovan continue; 25310a708f8fSGustavo F. Padovan 253280b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 25330a708f8fSGustavo F. Padovan kfree_skb(nskb); 25340a708f8fSGustavo F. Padovan } 25353d57dc68SGustavo F. Padovan 25363df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 25370a708f8fSGustavo F. Padovan } 25380a708f8fSGustavo F. Padovan 25390a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 2540b4400672SAndrei Emeltchenko static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code, 2541b4400672SAndrei Emeltchenko u8 ident, u16 dlen, void *data) 25420a708f8fSGustavo F. Padovan { 25430a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 25440a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 25450a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 25460a708f8fSGustavo F. Padovan int len, count; 25470a708f8fSGustavo F. Padovan 2548b4400672SAndrei Emeltchenko BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u", 25490a708f8fSGustavo F. Padovan conn, code, ident, dlen); 25500a708f8fSGustavo F. Padovan 25510a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 25520a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25530a708f8fSGustavo F. Padovan 25540a708f8fSGustavo F. Padovan skb = bt_skb_alloc(count, GFP_ATOMIC); 25550a708f8fSGustavo F. Padovan if (!skb) 25560a708f8fSGustavo F. Padovan return NULL; 25570a708f8fSGustavo F. Padovan 25580a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 25590a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 25603300d9a9SClaudio Takahasi 25613300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2562ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 25633300d9a9SClaudio Takahasi else 2564ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 25650a708f8fSGustavo F. Padovan 25660a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 25670a708f8fSGustavo F. Padovan cmd->code = code; 25680a708f8fSGustavo F. Padovan cmd->ident = ident; 25690a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 25700a708f8fSGustavo F. Padovan 25710a708f8fSGustavo F. Padovan if (dlen) { 25720a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 25730a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 25740a708f8fSGustavo F. Padovan data += count; 25750a708f8fSGustavo F. Padovan } 25760a708f8fSGustavo F. Padovan 25770a708f8fSGustavo F. Padovan len -= skb->len; 25780a708f8fSGustavo F. Padovan 25790a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 25800a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 25810a708f8fSGustavo F. Padovan while (len) { 25820a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25830a708f8fSGustavo F. Padovan 25840a708f8fSGustavo F. Padovan *frag = bt_skb_alloc(count, GFP_ATOMIC); 25850a708f8fSGustavo F. Padovan if (!*frag) 25860a708f8fSGustavo F. Padovan goto fail; 25870a708f8fSGustavo F. Padovan 25880a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 25890a708f8fSGustavo F. Padovan 25900a708f8fSGustavo F. Padovan len -= count; 25910a708f8fSGustavo F. Padovan data += count; 25920a708f8fSGustavo F. Padovan 25930a708f8fSGustavo F. Padovan frag = &(*frag)->next; 25940a708f8fSGustavo F. Padovan } 25950a708f8fSGustavo F. Padovan 25960a708f8fSGustavo F. Padovan return skb; 25970a708f8fSGustavo F. Padovan 25980a708f8fSGustavo F. Padovan fail: 25990a708f8fSGustavo F. Padovan kfree_skb(skb); 26000a708f8fSGustavo F. Padovan return NULL; 26010a708f8fSGustavo F. Padovan } 26020a708f8fSGustavo F. Padovan 26030a708f8fSGustavo F. Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val) 26040a708f8fSGustavo F. Padovan { 26050a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26060a708f8fSGustavo F. Padovan int len; 26070a708f8fSGustavo F. Padovan 26080a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 26090a708f8fSGustavo F. Padovan *ptr += len; 26100a708f8fSGustavo F. Padovan 26110a708f8fSGustavo F. Padovan *type = opt->type; 26120a708f8fSGustavo F. Padovan *olen = opt->len; 26130a708f8fSGustavo F. Padovan 26140a708f8fSGustavo F. Padovan switch (opt->len) { 26150a708f8fSGustavo F. Padovan case 1: 26160a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 26170a708f8fSGustavo F. Padovan break; 26180a708f8fSGustavo F. Padovan 26190a708f8fSGustavo F. Padovan case 2: 26200a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 26210a708f8fSGustavo F. Padovan break; 26220a708f8fSGustavo F. Padovan 26230a708f8fSGustavo F. Padovan case 4: 26240a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 26250a708f8fSGustavo F. Padovan break; 26260a708f8fSGustavo F. Padovan 26270a708f8fSGustavo F. Padovan default: 26280a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 26290a708f8fSGustavo F. Padovan break; 26300a708f8fSGustavo F. Padovan } 26310a708f8fSGustavo F. Padovan 2632b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val); 26330a708f8fSGustavo F. Padovan return len; 26340a708f8fSGustavo F. Padovan } 26350a708f8fSGustavo F. Padovan 26360a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 26370a708f8fSGustavo F. Padovan { 26380a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26390a708f8fSGustavo F. Padovan 2640b4400672SAndrei Emeltchenko BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val); 26410a708f8fSGustavo F. Padovan 26420a708f8fSGustavo F. Padovan opt->type = type; 26430a708f8fSGustavo F. Padovan opt->len = len; 26440a708f8fSGustavo F. Padovan 26450a708f8fSGustavo F. Padovan switch (len) { 26460a708f8fSGustavo F. Padovan case 1: 26470a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 26480a708f8fSGustavo F. Padovan break; 26490a708f8fSGustavo F. Padovan 26500a708f8fSGustavo F. Padovan case 2: 26510a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 26520a708f8fSGustavo F. Padovan break; 26530a708f8fSGustavo F. Padovan 26540a708f8fSGustavo F. Padovan case 4: 26550a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 26560a708f8fSGustavo F. Padovan break; 26570a708f8fSGustavo F. Padovan 26580a708f8fSGustavo F. Padovan default: 26590a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 26600a708f8fSGustavo F. Padovan break; 26610a708f8fSGustavo F. Padovan } 26620a708f8fSGustavo F. Padovan 26630a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 26640a708f8fSGustavo F. Padovan } 26650a708f8fSGustavo F. Padovan 2666f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2667f89cef09SAndrei Emeltchenko { 2668f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2669f89cef09SAndrei Emeltchenko 2670f89cef09SAndrei Emeltchenko switch (chan->mode) { 2671f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2672f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2673f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2674f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2675f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2676ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 2677ac73498cSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_DEFAULT_FLUSH_TO); 2678f89cef09SAndrei Emeltchenko break; 2679f89cef09SAndrei Emeltchenko 2680f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2681f89cef09SAndrei Emeltchenko efs.id = 1; 2682f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2683f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2684f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2685f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2686f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2687f89cef09SAndrei Emeltchenko break; 2688f89cef09SAndrei Emeltchenko 2689f89cef09SAndrei Emeltchenko default: 2690f89cef09SAndrei Emeltchenko return; 2691f89cef09SAndrei Emeltchenko } 2692f89cef09SAndrei Emeltchenko 2693f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2694f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2695f89cef09SAndrei Emeltchenko } 2696f89cef09SAndrei Emeltchenko 2697721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 26980a708f8fSGustavo F. Padovan { 2699721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2700721c4181SGustavo F. Padovan ack_timer.work); 27010362520bSMat Martineau u16 frames_to_ack; 27020a708f8fSGustavo F. Padovan 27032fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 27042fb9b3d4SGustavo F. Padovan 27056be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 27066be36555SAndrei Emeltchenko 27070362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 27080362520bSMat Martineau chan->last_acked_seq); 27090362520bSMat Martineau 27100362520bSMat Martineau if (frames_to_ack) 27110362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 27126be36555SAndrei Emeltchenko 27136be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 271409bfb2eeSSzymon Janc l2cap_chan_put(chan); 27150a708f8fSGustavo F. Padovan } 27160a708f8fSGustavo F. Padovan 2717466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 27180a708f8fSGustavo F. Padovan { 27193c588192SMat Martineau int err; 27203c588192SMat Martineau 2721105bdf9eSMat Martineau chan->next_tx_seq = 0; 2722105bdf9eSMat Martineau chan->expected_tx_seq = 0; 272342e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 27246a026610SGustavo F. Padovan chan->unacked_frames = 0; 272542e5c802SGustavo F. Padovan chan->buffer_seq = 0; 27266a026610SGustavo F. Padovan chan->frames_sent = 0; 2727105bdf9eSMat Martineau chan->last_acked_seq = 0; 2728105bdf9eSMat Martineau chan->sdu = NULL; 2729105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2730105bdf9eSMat Martineau chan->sdu_len = 0; 2731105bdf9eSMat Martineau 2732d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2733d34c34fbSMat Martineau 2734105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2735105bdf9eSMat Martineau return 0; 2736105bdf9eSMat Martineau 2737105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2738105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 27390a708f8fSGustavo F. Padovan 2740721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2741721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2742721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 27430a708f8fSGustavo F. Padovan 2744f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 27450a708f8fSGustavo F. Padovan 27463c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 27473c588192SMat Martineau if (err < 0) 27483c588192SMat Martineau return err; 27493c588192SMat Martineau 27509dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 27519dc9affcSMat Martineau if (err < 0) 27529dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 27539dc9affcSMat Martineau 27549dc9affcSMat Martineau return err; 27550a708f8fSGustavo F. Padovan } 27560a708f8fSGustavo F. Padovan 27570a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 27580a708f8fSGustavo F. Padovan { 27590a708f8fSGustavo F. Padovan switch (mode) { 27600a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 27610a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 27620a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 27630a708f8fSGustavo F. Padovan return mode; 27640a708f8fSGustavo F. Padovan /* fall through */ 27650a708f8fSGustavo F. Padovan default: 27660a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 27670a708f8fSGustavo F. Padovan } 27680a708f8fSGustavo F. Padovan } 27690a708f8fSGustavo F. Padovan 27706327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 27716327eb98SAndrei Emeltchenko { 27726327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 27736327eb98SAndrei Emeltchenko } 27746327eb98SAndrei Emeltchenko 2775f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2776f89cef09SAndrei Emeltchenko { 2777f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2778f89cef09SAndrei Emeltchenko } 2779f89cef09SAndrei Emeltchenko 27806327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 27816327eb98SAndrei Emeltchenko { 27826327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 2783836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 27846327eb98SAndrei Emeltchenko /* use extended control field */ 27856327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 2786836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 2787836be934SAndrei Emeltchenko } else { 27886327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 27896327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 2790836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 2791836be934SAndrei Emeltchenko } 2792c20f8e35SMat Martineau chan->ack_win = chan->tx_win; 27936327eb98SAndrei Emeltchenko } 27946327eb98SAndrei Emeltchenko 2795710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 27960a708f8fSGustavo F. Padovan { 27970a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 27980c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 27990a708f8fSGustavo F. Padovan void *ptr = req->data; 2800c8f79162SAndrei Emeltchenko u16 size; 28010a708f8fSGustavo F. Padovan 280249208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 28030a708f8fSGustavo F. Padovan 280473ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 28050a708f8fSGustavo F. Padovan goto done; 28060a708f8fSGustavo F. Padovan 28070c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28080a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 28090a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2810c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 28110a708f8fSGustavo F. Padovan break; 28120a708f8fSGustavo F. Padovan 2813f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 2814f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 2815f89cef09SAndrei Emeltchenko 28160a708f8fSGustavo F. Padovan /* fall through */ 28170a708f8fSGustavo F. Padovan default: 28188c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 28190a708f8fSGustavo F. Padovan break; 28200a708f8fSGustavo F. Padovan } 28210a708f8fSGustavo F. Padovan 28220a708f8fSGustavo F. Padovan done: 28230c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 28240c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 28250a708f8fSGustavo F. Padovan 28260c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28270a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 28288c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 28298c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 28300a708f8fSGustavo F. Padovan break; 28310a708f8fSGustavo F. Padovan 28320a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 28330a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28340a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28350a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28360a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 28370a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 28380a708f8fSGustavo F. Padovan 28390a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28400a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28410a708f8fSGustavo F. Padovan break; 28420a708f8fSGustavo F. Padovan 28430a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 28440a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 284547d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 28460a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28470a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2848c8f79162SAndrei Emeltchenko 2849c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2850c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2851c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2852c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2853c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28540a708f8fSGustavo F. Padovan 28556327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 28566327eb98SAndrei Emeltchenko 28576327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 28586327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 28590a708f8fSGustavo F. Padovan 28600a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28610a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28620a708f8fSGustavo F. Padovan 2863f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2864f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2865f89cef09SAndrei Emeltchenko 28668c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 28670a708f8fSGustavo F. Padovan break; 28680a708f8fSGustavo F. Padovan 286947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2870c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 287147d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 287247d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 28730a708f8fSGustavo F. Padovan } 28746327eb98SAndrei Emeltchenko 28756327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 28766327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 28776327eb98SAndrei Emeltchenko chan->tx_win); 28780a708f8fSGustavo F. Padovan break; 28790a708f8fSGustavo F. Padovan 28800a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 2881273759e2SMat Martineau l2cap_txwin_setup(chan); 28820a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 28830a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28840a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28850a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28860a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2887c8f79162SAndrei Emeltchenko 2888c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2889c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2890c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2891c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2892c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28930a708f8fSGustavo F. Padovan 28940a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28950a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28960a708f8fSGustavo F. Padovan 2897f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2898f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2899f89cef09SAndrei Emeltchenko 29008c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 29010a708f8fSGustavo F. Padovan break; 29020a708f8fSGustavo F. Padovan 290347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2904c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 290547d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 290647d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 29070a708f8fSGustavo F. Padovan } 29080a708f8fSGustavo F. Padovan break; 29090a708f8fSGustavo F. Padovan } 29100a708f8fSGustavo F. Padovan 2911fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 291259e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 29130a708f8fSGustavo F. Padovan 29140a708f8fSGustavo F. Padovan return ptr - data; 29150a708f8fSGustavo F. Padovan } 29160a708f8fSGustavo F. Padovan 291773ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 29180a708f8fSGustavo F. Padovan { 29190a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 29200a708f8fSGustavo F. Padovan void *ptr = rsp->data; 292173ffa904SGustavo F. Padovan void *req = chan->conf_req; 292273ffa904SGustavo F. Padovan int len = chan->conf_len; 29230a708f8fSGustavo F. Padovan int type, hint, olen; 29240a708f8fSGustavo F. Padovan unsigned long val; 29250a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 292642dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 292742dceae2SAndrei Emeltchenko u8 remote_efs = 0; 29280a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 29290a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 2930c8f79162SAndrei Emeltchenko u16 size; 29310a708f8fSGustavo F. Padovan 293273ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 29330a708f8fSGustavo F. Padovan 29340a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 29350a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 29360a708f8fSGustavo F. Padovan 29370a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 29380a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 29390a708f8fSGustavo F. Padovan 29400a708f8fSGustavo F. Padovan switch (type) { 29410a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 29420a708f8fSGustavo F. Padovan mtu = val; 29430a708f8fSGustavo F. Padovan break; 29440a708f8fSGustavo F. Padovan 29450a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 29460c1bc5c6SGustavo F. Padovan chan->flush_to = val; 29470a708f8fSGustavo F. Padovan break; 29480a708f8fSGustavo F. Padovan 29490a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 29500a708f8fSGustavo F. Padovan break; 29510a708f8fSGustavo F. Padovan 29520a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 29530a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 29540a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 29550a708f8fSGustavo F. Padovan break; 29560a708f8fSGustavo F. Padovan 29570a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 29580a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 2959c1360a1cSGustavo F. Padovan set_bit(CONF_NO_FCS_RECV, &chan->conf_state); 296042dceae2SAndrei Emeltchenko break; 29610a708f8fSGustavo F. Padovan 296242dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 296342dceae2SAndrei Emeltchenko remote_efs = 1; 296442dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 296542dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 29660a708f8fSGustavo F. Padovan break; 29670a708f8fSGustavo F. Padovan 29686327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 29696327eb98SAndrei Emeltchenko if (!enable_hs) 29706327eb98SAndrei Emeltchenko return -ECONNREFUSED; 29716327eb98SAndrei Emeltchenko 29726327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 29736327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 2974836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 29756327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 29760a708f8fSGustavo F. Padovan break; 29770a708f8fSGustavo F. Padovan 29780a708f8fSGustavo F. Padovan default: 29790a708f8fSGustavo F. Padovan if (hint) 29800a708f8fSGustavo F. Padovan break; 29810a708f8fSGustavo F. Padovan 29820a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 29830a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 29840a708f8fSGustavo F. Padovan break; 29850a708f8fSGustavo F. Padovan } 29860a708f8fSGustavo F. Padovan } 29870a708f8fSGustavo F. Padovan 298873ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 29890a708f8fSGustavo F. Padovan goto done; 29900a708f8fSGustavo F. Padovan 29910c1bc5c6SGustavo F. Padovan switch (chan->mode) { 29920a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 29930a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2994c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 29950c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 29968c1d787bSGustavo F. Padovan chan->conn->feat_mask); 29970a708f8fSGustavo F. Padovan break; 29980a708f8fSGustavo F. Padovan } 29990a708f8fSGustavo F. Padovan 300042dceae2SAndrei Emeltchenko if (remote_efs) { 300142dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 300242dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 300342dceae2SAndrei Emeltchenko else 300442dceae2SAndrei Emeltchenko return -ECONNREFUSED; 300542dceae2SAndrei Emeltchenko } 300642dceae2SAndrei Emeltchenko 30070c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 30080a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30090a708f8fSGustavo F. Padovan 30100a708f8fSGustavo F. Padovan break; 30110a708f8fSGustavo F. Padovan } 30120a708f8fSGustavo F. Padovan 30130a708f8fSGustavo F. Padovan done: 30140c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 30150a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30160c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 30170a708f8fSGustavo F. Padovan 301873ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 30190a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30200a708f8fSGustavo F. Padovan 30210a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30220a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30230a708f8fSGustavo F. Padovan } 30240a708f8fSGustavo F. Padovan 30250a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 30260a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 30270a708f8fSGustavo F. Padovan * which ones we don't like. */ 30280a708f8fSGustavo F. Padovan 30290a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 30300a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30310a708f8fSGustavo F. Padovan else { 30320c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3033c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 30340a708f8fSGustavo F. Padovan } 30350c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 30360a708f8fSGustavo F. Padovan 303742dceae2SAndrei Emeltchenko if (remote_efs) { 303842dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 303942dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 304042dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 304142dceae2SAndrei Emeltchenko 304242dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 304342dceae2SAndrei Emeltchenko 304442dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 304542dceae2SAndrei Emeltchenko return -ECONNREFUSED; 304642dceae2SAndrei Emeltchenko 304742dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 304842dceae2SAndrei Emeltchenko sizeof(efs), 304942dceae2SAndrei Emeltchenko (unsigned long) &efs); 30500e8b207eSAndrei Emeltchenko } else { 30513e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 30520e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 30530e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 305442dceae2SAndrei Emeltchenko } 305542dceae2SAndrei Emeltchenko } 305642dceae2SAndrei Emeltchenko 30570a708f8fSGustavo F. Padovan switch (rfc.mode) { 30580a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 305947d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3060c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30610a708f8fSGustavo F. Padovan break; 30620a708f8fSGustavo F. Padovan 30630a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30646327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 30652c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 30666327eb98SAndrei Emeltchenko else 30676327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 30686327eb98SAndrei Emeltchenko 30692c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 30700a708f8fSGustavo F. Padovan 3071c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3072c8f79162SAndrei Emeltchenko chan->conn->mtu - 3073c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3074c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3075c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3076c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3077c8f79162SAndrei Emeltchenko chan->remote_mps = size; 30780a708f8fSGustavo F. Padovan 30790a708f8fSGustavo F. Padovan rfc.retrans_timeout = 30804fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 30810a708f8fSGustavo F. Padovan rfc.monitor_timeout = 30824fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 30830a708f8fSGustavo F. Padovan 3084c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30850a708f8fSGustavo F. Padovan 30860a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30870a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30880a708f8fSGustavo F. Padovan 308942dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 309042dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 309142dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 309242dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 309342dceae2SAndrei Emeltchenko chan->remote_flush_to = 309442dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 309542dceae2SAndrei Emeltchenko chan->remote_acc_lat = 309642dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 309742dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 309842dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 309942dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 310042dceae2SAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 310142dceae2SAndrei Emeltchenko } 31020a708f8fSGustavo F. Padovan break; 31030a708f8fSGustavo F. Padovan 31040a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3105c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3106c8f79162SAndrei Emeltchenko chan->conn->mtu - 3107c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3108c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3109c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3110c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3111c8f79162SAndrei Emeltchenko chan->remote_mps = size; 31120a708f8fSGustavo F. Padovan 3113c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 31140a708f8fSGustavo F. Padovan 31150a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31160a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31170a708f8fSGustavo F. Padovan 31180a708f8fSGustavo F. Padovan break; 31190a708f8fSGustavo F. Padovan 31200a708f8fSGustavo F. Padovan default: 31210a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 31220a708f8fSGustavo F. Padovan 31230a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 31240c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 31250a708f8fSGustavo F. Padovan } 31260a708f8fSGustavo F. Padovan 31270a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3128c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 31290a708f8fSGustavo F. Padovan } 3130fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 31310a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 313259e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 31330a708f8fSGustavo F. Padovan 31340a708f8fSGustavo F. Padovan return ptr - data; 31350a708f8fSGustavo F. Padovan } 31360a708f8fSGustavo F. Padovan 3137b4450035SGustavo F. Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, void *data, u16 *result) 31380a708f8fSGustavo F. Padovan { 31390a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 31400a708f8fSGustavo F. Padovan void *ptr = req->data; 31410a708f8fSGustavo F. Padovan int type, olen; 31420a708f8fSGustavo F. Padovan unsigned long val; 314336e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 314466af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 31450a708f8fSGustavo F. Padovan 3146fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 31470a708f8fSGustavo F. Padovan 31480a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 31490a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 31500a708f8fSGustavo F. Padovan 31510a708f8fSGustavo F. Padovan switch (type) { 31520a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 31530a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 31540a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 31550c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 31560a708f8fSGustavo F. Padovan } else 31570c1bc5c6SGustavo F. Padovan chan->imtu = val; 31580c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 31590a708f8fSGustavo F. Padovan break; 31600a708f8fSGustavo F. Padovan 31610a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 31620c1bc5c6SGustavo F. Padovan chan->flush_to = val; 31630a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 31640c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 31650a708f8fSGustavo F. Padovan break; 31660a708f8fSGustavo F. Padovan 31670a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 31680a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 31690a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 31700a708f8fSGustavo F. Padovan 3171c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 31720c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 31730a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31740a708f8fSGustavo F. Padovan 317547d1ec61SGustavo F. Padovan chan->fcs = 0; 31760a708f8fSGustavo F. Padovan 31770a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31780a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31790a708f8fSGustavo F. Padovan break; 31806327eb98SAndrei Emeltchenko 31816327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 3182c20f8e35SMat Martineau chan->ack_win = min_t(u16, val, chan->ack_win); 31833e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 31843e6b3b95SGustavo F. Padovan chan->tx_win); 31856327eb98SAndrei Emeltchenko break; 318666af7aafSAndrei Emeltchenko 318766af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 318866af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 318966af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 319066af7aafSAndrei Emeltchenko 319166af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 319266af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 319366af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 319466af7aafSAndrei Emeltchenko return -ECONNREFUSED; 319566af7aafSAndrei Emeltchenko 319666af7aafSAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 319766af7aafSAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 319866af7aafSAndrei Emeltchenko break; 31990a708f8fSGustavo F. Padovan } 32000a708f8fSGustavo F. Padovan } 32010a708f8fSGustavo F. Padovan 32020c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 32030a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32040a708f8fSGustavo F. Padovan 32050c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 32060a708f8fSGustavo F. Padovan 32070e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 32080a708f8fSGustavo F. Padovan switch (rfc.mode) { 32090a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 321047d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 321147d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 321247d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3213c20f8e35SMat Martineau if (!test_bit(FLAG_EXT_CTRL, &chan->flags)) 3214c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3215c20f8e35SMat Martineau rfc.txwin_size); 321666af7aafSAndrei Emeltchenko 321766af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 321866af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 321966af7aafSAndrei Emeltchenko chan->local_sdu_itime = 322066af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 322166af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 322266af7aafSAndrei Emeltchenko chan->local_flush_to = 322366af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 322466af7aafSAndrei Emeltchenko } 32250a708f8fSGustavo F. Padovan break; 322666af7aafSAndrei Emeltchenko 32270a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 322847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 32290a708f8fSGustavo F. Padovan } 32300a708f8fSGustavo F. Padovan } 32310a708f8fSGustavo F. Padovan 3232fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 323359e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 32340a708f8fSGustavo F. Padovan 32350a708f8fSGustavo F. Padovan return ptr - data; 32360a708f8fSGustavo F. Padovan } 32370a708f8fSGustavo F. Padovan 3238fe4128e0SGustavo F. Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, u16 result, u16 flags) 32390a708f8fSGustavo F. Padovan { 32400a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 32410a708f8fSGustavo F. Padovan void *ptr = rsp->data; 32420a708f8fSGustavo F. Padovan 3243fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 32440a708f8fSGustavo F. Padovan 3245fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 32460a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 32470a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 32480a708f8fSGustavo F. Padovan 32490a708f8fSGustavo F. Padovan return ptr - data; 32500a708f8fSGustavo F. Padovan } 32510a708f8fSGustavo F. Padovan 32528c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3253710f9b0aSGustavo F. Padovan { 3254710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 32558c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3256710f9b0aSGustavo F. Padovan u8 buf[128]; 3257710f9b0aSGustavo F. Padovan 3258fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3259fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3260ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3261ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3262710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, 3263710f9b0aSGustavo F. Padovan L2CAP_CONN_RSP, sizeof(rsp), &rsp); 3264710f9b0aSGustavo F. Padovan 3265c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3266710f9b0aSGustavo F. Padovan return; 3267710f9b0aSGustavo F. Padovan 3268710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3269710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3270710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3271710f9b0aSGustavo F. Padovan } 3272710f9b0aSGustavo F. Padovan 327347d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 32740a708f8fSGustavo F. Padovan { 32750a708f8fSGustavo F. Padovan int type, olen; 32760a708f8fSGustavo F. Padovan unsigned long val; 3277c20f8e35SMat Martineau /* Use sane default values in case a misbehaving remote device 3278c20f8e35SMat Martineau * did not send an RFC or extended window size option. 3279c20f8e35SMat Martineau */ 3280c20f8e35SMat Martineau u16 txwin_ext = chan->ack_win; 3281c20f8e35SMat Martineau struct l2cap_conf_rfc rfc = { 3282c20f8e35SMat Martineau .mode = chan->mode, 3283c20f8e35SMat Martineau .retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO), 3284c20f8e35SMat Martineau .monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO), 3285c20f8e35SMat Martineau .max_pdu_size = cpu_to_le16(chan->imtu), 3286c20f8e35SMat Martineau .txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW), 3287c20f8e35SMat Martineau }; 32880a708f8fSGustavo F. Padovan 328947d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 32900a708f8fSGustavo F. Padovan 32910c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 32920a708f8fSGustavo F. Padovan return; 32930a708f8fSGustavo F. Padovan 32940a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32950a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 32960a708f8fSGustavo F. Padovan 3297c20f8e35SMat Martineau switch (type) { 3298c20f8e35SMat Martineau case L2CAP_CONF_RFC: 3299c20f8e35SMat Martineau if (olen == sizeof(rfc)) 33000a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 3301c20f8e35SMat Martineau break; 3302c20f8e35SMat Martineau case L2CAP_CONF_EWS: 3303c20f8e35SMat Martineau txwin_ext = val; 3304c20f8e35SMat Martineau break; 3305c20f8e35SMat Martineau } 33060a708f8fSGustavo F. Padovan } 33070a708f8fSGustavo F. Padovan 33080a708f8fSGustavo F. Padovan switch (rfc.mode) { 33090a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 331047d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 331147d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 331247d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 3313c20f8e35SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 3314c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, txwin_ext); 3315c20f8e35SMat Martineau else 3316c20f8e35SMat Martineau chan->ack_win = min_t(u16, chan->ack_win, 3317c20f8e35SMat Martineau rfc.txwin_size); 33180a708f8fSGustavo F. Padovan break; 33190a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 332047d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 33210a708f8fSGustavo F. Padovan } 33220a708f8fSGustavo F. Padovan } 33230a708f8fSGustavo F. Padovan 33240a708f8fSGustavo F. Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 33250a708f8fSGustavo F. Padovan { 3326e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 33270a708f8fSGustavo F. Padovan 3328e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 33290a708f8fSGustavo F. Padovan return 0; 33300a708f8fSGustavo F. Padovan 33310a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 33320a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 333317cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 33340a708f8fSGustavo F. Padovan 33350a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 33360a708f8fSGustavo F. Padovan conn->info_ident = 0; 33370a708f8fSGustavo F. Padovan 33380a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 33390a708f8fSGustavo F. Padovan } 33400a708f8fSGustavo F. Padovan 33410a708f8fSGustavo F. Padovan return 0; 33420a708f8fSGustavo F. Padovan } 33430a708f8fSGustavo F. Padovan 33440a708f8fSGustavo F. Padovan static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 33450a708f8fSGustavo F. Padovan { 33460a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 33470a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 334823691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 33490a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 33500a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 33510a708f8fSGustavo F. Padovan 33520a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 33530a708f8fSGustavo F. Padovan __le16 psm = req->psm; 33540a708f8fSGustavo F. Padovan 3355097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 33560a708f8fSGustavo F. Padovan 33570a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3358c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 335923691d75SGustavo F. Padovan if (!pchan) { 33600a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 33610a708f8fSGustavo F. Padovan goto sendresp; 33620a708f8fSGustavo F. Padovan } 33630a708f8fSGustavo F. Padovan 336423691d75SGustavo F. Padovan parent = pchan->sk; 336523691d75SGustavo F. Padovan 33663df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3367aa2ac881SGustavo F. Padovan lock_sock(parent); 33680a708f8fSGustavo F. Padovan 33690a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 33702983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 33710a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 33729f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 33730a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 33740a708f8fSGustavo F. Padovan goto response; 33750a708f8fSGustavo F. Padovan } 33760a708f8fSGustavo F. Padovan 33770a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 33780a708f8fSGustavo F. Padovan 33792dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 33802dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 33812dfa1003SGustavo Padovan goto response; 33822dfa1003SGustavo Padovan 338380b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 338480808e43SGustavo F. Padovan if (!chan) 33850a708f8fSGustavo F. Padovan goto response; 33860a708f8fSGustavo F. Padovan 338780808e43SGustavo F. Padovan sk = chan->sk; 338880808e43SGustavo F. Padovan 33890a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 33900a708f8fSGustavo F. Padovan 33910a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 33920a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3393fe4128e0SGustavo F. Padovan chan->psm = psm; 3394fe4128e0SGustavo F. Padovan chan->dcid = scid; 33950a708f8fSGustavo F. Padovan 3396d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 3397d1010240SGustavo F. Padovan 33986be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 339948454079SGustavo F. Padovan 3400fe4128e0SGustavo F. Padovan dcid = chan->scid; 34010a708f8fSGustavo F. Padovan 3402c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 34030a708f8fSGustavo F. Padovan 3404fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 34050a708f8fSGustavo F. Padovan 34060a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3407d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3408c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 34090e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34100a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34110a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 34120a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 34130a708f8fSGustavo F. Padovan } else { 34140e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 34150a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 34160a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 34170a708f8fSGustavo F. Padovan } 34180a708f8fSGustavo F. Padovan } else { 34190e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34200a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34210a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 34220a708f8fSGustavo F. Padovan } 34230a708f8fSGustavo F. Padovan } else { 34240e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34250a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34260a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 34270a708f8fSGustavo F. Padovan } 34280a708f8fSGustavo F. Padovan 34290a708f8fSGustavo F. Padovan response: 3430aa2ac881SGustavo F. Padovan release_sock(parent); 34313df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 34320a708f8fSGustavo F. Padovan 34330a708f8fSGustavo F. Padovan sendresp: 34340a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 34350a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 34360a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 34370a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 34380a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp); 34390a708f8fSGustavo F. Padovan 34400a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 34410a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3442ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 34430a708f8fSGustavo F. Padovan 34440a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 34450a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 34460a708f8fSGustavo F. Padovan 3447ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 34480a708f8fSGustavo F. Padovan 34490a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 34500a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(info), &info); 34510a708f8fSGustavo F. Padovan } 34520a708f8fSGustavo F. Padovan 3453c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 34540a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 34550a708f8fSGustavo F. Padovan u8 buf[128]; 3456c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 34570a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 345873ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 345973ffa904SGustavo F. Padovan chan->num_conf_req++; 34600a708f8fSGustavo F. Padovan } 34610a708f8fSGustavo F. Padovan 34620a708f8fSGustavo F. Padovan return 0; 34630a708f8fSGustavo F. Padovan } 34640a708f8fSGustavo F. Padovan 34650a708f8fSGustavo F. Padovan static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 34660a708f8fSGustavo F. Padovan { 34670a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 34680a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 346948454079SGustavo F. Padovan struct l2cap_chan *chan; 34700a708f8fSGustavo F. Padovan u8 req[128]; 34713df91ea2SAndrei Emeltchenko int err; 34720a708f8fSGustavo F. Padovan 34730a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 34740a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 34750a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 34760a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 34770a708f8fSGustavo F. Padovan 34781b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 34791b009c98SAndrei Emeltchenko dcid, scid, result, status); 34800a708f8fSGustavo F. Padovan 34813df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 34823df91ea2SAndrei Emeltchenko 34830a708f8fSGustavo F. Padovan if (scid) { 34843df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 34853df91ea2SAndrei Emeltchenko if (!chan) { 34863df91ea2SAndrei Emeltchenko err = -EFAULT; 34873df91ea2SAndrei Emeltchenko goto unlock; 34883df91ea2SAndrei Emeltchenko } 34890a708f8fSGustavo F. Padovan } else { 34903df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 34913df91ea2SAndrei Emeltchenko if (!chan) { 34923df91ea2SAndrei Emeltchenko err = -EFAULT; 34933df91ea2SAndrei Emeltchenko goto unlock; 34943df91ea2SAndrei Emeltchenko } 34950a708f8fSGustavo F. Padovan } 34960a708f8fSGustavo F. Padovan 34973df91ea2SAndrei Emeltchenko err = 0; 34983df91ea2SAndrei Emeltchenko 34996be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 350048454079SGustavo F. Padovan 35010a708f8fSGustavo F. Padovan switch (result) { 35020a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 350389bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3504fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3505fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3506c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 35070a708f8fSGustavo F. Padovan 3508c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 35090a708f8fSGustavo F. Padovan break; 35100a708f8fSGustavo F. Padovan 35110a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 351273ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 351373ffa904SGustavo F. Padovan chan->num_conf_req++; 35140a708f8fSGustavo F. Padovan break; 35150a708f8fSGustavo F. Padovan 35160a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3517c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 35180a708f8fSGustavo F. Padovan break; 35190a708f8fSGustavo F. Padovan 35200a708f8fSGustavo F. Padovan default: 352148454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 35220a708f8fSGustavo F. Padovan break; 35230a708f8fSGustavo F. Padovan } 35240a708f8fSGustavo F. Padovan 35256be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 35263df91ea2SAndrei Emeltchenko 35273df91ea2SAndrei Emeltchenko unlock: 35283df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 35293df91ea2SAndrei Emeltchenko 35303df91ea2SAndrei Emeltchenko return err; 35310a708f8fSGustavo F. Padovan } 35320a708f8fSGustavo F. Padovan 353347d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 35340a708f8fSGustavo F. Padovan { 35350a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 35360a708f8fSGustavo F. Padovan * sides request it. 35370a708f8fSGustavo F. Padovan */ 35380c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 353947d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3540c1360a1cSGustavo F. Padovan else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) 354147d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 35420a708f8fSGustavo F. Padovan } 35430a708f8fSGustavo F. Padovan 35440a708f8fSGustavo F. Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 35450a708f8fSGustavo F. Padovan { 35460a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 35470a708f8fSGustavo F. Padovan u16 dcid, flags; 35480a708f8fSGustavo F. Padovan u8 rsp[64]; 354948454079SGustavo F. Padovan struct l2cap_chan *chan; 35503c588192SMat Martineau int len, err = 0; 35510a708f8fSGustavo F. Padovan 35520a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 35530a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 35540a708f8fSGustavo F. Padovan 35550a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 35560a708f8fSGustavo F. Padovan 3557baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 355848454079SGustavo F. Padovan if (!chan) 35590a708f8fSGustavo F. Padovan return -ENOENT; 35600a708f8fSGustavo F. Padovan 3561033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3562e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 35630a708f8fSGustavo F. Padovan 3564ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3565e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3566e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3567e2fd318eSIlia Kolomisnky 35680a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 35690a708f8fSGustavo F. Padovan sizeof(rej), &rej); 35700a708f8fSGustavo F. Padovan goto unlock; 35710a708f8fSGustavo F. Padovan } 35720a708f8fSGustavo F. Padovan 35730a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 35740a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 35757ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 35760a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3577fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35780a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 35790a708f8fSGustavo F. Padovan goto unlock; 35800a708f8fSGustavo F. Padovan } 35810a708f8fSGustavo F. Padovan 35820a708f8fSGustavo F. Padovan /* Store config. */ 358373ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 358473ffa904SGustavo F. Padovan chan->conf_len += len; 35850a708f8fSGustavo F. Padovan 358659e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 35870a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 35880a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3589fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35905325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 35910a708f8fSGustavo F. Padovan goto unlock; 35920a708f8fSGustavo F. Padovan } 35930a708f8fSGustavo F. Padovan 35940a708f8fSGustavo F. Padovan /* Complete config. */ 359573ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 35960a708f8fSGustavo F. Padovan if (len < 0) { 3597e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 35980a708f8fSGustavo F. Padovan goto unlock; 35990a708f8fSGustavo F. Padovan } 36000a708f8fSGustavo F. Padovan 36010a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 360273ffa904SGustavo F. Padovan chan->num_conf_rsp++; 36030a708f8fSGustavo F. Padovan 36040a708f8fSGustavo F. Padovan /* Reset config buffer. */ 360573ffa904SGustavo F. Padovan chan->conf_len = 0; 36060a708f8fSGustavo F. Padovan 3607c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 36080a708f8fSGustavo F. Padovan goto unlock; 36090a708f8fSGustavo F. Padovan 3610c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 361147d1ec61SGustavo F. Padovan set_default_fcs(chan); 36120a708f8fSGustavo F. Padovan 3613105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3614105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 36153c588192SMat Martineau err = l2cap_ertm_init(chan); 36160a708f8fSGustavo F. Padovan 36173c588192SMat Martineau if (err < 0) 36183c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 36193c588192SMat Martineau else 3620cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 36213c588192SMat Martineau 36220a708f8fSGustavo F. Padovan goto unlock; 36230a708f8fSGustavo F. Padovan } 36240a708f8fSGustavo F. Padovan 3625c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 36260a708f8fSGustavo F. Padovan u8 buf[64]; 36270a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 362873ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 362973ffa904SGustavo F. Padovan chan->num_conf_req++; 36300a708f8fSGustavo F. Padovan } 36310a708f8fSGustavo F. Padovan 36320e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 36330e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 36340e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 36350e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36360e8b207eSAndrei Emeltchenko 36370e8b207eSAndrei Emeltchenko /* check compatibility */ 36380e8b207eSAndrei Emeltchenko 36390e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36400e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36410e8b207eSAndrei Emeltchenko 36420e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36430e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, rsp, 36445325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 36450e8b207eSAndrei Emeltchenko } 36460e8b207eSAndrei Emeltchenko 36470a708f8fSGustavo F. Padovan unlock: 36486be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 36493c588192SMat Martineau return err; 36500a708f8fSGustavo F. Padovan } 36510a708f8fSGustavo F. Padovan 36520a708f8fSGustavo F. Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 36530a708f8fSGustavo F. Padovan { 36540a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 36550a708f8fSGustavo F. Padovan u16 scid, flags, result; 365648454079SGustavo F. Padovan struct l2cap_chan *chan; 365761386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 36583c588192SMat Martineau int err = 0; 36590a708f8fSGustavo F. Padovan 36600a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 36610a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 36620a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 36630a708f8fSGustavo F. Padovan 366461386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 366561386cbaSAndrei Emeltchenko result, len); 36660a708f8fSGustavo F. Padovan 3667baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 366848454079SGustavo F. Padovan if (!chan) 36690a708f8fSGustavo F. Padovan return 0; 36700a708f8fSGustavo F. Padovan 36710a708f8fSGustavo F. Padovan switch (result) { 36720a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 367347d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 36740e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36750a708f8fSGustavo F. Padovan break; 36760a708f8fSGustavo F. Padovan 36770e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 36780e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36790e8b207eSAndrei Emeltchenko 36800e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36810e8b207eSAndrei Emeltchenko char buf[64]; 36820e8b207eSAndrei Emeltchenko 36830e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 36840e8b207eSAndrei Emeltchenko buf, &result); 36850e8b207eSAndrei Emeltchenko if (len < 0) { 36860e8b207eSAndrei Emeltchenko l2cap_send_disconn_req(conn, chan, ECONNRESET); 36870e8b207eSAndrei Emeltchenko goto done; 36880e8b207eSAndrei Emeltchenko } 36890e8b207eSAndrei Emeltchenko 36900e8b207eSAndrei Emeltchenko /* check compatibility */ 36910e8b207eSAndrei Emeltchenko 36920e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36930e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36940e8b207eSAndrei Emeltchenko 36950e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36960e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, buf, 36970e8b207eSAndrei Emeltchenko L2CAP_CONF_SUCCESS, 0x0000), buf); 36980e8b207eSAndrei Emeltchenko } 36990e8b207eSAndrei Emeltchenko goto done; 37000e8b207eSAndrei Emeltchenko 37010a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 370273ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 37030a708f8fSGustavo F. Padovan char req[64]; 37040a708f8fSGustavo F. Padovan 37050a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 3706e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 37070a708f8fSGustavo F. Padovan goto done; 37080a708f8fSGustavo F. Padovan } 37090a708f8fSGustavo F. Padovan 37100a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 37110a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 3712b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 3713b4450035SGustavo F. Padovan req, &result); 37140a708f8fSGustavo F. Padovan if (len < 0) { 3715e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 37160a708f8fSGustavo F. Padovan goto done; 37170a708f8fSGustavo F. Padovan } 37180a708f8fSGustavo F. Padovan 37190a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 37200a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 372173ffa904SGustavo F. Padovan chan->num_conf_req++; 37220a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 37230a708f8fSGustavo F. Padovan goto done; 37240a708f8fSGustavo F. Padovan break; 37250a708f8fSGustavo F. Padovan } 37260a708f8fSGustavo F. Padovan 37270a708f8fSGustavo F. Padovan default: 37286be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 37292e0052e4SAndrei Emeltchenko 3730ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 3731e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 37320a708f8fSGustavo F. Padovan goto done; 37330a708f8fSGustavo F. Padovan } 37340a708f8fSGustavo F. Padovan 373559e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 37360a708f8fSGustavo F. Padovan goto done; 37370a708f8fSGustavo F. Padovan 3738c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 37390a708f8fSGustavo F. Padovan 3740c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 374147d1ec61SGustavo F. Padovan set_default_fcs(chan); 37420a708f8fSGustavo F. Padovan 3743105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3744105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 37453c588192SMat Martineau err = l2cap_ertm_init(chan); 37460a708f8fSGustavo F. Padovan 37473c588192SMat Martineau if (err < 0) 37483c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 37493c588192SMat Martineau else 3750cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 37510a708f8fSGustavo F. Padovan } 37520a708f8fSGustavo F. Padovan 37530a708f8fSGustavo F. Padovan done: 37546be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37553c588192SMat Martineau return err; 37560a708f8fSGustavo F. Padovan } 37570a708f8fSGustavo F. Padovan 37580a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 37590a708f8fSGustavo F. Padovan { 37600a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 37610a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 37620a708f8fSGustavo F. Padovan u16 dcid, scid; 376348454079SGustavo F. Padovan struct l2cap_chan *chan; 37640a708f8fSGustavo F. Padovan struct sock *sk; 37650a708f8fSGustavo F. Padovan 37660a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 37670a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 37680a708f8fSGustavo F. Padovan 37690a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 37700a708f8fSGustavo F. Padovan 37713df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37723df91ea2SAndrei Emeltchenko 37733df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 37743df91ea2SAndrei Emeltchenko if (!chan) { 37753df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37760a708f8fSGustavo F. Padovan return 0; 37773df91ea2SAndrei Emeltchenko } 37780a708f8fSGustavo F. Padovan 37796be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 37806be36555SAndrei Emeltchenko 378148454079SGustavo F. Padovan sk = chan->sk; 378248454079SGustavo F. Padovan 3783fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3784fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 37850a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 37860a708f8fSGustavo F. Padovan 37876be36555SAndrei Emeltchenko lock_sock(sk); 37880a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 37896be36555SAndrei Emeltchenko release_sock(sk); 37900a708f8fSGustavo F. Padovan 379161d6ef3eSMat Martineau l2cap_chan_hold(chan); 379248454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 37936be36555SAndrei Emeltchenko 37946be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37950a708f8fSGustavo F. Padovan 379680b98027SGustavo Padovan chan->ops->close(chan); 379761d6ef3eSMat Martineau l2cap_chan_put(chan); 37983df91ea2SAndrei Emeltchenko 37993df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38003df91ea2SAndrei Emeltchenko 38010a708f8fSGustavo F. Padovan return 0; 38020a708f8fSGustavo F. Padovan } 38030a708f8fSGustavo F. Padovan 38040a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38050a708f8fSGustavo F. Padovan { 38060a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 38070a708f8fSGustavo F. Padovan u16 dcid, scid; 380848454079SGustavo F. Padovan struct l2cap_chan *chan; 38090a708f8fSGustavo F. Padovan 38100a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 38110a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 38120a708f8fSGustavo F. Padovan 38130a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 38140a708f8fSGustavo F. Padovan 38153df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 38163df91ea2SAndrei Emeltchenko 38173df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 38183df91ea2SAndrei Emeltchenko if (!chan) { 38193df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38200a708f8fSGustavo F. Padovan return 0; 38213df91ea2SAndrei Emeltchenko } 38220a708f8fSGustavo F. Padovan 38236be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 382448454079SGustavo F. Padovan 382561d6ef3eSMat Martineau l2cap_chan_hold(chan); 382648454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 38276be36555SAndrei Emeltchenko 38286be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 38290a708f8fSGustavo F. Padovan 383080b98027SGustavo Padovan chan->ops->close(chan); 383161d6ef3eSMat Martineau l2cap_chan_put(chan); 38323df91ea2SAndrei Emeltchenko 38333df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38343df91ea2SAndrei Emeltchenko 38350a708f8fSGustavo F. Padovan return 0; 38360a708f8fSGustavo F. Padovan } 38370a708f8fSGustavo F. Padovan 38380a708f8fSGustavo F. Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38390a708f8fSGustavo F. Padovan { 38400a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 38410a708f8fSGustavo F. Padovan u16 type; 38420a708f8fSGustavo F. Padovan 38430a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 38440a708f8fSGustavo F. Padovan 38450a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 38460a708f8fSGustavo F. Padovan 38470a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 38480a708f8fSGustavo F. Padovan u8 buf[8]; 38490a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 38500a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 3851ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 3852ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 38530a708f8fSGustavo F. Padovan if (!disable_ertm) 38540a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 38550a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 3856a5fd6f30SAndrei Emeltchenko if (enable_hs) 38576327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 38586327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 3859a5fd6f30SAndrei Emeltchenko 38600a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 38610a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38620a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38630a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 38640a708f8fSGustavo F. Padovan u8 buf[12]; 38650a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 386650a147cdSMat Martineau 386750a147cdSMat Martineau if (enable_hs) 386850a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 386950a147cdSMat Martineau else 387050a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 387150a147cdSMat Martineau 3872ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 3873ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 3874c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 38750a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38760a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38770a708f8fSGustavo F. Padovan } else { 38780a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 38790a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 3880ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 38810a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38820a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(rsp), &rsp); 38830a708f8fSGustavo F. Padovan } 38840a708f8fSGustavo F. Padovan 38850a708f8fSGustavo F. Padovan return 0; 38860a708f8fSGustavo F. Padovan } 38870a708f8fSGustavo F. Padovan 38880a708f8fSGustavo F. Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38890a708f8fSGustavo F. Padovan { 38900a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 38910a708f8fSGustavo F. Padovan u16 type, result; 38920a708f8fSGustavo F. Padovan 38930a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 38940a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 38950a708f8fSGustavo F. Padovan 38960a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 38970a708f8fSGustavo F. Padovan 3898e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 3899e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 3900e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 3901e90165beSAndrei Emeltchenko return 0; 3902e90165beSAndrei Emeltchenko 390317cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 39040a708f8fSGustavo F. Padovan 39050a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 39060a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39070a708f8fSGustavo F. Padovan conn->info_ident = 0; 39080a708f8fSGustavo F. Padovan 39090a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 39100a708f8fSGustavo F. Padovan 39110a708f8fSGustavo F. Padovan return 0; 39120a708f8fSGustavo F. Padovan } 39130a708f8fSGustavo F. Padovan 3914978c93b9SAndrei Emeltchenko switch (type) { 3915978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 39160a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 39170a708f8fSGustavo F. Padovan 39180a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 39190a708f8fSGustavo F. Padovan struct l2cap_info_req req; 3920ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 39210a708f8fSGustavo F. Padovan 39220a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 39230a708f8fSGustavo F. Padovan 39240a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 39250a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 39260a708f8fSGustavo F. Padovan } else { 39270a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39280a708f8fSGustavo F. Padovan conn->info_ident = 0; 39290a708f8fSGustavo F. Padovan 39300a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 39310a708f8fSGustavo F. Padovan } 3932978c93b9SAndrei Emeltchenko break; 3933978c93b9SAndrei Emeltchenko 3934978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 3935978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 39360a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39370a708f8fSGustavo F. Padovan conn->info_ident = 0; 39380a708f8fSGustavo F. Padovan 39390a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 3940978c93b9SAndrei Emeltchenko break; 39410a708f8fSGustavo F. Padovan } 39420a708f8fSGustavo F. Padovan 39430a708f8fSGustavo F. Padovan return 0; 39440a708f8fSGustavo F. Padovan } 39450a708f8fSGustavo F. Padovan 3946f94ff6ffSMat Martineau static inline int l2cap_create_channel_req(struct l2cap_conn *conn, 3947f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3948f94ff6ffSMat Martineau void *data) 3949f94ff6ffSMat Martineau { 3950f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 3951f94ff6ffSMat Martineau struct l2cap_create_chan_rsp rsp; 3952f94ff6ffSMat Martineau u16 psm, scid; 3953f94ff6ffSMat Martineau 3954f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 3955f94ff6ffSMat Martineau return -EPROTO; 3956f94ff6ffSMat Martineau 3957f94ff6ffSMat Martineau if (!enable_hs) 3958f94ff6ffSMat Martineau return -EINVAL; 3959f94ff6ffSMat Martineau 3960f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 3961f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 3962f94ff6ffSMat Martineau 3963ad0ac6caSAndrei Emeltchenko BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id); 3964f94ff6ffSMat Martineau 3965f94ff6ffSMat Martineau /* Placeholder: Always reject */ 3966f94ff6ffSMat Martineau rsp.dcid = 0; 3967f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 39688ce0c498SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_NO_MEM); 39698ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3970f94ff6ffSMat Martineau 3971f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 3972f94ff6ffSMat Martineau sizeof(rsp), &rsp); 3973f94ff6ffSMat Martineau 3974f94ff6ffSMat Martineau return 0; 3975f94ff6ffSMat Martineau } 3976f94ff6ffSMat Martineau 3977f94ff6ffSMat Martineau static inline int l2cap_create_channel_rsp(struct l2cap_conn *conn, 3978f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, void *data) 3979f94ff6ffSMat Martineau { 3980f94ff6ffSMat Martineau BT_DBG("conn %p", conn); 3981f94ff6ffSMat Martineau 3982f94ff6ffSMat Martineau return l2cap_connect_rsp(conn, cmd, data); 3983f94ff6ffSMat Martineau } 3984f94ff6ffSMat Martineau 39858d5a04a1SMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_conn *conn, u8 ident, 39868d5a04a1SMat Martineau u16 icid, u16 result) 39878d5a04a1SMat Martineau { 39888d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 39898d5a04a1SMat Martineau 3990ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 39918d5a04a1SMat Martineau 39928d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 39938d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 39948d5a04a1SMat Martineau 39958d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_RSP, sizeof(rsp), &rsp); 39968d5a04a1SMat Martineau } 39978d5a04a1SMat Martineau 39988d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_conn *conn, 3999ad0ac6caSAndrei Emeltchenko struct l2cap_chan *chan, 4000ad0ac6caSAndrei Emeltchenko u16 icid, u16 result) 40018d5a04a1SMat Martineau { 40028d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 40038d5a04a1SMat Martineau u8 ident; 40048d5a04a1SMat Martineau 4005ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 40068d5a04a1SMat Martineau 40078d5a04a1SMat Martineau ident = l2cap_get_ident(conn); 40088d5a04a1SMat Martineau if (chan) 40098d5a04a1SMat Martineau chan->ident = ident; 40108d5a04a1SMat Martineau 40118d5a04a1SMat Martineau cfm.icid = cpu_to_le16(icid); 40128d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 40138d5a04a1SMat Martineau 40148d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM, sizeof(cfm), &cfm); 40158d5a04a1SMat Martineau } 40168d5a04a1SMat Martineau 40178d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 40188d5a04a1SMat Martineau u16 icid) 40198d5a04a1SMat Martineau { 40208d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 40218d5a04a1SMat Martineau 4022ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 40238d5a04a1SMat Martineau 40248d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 40258d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 40268d5a04a1SMat Martineau } 40278d5a04a1SMat Martineau 40288d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 4029ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4030ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 40318d5a04a1SMat Martineau { 40328d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 40338d5a04a1SMat Martineau u16 icid = 0; 40348d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 40358d5a04a1SMat Martineau 40368d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 40378d5a04a1SMat Martineau return -EPROTO; 40388d5a04a1SMat Martineau 40398d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 40408d5a04a1SMat Martineau 4041ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id); 40428d5a04a1SMat Martineau 40438d5a04a1SMat Martineau if (!enable_hs) 40448d5a04a1SMat Martineau return -EINVAL; 40458d5a04a1SMat Martineau 40468d5a04a1SMat Martineau /* Placeholder: Always refuse */ 40478d5a04a1SMat Martineau l2cap_send_move_chan_rsp(conn, cmd->ident, icid, result); 40488d5a04a1SMat Martineau 40498d5a04a1SMat Martineau return 0; 40508d5a04a1SMat Martineau } 40518d5a04a1SMat Martineau 40528d5a04a1SMat Martineau static inline int l2cap_move_channel_rsp(struct l2cap_conn *conn, 4053ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4054ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 40558d5a04a1SMat Martineau { 40568d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 40578d5a04a1SMat Martineau u16 icid, result; 40588d5a04a1SMat Martineau 40598d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 40608d5a04a1SMat Martineau return -EPROTO; 40618d5a04a1SMat Martineau 40628d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 40638d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 40648d5a04a1SMat Martineau 4065ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 40668d5a04a1SMat Martineau 40678d5a04a1SMat Martineau /* Placeholder: Always unconfirmed */ 40688d5a04a1SMat Martineau l2cap_send_move_chan_cfm(conn, NULL, icid, L2CAP_MC_UNCONFIRMED); 40698d5a04a1SMat Martineau 40708d5a04a1SMat Martineau return 0; 40718d5a04a1SMat Martineau } 40728d5a04a1SMat Martineau 40738d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm(struct l2cap_conn *conn, 4074ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4075ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 40768d5a04a1SMat Martineau { 40778d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 40788d5a04a1SMat Martineau u16 icid, result; 40798d5a04a1SMat Martineau 40808d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 40818d5a04a1SMat Martineau return -EPROTO; 40828d5a04a1SMat Martineau 40838d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 40848d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 40858d5a04a1SMat Martineau 4086ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result); 40878d5a04a1SMat Martineau 40888d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 40898d5a04a1SMat Martineau 40908d5a04a1SMat Martineau return 0; 40918d5a04a1SMat Martineau } 40928d5a04a1SMat Martineau 40938d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 4094ad0ac6caSAndrei Emeltchenko struct l2cap_cmd_hdr *cmd, 4095ad0ac6caSAndrei Emeltchenko u16 cmd_len, void *data) 40968d5a04a1SMat Martineau { 40978d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 40988d5a04a1SMat Martineau u16 icid; 40998d5a04a1SMat Martineau 41008d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 41018d5a04a1SMat Martineau return -EPROTO; 41028d5a04a1SMat Martineau 41038d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 41048d5a04a1SMat Martineau 4105ad0ac6caSAndrei Emeltchenko BT_DBG("icid 0x%4.4x", icid); 41068d5a04a1SMat Martineau 41078d5a04a1SMat Martineau return 0; 41088d5a04a1SMat Martineau } 41098d5a04a1SMat Martineau 4110e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4111de73115aSClaudio Takahasi u16 to_multiplier) 4112de73115aSClaudio Takahasi { 4113de73115aSClaudio Takahasi u16 max_latency; 4114de73115aSClaudio Takahasi 4115de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4116de73115aSClaudio Takahasi return -EINVAL; 4117de73115aSClaudio Takahasi 4118de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4119de73115aSClaudio Takahasi return -EINVAL; 4120de73115aSClaudio Takahasi 4121de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4122de73115aSClaudio Takahasi return -EINVAL; 4123de73115aSClaudio Takahasi 4124de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 4125de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 4126de73115aSClaudio Takahasi return -EINVAL; 4127de73115aSClaudio Takahasi 4128de73115aSClaudio Takahasi return 0; 4129de73115aSClaudio Takahasi } 4130de73115aSClaudio Takahasi 4131de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 4132de73115aSClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 4133de73115aSClaudio Takahasi { 4134de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 4135de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 4136de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 4137de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 41382ce603ebSClaudio Takahasi int err; 4139de73115aSClaudio Takahasi 4140de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 4141de73115aSClaudio Takahasi return -EINVAL; 4142de73115aSClaudio Takahasi 4143de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 4144de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 4145de73115aSClaudio Takahasi return -EPROTO; 4146de73115aSClaudio Takahasi 4147de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 4148de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 4149de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 4150de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 4151de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 4152de73115aSClaudio Takahasi 4153de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 4154de73115aSClaudio Takahasi min, max, latency, to_multiplier); 4155de73115aSClaudio Takahasi 4156de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 41572ce603ebSClaudio Takahasi 41582ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 41592ce603ebSClaudio Takahasi if (err) 4160ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 4161de73115aSClaudio Takahasi else 4162ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 4163de73115aSClaudio Takahasi 4164de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 4165de73115aSClaudio Takahasi sizeof(rsp), &rsp); 4166de73115aSClaudio Takahasi 41672ce603ebSClaudio Takahasi if (!err) 41682ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 41692ce603ebSClaudio Takahasi 4170de73115aSClaudio Takahasi return 0; 4171de73115aSClaudio Takahasi } 4172de73115aSClaudio Takahasi 41733300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 41743300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 41753300d9a9SClaudio Takahasi { 41763300d9a9SClaudio Takahasi int err = 0; 41773300d9a9SClaudio Takahasi 41783300d9a9SClaudio Takahasi switch (cmd->code) { 41793300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 41803300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 41813300d9a9SClaudio Takahasi break; 41823300d9a9SClaudio Takahasi 41833300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 41843300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 41853300d9a9SClaudio Takahasi break; 41863300d9a9SClaudio Takahasi 41873300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 41883300d9a9SClaudio Takahasi err = l2cap_connect_rsp(conn, cmd, data); 41893300d9a9SClaudio Takahasi break; 41903300d9a9SClaudio Takahasi 41913300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 41923300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 41933300d9a9SClaudio Takahasi break; 41943300d9a9SClaudio Takahasi 41953300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 41963300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 41973300d9a9SClaudio Takahasi break; 41983300d9a9SClaudio Takahasi 41993300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 42003300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 42013300d9a9SClaudio Takahasi break; 42023300d9a9SClaudio Takahasi 42033300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 42043300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 42053300d9a9SClaudio Takahasi break; 42063300d9a9SClaudio Takahasi 42073300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 42083300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 42093300d9a9SClaudio Takahasi break; 42103300d9a9SClaudio Takahasi 42113300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 42123300d9a9SClaudio Takahasi break; 42133300d9a9SClaudio Takahasi 42143300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 42153300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 42163300d9a9SClaudio Takahasi break; 42173300d9a9SClaudio Takahasi 42183300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 42193300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 42203300d9a9SClaudio Takahasi break; 42213300d9a9SClaudio Takahasi 4222f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 4223f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 4224f94ff6ffSMat Martineau break; 4225f94ff6ffSMat Martineau 4226f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_RSP: 4227f94ff6ffSMat Martineau err = l2cap_create_channel_rsp(conn, cmd, data); 4228f94ff6ffSMat Martineau break; 4229f94ff6ffSMat Martineau 42308d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 42318d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 42328d5a04a1SMat Martineau break; 42338d5a04a1SMat Martineau 42348d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 42358d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 42368d5a04a1SMat Martineau break; 42378d5a04a1SMat Martineau 42388d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 42398d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 42408d5a04a1SMat Martineau break; 42418d5a04a1SMat Martineau 42428d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 42438d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 42448d5a04a1SMat Martineau break; 42458d5a04a1SMat Martineau 42463300d9a9SClaudio Takahasi default: 42473300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 42483300d9a9SClaudio Takahasi err = -EINVAL; 42493300d9a9SClaudio Takahasi break; 42503300d9a9SClaudio Takahasi } 42513300d9a9SClaudio Takahasi 42523300d9a9SClaudio Takahasi return err; 42533300d9a9SClaudio Takahasi } 42543300d9a9SClaudio Takahasi 42553300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 42563300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 42573300d9a9SClaudio Takahasi { 42583300d9a9SClaudio Takahasi switch (cmd->code) { 42593300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 42603300d9a9SClaudio Takahasi return 0; 42613300d9a9SClaudio Takahasi 42623300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 4263de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 42643300d9a9SClaudio Takahasi 42653300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 42663300d9a9SClaudio Takahasi return 0; 42673300d9a9SClaudio Takahasi 42683300d9a9SClaudio Takahasi default: 42693300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 42703300d9a9SClaudio Takahasi return -EINVAL; 42713300d9a9SClaudio Takahasi } 42723300d9a9SClaudio Takahasi } 42733300d9a9SClaudio Takahasi 42743300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 42753300d9a9SClaudio Takahasi struct sk_buff *skb) 42760a708f8fSGustavo F. Padovan { 42770a708f8fSGustavo F. Padovan u8 *data = skb->data; 42780a708f8fSGustavo F. Padovan int len = skb->len; 42790a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 42803300d9a9SClaudio Takahasi int err; 42810a708f8fSGustavo F. Padovan 42820a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 42830a708f8fSGustavo F. Padovan 42840a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 42850a708f8fSGustavo F. Padovan u16 cmd_len; 42860a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 42870a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 42880a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 42890a708f8fSGustavo F. Padovan 42900a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 42910a708f8fSGustavo F. Padovan 42920a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, cmd.ident); 42930a708f8fSGustavo F. Padovan 42940a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 42950a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 42960a708f8fSGustavo F. Padovan break; 42970a708f8fSGustavo F. Padovan } 42980a708f8fSGustavo F. Padovan 42993300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 43003300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 43013300d9a9SClaudio Takahasi else 43023300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 43030a708f8fSGustavo F. Padovan 43040a708f8fSGustavo F. Padovan if (err) { 4305e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 43062c6d1a2eSGustavo F. Padovan 43072c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 43080a708f8fSGustavo F. Padovan 43090a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 4310ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 43110a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej); 43120a708f8fSGustavo F. Padovan } 43130a708f8fSGustavo F. Padovan 43140a708f8fSGustavo F. Padovan data += cmd_len; 43150a708f8fSGustavo F. Padovan len -= cmd_len; 43160a708f8fSGustavo F. Padovan } 43170a708f8fSGustavo F. Padovan 43180a708f8fSGustavo F. Padovan kfree_skb(skb); 43190a708f8fSGustavo F. Padovan } 43200a708f8fSGustavo F. Padovan 432147d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 43220a708f8fSGustavo F. Padovan { 43230a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 4324e4ca6d98SAndrei Emeltchenko int hdr_size; 4325e4ca6d98SAndrei Emeltchenko 4326e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 4327e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 4328e4ca6d98SAndrei Emeltchenko else 4329e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 43300a708f8fSGustavo F. Padovan 433147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 433203a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 43330a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 43340a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 43350a708f8fSGustavo F. Padovan 43360a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 43370a708f8fSGustavo F. Padovan return -EBADMSG; 43380a708f8fSGustavo F. Padovan } 43390a708f8fSGustavo F. Padovan return 0; 43400a708f8fSGustavo F. Padovan } 43410a708f8fSGustavo F. Padovan 43426ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 43430a708f8fSGustavo F. Padovan { 4344e31f7633SMat Martineau struct l2cap_ctrl control; 43450a708f8fSGustavo F. Padovan 4346e31f7633SMat Martineau BT_DBG("chan %p", chan); 43470a708f8fSGustavo F. Padovan 4348e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 4349e31f7633SMat Martineau control.sframe = 1; 4350e31f7633SMat Martineau control.final = 1; 4351e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 4352e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 43530a708f8fSGustavo F. Padovan 4354e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4355e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 4356e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43570a708f8fSGustavo F. Padovan } 43580a708f8fSGustavo F. Padovan 4359e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 4360e31f7633SMat Martineau chan->unacked_frames > 0) 4361e31f7633SMat Martineau __set_retrans_timer(chan); 43620a708f8fSGustavo F. Padovan 4363e31f7633SMat Martineau /* Send pending iframes */ 4364525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 43650a708f8fSGustavo F. Padovan 4366e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 4367e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 4368e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 4369e31f7633SMat Martineau * send it now. 4370e31f7633SMat Martineau */ 4371e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 4372e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43730a708f8fSGustavo F. Padovan } 43740a708f8fSGustavo F. Padovan } 43750a708f8fSGustavo F. Padovan 437684084a31SMat Martineau static void append_skb_frag(struct sk_buff *skb, 437784084a31SMat Martineau struct sk_buff *new_frag, struct sk_buff **last_frag) 43780a708f8fSGustavo F. Padovan { 437984084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 438084084a31SMat Martineau * skb->data_len reflects only data in fragments 438184084a31SMat Martineau */ 438284084a31SMat Martineau if (!skb_has_frag_list(skb)) 438384084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 438484084a31SMat Martineau 438584084a31SMat Martineau new_frag->next = NULL; 438684084a31SMat Martineau 438784084a31SMat Martineau (*last_frag)->next = new_frag; 438884084a31SMat Martineau *last_frag = new_frag; 438984084a31SMat Martineau 439084084a31SMat Martineau skb->len += new_frag->len; 439184084a31SMat Martineau skb->data_len += new_frag->len; 439284084a31SMat Martineau skb->truesize += new_frag->truesize; 439384084a31SMat Martineau } 439484084a31SMat Martineau 43954b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 43964b51dae9SMat Martineau struct l2cap_ctrl *control) 439784084a31SMat Martineau { 439884084a31SMat Martineau int err = -EINVAL; 43990a708f8fSGustavo F. Padovan 44004b51dae9SMat Martineau switch (control->sar) { 44017e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 440284084a31SMat Martineau if (chan->sdu) 440384084a31SMat Martineau break; 44040a708f8fSGustavo F. Padovan 440580b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 440684084a31SMat Martineau break; 44070a708f8fSGustavo F. Padovan 44087e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 440984084a31SMat Martineau if (chan->sdu) 441084084a31SMat Martineau break; 44110a708f8fSGustavo F. Padovan 44126f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 441303a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 44140a708f8fSGustavo F. Padovan 441584084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 441684084a31SMat Martineau err = -EMSGSIZE; 441784084a31SMat Martineau break; 441884084a31SMat Martineau } 44190a708f8fSGustavo F. Padovan 442084084a31SMat Martineau if (skb->len >= chan->sdu_len) 442184084a31SMat Martineau break; 442284084a31SMat Martineau 442384084a31SMat Martineau chan->sdu = skb; 442484084a31SMat Martineau chan->sdu_last_frag = skb; 442584084a31SMat Martineau 442684084a31SMat Martineau skb = NULL; 442784084a31SMat Martineau err = 0; 44280a708f8fSGustavo F. Padovan break; 44290a708f8fSGustavo F. Padovan 44307e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 44316f61fd47SGustavo F. Padovan if (!chan->sdu) 443284084a31SMat Martineau break; 44330a708f8fSGustavo F. Padovan 443484084a31SMat Martineau append_skb_frag(chan->sdu, skb, 443584084a31SMat Martineau &chan->sdu_last_frag); 443684084a31SMat Martineau skb = NULL; 44370a708f8fSGustavo F. Padovan 443884084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 443984084a31SMat Martineau break; 44400a708f8fSGustavo F. Padovan 444184084a31SMat Martineau err = 0; 44420a708f8fSGustavo F. Padovan break; 44430a708f8fSGustavo F. Padovan 44447e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 44456f61fd47SGustavo F. Padovan if (!chan->sdu) 444684084a31SMat Martineau break; 44470a708f8fSGustavo F. Padovan 444884084a31SMat Martineau append_skb_frag(chan->sdu, skb, 444984084a31SMat Martineau &chan->sdu_last_frag); 445084084a31SMat Martineau skb = NULL; 44510a708f8fSGustavo F. Padovan 445284084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 445384084a31SMat Martineau break; 44540a708f8fSGustavo F. Padovan 445580b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 44560a708f8fSGustavo F. Padovan 445784084a31SMat Martineau if (!err) { 445884084a31SMat Martineau /* Reassembly complete */ 445984084a31SMat Martineau chan->sdu = NULL; 446084084a31SMat Martineau chan->sdu_last_frag = NULL; 446184084a31SMat Martineau chan->sdu_len = 0; 44620a708f8fSGustavo F. Padovan } 44630a708f8fSGustavo F. Padovan break; 44640a708f8fSGustavo F. Padovan } 44650a708f8fSGustavo F. Padovan 446684084a31SMat Martineau if (err) { 44670a708f8fSGustavo F. Padovan kfree_skb(skb); 44686f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 44696f61fd47SGustavo F. Padovan chan->sdu = NULL; 447084084a31SMat Martineau chan->sdu_last_frag = NULL; 447184084a31SMat Martineau chan->sdu_len = 0; 447284084a31SMat Martineau } 44730a708f8fSGustavo F. Padovan 447484084a31SMat Martineau return err; 44750a708f8fSGustavo F. Padovan } 44760a708f8fSGustavo F. Padovan 4477e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 44780a708f8fSGustavo F. Padovan { 447961aa4f5bSMat Martineau u8 event; 448061aa4f5bSMat Martineau 448161aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 448261aa4f5bSMat Martineau return; 448361aa4f5bSMat Martineau 448461aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 4485401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 44860a708f8fSGustavo F. Padovan } 44870a708f8fSGustavo F. Padovan 4488d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 4489d2a7ac5dSMat Martineau { 449063838725SMat Martineau int err = 0; 449163838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 449263838725SMat Martineau * until a gap is encountered. 449363838725SMat Martineau */ 449463838725SMat Martineau 449563838725SMat Martineau BT_DBG("chan %p", chan); 449663838725SMat Martineau 449763838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 449863838725SMat Martineau struct sk_buff *skb; 449963838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 450063838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 450163838725SMat Martineau 450263838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 450363838725SMat Martineau 450463838725SMat Martineau if (!skb) 450563838725SMat Martineau break; 450663838725SMat Martineau 450763838725SMat Martineau skb_unlink(skb, &chan->srej_q); 450863838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 450963838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 451063838725SMat Martineau if (err) 451163838725SMat Martineau break; 451263838725SMat Martineau } 451363838725SMat Martineau 451463838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 451563838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 451663838725SMat Martineau l2cap_send_ack(chan); 451763838725SMat Martineau } 451863838725SMat Martineau 451963838725SMat Martineau return err; 4520d2a7ac5dSMat Martineau } 4521d2a7ac5dSMat Martineau 4522d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 4523d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4524d2a7ac5dSMat Martineau { 4525f80842a8SMat Martineau struct sk_buff *skb; 4526f80842a8SMat Martineau 4527f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 4528f80842a8SMat Martineau 4529f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 4530f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4531f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4532f80842a8SMat Martineau return; 4533f80842a8SMat Martineau } 4534f80842a8SMat Martineau 4535f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4536f80842a8SMat Martineau 4537f80842a8SMat Martineau if (skb == NULL) { 4538f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 4539f80842a8SMat Martineau control->reqseq); 4540f80842a8SMat Martineau return; 4541f80842a8SMat Martineau } 4542f80842a8SMat Martineau 4543f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 4544f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4545f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4546f80842a8SMat Martineau return; 4547f80842a8SMat Martineau } 4548f80842a8SMat Martineau 4549f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4550f80842a8SMat Martineau 4551f80842a8SMat Martineau if (control->poll) { 4552f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 4553f80842a8SMat Martineau 4554f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4555f80842a8SMat Martineau l2cap_retransmit(chan, control); 4556f80842a8SMat Martineau l2cap_ertm_send(chan); 4557f80842a8SMat Martineau 4558f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4559f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4560f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4561f80842a8SMat Martineau } 4562f80842a8SMat Martineau } else { 4563f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 4564f80842a8SMat Martineau 4565f80842a8SMat Martineau if (control->final) { 4566f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 4567f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 4568f80842a8SMat Martineau &chan->conn_state)) 4569f80842a8SMat Martineau l2cap_retransmit(chan, control); 4570f80842a8SMat Martineau } else { 4571f80842a8SMat Martineau l2cap_retransmit(chan, control); 4572f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4573f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4574f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4575f80842a8SMat Martineau } 4576f80842a8SMat Martineau } 4577f80842a8SMat Martineau } 4578d2a7ac5dSMat Martineau } 4579d2a7ac5dSMat Martineau 4580d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 4581d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4582d2a7ac5dSMat Martineau { 4583fcd289dfSMat Martineau struct sk_buff *skb; 4584fcd289dfSMat Martineau 4585fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 4586fcd289dfSMat Martineau 4587fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 4588fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4589fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4590fcd289dfSMat Martineau return; 4591fcd289dfSMat Martineau } 4592fcd289dfSMat Martineau 4593fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4594fcd289dfSMat Martineau 4595fcd289dfSMat Martineau if (chan->max_tx && skb && 4596fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 4597fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4598fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4599fcd289dfSMat Martineau return; 4600fcd289dfSMat Martineau } 4601fcd289dfSMat Martineau 4602fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4603fcd289dfSMat Martineau 4604fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 4605fcd289dfSMat Martineau 4606fcd289dfSMat Martineau if (control->final) { 4607fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 4608fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4609fcd289dfSMat Martineau } else { 4610fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4611fcd289dfSMat Martineau l2cap_ertm_send(chan); 4612fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 4613fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 4614fcd289dfSMat Martineau } 4615d2a7ac5dSMat Martineau } 4616d2a7ac5dSMat Martineau 46174b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 46184b51dae9SMat Martineau { 46194b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 46204b51dae9SMat Martineau 46214b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 46224b51dae9SMat Martineau chan->expected_tx_seq); 46234b51dae9SMat Martineau 46244b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 46254b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 46264b51dae9SMat Martineau chan->tx_win) { 46274b51dae9SMat Martineau /* See notes below regarding "double poll" and 46284b51dae9SMat Martineau * invalid packets. 46294b51dae9SMat Martineau */ 46304b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 46314b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 46324b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 46334b51dae9SMat Martineau } else { 46344b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 46354b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46364b51dae9SMat Martineau } 46374b51dae9SMat Martineau } 46384b51dae9SMat Martineau 46394b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 46404b51dae9SMat Martineau BT_DBG("Expected SREJ"); 46414b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 46424b51dae9SMat Martineau } 46434b51dae9SMat Martineau 46444b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 46454b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 46464b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 46474b51dae9SMat Martineau } 46484b51dae9SMat Martineau 46494b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 46504b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 46514b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 46524b51dae9SMat Martineau } 46534b51dae9SMat Martineau } 46544b51dae9SMat Martineau 46554b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 46564b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 46574b51dae9SMat Martineau chan->tx_win) { 46584b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46594b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46604b51dae9SMat Martineau } else { 46614b51dae9SMat Martineau BT_DBG("Expected"); 46624b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 46634b51dae9SMat Martineau } 46644b51dae9SMat Martineau } 46654b51dae9SMat Martineau 46664b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 46674b51dae9SMat Martineau __seq_offset(chan, chan->expected_tx_seq, 46684b51dae9SMat Martineau chan->last_acked_seq)){ 46694b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 46704b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 46714b51dae9SMat Martineau } 46724b51dae9SMat Martineau 46734b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 46744b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 46754b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 46764b51dae9SMat Martineau * the remote stack receives and processes both polls, 46774b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 46784b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 46794b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 46804b51dae9SMat Martineau * request. 46814b51dae9SMat Martineau * 46824b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 46834b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 46844b51dae9SMat Martineau * invalid frames to be safely ignored. 46854b51dae9SMat Martineau * 46864b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 46874b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 46884b51dae9SMat Martineau * causes a disconnect. 46894b51dae9SMat Martineau */ 46904b51dae9SMat Martineau 46914b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 46924b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 46934b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 46944b51dae9SMat Martineau } else { 46954b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46964b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46974b51dae9SMat Martineau } 46984b51dae9SMat Martineau } else { 46994b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 47004b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 47014b51dae9SMat Martineau } 47024b51dae9SMat Martineau } 47034b51dae9SMat Martineau 4704d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 4705d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4706d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4707d2a7ac5dSMat Martineau { 4708d2a7ac5dSMat Martineau int err = 0; 4709d2a7ac5dSMat Martineau bool skb_in_use = 0; 4710d2a7ac5dSMat Martineau 4711d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4712d2a7ac5dSMat Martineau event); 4713d2a7ac5dSMat Martineau 4714d2a7ac5dSMat Martineau switch (event) { 4715d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4716d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 4717d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4718d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4719d2a7ac5dSMat Martineau 4720d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4721d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 4722d2a7ac5dSMat Martineau control->txseq); 4723d2a7ac5dSMat Martineau break; 4724d2a7ac5dSMat Martineau } 4725d2a7ac5dSMat Martineau 4726d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 4727d2a7ac5dSMat Martineau control->txseq); 4728d2a7ac5dSMat Martineau 4729d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 4730d2a7ac5dSMat Martineau skb_in_use = 1; 4731d2a7ac5dSMat Martineau 4732d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 4733d2a7ac5dSMat Martineau if (err) 4734d2a7ac5dSMat Martineau break; 4735d2a7ac5dSMat Martineau 4736d2a7ac5dSMat Martineau if (control->final) { 4737d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4738d2a7ac5dSMat Martineau &chan->conn_state)) { 4739d2a7ac5dSMat Martineau control->final = 0; 4740d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4741d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4742d2a7ac5dSMat Martineau } 4743d2a7ac5dSMat Martineau } 4744d2a7ac5dSMat Martineau 4745d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 4746d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4747d2a7ac5dSMat Martineau break; 4748d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4749d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4750d2a7ac5dSMat Martineau 4751d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 4752d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 4753d2a7ac5dSMat Martineau * when local busy is exited. 4754d2a7ac5dSMat Martineau */ 4755d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4756d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 4757d2a7ac5dSMat Martineau control->txseq); 4758d2a7ac5dSMat Martineau break; 4759d2a7ac5dSMat Martineau } 4760d2a7ac5dSMat Martineau 4761d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 4762d2a7ac5dSMat Martineau * must be sent for each missing frame. The 4763d2a7ac5dSMat Martineau * current frame is stored for later use. 4764d2a7ac5dSMat Martineau */ 4765d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4766d2a7ac5dSMat Martineau skb_in_use = 1; 4767d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4768d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4769d2a7ac5dSMat Martineau 4770d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 4771d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 4772d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4773d2a7ac5dSMat Martineau 4774d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 4775d2a7ac5dSMat Martineau break; 4776d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4777d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4778d2a7ac5dSMat Martineau break; 4779d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4780d2a7ac5dSMat Martineau break; 4781d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4782d2a7ac5dSMat Martineau default: 4783d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4784d2a7ac5dSMat Martineau ECONNRESET); 4785d2a7ac5dSMat Martineau break; 4786d2a7ac5dSMat Martineau } 4787d2a7ac5dSMat Martineau break; 4788d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4789d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4790d2a7ac5dSMat Martineau if (control->final) { 4791d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4792d2a7ac5dSMat Martineau 4793d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4794d2a7ac5dSMat Martineau &chan->conn_state)) { 4795d2a7ac5dSMat Martineau control->final = 0; 4796d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4797d2a7ac5dSMat Martineau } 4798d2a7ac5dSMat Martineau 4799d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4800d2a7ac5dSMat Martineau } else if (control->poll) { 4801d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 4802d2a7ac5dSMat Martineau } else { 4803d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4804d2a7ac5dSMat Martineau &chan->conn_state) && 4805d2a7ac5dSMat Martineau chan->unacked_frames) 4806d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4807d2a7ac5dSMat Martineau 4808d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4809d2a7ac5dSMat Martineau } 4810d2a7ac5dSMat Martineau break; 4811d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4812d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4813d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4814d2a7ac5dSMat Martineau if (control && control->poll) { 4815d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4816d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 4817d2a7ac5dSMat Martineau } 4818d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 4819d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 4820d2a7ac5dSMat Martineau break; 4821d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4822d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4823d2a7ac5dSMat Martineau break; 4824d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4825d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4826d2a7ac5dSMat Martineau break; 4827d2a7ac5dSMat Martineau default: 4828d2a7ac5dSMat Martineau break; 4829d2a7ac5dSMat Martineau } 4830d2a7ac5dSMat Martineau 4831d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4832d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4833d2a7ac5dSMat Martineau kfree_skb(skb); 4834d2a7ac5dSMat Martineau } 4835d2a7ac5dSMat Martineau 4836d2a7ac5dSMat Martineau return err; 4837d2a7ac5dSMat Martineau } 4838d2a7ac5dSMat Martineau 4839d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 4840d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4841d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4842d2a7ac5dSMat Martineau { 4843d2a7ac5dSMat Martineau int err = 0; 4844d2a7ac5dSMat Martineau u16 txseq = control->txseq; 4845d2a7ac5dSMat Martineau bool skb_in_use = 0; 4846d2a7ac5dSMat Martineau 4847d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4848d2a7ac5dSMat Martineau event); 4849d2a7ac5dSMat Martineau 4850d2a7ac5dSMat Martineau switch (event) { 4851d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4852d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 4853d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4854d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 4855d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4856d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4857d2a7ac5dSMat Martineau skb_in_use = 1; 4858d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4859d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4860d2a7ac5dSMat Martineau 4861d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 4862d2a7ac5dSMat Martineau break; 4863d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 4864d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 4865d2a7ac5dSMat Martineau 4866d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4867d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4868d2a7ac5dSMat Martineau skb_in_use = 1; 4869d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4870d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4871d2a7ac5dSMat Martineau 4872d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 4873d2a7ac5dSMat Martineau if (err) 4874d2a7ac5dSMat Martineau break; 4875d2a7ac5dSMat Martineau 4876d2a7ac5dSMat Martineau break; 4877d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4878d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 4879d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 4880d2a7ac5dSMat Martineau * the missing frames. 4881d2a7ac5dSMat Martineau */ 4882d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4883d2a7ac5dSMat Martineau skb_in_use = 1; 4884d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4885d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4886d2a7ac5dSMat Martineau 4887d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4888d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4889d2a7ac5dSMat Martineau break; 4890d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 4891d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 4892d2a7ac5dSMat Martineau * some expected retransmitted frames are 4893d2a7ac5dSMat Martineau * missing. Request retransmission of missing 4894d2a7ac5dSMat Martineau * SREJ'd frames. 4895d2a7ac5dSMat Martineau */ 4896d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4897d2a7ac5dSMat Martineau skb_in_use = 1; 4898d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4899d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4900d2a7ac5dSMat Martineau 4901d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4902d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 4903d2a7ac5dSMat Martineau break; 4904d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 4905d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 4906d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4907d2a7ac5dSMat Martineau break; 4908d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4909d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 4910d2a7ac5dSMat Martineau * was already received. Ignore it completely. 4911d2a7ac5dSMat Martineau */ 4912d2a7ac5dSMat Martineau break; 4913d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4914d2a7ac5dSMat Martineau break; 4915d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4916d2a7ac5dSMat Martineau default: 4917d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4918d2a7ac5dSMat Martineau ECONNRESET); 4919d2a7ac5dSMat Martineau break; 4920d2a7ac5dSMat Martineau } 4921d2a7ac5dSMat Martineau break; 4922d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4923d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4924d2a7ac5dSMat Martineau if (control->final) { 4925d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4926d2a7ac5dSMat Martineau 4927d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4928d2a7ac5dSMat Martineau &chan->conn_state)) { 4929d2a7ac5dSMat Martineau control->final = 0; 4930d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4931d2a7ac5dSMat Martineau } 4932d2a7ac5dSMat Martineau 4933d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4934d2a7ac5dSMat Martineau } else if (control->poll) { 4935d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4936d2a7ac5dSMat Martineau &chan->conn_state) && 4937d2a7ac5dSMat Martineau chan->unacked_frames) { 4938d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4939d2a7ac5dSMat Martineau } 4940d2a7ac5dSMat Martineau 4941d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4942d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4943d2a7ac5dSMat Martineau } else { 4944d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4945d2a7ac5dSMat Martineau &chan->conn_state) && 4946d2a7ac5dSMat Martineau chan->unacked_frames) 4947d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4948d2a7ac5dSMat Martineau 4949d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4950d2a7ac5dSMat Martineau } 4951d2a7ac5dSMat Martineau break; 4952d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4953d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4954d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4955d2a7ac5dSMat Martineau if (control->poll) { 4956d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4957d2a7ac5dSMat Martineau } else { 4958d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 4959d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 4960d2a7ac5dSMat Martineau rr_control.sframe = 1; 4961d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 4962d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 4963d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 4964d2a7ac5dSMat Martineau } 4965d2a7ac5dSMat Martineau 4966d2a7ac5dSMat Martineau break; 4967d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4968d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4969d2a7ac5dSMat Martineau break; 4970d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4971d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4972d2a7ac5dSMat Martineau break; 4973d2a7ac5dSMat Martineau } 4974d2a7ac5dSMat Martineau 4975d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4976d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4977d2a7ac5dSMat Martineau kfree_skb(skb); 4978d2a7ac5dSMat Martineau } 4979d2a7ac5dSMat Martineau 4980d2a7ac5dSMat Martineau return err; 4981d2a7ac5dSMat Martineau } 4982d2a7ac5dSMat Martineau 4983d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 4984d2a7ac5dSMat Martineau { 4985d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 4986d2a7ac5dSMat Martineau u16 unacked; 4987d2a7ac5dSMat Martineau 4988d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 4989d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 4990d2a7ac5dSMat Martineau } 4991d2a7ac5dSMat Martineau 4992cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 4993cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 49940a708f8fSGustavo F. Padovan { 4995d2a7ac5dSMat Martineau int err = 0; 4996d2a7ac5dSMat Martineau 4997d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 4998d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 4999d2a7ac5dSMat Martineau 5000d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 5001d2a7ac5dSMat Martineau switch (chan->rx_state) { 5002d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 5003d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 5004d2a7ac5dSMat Martineau break; 5005d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 5006d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 5007d2a7ac5dSMat Martineau event); 5008d2a7ac5dSMat Martineau break; 5009d2a7ac5dSMat Martineau default: 5010d2a7ac5dSMat Martineau /* shut it down */ 5011d2a7ac5dSMat Martineau break; 5012d2a7ac5dSMat Martineau } 5013d2a7ac5dSMat Martineau } else { 5014d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 5015d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 5016d2a7ac5dSMat Martineau chan->expected_ack_seq); 5017d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 5018d2a7ac5dSMat Martineau } 5019d2a7ac5dSMat Martineau 5020d2a7ac5dSMat Martineau return err; 5021cec8ab6eSMat Martineau } 5022cec8ab6eSMat Martineau 5023cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5024cec8ab6eSMat Martineau struct sk_buff *skb) 5025cec8ab6eSMat Martineau { 50264b51dae9SMat Martineau int err = 0; 50274b51dae9SMat Martineau 50284b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 50294b51dae9SMat Martineau chan->rx_state); 50304b51dae9SMat Martineau 50314b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 50324b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 50334b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 50344b51dae9SMat Martineau 50354b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 50364b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 50374b51dae9SMat Martineau 50384b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 50394b51dae9SMat Martineau 50404b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 50414b51dae9SMat Martineau } else { 50424b51dae9SMat Martineau if (chan->sdu) { 50434b51dae9SMat Martineau kfree_skb(chan->sdu); 50444b51dae9SMat Martineau chan->sdu = NULL; 50454b51dae9SMat Martineau } 50464b51dae9SMat Martineau chan->sdu_last_frag = NULL; 50474b51dae9SMat Martineau chan->sdu_len = 0; 50484b51dae9SMat Martineau 50494b51dae9SMat Martineau if (skb) { 50504b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 50514b51dae9SMat Martineau kfree_skb(skb); 50524b51dae9SMat Martineau } 50534b51dae9SMat Martineau } 50544b51dae9SMat Martineau 50554b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 50564b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 50574b51dae9SMat Martineau 50584b51dae9SMat Martineau return err; 5059cec8ab6eSMat Martineau } 5060cec8ab6eSMat Martineau 5061cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 5062cec8ab6eSMat Martineau { 5063cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 5064cec8ab6eSMat Martineau u16 len; 5065cec8ab6eSMat Martineau u8 event; 50660a708f8fSGustavo F. Padovan 5067b76bbd66SMat Martineau __unpack_control(chan, skb); 5068b76bbd66SMat Martineau 50690a708f8fSGustavo F. Padovan len = skb->len; 50700a708f8fSGustavo F. Padovan 50710a708f8fSGustavo F. Padovan /* 50720a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 50730a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 5074cec8ab6eSMat Martineau * procedures and ask for retransmission. 50750a708f8fSGustavo F. Padovan */ 507647d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 50770a708f8fSGustavo F. Padovan goto drop; 50780a708f8fSGustavo F. Padovan 5079cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 508003a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 50810a708f8fSGustavo F. Padovan 508247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 508303a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 50840a708f8fSGustavo F. Padovan 508547d1ec61SGustavo F. Padovan if (len > chan->mps) { 50868c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 50870a708f8fSGustavo F. Padovan goto drop; 50880a708f8fSGustavo F. Padovan } 50890a708f8fSGustavo F. Padovan 5090cec8ab6eSMat Martineau if (!control->sframe) { 5091cec8ab6eSMat Martineau int err; 50920a708f8fSGustavo F. Padovan 5093cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 5094cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 5095cec8ab6eSMat Martineau control->txseq); 5096836be934SAndrei Emeltchenko 5097cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 5098cec8ab6eSMat Martineau * valid in TX WAIT_F 5099cec8ab6eSMat Martineau */ 5100cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 51010a708f8fSGustavo F. Padovan goto drop; 51020a708f8fSGustavo F. Padovan 5103cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 5104cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 5105cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 51060a708f8fSGustavo F. Padovan } else { 5107cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 5108cec8ab6eSMat Martineau } 5109cec8ab6eSMat Martineau 5110cec8ab6eSMat Martineau if (err) 5111cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5112cec8ab6eSMat Martineau ECONNRESET); 5113cec8ab6eSMat Martineau } else { 5114cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 5115cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 5116cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 5117cec8ab6eSMat Martineau }; 5118cec8ab6eSMat Martineau 5119cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 5120cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 5121cec8ab6eSMat Martineau goto drop; 5122cec8ab6eSMat Martineau 5123cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 5124cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 5125cec8ab6eSMat Martineau control->super); 5126cec8ab6eSMat Martineau 51270a708f8fSGustavo F. Padovan if (len != 0) { 51280a708f8fSGustavo F. Padovan BT_ERR("%d", len); 51298c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51300a708f8fSGustavo F. Padovan goto drop; 51310a708f8fSGustavo F. Padovan } 51320a708f8fSGustavo F. Padovan 5133cec8ab6eSMat Martineau /* Validate F and P bits */ 5134cec8ab6eSMat Martineau if (control->final && (control->poll || 5135cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 5136cec8ab6eSMat Martineau goto drop; 5137cec8ab6eSMat Martineau 5138cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 5139cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 5140cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51410a708f8fSGustavo F. Padovan } 51420a708f8fSGustavo F. Padovan 51430a708f8fSGustavo F. Padovan return 0; 51440a708f8fSGustavo F. Padovan 51450a708f8fSGustavo F. Padovan drop: 51460a708f8fSGustavo F. Padovan kfree_skb(skb); 51470a708f8fSGustavo F. Padovan return 0; 51480a708f8fSGustavo F. Padovan } 51490a708f8fSGustavo F. Padovan 515013ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 515113ca56e0SAndrei Emeltchenko struct sk_buff *skb) 51520a708f8fSGustavo F. Padovan { 515348454079SGustavo F. Padovan struct l2cap_chan *chan; 51540a708f8fSGustavo F. Padovan 5155baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 515648454079SGustavo F. Padovan if (!chan) { 515797e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 515897e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 515997e8e89dSAndrei Emeltchenko if (!chan) { 516097e8e89dSAndrei Emeltchenko kfree_skb(skb); 516113ca56e0SAndrei Emeltchenko return; 516297e8e89dSAndrei Emeltchenko } 516397e8e89dSAndrei Emeltchenko 516497e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 516597e8e89dSAndrei Emeltchenko } else { 51660a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 51676be36555SAndrei Emeltchenko /* Drop packet and return */ 51683379013bSDan Carpenter kfree_skb(skb); 516913ca56e0SAndrei Emeltchenko return; 51700a708f8fSGustavo F. Padovan } 517197e8e89dSAndrei Emeltchenko } 51720a708f8fSGustavo F. Padovan 517349208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 51740a708f8fSGustavo F. Padovan 517589bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 51760a708f8fSGustavo F. Padovan goto drop; 51770a708f8fSGustavo F. Padovan 51780c1bc5c6SGustavo F. Padovan switch (chan->mode) { 51790a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 51800a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 51810a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 51820a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 51830a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 51840a708f8fSGustavo F. Padovan 51850c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 51860a708f8fSGustavo F. Padovan goto drop; 51870a708f8fSGustavo F. Padovan 518880b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 51890a708f8fSGustavo F. Padovan goto done; 51900a708f8fSGustavo F. Padovan break; 51910a708f8fSGustavo F. Padovan 51920a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 51930a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 5194cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 51950a708f8fSGustavo F. Padovan goto done; 51960a708f8fSGustavo F. Padovan 51970a708f8fSGustavo F. Padovan default: 51980c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 51990a708f8fSGustavo F. Padovan break; 52000a708f8fSGustavo F. Padovan } 52010a708f8fSGustavo F. Padovan 52020a708f8fSGustavo F. Padovan drop: 52030a708f8fSGustavo F. Padovan kfree_skb(skb); 52040a708f8fSGustavo F. Padovan 52050a708f8fSGustavo F. Padovan done: 52066be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 52070a708f8fSGustavo F. Padovan } 52080a708f8fSGustavo F. Padovan 520984104b24SAndrei Emeltchenko static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, 521084104b24SAndrei Emeltchenko struct sk_buff *skb) 52110a708f8fSGustavo F. Padovan { 521223691d75SGustavo F. Padovan struct l2cap_chan *chan; 52130a708f8fSGustavo F. Padovan 5214c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 521523691d75SGustavo F. Padovan if (!chan) 52160a708f8fSGustavo F. Padovan goto drop; 52170a708f8fSGustavo F. Padovan 52185b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 52190a708f8fSGustavo F. Padovan 522089bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 52210a708f8fSGustavo F. Padovan goto drop; 52220a708f8fSGustavo F. Padovan 5223e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 52240a708f8fSGustavo F. Padovan goto drop; 52250a708f8fSGustavo F. Padovan 522680b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 522784104b24SAndrei Emeltchenko return; 52280a708f8fSGustavo F. Padovan 52290a708f8fSGustavo F. Padovan drop: 52300a708f8fSGustavo F. Padovan kfree_skb(skb); 52310a708f8fSGustavo F. Padovan } 52320a708f8fSGustavo F. Padovan 52336810fca7SAndrei Emeltchenko static void l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 5234d9b88702SAndrei Emeltchenko struct sk_buff *skb) 52359f69bda6SGustavo F. Padovan { 523623691d75SGustavo F. Padovan struct l2cap_chan *chan; 52379f69bda6SGustavo F. Padovan 5238c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 523923691d75SGustavo F. Padovan if (!chan) 52409f69bda6SGustavo F. Padovan goto drop; 52419f69bda6SGustavo F. Padovan 52425b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 52439f69bda6SGustavo F. Padovan 524489bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 52459f69bda6SGustavo F. Padovan goto drop; 52469f69bda6SGustavo F. Padovan 5247e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 52489f69bda6SGustavo F. Padovan goto drop; 52499f69bda6SGustavo F. Padovan 525080b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 52516810fca7SAndrei Emeltchenko return; 52529f69bda6SGustavo F. Padovan 52539f69bda6SGustavo F. Padovan drop: 52549f69bda6SGustavo F. Padovan kfree_skb(skb); 52559f69bda6SGustavo F. Padovan } 52569f69bda6SGustavo F. Padovan 52570a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 52580a708f8fSGustavo F. Padovan { 52590a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 52600a708f8fSGustavo F. Padovan u16 cid, len; 52610a708f8fSGustavo F. Padovan __le16 psm; 52620a708f8fSGustavo F. Padovan 52630a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 52640a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 52650a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 52660a708f8fSGustavo F. Padovan 52670a708f8fSGustavo F. Padovan if (len != skb->len) { 52680a708f8fSGustavo F. Padovan kfree_skb(skb); 52690a708f8fSGustavo F. Padovan return; 52700a708f8fSGustavo F. Padovan } 52710a708f8fSGustavo F. Padovan 52720a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 52730a708f8fSGustavo F. Padovan 52740a708f8fSGustavo F. Padovan switch (cid) { 52753300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 52760a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 52770a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 52780a708f8fSGustavo F. Padovan break; 52790a708f8fSGustavo F. Padovan 52800a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 5281097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 52820181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 52830a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 52840a708f8fSGustavo F. Padovan break; 52850a708f8fSGustavo F. Padovan 52869f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 52879f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 52889f69bda6SGustavo F. Padovan break; 52899f69bda6SGustavo F. Padovan 5290b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 5291b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 5292b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 5293b501d6a1SAnderson Briglia break; 5294b501d6a1SAnderson Briglia 52950a708f8fSGustavo F. Padovan default: 52960a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 52970a708f8fSGustavo F. Padovan break; 52980a708f8fSGustavo F. Padovan } 52990a708f8fSGustavo F. Padovan } 53000a708f8fSGustavo F. Padovan 53010a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 53020a708f8fSGustavo F. Padovan 5303686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 53040a708f8fSGustavo F. Padovan { 53050a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 530623691d75SGustavo F. Padovan struct l2cap_chan *c; 53070a708f8fSGustavo F. Padovan 53080a708f8fSGustavo F. Padovan BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr)); 53090a708f8fSGustavo F. Padovan 53100a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 531123691d75SGustavo F. Padovan read_lock(&chan_list_lock); 531223691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 531323691d75SGustavo F. Padovan struct sock *sk = c->sk; 53144343478fSGustavo F. Padovan 531589bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 53160a708f8fSGustavo F. Padovan continue; 53170a708f8fSGustavo F. Padovan 53180a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 53190a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 532043bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 53210a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 53220a708f8fSGustavo F. Padovan exact++; 53230a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 53240a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 532543bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 53260a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 53270a708f8fSGustavo F. Padovan } 53280a708f8fSGustavo F. Padovan } 532923691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 53300a708f8fSGustavo F. Padovan 53310a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 53320a708f8fSGustavo F. Padovan } 53330a708f8fSGustavo F. Padovan 5334686ebf28SUlisses Furquim int l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 53350a708f8fSGustavo F. Padovan { 53360a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 53370a708f8fSGustavo F. Padovan 53380a708f8fSGustavo F. Padovan BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status); 53390a708f8fSGustavo F. Padovan 53400a708f8fSGustavo F. Padovan if (!status) { 53410a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 53420a708f8fSGustavo F. Padovan if (conn) 53430a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 53440a708f8fSGustavo F. Padovan } else 5345e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 53460a708f8fSGustavo F. Padovan 53470a708f8fSGustavo F. Padovan return 0; 53480a708f8fSGustavo F. Padovan } 53490a708f8fSGustavo F. Padovan 5350686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 53510a708f8fSGustavo F. Padovan { 53520a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 53530a708f8fSGustavo F. Padovan 53540a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 53550a708f8fSGustavo F. Padovan 5356686ebf28SUlisses Furquim if (!conn) 53579f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 53580a708f8fSGustavo F. Padovan return conn->disc_reason; 53590a708f8fSGustavo F. Padovan } 53600a708f8fSGustavo F. Padovan 5361686ebf28SUlisses Furquim int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 53620a708f8fSGustavo F. Padovan { 53630a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 53640a708f8fSGustavo F. Padovan 5365e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 53660a708f8fSGustavo F. Padovan return 0; 53670a708f8fSGustavo F. Padovan } 53680a708f8fSGustavo F. Padovan 53694343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 53700a708f8fSGustavo F. Padovan { 5371715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 53720a708f8fSGustavo F. Padovan return; 53730a708f8fSGustavo F. Padovan 53740a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 53754343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 5376ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 53774343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 53780f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 53790a708f8fSGustavo F. Padovan } else { 53804343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 5381c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 53820a708f8fSGustavo F. Padovan } 53830a708f8fSGustavo F. Padovan } 53840a708f8fSGustavo F. Padovan 5385686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 53860a708f8fSGustavo F. Padovan { 53870a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 538848454079SGustavo F. Padovan struct l2cap_chan *chan; 53890a708f8fSGustavo F. Padovan 53900a708f8fSGustavo F. Padovan if (!conn) 53910a708f8fSGustavo F. Padovan return 0; 53920a708f8fSGustavo F. Padovan 539389d8b407SAndrei Emeltchenko BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt); 53940a708f8fSGustavo F. Padovan 5395160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 539635d4adccSHemant Gupta if (!status && encrypt) 5397160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 539817cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 5399160dc6acSVinicius Costa Gomes } 5400160dc6acSVinicius Costa Gomes 54013df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 54020a708f8fSGustavo F. Padovan 54033df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 54046be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 54050a708f8fSGustavo F. Padovan 540689d8b407SAndrei Emeltchenko BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid, 540789d8b407SAndrei Emeltchenko state_to_string(chan->state)); 5408f1cb9af5SVinicius Costa Gomes 5409f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 5410f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 5411f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 5412cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 5413f1cb9af5SVinicius Costa Gomes } 5414f1cb9af5SVinicius Costa Gomes 54156be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 5416f1cb9af5SVinicius Costa Gomes continue; 5417f1cb9af5SVinicius Costa Gomes } 5418f1cb9af5SVinicius Costa Gomes 5419c1360a1cSGustavo F. Padovan if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 54206be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54210a708f8fSGustavo F. Padovan continue; 54220a708f8fSGustavo F. Padovan } 54230a708f8fSGustavo F. Padovan 542489bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 542589bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 5426a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 5427a7d7723aSGustavo Padovan 5428c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 5429a7d7723aSGustavo Padovan sk->sk_state_change(sk); 5430a7d7723aSGustavo Padovan 54314343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 54326be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54330a708f8fSGustavo F. Padovan continue; 54340a708f8fSGustavo F. Padovan } 54350a708f8fSGustavo F. Padovan 543689bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 54370a708f8fSGustavo F. Padovan if (!status) { 54389b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 54390a708f8fSGustavo F. Padovan } else { 5440ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 54410a708f8fSGustavo F. Padovan } 544289bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 54436be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 54440a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5445df3c3931SJohan Hedberg __u16 res, stat; 54460a708f8fSGustavo F. Padovan 54476be36555SAndrei Emeltchenko lock_sock(sk); 54486be36555SAndrei Emeltchenko 54490a708f8fSGustavo F. Padovan if (!status) { 5450c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 5451c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 5452df3c3931SJohan Hedberg struct sock *parent = bt_sk(sk)->parent; 5453df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 5454df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 545505e9a2f6SIlia Kolomisnky if (parent) 5456df3c3931SJohan Hedberg parent->sk_data_ready(parent, 0); 5457df3c3931SJohan Hedberg } else { 54580e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 5459df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 5460df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 5461df3c3931SJohan Hedberg } 54620a708f8fSGustavo F. Padovan } else { 54630e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 5464ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 5465df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 5466df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 54670a708f8fSGustavo F. Padovan } 54680a708f8fSGustavo F. Padovan 54696be36555SAndrei Emeltchenko release_sock(sk); 54706be36555SAndrei Emeltchenko 5471fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5472fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5473df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 5474df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 5475fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5476fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 54772d369359SMat Martineau 54782d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 54792d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 54802d369359SMat Martineau char buf[128]; 54812d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 54822d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 54832d369359SMat Martineau L2CAP_CONF_REQ, 54842d369359SMat Martineau l2cap_build_conf_req(chan, buf), 54852d369359SMat Martineau buf); 54862d369359SMat Martineau chan->num_conf_req++; 54872d369359SMat Martineau } 54880a708f8fSGustavo F. Padovan } 54890a708f8fSGustavo F. Padovan 54906be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54910a708f8fSGustavo F. Padovan } 54920a708f8fSGustavo F. Padovan 54933df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 54940a708f8fSGustavo F. Padovan 54950a708f8fSGustavo F. Padovan return 0; 54960a708f8fSGustavo F. Padovan } 54970a708f8fSGustavo F. Padovan 5498686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 54990a708f8fSGustavo F. Padovan { 55000a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 55010a708f8fSGustavo F. Padovan 55020a708f8fSGustavo F. Padovan if (!conn) 55030a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 55040a708f8fSGustavo F. Padovan 55050a708f8fSGustavo F. Padovan if (!conn) 55060a708f8fSGustavo F. Padovan goto drop; 55070a708f8fSGustavo F. Padovan 55080a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 55090a708f8fSGustavo F. Padovan 55100a708f8fSGustavo F. Padovan if (!(flags & ACL_CONT)) { 55110a708f8fSGustavo F. Padovan struct l2cap_hdr *hdr; 55120a708f8fSGustavo F. Padovan int len; 55130a708f8fSGustavo F. Padovan 55140a708f8fSGustavo F. Padovan if (conn->rx_len) { 55150a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 55160a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 55170a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55180a708f8fSGustavo F. Padovan conn->rx_len = 0; 55190a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55200a708f8fSGustavo F. Padovan } 55210a708f8fSGustavo F. Padovan 55220a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 55230a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 55240a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 55250a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55260a708f8fSGustavo F. Padovan goto drop; 55270a708f8fSGustavo F. Padovan } 55280a708f8fSGustavo F. Padovan 55290a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 55300a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 55310a708f8fSGustavo F. Padovan 55320a708f8fSGustavo F. Padovan if (len == skb->len) { 55330a708f8fSGustavo F. Padovan /* Complete frame received */ 55340a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 55350a708f8fSGustavo F. Padovan return 0; 55360a708f8fSGustavo F. Padovan } 55370a708f8fSGustavo F. Padovan 55380a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 55390a708f8fSGustavo F. Padovan 55400a708f8fSGustavo F. Padovan if (skb->len > len) { 55410a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 55420a708f8fSGustavo F. Padovan skb->len, len); 55430a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55440a708f8fSGustavo F. Padovan goto drop; 55450a708f8fSGustavo F. Padovan } 55460a708f8fSGustavo F. Padovan 55470a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 55480a708f8fSGustavo F. Padovan conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC); 55490a708f8fSGustavo F. Padovan if (!conn->rx_skb) 55500a708f8fSGustavo F. Padovan goto drop; 55510a708f8fSGustavo F. Padovan 55520a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55530a708f8fSGustavo F. Padovan skb->len); 55540a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 55550a708f8fSGustavo F. Padovan } else { 55560a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 55570a708f8fSGustavo F. Padovan 55580a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55590a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 55600a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55610a708f8fSGustavo F. Padovan goto drop; 55620a708f8fSGustavo F. Padovan } 55630a708f8fSGustavo F. Padovan 55640a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 55650a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 55660a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 55670a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 55680a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55690a708f8fSGustavo F. Padovan conn->rx_len = 0; 55700a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55710a708f8fSGustavo F. Padovan goto drop; 55720a708f8fSGustavo F. Padovan } 55730a708f8fSGustavo F. Padovan 55740a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55750a708f8fSGustavo F. Padovan skb->len); 55760a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 55770a708f8fSGustavo F. Padovan 55780a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55790a708f8fSGustavo F. Padovan /* Complete frame received */ 55800a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 55810a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55820a708f8fSGustavo F. Padovan } 55830a708f8fSGustavo F. Padovan } 55840a708f8fSGustavo F. Padovan 55850a708f8fSGustavo F. Padovan drop: 55860a708f8fSGustavo F. Padovan kfree_skb(skb); 55870a708f8fSGustavo F. Padovan return 0; 55880a708f8fSGustavo F. Padovan } 55890a708f8fSGustavo F. Padovan 55900a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 55910a708f8fSGustavo F. Padovan { 559223691d75SGustavo F. Padovan struct l2cap_chan *c; 55930a708f8fSGustavo F. Padovan 5594333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 55950a708f8fSGustavo F. Padovan 559623691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 559723691d75SGustavo F. Padovan struct sock *sk = c->sk; 55980a708f8fSGustavo F. Padovan 5599903d343eSGustavo F. Padovan seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 56000a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->src), 56010a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->dst), 560289bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 560323691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 560423691d75SGustavo F. Padovan c->sec_level, c->mode); 56050a708f8fSGustavo F. Padovan } 56060a708f8fSGustavo F. Padovan 5607333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 56080a708f8fSGustavo F. Padovan 56090a708f8fSGustavo F. Padovan return 0; 56100a708f8fSGustavo F. Padovan } 56110a708f8fSGustavo F. Padovan 56120a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 56130a708f8fSGustavo F. Padovan { 56140a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 56150a708f8fSGustavo F. Padovan } 56160a708f8fSGustavo F. Padovan 56170a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 56180a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 56190a708f8fSGustavo F. Padovan .read = seq_read, 56200a708f8fSGustavo F. Padovan .llseek = seq_lseek, 56210a708f8fSGustavo F. Padovan .release = single_release, 56220a708f8fSGustavo F. Padovan }; 56230a708f8fSGustavo F. Padovan 56240a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 56250a708f8fSGustavo F. Padovan 562664274518SGustavo F. Padovan int __init l2cap_init(void) 56270a708f8fSGustavo F. Padovan { 56280a708f8fSGustavo F. Padovan int err; 56290a708f8fSGustavo F. Padovan 5630bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 56310a708f8fSGustavo F. Padovan if (err < 0) 56320a708f8fSGustavo F. Padovan return err; 56330a708f8fSGustavo F. Padovan 56340a708f8fSGustavo F. Padovan if (bt_debugfs) { 56350a708f8fSGustavo F. Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, 56360a708f8fSGustavo F. Padovan bt_debugfs, NULL, &l2cap_debugfs_fops); 56370a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 56380a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 56390a708f8fSGustavo F. Padovan } 56400a708f8fSGustavo F. Padovan 56410a708f8fSGustavo F. Padovan return 0; 56420a708f8fSGustavo F. Padovan } 56430a708f8fSGustavo F. Padovan 564464274518SGustavo F. Padovan void l2cap_exit(void) 56450a708f8fSGustavo F. Padovan { 56460a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 5647bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 56480a708f8fSGustavo F. Padovan } 56490a708f8fSGustavo F. Padovan 56500a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 56510a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 5652