10a708f8fSGustavo F. Padovan /* 20a708f8fSGustavo F. Padovan BlueZ - Bluetooth protocol stack for Linux 30a708f8fSGustavo F. Padovan Copyright (C) 2000-2001 Qualcomm Incorporated 40a708f8fSGustavo F. Padovan Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org> 50a708f8fSGustavo F. Padovan Copyright (C) 2010 Google Inc. 6590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 7422e925bSMat Martineau Copyright (c) 2012 Code Aurora Forum. All rights reserved. 80a708f8fSGustavo F. Padovan 90a708f8fSGustavo F. Padovan Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 100a708f8fSGustavo F. Padovan 110a708f8fSGustavo F. Padovan This program is free software; you can redistribute it and/or modify 120a708f8fSGustavo F. Padovan it under the terms of the GNU General Public License version 2 as 130a708f8fSGustavo F. Padovan published by the Free Software Foundation; 140a708f8fSGustavo F. Padovan 150a708f8fSGustavo F. Padovan THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 160a708f8fSGustavo F. Padovan OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 170a708f8fSGustavo F. Padovan FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 180a708f8fSGustavo F. Padovan IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 190a708f8fSGustavo F. Padovan CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 200a708f8fSGustavo F. Padovan WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 210a708f8fSGustavo F. Padovan ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 220a708f8fSGustavo F. Padovan OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 230a708f8fSGustavo F. Padovan 240a708f8fSGustavo F. Padovan ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 250a708f8fSGustavo F. Padovan COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 260a708f8fSGustavo F. Padovan SOFTWARE IS DISCLAIMED. 270a708f8fSGustavo F. Padovan */ 280a708f8fSGustavo F. Padovan 29bb58f747SGustavo F. Padovan /* Bluetooth L2CAP core. */ 300a708f8fSGustavo F. Padovan 310a708f8fSGustavo F. Padovan #include <linux/module.h> 320a708f8fSGustavo F. Padovan 330a708f8fSGustavo F. Padovan #include <linux/debugfs.h> 340a708f8fSGustavo F. Padovan #include <linux/crc16.h> 350a708f8fSGustavo F. Padovan 360a708f8fSGustavo F. Padovan #include <net/bluetooth/bluetooth.h> 370a708f8fSGustavo F. Padovan #include <net/bluetooth/hci_core.h> 380a708f8fSGustavo F. Padovan #include <net/bluetooth/l2cap.h> 39b501d6a1SAnderson Briglia #include <net/bluetooth/smp.h> 4097e8e89dSAndrei Emeltchenko #include <net/bluetooth/a2mp.h> 410a708f8fSGustavo F. Padovan 42d1de6d46SMat Martineau bool disable_ertm; 430a708f8fSGustavo F. Padovan 440a708f8fSGustavo F. Padovan static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN; 4550a147cdSMat Martineau static u8 l2cap_fixed_chan[8] = { L2CAP_FC_L2CAP, }; 460a708f8fSGustavo F. Padovan 47b5ad8b7fSJohannes Berg static LIST_HEAD(chan_list); 48b5ad8b7fSJohannes Berg static DEFINE_RWLOCK(chan_list_lock); 490a708f8fSGustavo F. Padovan 500a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 510a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data); 524519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, 534519de9aSGustavo F. Padovan void *data); 54710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data); 554519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, 564519de9aSGustavo F. Padovan struct l2cap_chan *chan, int err); 570a708f8fSGustavo F. Padovan 58d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 59608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event); 60608bcc6dSMat Martineau 610a708f8fSGustavo F. Padovan /* ---- L2CAP channels ---- */ 6271ba0e56SGustavo F. Padovan 63baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, u16 cid) 640a708f8fSGustavo F. Padovan { 653df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 66baa7e1faSGustavo F. Padovan 673df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 683df91ea2SAndrei Emeltchenko if (c->dcid == cid) 693df91ea2SAndrei Emeltchenko return c; 700a708f8fSGustavo F. Padovan } 713df91ea2SAndrei Emeltchenko return NULL; 72baa7e1faSGustavo F. Padovan } 730a708f8fSGustavo F. Padovan 74baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid) 750a708f8fSGustavo F. Padovan { 763df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 77baa7e1faSGustavo F. Padovan 783df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 793df91ea2SAndrei Emeltchenko if (c->scid == cid) 803df91ea2SAndrei Emeltchenko return c; 810a708f8fSGustavo F. Padovan } 823df91ea2SAndrei Emeltchenko return NULL; 83baa7e1faSGustavo F. Padovan } 840a708f8fSGustavo F. Padovan 850a708f8fSGustavo F. Padovan /* Find channel with given SCID. 86ef191adeSMat Martineau * Returns locked channel. */ 87baa7e1faSGustavo F. Padovan static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid) 880a708f8fSGustavo F. Padovan { 8948454079SGustavo F. Padovan struct l2cap_chan *c; 90baa7e1faSGustavo F. Padovan 913df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 92baa7e1faSGustavo F. Padovan c = __l2cap_get_chan_by_scid(conn, cid); 93ef191adeSMat Martineau if (c) 94ef191adeSMat Martineau l2cap_chan_lock(c); 953df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 963df91ea2SAndrei Emeltchenko 9748454079SGustavo F. Padovan return c; 980a708f8fSGustavo F. Padovan } 990a708f8fSGustavo F. Padovan 100baa7e1faSGustavo F. Padovan static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident) 1010a708f8fSGustavo F. Padovan { 1023df91ea2SAndrei Emeltchenko struct l2cap_chan *c; 103baa7e1faSGustavo F. Padovan 1043df91ea2SAndrei Emeltchenko list_for_each_entry(c, &conn->chan_l, list) { 1053df91ea2SAndrei Emeltchenko if (c->ident == ident) 1063df91ea2SAndrei Emeltchenko return c; 1070a708f8fSGustavo F. Padovan } 1083df91ea2SAndrei Emeltchenko return NULL; 109baa7e1faSGustavo F. Padovan } 1100a708f8fSGustavo F. Padovan 11123691d75SGustavo F. Padovan static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src) 1129e4425ffSGustavo F. Padovan { 11323691d75SGustavo F. Padovan struct l2cap_chan *c; 1149e4425ffSGustavo F. Padovan 11523691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 11623691d75SGustavo F. Padovan if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src)) 11723691d75SGustavo F. Padovan return c; 1189e4425ffSGustavo F. Padovan } 119250938cbSSzymon Janc return NULL; 120250938cbSSzymon Janc } 1219e4425ffSGustavo F. Padovan 1229e4425ffSGustavo F. Padovan int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm) 1239e4425ffSGustavo F. Padovan { 12473b2ec18SGustavo F. Padovan int err; 12573b2ec18SGustavo F. Padovan 126333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1279e4425ffSGustavo F. Padovan 12823691d75SGustavo F. Padovan if (psm && __l2cap_global_chan_by_addr(psm, src)) { 12973b2ec18SGustavo F. Padovan err = -EADDRINUSE; 13073b2ec18SGustavo F. Padovan goto done; 1319e4425ffSGustavo F. Padovan } 1329e4425ffSGustavo F. Padovan 13373b2ec18SGustavo F. Padovan if (psm) { 1349e4425ffSGustavo F. Padovan chan->psm = psm; 1359e4425ffSGustavo F. Padovan chan->sport = psm; 13673b2ec18SGustavo F. Padovan err = 0; 13773b2ec18SGustavo F. Padovan } else { 13873b2ec18SGustavo F. Padovan u16 p; 1399e4425ffSGustavo F. Padovan 14073b2ec18SGustavo F. Padovan err = -EINVAL; 14173b2ec18SGustavo F. Padovan for (p = 0x1001; p < 0x1100; p += 2) 14223691d75SGustavo F. Padovan if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) { 14373b2ec18SGustavo F. Padovan chan->psm = cpu_to_le16(p); 14473b2ec18SGustavo F. Padovan chan->sport = cpu_to_le16(p); 14573b2ec18SGustavo F. Padovan err = 0; 14673b2ec18SGustavo F. Padovan break; 14773b2ec18SGustavo F. Padovan } 14873b2ec18SGustavo F. Padovan } 14973b2ec18SGustavo F. Padovan 15073b2ec18SGustavo F. Padovan done: 151333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 15273b2ec18SGustavo F. Padovan return err; 1539e4425ffSGustavo F. Padovan } 1549e4425ffSGustavo F. Padovan 1559e4425ffSGustavo F. Padovan int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid) 1569e4425ffSGustavo F. Padovan { 157333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 1589e4425ffSGustavo F. Padovan 1599e4425ffSGustavo F. Padovan chan->scid = scid; 1609e4425ffSGustavo F. Padovan 161333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 1629e4425ffSGustavo F. Padovan 1639e4425ffSGustavo F. Padovan return 0; 1649e4425ffSGustavo F. Padovan } 1659e4425ffSGustavo F. Padovan 166baa7e1faSGustavo F. Padovan static u16 l2cap_alloc_cid(struct l2cap_conn *conn) 1670a708f8fSGustavo F. Padovan { 1680a708f8fSGustavo F. Padovan u16 cid = L2CAP_CID_DYN_START; 1690a708f8fSGustavo F. Padovan 1700a708f8fSGustavo F. Padovan for (; cid < L2CAP_CID_DYN_END; cid++) { 171baa7e1faSGustavo F. Padovan if (!__l2cap_get_chan_by_scid(conn, cid)) 1720a708f8fSGustavo F. Padovan return cid; 1730a708f8fSGustavo F. Padovan } 1740a708f8fSGustavo F. Padovan 1750a708f8fSGustavo F. Padovan return 0; 1760a708f8fSGustavo F. Padovan } 1770a708f8fSGustavo F. Padovan 1780e587be7SAndrei Emeltchenko static void __l2cap_state_change(struct l2cap_chan *chan, int state) 17989bc500eSGustavo F. Padovan { 18042d2d87cSAndrei Emeltchenko BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state), 181badaaa00SGustavo F. Padovan state_to_string(state)); 182badaaa00SGustavo F. Padovan 18389bc500eSGustavo F. Padovan chan->state = state; 18480b98027SGustavo Padovan chan->ops->state_change(chan, state); 18589bc500eSGustavo F. Padovan } 18689bc500eSGustavo F. Padovan 1870e587be7SAndrei Emeltchenko static void l2cap_state_change(struct l2cap_chan *chan, int state) 1880e587be7SAndrei Emeltchenko { 1890e587be7SAndrei Emeltchenko struct sock *sk = chan->sk; 1900e587be7SAndrei Emeltchenko 1910e587be7SAndrei Emeltchenko lock_sock(sk); 1920e587be7SAndrei Emeltchenko __l2cap_state_change(chan, state); 1930e587be7SAndrei Emeltchenko release_sock(sk); 1940e587be7SAndrei Emeltchenko } 1950e587be7SAndrei Emeltchenko 1962e0052e4SAndrei Emeltchenko static inline void __l2cap_chan_set_err(struct l2cap_chan *chan, int err) 1972e0052e4SAndrei Emeltchenko { 1982e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 1992e0052e4SAndrei Emeltchenko 2002e0052e4SAndrei Emeltchenko sk->sk_err = err; 2012e0052e4SAndrei Emeltchenko } 2022e0052e4SAndrei Emeltchenko 2032e0052e4SAndrei Emeltchenko static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err) 2042e0052e4SAndrei Emeltchenko { 2052e0052e4SAndrei Emeltchenko struct sock *sk = chan->sk; 2062e0052e4SAndrei Emeltchenko 2072e0052e4SAndrei Emeltchenko lock_sock(sk); 2082e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 2092e0052e4SAndrei Emeltchenko release_sock(sk); 2102e0052e4SAndrei Emeltchenko } 2112e0052e4SAndrei Emeltchenko 2124239d16fSMat Martineau static void __set_retrans_timer(struct l2cap_chan *chan) 2134239d16fSMat Martineau { 2144239d16fSMat Martineau if (!delayed_work_pending(&chan->monitor_timer) && 2154239d16fSMat Martineau chan->retrans_timeout) { 2164239d16fSMat Martineau l2cap_set_timer(chan, &chan->retrans_timer, 2174239d16fSMat Martineau msecs_to_jiffies(chan->retrans_timeout)); 2184239d16fSMat Martineau } 2194239d16fSMat Martineau } 2204239d16fSMat Martineau 2214239d16fSMat Martineau static void __set_monitor_timer(struct l2cap_chan *chan) 2224239d16fSMat Martineau { 2234239d16fSMat Martineau __clear_retrans_timer(chan); 2244239d16fSMat Martineau if (chan->monitor_timeout) { 2254239d16fSMat Martineau l2cap_set_timer(chan, &chan->monitor_timer, 2264239d16fSMat Martineau msecs_to_jiffies(chan->monitor_timeout)); 2274239d16fSMat Martineau } 2284239d16fSMat Martineau } 2294239d16fSMat Martineau 230608bcc6dSMat Martineau static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head, 231608bcc6dSMat Martineau u16 seq) 232608bcc6dSMat Martineau { 233608bcc6dSMat Martineau struct sk_buff *skb; 234608bcc6dSMat Martineau 235608bcc6dSMat Martineau skb_queue_walk(head, skb) { 236608bcc6dSMat Martineau if (bt_cb(skb)->control.txseq == seq) 237608bcc6dSMat Martineau return skb; 238608bcc6dSMat Martineau } 239608bcc6dSMat Martineau 240608bcc6dSMat Martineau return NULL; 241608bcc6dSMat Martineau } 242608bcc6dSMat Martineau 2433c588192SMat Martineau /* ---- L2CAP sequence number lists ---- */ 2443c588192SMat Martineau 2453c588192SMat Martineau /* For ERTM, ordered lists of sequence numbers must be tracked for 2463c588192SMat Martineau * SREJ requests that are received and for frames that are to be 2473c588192SMat Martineau * retransmitted. These seq_list functions implement a singly-linked 2483c588192SMat Martineau * list in an array, where membership in the list can also be checked 2493c588192SMat Martineau * in constant time. Items can also be added to the tail of the list 2503c588192SMat Martineau * and removed from the head in constant time, without further memory 2513c588192SMat Martineau * allocs or frees. 2523c588192SMat Martineau */ 2533c588192SMat Martineau 2543c588192SMat Martineau static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size) 2553c588192SMat Martineau { 2563c588192SMat Martineau size_t alloc_size, i; 2573c588192SMat Martineau 2583c588192SMat Martineau /* Allocated size is a power of 2 to map sequence numbers 2593c588192SMat Martineau * (which may be up to 14 bits) in to a smaller array that is 2603c588192SMat Martineau * sized for the negotiated ERTM transmit windows. 2613c588192SMat Martineau */ 2623c588192SMat Martineau alloc_size = roundup_pow_of_two(size); 2633c588192SMat Martineau 2643c588192SMat Martineau seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL); 2653c588192SMat Martineau if (!seq_list->list) 2663c588192SMat Martineau return -ENOMEM; 2673c588192SMat Martineau 2683c588192SMat Martineau seq_list->mask = alloc_size - 1; 2693c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 2703c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 2713c588192SMat Martineau for (i = 0; i < alloc_size; i++) 2723c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 2733c588192SMat Martineau 2743c588192SMat Martineau return 0; 2753c588192SMat Martineau } 2763c588192SMat Martineau 2773c588192SMat Martineau static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list) 2783c588192SMat Martineau { 2793c588192SMat Martineau kfree(seq_list->list); 2803c588192SMat Martineau } 2813c588192SMat Martineau 2823c588192SMat Martineau static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list, 2833c588192SMat Martineau u16 seq) 2843c588192SMat Martineau { 2853c588192SMat Martineau /* Constant-time check for list membership */ 2863c588192SMat Martineau return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR; 2873c588192SMat Martineau } 2883c588192SMat Martineau 2893c588192SMat Martineau static u16 l2cap_seq_list_remove(struct l2cap_seq_list *seq_list, u16 seq) 2903c588192SMat Martineau { 2913c588192SMat Martineau u16 mask = seq_list->mask; 2923c588192SMat Martineau 2933c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) { 2943c588192SMat Martineau /* In case someone tries to pop the head of an empty list */ 2953c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 2963c588192SMat Martineau } else if (seq_list->head == seq) { 2973c588192SMat Martineau /* Head can be removed in constant time */ 2983c588192SMat Martineau seq_list->head = seq_list->list[seq & mask]; 2993c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3003c588192SMat Martineau 3013c588192SMat Martineau if (seq_list->head == L2CAP_SEQ_LIST_TAIL) { 3023c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3033c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3043c588192SMat Martineau } 3053c588192SMat Martineau } else { 3063c588192SMat Martineau /* Walk the list to find the sequence number */ 3073c588192SMat Martineau u16 prev = seq_list->head; 3083c588192SMat Martineau while (seq_list->list[prev & mask] != seq) { 3093c588192SMat Martineau prev = seq_list->list[prev & mask]; 3103c588192SMat Martineau if (prev == L2CAP_SEQ_LIST_TAIL) 3113c588192SMat Martineau return L2CAP_SEQ_LIST_CLEAR; 3123c588192SMat Martineau } 3133c588192SMat Martineau 3143c588192SMat Martineau /* Unlink the number from the list and clear it */ 3153c588192SMat Martineau seq_list->list[prev & mask] = seq_list->list[seq & mask]; 3163c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR; 3173c588192SMat Martineau if (seq_list->tail == seq) 3183c588192SMat Martineau seq_list->tail = prev; 3193c588192SMat Martineau } 3203c588192SMat Martineau return seq; 3213c588192SMat Martineau } 3223c588192SMat Martineau 3233c588192SMat Martineau static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list) 3243c588192SMat Martineau { 3253c588192SMat Martineau /* Remove the head in constant time */ 3263c588192SMat Martineau return l2cap_seq_list_remove(seq_list, seq_list->head); 3273c588192SMat Martineau } 3283c588192SMat Martineau 3293c588192SMat Martineau static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list) 3303c588192SMat Martineau { 3313c588192SMat Martineau u16 i; 332f522ae36SGustavo Padovan 333f522ae36SGustavo Padovan if (seq_list->head == L2CAP_SEQ_LIST_CLEAR) 334f522ae36SGustavo Padovan return; 335f522ae36SGustavo Padovan 3363c588192SMat Martineau for (i = 0; i <= seq_list->mask; i++) 3373c588192SMat Martineau seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR; 3383c588192SMat Martineau 3393c588192SMat Martineau seq_list->head = L2CAP_SEQ_LIST_CLEAR; 3403c588192SMat Martineau seq_list->tail = L2CAP_SEQ_LIST_CLEAR; 3413c588192SMat Martineau } 3423c588192SMat Martineau 3433c588192SMat Martineau static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq) 3443c588192SMat Martineau { 3453c588192SMat Martineau u16 mask = seq_list->mask; 3463c588192SMat Martineau 3473c588192SMat Martineau /* All appends happen in constant time */ 3483c588192SMat Martineau 349f522ae36SGustavo Padovan if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR) 350f522ae36SGustavo Padovan return; 351f522ae36SGustavo Padovan 3523c588192SMat Martineau if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR) 3533c588192SMat Martineau seq_list->head = seq; 3543c588192SMat Martineau else 3553c588192SMat Martineau seq_list->list[seq_list->tail & mask] = seq; 3563c588192SMat Martineau 3573c588192SMat Martineau seq_list->tail = seq; 3583c588192SMat Martineau seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL; 3593c588192SMat Martineau } 3603c588192SMat Martineau 361721c4181SGustavo F. Padovan static void l2cap_chan_timeout(struct work_struct *work) 362ab07801dSGustavo F. Padovan { 363721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 364721c4181SGustavo F. Padovan chan_timer.work); 3653df91ea2SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 366ab07801dSGustavo F. Padovan int reason; 367ab07801dSGustavo F. Padovan 368e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s", chan, state_to_string(chan->state)); 369ab07801dSGustavo F. Padovan 3703df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3716be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 372ab07801dSGustavo F. Padovan 37389bc500eSGustavo F. Padovan if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG) 374ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 37589bc500eSGustavo F. Padovan else if (chan->state == BT_CONNECT && 376ab07801dSGustavo F. Padovan chan->sec_level != BT_SECURITY_SDP) 377ab07801dSGustavo F. Padovan reason = ECONNREFUSED; 378ab07801dSGustavo F. Padovan else 379ab07801dSGustavo F. Padovan reason = ETIMEDOUT; 380ab07801dSGustavo F. Padovan 3810f852724SGustavo F. Padovan l2cap_chan_close(chan, reason); 382ab07801dSGustavo F. Padovan 3836be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 384ab07801dSGustavo F. Padovan 38580b98027SGustavo Padovan chan->ops->close(chan); 3863df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 3873df91ea2SAndrei Emeltchenko 388371fd835SUlisses Furquim l2cap_chan_put(chan); 389ab07801dSGustavo F. Padovan } 390ab07801dSGustavo F. Padovan 391eef1d9b6SGustavo Padovan struct l2cap_chan *l2cap_chan_create(void) 3920a708f8fSGustavo F. Padovan { 39348454079SGustavo F. Padovan struct l2cap_chan *chan; 3940a708f8fSGustavo F. Padovan 39548454079SGustavo F. Padovan chan = kzalloc(sizeof(*chan), GFP_ATOMIC); 39648454079SGustavo F. Padovan if (!chan) 39748454079SGustavo F. Padovan return NULL; 3980a708f8fSGustavo F. Padovan 399c03b355eSAndrei Emeltchenko mutex_init(&chan->lock); 400c03b355eSAndrei Emeltchenko 401333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 40223691d75SGustavo F. Padovan list_add(&chan->global_l, &chan_list); 403333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 40423691d75SGustavo F. Padovan 405721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout); 406ab07801dSGustavo F. Padovan 40789bc500eSGustavo F. Padovan chan->state = BT_OPEN; 40889bc500eSGustavo F. Padovan 40971ba0e56SGustavo F. Padovan atomic_set(&chan->refcnt, 1); 41071ba0e56SGustavo F. Padovan 4112827011fSMat Martineau /* This flag is cleared in l2cap_chan_ready() */ 4122827011fSMat Martineau set_bit(CONF_NOT_COMPLETE, &chan->conf_state); 4132827011fSMat Martineau 414eef1d9b6SGustavo Padovan BT_DBG("chan %p", chan); 415abc545b8SSzymon Janc 41648454079SGustavo F. Padovan return chan; 4170a708f8fSGustavo F. Padovan } 4180a708f8fSGustavo F. Padovan 41923691d75SGustavo F. Padovan void l2cap_chan_destroy(struct l2cap_chan *chan) 4206ff5abbfSGustavo F. Padovan { 421333055f2SGustavo F. Padovan write_lock(&chan_list_lock); 42223691d75SGustavo F. Padovan list_del(&chan->global_l); 423333055f2SGustavo F. Padovan write_unlock(&chan_list_lock); 42423691d75SGustavo F. Padovan 425371fd835SUlisses Furquim l2cap_chan_put(chan); 4266ff5abbfSGustavo F. Padovan } 4276ff5abbfSGustavo F. Padovan 428bd4b1653SAndrei Emeltchenko void l2cap_chan_set_defaults(struct l2cap_chan *chan) 429bd4b1653SAndrei Emeltchenko { 430bd4b1653SAndrei Emeltchenko chan->fcs = L2CAP_FCS_CRC16; 431bd4b1653SAndrei Emeltchenko chan->max_tx = L2CAP_DEFAULT_MAX_TX; 432bd4b1653SAndrei Emeltchenko chan->tx_win = L2CAP_DEFAULT_TX_WINDOW; 433bd4b1653SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 434bd4b1653SAndrei Emeltchenko chan->sec_level = BT_SECURITY_LOW; 435bd4b1653SAndrei Emeltchenko 436bd4b1653SAndrei Emeltchenko set_bit(FLAG_FORCE_ACTIVE, &chan->flags); 437bd4b1653SAndrei Emeltchenko } 438bd4b1653SAndrei Emeltchenko 43914a28491SAndrei Emeltchenko static void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 4400a708f8fSGustavo F. Padovan { 4410a708f8fSGustavo F. Padovan BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, 442097db76cSAndrei Emeltchenko __le16_to_cpu(chan->psm), chan->dcid); 4430a708f8fSGustavo F. Padovan 4449f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 4450a708f8fSGustavo F. Padovan 4468c1d787bSGustavo F. Padovan chan->conn = conn; 4470a708f8fSGustavo F. Padovan 4485491120eSAndrei Emeltchenko switch (chan->chan_type) { 4495491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_ORIENTED: 450b62f328bSVille Tervo if (conn->hcon->type == LE_LINK) { 451b62f328bSVille Tervo /* LE connection */ 4520c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_LE_DEFAULT_MTU; 453fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_LE_DATA; 454fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_LE_DATA; 455b62f328bSVille Tervo } else { 4560a708f8fSGustavo F. Padovan /* Alloc CID for connection-oriented socket */ 457fe4128e0SGustavo F. Padovan chan->scid = l2cap_alloc_cid(conn); 4580c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 459b62f328bSVille Tervo } 4605491120eSAndrei Emeltchenko break; 4615491120eSAndrei Emeltchenko 4625491120eSAndrei Emeltchenko case L2CAP_CHAN_CONN_LESS: 4630a708f8fSGustavo F. Padovan /* Connectionless socket */ 464fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_CONN_LESS; 465fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_CONN_LESS; 4660c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4675491120eSAndrei Emeltchenko break; 4685491120eSAndrei Emeltchenko 469416fa752SAndrei Emeltchenko case L2CAP_CHAN_CONN_FIX_A2MP: 470416fa752SAndrei Emeltchenko chan->scid = L2CAP_CID_A2MP; 471416fa752SAndrei Emeltchenko chan->dcid = L2CAP_CID_A2MP; 472416fa752SAndrei Emeltchenko chan->omtu = L2CAP_A2MP_DEFAULT_MTU; 473416fa752SAndrei Emeltchenko chan->imtu = L2CAP_A2MP_DEFAULT_MTU; 474416fa752SAndrei Emeltchenko break; 475416fa752SAndrei Emeltchenko 4765491120eSAndrei Emeltchenko default: 4770a708f8fSGustavo F. Padovan /* Raw socket can send/recv signalling messages only */ 478fe4128e0SGustavo F. Padovan chan->scid = L2CAP_CID_SIGNALING; 479fe4128e0SGustavo F. Padovan chan->dcid = L2CAP_CID_SIGNALING; 4800c1bc5c6SGustavo F. Padovan chan->omtu = L2CAP_DEFAULT_MTU; 4810a708f8fSGustavo F. Padovan } 4820a708f8fSGustavo F. Padovan 4838f7975b1SAndrei Emeltchenko chan->local_id = L2CAP_BESTEFFORT_ID; 4848f7975b1SAndrei Emeltchenko chan->local_stype = L2CAP_SERV_BESTEFFORT; 4858f7975b1SAndrei Emeltchenko chan->local_msdu = L2CAP_DEFAULT_MAX_SDU_SIZE; 4868f7975b1SAndrei Emeltchenko chan->local_sdu_itime = L2CAP_DEFAULT_SDU_ITIME; 4878f7975b1SAndrei Emeltchenko chan->local_acc_lat = L2CAP_DEFAULT_ACC_LAT; 4888f7975b1SAndrei Emeltchenko chan->local_flush_to = L2CAP_DEFAULT_FLUSH_TO; 4898f7975b1SAndrei Emeltchenko 490371fd835SUlisses Furquim l2cap_chan_hold(chan); 491baa7e1faSGustavo F. Padovan 4923df91ea2SAndrei Emeltchenko list_add(&chan->list, &conn->chan_l); 493643162a8SAndrei Emeltchenko } 494643162a8SAndrei Emeltchenko 495466f8004SAndrei Emeltchenko void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) 496643162a8SAndrei Emeltchenko { 497643162a8SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 498643162a8SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 4993df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 5000a708f8fSGustavo F. Padovan } 5010a708f8fSGustavo F. Padovan 502466f8004SAndrei Emeltchenko void l2cap_chan_del(struct l2cap_chan *chan, int err) 5030a708f8fSGustavo F. Padovan { 5048c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5050a708f8fSGustavo F. Padovan 506c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 5070a708f8fSGustavo F. Padovan 50849208c9cSGustavo F. Padovan BT_DBG("chan %p, conn %p, err %d", chan, conn, err); 5090a708f8fSGustavo F. Padovan 5100a708f8fSGustavo F. Padovan if (conn) { 511baa7e1faSGustavo F. Padovan /* Delete from channel list */ 5123df91ea2SAndrei Emeltchenko list_del(&chan->list); 5133d57dc68SGustavo F. Padovan 514371fd835SUlisses Furquim l2cap_chan_put(chan); 515baa7e1faSGustavo F. Padovan 5168c1d787bSGustavo F. Padovan chan->conn = NULL; 5173cabbfdaSAndrei Emeltchenko 5183cabbfdaSAndrei Emeltchenko if (chan->chan_type != L2CAP_CHAN_CONN_FIX_A2MP) 5190a708f8fSGustavo F. Padovan hci_conn_put(conn->hcon); 5200a708f8fSGustavo F. Padovan } 5210a708f8fSGustavo F. Padovan 522c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 523c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, err); 5246be36555SAndrei Emeltchenko 5252827011fSMat Martineau if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state)) 5266ff5abbfSGustavo F. Padovan return; 5272ead70b8SGustavo F. Padovan 528ee556f66SGustavo Padovan switch(chan->mode) { 529ee556f66SGustavo Padovan case L2CAP_MODE_BASIC: 530ee556f66SGustavo Padovan break; 5310a708f8fSGustavo F. Padovan 532ee556f66SGustavo Padovan case L2CAP_MODE_ERTM: 5331a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 5341a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 5351a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 5360a708f8fSGustavo F. Padovan 537f1c6775bSGustavo F. Padovan skb_queue_purge(&chan->srej_q); 5380a708f8fSGustavo F. Padovan 5393c588192SMat Martineau l2cap_seq_list_free(&chan->srej_list); 5403c588192SMat Martineau l2cap_seq_list_free(&chan->retrans_list); 541ee556f66SGustavo Padovan 542ee556f66SGustavo Padovan /* fall through */ 543ee556f66SGustavo Padovan 544ee556f66SGustavo Padovan case L2CAP_MODE_STREAMING: 545ee556f66SGustavo Padovan skb_queue_purge(&chan->tx_q); 546ee556f66SGustavo Padovan break; 5470a708f8fSGustavo F. Padovan } 548ee556f66SGustavo Padovan 549ee556f66SGustavo Padovan return; 5500a708f8fSGustavo F. Padovan } 5510a708f8fSGustavo F. Padovan 5520f852724SGustavo F. Padovan void l2cap_chan_close(struct l2cap_chan *chan, int reason) 5534519de9aSGustavo F. Padovan { 5544519de9aSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 5554519de9aSGustavo F. Padovan struct sock *sk = chan->sk; 5564519de9aSGustavo F. Padovan 557e05dcc32SAndrei Emeltchenko BT_DBG("chan %p state %s sk %p", chan, 558e05dcc32SAndrei Emeltchenko state_to_string(chan->state), sk); 5594519de9aSGustavo F. Padovan 56089bc500eSGustavo F. Padovan switch (chan->state) { 5614519de9aSGustavo F. Padovan case BT_LISTEN: 562c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 563c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 5644519de9aSGustavo F. Padovan break; 5654519de9aSGustavo F. Padovan 5664519de9aSGustavo F. Padovan case BT_CONNECTED: 5674519de9aSGustavo F. Padovan case BT_CONFIG: 568715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5694519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 570c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 5714519de9aSGustavo F. Padovan l2cap_send_disconn_req(conn, chan, reason); 5724519de9aSGustavo F. Padovan } else 5734519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5744519de9aSGustavo F. Padovan break; 5754519de9aSGustavo F. Padovan 5764519de9aSGustavo F. Padovan case BT_CONNECT2: 577715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && 5784519de9aSGustavo F. Padovan conn->hcon->type == ACL_LINK) { 5794519de9aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5804519de9aSGustavo F. Padovan __u16 result; 5814519de9aSGustavo F. Padovan 582c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) 5834519de9aSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 5844519de9aSGustavo F. Padovan else 5854519de9aSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 58689bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_DISCONN); 5874519de9aSGustavo F. Padovan 5884519de9aSGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5894519de9aSGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5904519de9aSGustavo F. Padovan rsp.result = cpu_to_le16(result); 591ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 5924519de9aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5934519de9aSGustavo F. Padovan sizeof(rsp), &rsp); 5944519de9aSGustavo F. Padovan } 5954519de9aSGustavo F. Padovan 5964519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 5974519de9aSGustavo F. Padovan break; 5984519de9aSGustavo F. Padovan 5994519de9aSGustavo F. Padovan case BT_CONNECT: 6004519de9aSGustavo F. Padovan case BT_DISCONN: 6014519de9aSGustavo F. Padovan l2cap_chan_del(chan, reason); 6024519de9aSGustavo F. Padovan break; 6034519de9aSGustavo F. Padovan 6044519de9aSGustavo F. Padovan default: 605c0df7f6eSAndrei Emeltchenko if (chan->ops->teardown) 606c0df7f6eSAndrei Emeltchenko chan->ops->teardown(chan, 0); 6074519de9aSGustavo F. Padovan break; 6084519de9aSGustavo F. Padovan } 6094519de9aSGustavo F. Padovan } 6104519de9aSGustavo F. Padovan 6114343478fSGustavo F. Padovan static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan) 6120a708f8fSGustavo F. Padovan { 613715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_RAW) { 6144343478fSGustavo F. Padovan switch (chan->sec_level) { 6150a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6160a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING_MITM; 6170a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6180a708f8fSGustavo F. Padovan return HCI_AT_DEDICATED_BONDING; 6190a708f8fSGustavo F. Padovan default: 6200a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6210a708f8fSGustavo F. Padovan } 6222983fd68SAndrei Emeltchenko } else if (chan->psm == __constant_cpu_to_le16(L2CAP_PSM_SDP)) { 6234343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_LOW) 6244343478fSGustavo F. Padovan chan->sec_level = BT_SECURITY_SDP; 6250a708f8fSGustavo F. Padovan 6264343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_HIGH) 6270a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING_MITM; 6280a708f8fSGustavo F. Padovan else 6290a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6300a708f8fSGustavo F. Padovan } else { 6314343478fSGustavo F. Padovan switch (chan->sec_level) { 6320a708f8fSGustavo F. Padovan case BT_SECURITY_HIGH: 6330a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING_MITM; 6340a708f8fSGustavo F. Padovan case BT_SECURITY_MEDIUM: 6350a708f8fSGustavo F. Padovan return HCI_AT_GENERAL_BONDING; 6360a708f8fSGustavo F. Padovan default: 6370a708f8fSGustavo F. Padovan return HCI_AT_NO_BONDING; 6380a708f8fSGustavo F. Padovan } 6390a708f8fSGustavo F. Padovan } 6400a708f8fSGustavo F. Padovan } 6410a708f8fSGustavo F. Padovan 6420a708f8fSGustavo F. Padovan /* Service level security */ 643d45fc423SGustavo F. Padovan int l2cap_chan_check_security(struct l2cap_chan *chan) 6440a708f8fSGustavo F. Padovan { 6458c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 6460a708f8fSGustavo F. Padovan __u8 auth_type; 6470a708f8fSGustavo F. Padovan 6484343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 6490a708f8fSGustavo F. Padovan 6504343478fSGustavo F. Padovan return hci_conn_security(conn->hcon, chan->sec_level, auth_type); 6510a708f8fSGustavo F. Padovan } 6520a708f8fSGustavo F. Padovan 653b5ad8b7fSJohannes Berg static u8 l2cap_get_ident(struct l2cap_conn *conn) 6540a708f8fSGustavo F. Padovan { 6550a708f8fSGustavo F. Padovan u8 id; 6560a708f8fSGustavo F. Padovan 6570a708f8fSGustavo F. Padovan /* Get next available identificator. 6580a708f8fSGustavo F. Padovan * 1 - 128 are used by kernel. 6590a708f8fSGustavo F. Padovan * 129 - 199 are reserved. 6600a708f8fSGustavo F. Padovan * 200 - 254 are used by utilities like l2ping, etc. 6610a708f8fSGustavo F. Padovan */ 6620a708f8fSGustavo F. Padovan 663333055f2SGustavo F. Padovan spin_lock(&conn->lock); 6640a708f8fSGustavo F. Padovan 6650a708f8fSGustavo F. Padovan if (++conn->tx_ident > 128) 6660a708f8fSGustavo F. Padovan conn->tx_ident = 1; 6670a708f8fSGustavo F. Padovan 6680a708f8fSGustavo F. Padovan id = conn->tx_ident; 6690a708f8fSGustavo F. Padovan 670333055f2SGustavo F. Padovan spin_unlock(&conn->lock); 6710a708f8fSGustavo F. Padovan 6720a708f8fSGustavo F. Padovan return id; 6730a708f8fSGustavo F. Padovan } 6740a708f8fSGustavo F. Padovan 6754519de9aSGustavo F. Padovan static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data) 6760a708f8fSGustavo F. Padovan { 6770a708f8fSGustavo F. Padovan struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data); 6780a708f8fSGustavo F. Padovan u8 flags; 6790a708f8fSGustavo F. Padovan 6800a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x", code); 6810a708f8fSGustavo F. Padovan 6820a708f8fSGustavo F. Padovan if (!skb) 6830a708f8fSGustavo F. Padovan return; 6840a708f8fSGustavo F. Padovan 6850a708f8fSGustavo F. Padovan if (lmp_no_flush_capable(conn->hcon->hdev)) 6860a708f8fSGustavo F. Padovan flags = ACL_START_NO_FLUSH; 6870a708f8fSGustavo F. Padovan else 6880a708f8fSGustavo F. Padovan flags = ACL_START; 6890a708f8fSGustavo F. Padovan 69014b12d0bSJaikumar Ganesh bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON; 6915e59b791SLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 69214b12d0bSJaikumar Ganesh 69373d80debSLuiz Augusto von Dentz hci_send_acl(conn->hchan, skb, flags); 6940a708f8fSGustavo F. Padovan } 6950a708f8fSGustavo F. Padovan 69673d80debSLuiz Augusto von Dentz static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb) 69773d80debSLuiz Augusto von Dentz { 69873d80debSLuiz Augusto von Dentz struct hci_conn *hcon = chan->conn->hcon; 69973d80debSLuiz Augusto von Dentz u16 flags; 70073d80debSLuiz Augusto von Dentz 70173d80debSLuiz Augusto von Dentz BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len, 70273d80debSLuiz Augusto von Dentz skb->priority); 70373d80debSLuiz Augusto von Dentz 70473d80debSLuiz Augusto von Dentz if (!test_bit(FLAG_FLUSHABLE, &chan->flags) && 70573d80debSLuiz Augusto von Dentz lmp_no_flush_capable(hcon->hdev)) 70673d80debSLuiz Augusto von Dentz flags = ACL_START_NO_FLUSH; 70773d80debSLuiz Augusto von Dentz else 70873d80debSLuiz Augusto von Dentz flags = ACL_START; 70973d80debSLuiz Augusto von Dentz 71073d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags); 71173d80debSLuiz Augusto von Dentz hci_send_acl(chan->conn->hchan, skb, flags); 7120a708f8fSGustavo F. Padovan } 7130a708f8fSGustavo F. Padovan 714b5c6aaedSMat Martineau static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control) 715b5c6aaedSMat Martineau { 716b5c6aaedSMat Martineau control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT; 717b5c6aaedSMat Martineau control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT; 718b5c6aaedSMat Martineau 719b5c6aaedSMat Martineau if (enh & L2CAP_CTRL_FRAME_TYPE) { 720b5c6aaedSMat Martineau /* S-Frame */ 721b5c6aaedSMat Martineau control->sframe = 1; 722b5c6aaedSMat Martineau control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT; 723b5c6aaedSMat Martineau control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT; 724b5c6aaedSMat Martineau 725b5c6aaedSMat Martineau control->sar = 0; 726b5c6aaedSMat Martineau control->txseq = 0; 727b5c6aaedSMat Martineau } else { 728b5c6aaedSMat Martineau /* I-Frame */ 729b5c6aaedSMat Martineau control->sframe = 0; 730b5c6aaedSMat Martineau control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT; 731b5c6aaedSMat Martineau control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT; 732b5c6aaedSMat Martineau 733b5c6aaedSMat Martineau control->poll = 0; 734b5c6aaedSMat Martineau control->super = 0; 735b5c6aaedSMat Martineau } 736b5c6aaedSMat Martineau } 737b5c6aaedSMat Martineau 738b5c6aaedSMat Martineau static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control) 739b5c6aaedSMat Martineau { 740b5c6aaedSMat Martineau control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT; 741b5c6aaedSMat Martineau control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT; 742b5c6aaedSMat Martineau 743b5c6aaedSMat Martineau if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) { 744b5c6aaedSMat Martineau /* S-Frame */ 745b5c6aaedSMat Martineau control->sframe = 1; 746b5c6aaedSMat Martineau control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT; 747b5c6aaedSMat Martineau control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT; 748b5c6aaedSMat Martineau 749b5c6aaedSMat Martineau control->sar = 0; 750b5c6aaedSMat Martineau control->txseq = 0; 751b5c6aaedSMat Martineau } else { 752b5c6aaedSMat Martineau /* I-Frame */ 753b5c6aaedSMat Martineau control->sframe = 0; 754b5c6aaedSMat Martineau control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT; 755b5c6aaedSMat Martineau control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT; 756b5c6aaedSMat Martineau 757b5c6aaedSMat Martineau control->poll = 0; 758b5c6aaedSMat Martineau control->super = 0; 759b5c6aaedSMat Martineau } 760b5c6aaedSMat Martineau } 761b5c6aaedSMat Martineau 762b5c6aaedSMat Martineau static inline void __unpack_control(struct l2cap_chan *chan, 763b5c6aaedSMat Martineau struct sk_buff *skb) 764b5c6aaedSMat Martineau { 765b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 766b5c6aaedSMat Martineau __unpack_extended_control(get_unaligned_le32(skb->data), 767b5c6aaedSMat Martineau &bt_cb(skb)->control); 768cec8ab6eSMat Martineau skb_pull(skb, L2CAP_EXT_CTRL_SIZE); 769b5c6aaedSMat Martineau } else { 770b5c6aaedSMat Martineau __unpack_enhanced_control(get_unaligned_le16(skb->data), 771b5c6aaedSMat Martineau &bt_cb(skb)->control); 772cec8ab6eSMat Martineau skb_pull(skb, L2CAP_ENH_CTRL_SIZE); 773b5c6aaedSMat Martineau } 774b5c6aaedSMat Martineau } 775b5c6aaedSMat Martineau 776b5c6aaedSMat Martineau static u32 __pack_extended_control(struct l2cap_ctrl *control) 777b5c6aaedSMat Martineau { 778b5c6aaedSMat Martineau u32 packed; 779b5c6aaedSMat Martineau 780b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT; 781b5c6aaedSMat Martineau packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT; 782b5c6aaedSMat Martineau 783b5c6aaedSMat Martineau if (control->sframe) { 784b5c6aaedSMat Martineau packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT; 785b5c6aaedSMat Martineau packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT; 786b5c6aaedSMat Martineau packed |= L2CAP_EXT_CTRL_FRAME_TYPE; 787b5c6aaedSMat Martineau } else { 788b5c6aaedSMat Martineau packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT; 789b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT; 790b5c6aaedSMat Martineau } 791b5c6aaedSMat Martineau 792b5c6aaedSMat Martineau return packed; 793b5c6aaedSMat Martineau } 794b5c6aaedSMat Martineau 795b5c6aaedSMat Martineau static u16 __pack_enhanced_control(struct l2cap_ctrl *control) 796b5c6aaedSMat Martineau { 797b5c6aaedSMat Martineau u16 packed; 798b5c6aaedSMat Martineau 799b5c6aaedSMat Martineau packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT; 800b5c6aaedSMat Martineau packed |= control->final << L2CAP_CTRL_FINAL_SHIFT; 801b5c6aaedSMat Martineau 802b5c6aaedSMat Martineau if (control->sframe) { 803b5c6aaedSMat Martineau packed |= control->poll << L2CAP_CTRL_POLL_SHIFT; 804b5c6aaedSMat Martineau packed |= control->super << L2CAP_CTRL_SUPER_SHIFT; 805b5c6aaedSMat Martineau packed |= L2CAP_CTRL_FRAME_TYPE; 806b5c6aaedSMat Martineau } else { 807b5c6aaedSMat Martineau packed |= control->sar << L2CAP_CTRL_SAR_SHIFT; 808b5c6aaedSMat Martineau packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT; 809b5c6aaedSMat Martineau } 810b5c6aaedSMat Martineau 811b5c6aaedSMat Martineau return packed; 812b5c6aaedSMat Martineau } 813b5c6aaedSMat Martineau 814b5c6aaedSMat Martineau static inline void __pack_control(struct l2cap_chan *chan, 815b5c6aaedSMat Martineau struct l2cap_ctrl *control, 816b5c6aaedSMat Martineau struct sk_buff *skb) 817b5c6aaedSMat Martineau { 818b5c6aaedSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 819b5c6aaedSMat Martineau put_unaligned_le32(__pack_extended_control(control), 820b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 821b5c6aaedSMat Martineau } else { 822b5c6aaedSMat Martineau put_unaligned_le16(__pack_enhanced_control(control), 823b5c6aaedSMat Martineau skb->data + L2CAP_HDR_SIZE); 824b5c6aaedSMat Martineau } 825b5c6aaedSMat Martineau } 826b5c6aaedSMat Martineau 827a67d7f6fSMat Martineau static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan, 828a67d7f6fSMat Martineau u32 control) 8290a708f8fSGustavo F. Padovan { 8300a708f8fSGustavo F. Padovan struct sk_buff *skb; 8310a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 832a67d7f6fSMat Martineau int hlen; 8330a708f8fSGustavo F. Padovan 834e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 835e4ca6d98SAndrei Emeltchenko hlen = L2CAP_EXT_HDR_SIZE; 836e4ca6d98SAndrei Emeltchenko else 837e4ca6d98SAndrei Emeltchenko hlen = L2CAP_ENH_HDR_SIZE; 8380a708f8fSGustavo F. Padovan 8390a708f8fSGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 84003a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 8410a708f8fSGustavo F. Padovan 842a67d7f6fSMat Martineau skb = bt_skb_alloc(hlen, GFP_KERNEL); 8430a708f8fSGustavo F. Padovan 8440a708f8fSGustavo F. Padovan if (!skb) 845a67d7f6fSMat Martineau return ERR_PTR(-ENOMEM); 8460a708f8fSGustavo F. Padovan 8470a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 8480a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE); 849fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 85088843ab0SAndrei Emeltchenko 851a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 852a67d7f6fSMat Martineau put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 853a67d7f6fSMat Martineau else 854a67d7f6fSMat Martineau put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 8550a708f8fSGustavo F. Padovan 85647d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 857a67d7f6fSMat Martineau u16 fcs = crc16(0, (u8 *)skb->data, skb->len); 85803a51213SAndrei Emeltchenko put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 8590a708f8fSGustavo F. Padovan } 8600a708f8fSGustavo F. Padovan 86173d80debSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX; 862a67d7f6fSMat Martineau return skb; 863a67d7f6fSMat Martineau } 864a67d7f6fSMat Martineau 865a67d7f6fSMat Martineau static void l2cap_send_sframe(struct l2cap_chan *chan, 866a67d7f6fSMat Martineau struct l2cap_ctrl *control) 867a67d7f6fSMat Martineau { 868a67d7f6fSMat Martineau struct sk_buff *skb; 869a67d7f6fSMat Martineau u32 control_field; 870a67d7f6fSMat Martineau 871a67d7f6fSMat Martineau BT_DBG("chan %p, control %p", chan, control); 872a67d7f6fSMat Martineau 873a67d7f6fSMat Martineau if (!control->sframe) 874a67d7f6fSMat Martineau return; 875a67d7f6fSMat Martineau 876a67d7f6fSMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) && 877a67d7f6fSMat Martineau !control->poll) 878a67d7f6fSMat Martineau control->final = 1; 879a67d7f6fSMat Martineau 880a67d7f6fSMat Martineau if (control->super == L2CAP_SUPER_RR) 881a67d7f6fSMat Martineau clear_bit(CONN_RNR_SENT, &chan->conn_state); 882a67d7f6fSMat Martineau else if (control->super == L2CAP_SUPER_RNR) 883a67d7f6fSMat Martineau set_bit(CONN_RNR_SENT, &chan->conn_state); 884a67d7f6fSMat Martineau 885a67d7f6fSMat Martineau if (control->super != L2CAP_SUPER_SREJ) { 886a67d7f6fSMat Martineau chan->last_acked_seq = control->reqseq; 887a67d7f6fSMat Martineau __clear_ack_timer(chan); 888a67d7f6fSMat Martineau } 889a67d7f6fSMat Martineau 890a67d7f6fSMat Martineau BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq, 891a67d7f6fSMat Martineau control->final, control->poll, control->super); 892a67d7f6fSMat Martineau 893a67d7f6fSMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 894a67d7f6fSMat Martineau control_field = __pack_extended_control(control); 895a67d7f6fSMat Martineau else 896a67d7f6fSMat Martineau control_field = __pack_enhanced_control(control); 897a67d7f6fSMat Martineau 898a67d7f6fSMat Martineau skb = l2cap_create_sframe_pdu(chan, control_field); 899a67d7f6fSMat Martineau if (!IS_ERR(skb)) 90073d80debSLuiz Augusto von Dentz l2cap_do_send(chan, skb); 9010a708f8fSGustavo F. Padovan } 9020a708f8fSGustavo F. Padovan 903c9e3d5e0SMat Martineau static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll) 9040a708f8fSGustavo F. Padovan { 905c9e3d5e0SMat Martineau struct l2cap_ctrl control; 9060a708f8fSGustavo F. Padovan 907c9e3d5e0SMat Martineau BT_DBG("chan %p, poll %d", chan, poll); 908c9e3d5e0SMat Martineau 909c9e3d5e0SMat Martineau memset(&control, 0, sizeof(control)); 910c9e3d5e0SMat Martineau control.sframe = 1; 911c9e3d5e0SMat Martineau control.poll = poll; 912c9e3d5e0SMat Martineau 913c9e3d5e0SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 914c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RNR; 915c9e3d5e0SMat Martineau else 916c9e3d5e0SMat Martineau control.super = L2CAP_SUPER_RR; 917c9e3d5e0SMat Martineau 918c9e3d5e0SMat Martineau control.reqseq = chan->buffer_seq; 919c9e3d5e0SMat Martineau l2cap_send_sframe(chan, &control); 9200a708f8fSGustavo F. Padovan } 9210a708f8fSGustavo F. Padovan 922b4450035SGustavo F. Padovan static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan) 9230a708f8fSGustavo F. Padovan { 924c1360a1cSGustavo F. Padovan return !test_bit(CONF_CONNECT_PEND, &chan->conf_state); 9250a708f8fSGustavo F. Padovan } 9260a708f8fSGustavo F. Padovan 9279b27f350SAndrei Emeltchenko static void l2cap_send_conn_req(struct l2cap_chan *chan) 9289b27f350SAndrei Emeltchenko { 9299b27f350SAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 9309b27f350SAndrei Emeltchenko struct l2cap_conn_req req; 9319b27f350SAndrei Emeltchenko 9329b27f350SAndrei Emeltchenko req.scid = cpu_to_le16(chan->scid); 9339b27f350SAndrei Emeltchenko req.psm = chan->psm; 9349b27f350SAndrei Emeltchenko 9359b27f350SAndrei Emeltchenko chan->ident = l2cap_get_ident(conn); 9369b27f350SAndrei Emeltchenko 9379b27f350SAndrei Emeltchenko set_bit(CONF_CONNECT_PEND, &chan->conf_state); 9389b27f350SAndrei Emeltchenko 9399b27f350SAndrei Emeltchenko l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req); 9409b27f350SAndrei Emeltchenko } 9419b27f350SAndrei Emeltchenko 9429f0caeb1SVinicius Costa Gomes static void l2cap_chan_ready(struct l2cap_chan *chan) 9439f0caeb1SVinicius Costa Gomes { 9442827011fSMat Martineau /* This clears all conf flags, including CONF_NOT_COMPLETE */ 9459f0caeb1SVinicius Costa Gomes chan->conf_state = 0; 9469f0caeb1SVinicius Costa Gomes __clear_chan_timer(chan); 9479f0caeb1SVinicius Costa Gomes 94854a59aa2SAndrei Emeltchenko chan->state = BT_CONNECTED; 9499f0caeb1SVinicius Costa Gomes 95054a59aa2SAndrei Emeltchenko chan->ops->ready(chan); 9519f0caeb1SVinicius Costa Gomes } 9529f0caeb1SVinicius Costa Gomes 953fc7f8a7eSGustavo F. Padovan static void l2cap_do_start(struct l2cap_chan *chan) 9540a708f8fSGustavo F. Padovan { 9558c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 9560a708f8fSGustavo F. Padovan 9579f0caeb1SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 9589f0caeb1SVinicius Costa Gomes l2cap_chan_ready(chan); 9599f0caeb1SVinicius Costa Gomes return; 9609f0caeb1SVinicius Costa Gomes } 9619f0caeb1SVinicius Costa Gomes 9620a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) { 9630a708f8fSGustavo F. Padovan if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)) 9640a708f8fSGustavo F. Padovan return; 9650a708f8fSGustavo F. Padovan 966d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan) && 9679b27f350SAndrei Emeltchenko __l2cap_no_conn_pending(chan)) 9689b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 9690a708f8fSGustavo F. Padovan } else { 9700a708f8fSGustavo F. Padovan struct l2cap_info_req req; 971ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 9720a708f8fSGustavo F. Padovan 9730a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 9740a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 9750a708f8fSGustavo F. Padovan 976ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 9770a708f8fSGustavo F. Padovan 9780a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 9790a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 9800a708f8fSGustavo F. Padovan } 9810a708f8fSGustavo F. Padovan } 9820a708f8fSGustavo F. Padovan 9830a708f8fSGustavo F. Padovan static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask) 9840a708f8fSGustavo F. Padovan { 9850a708f8fSGustavo F. Padovan u32 local_feat_mask = l2cap_feat_mask; 9860a708f8fSGustavo F. Padovan if (!disable_ertm) 9870a708f8fSGustavo F. Padovan local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING; 9880a708f8fSGustavo F. Padovan 9890a708f8fSGustavo F. Padovan switch (mode) { 9900a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 9910a708f8fSGustavo F. Padovan return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask; 9920a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 9930a708f8fSGustavo F. Padovan return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask; 9940a708f8fSGustavo F. Padovan default: 9950a708f8fSGustavo F. Padovan return 0x00; 9960a708f8fSGustavo F. Padovan } 9970a708f8fSGustavo F. Padovan } 9980a708f8fSGustavo F. Padovan 9994519de9aSGustavo F. Padovan static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err) 10000a708f8fSGustavo F. Padovan { 10016be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 10020a708f8fSGustavo F. Padovan struct l2cap_disconn_req req; 10030a708f8fSGustavo F. Padovan 10040a708f8fSGustavo F. Padovan if (!conn) 10050a708f8fSGustavo F. Padovan return; 10060a708f8fSGustavo F. Padovan 10070c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_ERTM) { 10081a09bcb9SGustavo F. Padovan __clear_retrans_timer(chan); 10091a09bcb9SGustavo F. Padovan __clear_monitor_timer(chan); 10101a09bcb9SGustavo F. Padovan __clear_ack_timer(chan); 10110a708f8fSGustavo F. Padovan } 10120a708f8fSGustavo F. Padovan 1013416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1014416fa752SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 1015416fa752SAndrei Emeltchenko return; 1016416fa752SAndrei Emeltchenko } 1017416fa752SAndrei Emeltchenko 1018fe4128e0SGustavo F. Padovan req.dcid = cpu_to_le16(chan->dcid); 1019fe4128e0SGustavo F. Padovan req.scid = cpu_to_le16(chan->scid); 10200a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 10210a708f8fSGustavo F. Padovan L2CAP_DISCONN_REQ, sizeof(req), &req); 10220a708f8fSGustavo F. Padovan 10236be36555SAndrei Emeltchenko lock_sock(sk); 10240e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 10252e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 10266be36555SAndrei Emeltchenko release_sock(sk); 10270a708f8fSGustavo F. Padovan } 10280a708f8fSGustavo F. Padovan 10290a708f8fSGustavo F. Padovan /* ---- L2CAP connections ---- */ 10300a708f8fSGustavo F. Padovan static void l2cap_conn_start(struct l2cap_conn *conn) 10310a708f8fSGustavo F. Padovan { 10323df91ea2SAndrei Emeltchenko struct l2cap_chan *chan, *tmp; 10330a708f8fSGustavo F. Padovan 10340a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 10350a708f8fSGustavo F. Padovan 10363df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 10370a708f8fSGustavo F. Padovan 10383df91ea2SAndrei Emeltchenko list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { 103948454079SGustavo F. Padovan struct sock *sk = chan->sk; 1040baa7e1faSGustavo F. Padovan 10416be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 10420a708f8fSGustavo F. Padovan 1043715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 10446be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10450a708f8fSGustavo F. Padovan continue; 10460a708f8fSGustavo F. Padovan } 10470a708f8fSGustavo F. Padovan 104889bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 1049d45fc423SGustavo F. Padovan if (!l2cap_chan_check_security(chan) || 1050b4450035SGustavo F. Padovan !__l2cap_no_conn_pending(chan)) { 10516be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10520a708f8fSGustavo F. Padovan continue; 10530a708f8fSGustavo F. Padovan } 10540a708f8fSGustavo F. Padovan 1055c1360a1cSGustavo F. Padovan if (!l2cap_mode_supported(chan->mode, conn->feat_mask) 1056c1360a1cSGustavo F. Padovan && test_bit(CONF_STATE2_DEVICE, 1057c1360a1cSGustavo F. Padovan &chan->conf_state)) { 10580f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNRESET); 10596be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10600a708f8fSGustavo F. Padovan continue; 10610a708f8fSGustavo F. Padovan } 10620a708f8fSGustavo F. Padovan 10639b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 10640a708f8fSGustavo F. Padovan 106589bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 10660a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 10670a708f8fSGustavo F. Padovan char buf[128]; 1068fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 1069fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 10700a708f8fSGustavo F. Padovan 1071d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 10726be36555SAndrei Emeltchenko lock_sock(sk); 1073c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 1074c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 10750a708f8fSGustavo F. Padovan struct sock *parent = bt_sk(sk)->parent; 1076ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1077ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHOR_PEND); 107805e9a2f6SIlia Kolomisnky if (parent) 10790a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 10800a708f8fSGustavo F. Padovan 10810a708f8fSGustavo F. Padovan } else { 10820e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 1083ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 1084ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 10850a708f8fSGustavo F. Padovan } 10866be36555SAndrei Emeltchenko release_sock(sk); 10870a708f8fSGustavo F. Padovan } else { 1088ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_PEND); 1089ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_AUTHEN_PEND); 10900a708f8fSGustavo F. Padovan } 10910a708f8fSGustavo F. Padovan 1092fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 1093fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 10940a708f8fSGustavo F. Padovan 1095c1360a1cSGustavo F. Padovan if (test_bit(CONF_REQ_SENT, &chan->conf_state) || 10960a708f8fSGustavo F. Padovan rsp.result != L2CAP_CR_SUCCESS) { 10976be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 10980a708f8fSGustavo F. Padovan continue; 10990a708f8fSGustavo F. Padovan } 11000a708f8fSGustavo F. Padovan 1101c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 11020a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 110373ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 110473ffa904SGustavo F. Padovan chan->num_conf_req++; 11050a708f8fSGustavo F. Padovan } 11060a708f8fSGustavo F. Padovan 11076be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 11080a708f8fSGustavo F. Padovan } 11090a708f8fSGustavo F. Padovan 11103df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 11110a708f8fSGustavo F. Padovan } 11120a708f8fSGustavo F. Padovan 1113c2287681SIdo Yariv /* Find socket with cid and source/destination bdaddr. 1114b62f328bSVille Tervo * Returns closest match, locked. 1115b62f328bSVille Tervo */ 1116d9b88702SAndrei Emeltchenko static struct l2cap_chan *l2cap_global_chan_by_scid(int state, u16 cid, 1117c2287681SIdo Yariv bdaddr_t *src, 1118c2287681SIdo Yariv bdaddr_t *dst) 1119b62f328bSVille Tervo { 112023691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 1121b62f328bSVille Tervo 112223691d75SGustavo F. Padovan read_lock(&chan_list_lock); 1123b62f328bSVille Tervo 112423691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 112523691d75SGustavo F. Padovan struct sock *sk = c->sk; 1126fe4128e0SGustavo F. Padovan 112789bc500eSGustavo F. Padovan if (state && c->state != state) 1128b62f328bSVille Tervo continue; 1129b62f328bSVille Tervo 113023691d75SGustavo F. Padovan if (c->scid == cid) { 1131c2287681SIdo Yariv int src_match, dst_match; 1132c2287681SIdo Yariv int src_any, dst_any; 1133c2287681SIdo Yariv 1134b62f328bSVille Tervo /* Exact match. */ 1135c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1136c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1137c2287681SIdo Yariv if (src_match && dst_match) { 113823691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 113923691d75SGustavo F. Padovan return c; 114023691d75SGustavo F. Padovan } 1141b62f328bSVille Tervo 1142b62f328bSVille Tervo /* Closest match */ 1143c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1144c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1145c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1146c2287681SIdo Yariv (src_any && dst_any)) 114723691d75SGustavo F. Padovan c1 = c; 1148b62f328bSVille Tervo } 1149b62f328bSVille Tervo } 1150280f294fSGustavo F. Padovan 115123691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 1152b62f328bSVille Tervo 115323691d75SGustavo F. Padovan return c1; 1154b62f328bSVille Tervo } 1155b62f328bSVille Tervo 1156b62f328bSVille Tervo static void l2cap_le_conn_ready(struct l2cap_conn *conn) 1157b62f328bSVille Tervo { 1158c916fbe4SGustavo F. Padovan struct sock *parent, *sk; 115923691d75SGustavo F. Padovan struct l2cap_chan *chan, *pchan; 1160b62f328bSVille Tervo 1161b62f328bSVille Tervo BT_DBG(""); 1162b62f328bSVille Tervo 1163b62f328bSVille Tervo /* Check if we have socket listening on cid */ 116423691d75SGustavo F. Padovan pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA, 1165c2287681SIdo Yariv conn->src, conn->dst); 116623691d75SGustavo F. Padovan if (!pchan) 1167b62f328bSVille Tervo return; 1168b62f328bSVille Tervo 116923691d75SGustavo F. Padovan parent = pchan->sk; 117023691d75SGustavo F. Padovan 1171aa2ac881SGustavo F. Padovan lock_sock(parent); 117262f3a2cfSGustavo F. Padovan 117380b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 117480808e43SGustavo F. Padovan if (!chan) 1175b62f328bSVille Tervo goto clean; 1176b62f328bSVille Tervo 117780808e43SGustavo F. Padovan sk = chan->sk; 11785d41ce1dSGustavo F. Padovan 1179b62f328bSVille Tervo hci_conn_hold(conn->hcon); 1180b62f328bSVille Tervo 1181b62f328bSVille Tervo bacpy(&bt_sk(sk)->src, conn->src); 1182b62f328bSVille Tervo bacpy(&bt_sk(sk)->dst, conn->dst); 1183b62f328bSVille Tervo 1184d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 1185d1010240SGustavo F. Padovan 11863d57dc68SGustavo F. Padovan l2cap_chan_add(conn, chan); 118748454079SGustavo F. Padovan 11886754e0dfSGustavo Padovan l2cap_chan_ready(chan); 1189b62f328bSVille Tervo 1190b62f328bSVille Tervo clean: 1191aa2ac881SGustavo F. Padovan release_sock(parent); 1192b62f328bSVille Tervo } 1193b62f328bSVille Tervo 11940a708f8fSGustavo F. Padovan static void l2cap_conn_ready(struct l2cap_conn *conn) 11950a708f8fSGustavo F. Padovan { 119648454079SGustavo F. Padovan struct l2cap_chan *chan; 11970a708f8fSGustavo F. Padovan 11980a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 11990a708f8fSGustavo F. Padovan 1200b62f328bSVille Tervo if (!conn->hcon->out && conn->hcon->type == LE_LINK) 1201b62f328bSVille Tervo l2cap_le_conn_ready(conn); 1202b62f328bSVille Tervo 1203160dc6acSVinicius Costa Gomes if (conn->hcon->out && conn->hcon->type == LE_LINK) 1204160dc6acSVinicius Costa Gomes smp_conn_security(conn, conn->hcon->pending_sec_level); 1205160dc6acSVinicius Costa Gomes 12063df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12070a708f8fSGustavo F. Padovan 12083df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1209baa7e1faSGustavo F. Padovan 12106be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12110a708f8fSGustavo F. Padovan 1212416fa752SAndrei Emeltchenko if (chan->chan_type == L2CAP_CHAN_CONN_FIX_A2MP) { 1213416fa752SAndrei Emeltchenko l2cap_chan_unlock(chan); 1214416fa752SAndrei Emeltchenko continue; 1215416fa752SAndrei Emeltchenko } 1216416fa752SAndrei Emeltchenko 121763128451SVinicius Costa Gomes if (conn->hcon->type == LE_LINK) { 1218b501d6a1SAnderson Briglia if (smp_conn_security(conn, chan->sec_level)) 1219cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 1220acd7d370SVille Tervo 122163128451SVinicius Costa Gomes } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 12226be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 1223c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 12246be36555SAndrei Emeltchenko lock_sock(sk); 12250e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECTED); 12260a708f8fSGustavo F. Padovan sk->sk_state_change(sk); 12276be36555SAndrei Emeltchenko release_sock(sk); 1228b501d6a1SAnderson Briglia 122989bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT) 1230fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 12310a708f8fSGustavo F. Padovan 12326be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12330a708f8fSGustavo F. Padovan } 12340a708f8fSGustavo F. Padovan 12353df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12360a708f8fSGustavo F. Padovan } 12370a708f8fSGustavo F. Padovan 12380a708f8fSGustavo F. Padovan /* Notify sockets that we cannot guaranty reliability anymore */ 12390a708f8fSGustavo F. Padovan static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err) 12400a708f8fSGustavo F. Padovan { 124148454079SGustavo F. Padovan struct l2cap_chan *chan; 12420a708f8fSGustavo F. Padovan 12430a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 12440a708f8fSGustavo F. Padovan 12453df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12460a708f8fSGustavo F. Padovan 12473df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 1248ecf61bdbSAndrei Emeltchenko if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags)) 12492e0052e4SAndrei Emeltchenko __l2cap_chan_set_err(chan, err); 12500a708f8fSGustavo F. Padovan } 12510a708f8fSGustavo F. Padovan 12523df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12530a708f8fSGustavo F. Padovan } 12540a708f8fSGustavo F. Padovan 1255f878fcadSGustavo F. Padovan static void l2cap_info_timeout(struct work_struct *work) 12560a708f8fSGustavo F. Padovan { 1257f878fcadSGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 1258030013d8SGustavo F. Padovan info_timer.work); 12590a708f8fSGustavo F. Padovan 12600a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 12610a708f8fSGustavo F. Padovan conn->info_ident = 0; 12620a708f8fSGustavo F. Padovan 12630a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 12640a708f8fSGustavo F. Padovan } 12650a708f8fSGustavo F. Padovan 12665d3de7dfSVinicius Costa Gomes static void l2cap_conn_del(struct hci_conn *hcon, int err) 12675d3de7dfSVinicius Costa Gomes { 12685d3de7dfSVinicius Costa Gomes struct l2cap_conn *conn = hcon->l2cap_data; 12695d3de7dfSVinicius Costa Gomes struct l2cap_chan *chan, *l; 12705d3de7dfSVinicius Costa Gomes 12715d3de7dfSVinicius Costa Gomes if (!conn) 12725d3de7dfSVinicius Costa Gomes return; 12735d3de7dfSVinicius Costa Gomes 12745d3de7dfSVinicius Costa Gomes BT_DBG("hcon %p conn %p, err %d", hcon, conn, err); 12755d3de7dfSVinicius Costa Gomes 12765d3de7dfSVinicius Costa Gomes kfree_skb(conn->rx_skb); 12775d3de7dfSVinicius Costa Gomes 12783df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 12793df91ea2SAndrei Emeltchenko 12805d3de7dfSVinicius Costa Gomes /* Kill channels */ 12815d3de7dfSVinicius Costa Gomes list_for_each_entry_safe(chan, l, &conn->chan_l, list) { 128261d6ef3eSMat Martineau l2cap_chan_hold(chan); 12836be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 12846be36555SAndrei Emeltchenko 12855d3de7dfSVinicius Costa Gomes l2cap_chan_del(chan, err); 12866be36555SAndrei Emeltchenko 12876be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 12886be36555SAndrei Emeltchenko 128980b98027SGustavo Padovan chan->ops->close(chan); 129061d6ef3eSMat Martineau l2cap_chan_put(chan); 12915d3de7dfSVinicius Costa Gomes } 12925d3de7dfSVinicius Costa Gomes 12933df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 12943df91ea2SAndrei Emeltchenko 129573d80debSLuiz Augusto von Dentz hci_chan_del(conn->hchan); 129673d80debSLuiz Augusto von Dentz 12975d3de7dfSVinicius Costa Gomes if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) 1298127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->info_timer); 12995d3de7dfSVinicius Costa Gomes 130051a8efd7SJohan Hedberg if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags)) { 1301127074bfSUlisses Furquim cancel_delayed_work_sync(&conn->security_timer); 13028aab4757SVinicius Costa Gomes smp_chan_destroy(conn); 1303d26a2345SVinicius Costa Gomes } 13045d3de7dfSVinicius Costa Gomes 13055d3de7dfSVinicius Costa Gomes hcon->l2cap_data = NULL; 13065d3de7dfSVinicius Costa Gomes kfree(conn); 13075d3de7dfSVinicius Costa Gomes } 13085d3de7dfSVinicius Costa Gomes 13096c9d42a1SGustavo F. Padovan static void security_timeout(struct work_struct *work) 13105d3de7dfSVinicius Costa Gomes { 13116c9d42a1SGustavo F. Padovan struct l2cap_conn *conn = container_of(work, struct l2cap_conn, 13126c9d42a1SGustavo F. Padovan security_timer.work); 13135d3de7dfSVinicius Costa Gomes 13145d3de7dfSVinicius Costa Gomes l2cap_conn_del(conn->hcon, ETIMEDOUT); 13155d3de7dfSVinicius Costa Gomes } 13165d3de7dfSVinicius Costa Gomes 13170a708f8fSGustavo F. Padovan static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status) 13180a708f8fSGustavo F. Padovan { 13190a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 132073d80debSLuiz Augusto von Dentz struct hci_chan *hchan; 13210a708f8fSGustavo F. Padovan 13220a708f8fSGustavo F. Padovan if (conn || status) 13230a708f8fSGustavo F. Padovan return conn; 13240a708f8fSGustavo F. Padovan 132573d80debSLuiz Augusto von Dentz hchan = hci_chan_create(hcon); 132673d80debSLuiz Augusto von Dentz if (!hchan) 13270a708f8fSGustavo F. Padovan return NULL; 13280a708f8fSGustavo F. Padovan 132973d80debSLuiz Augusto von Dentz conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC); 133073d80debSLuiz Augusto von Dentz if (!conn) { 133173d80debSLuiz Augusto von Dentz hci_chan_del(hchan); 133273d80debSLuiz Augusto von Dentz return NULL; 133373d80debSLuiz Augusto von Dentz } 133473d80debSLuiz Augusto von Dentz 13350a708f8fSGustavo F. Padovan hcon->l2cap_data = conn; 13360a708f8fSGustavo F. Padovan conn->hcon = hcon; 133773d80debSLuiz Augusto von Dentz conn->hchan = hchan; 13380a708f8fSGustavo F. Padovan 133973d80debSLuiz Augusto von Dentz BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan); 13400a708f8fSGustavo F. Padovan 1341acd7d370SVille Tervo if (hcon->hdev->le_mtu && hcon->type == LE_LINK) 1342acd7d370SVille Tervo conn->mtu = hcon->hdev->le_mtu; 1343acd7d370SVille Tervo else 13440a708f8fSGustavo F. Padovan conn->mtu = hcon->hdev->acl_mtu; 1345acd7d370SVille Tervo 13460a708f8fSGustavo F. Padovan conn->src = &hcon->hdev->bdaddr; 13470a708f8fSGustavo F. Padovan conn->dst = &hcon->dst; 13480a708f8fSGustavo F. Padovan 13490a708f8fSGustavo F. Padovan conn->feat_mask = 0; 13500a708f8fSGustavo F. Padovan 13510a708f8fSGustavo F. Padovan spin_lock_init(&conn->lock); 13523df91ea2SAndrei Emeltchenko mutex_init(&conn->chan_lock); 1353baa7e1faSGustavo F. Padovan 1354baa7e1faSGustavo F. Padovan INIT_LIST_HEAD(&conn->chan_l); 13550a708f8fSGustavo F. Padovan 13565d3de7dfSVinicius Costa Gomes if (hcon->type == LE_LINK) 13576c9d42a1SGustavo F. Padovan INIT_DELAYED_WORK(&conn->security_timer, security_timeout); 13585d3de7dfSVinicius Costa Gomes else 1359030013d8SGustavo F. Padovan INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout); 13600a708f8fSGustavo F. Padovan 13619f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM; 13620a708f8fSGustavo F. Padovan 13630a708f8fSGustavo F. Padovan return conn; 13640a708f8fSGustavo F. Padovan } 13650a708f8fSGustavo F. Padovan 13660a708f8fSGustavo F. Padovan /* ---- Socket interface ---- */ 13670a708f8fSGustavo F. Padovan 1368c2287681SIdo Yariv /* Find socket with psm and source / destination bdaddr. 13690a708f8fSGustavo F. Padovan * Returns closest match. 13700a708f8fSGustavo F. Padovan */ 1371c2287681SIdo Yariv static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, 1372c2287681SIdo Yariv bdaddr_t *src, 1373c2287681SIdo Yariv bdaddr_t *dst) 13740a708f8fSGustavo F. Padovan { 137523691d75SGustavo F. Padovan struct l2cap_chan *c, *c1 = NULL; 13760a708f8fSGustavo F. Padovan 137723691d75SGustavo F. Padovan read_lock(&chan_list_lock); 13780a708f8fSGustavo F. Padovan 137923691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 138023691d75SGustavo F. Padovan struct sock *sk = c->sk; 1381fe4128e0SGustavo F. Padovan 138289bc500eSGustavo F. Padovan if (state && c->state != state) 13830a708f8fSGustavo F. Padovan continue; 13840a708f8fSGustavo F. Padovan 138523691d75SGustavo F. Padovan if (c->psm == psm) { 1386c2287681SIdo Yariv int src_match, dst_match; 1387c2287681SIdo Yariv int src_any, dst_any; 1388c2287681SIdo Yariv 13890a708f8fSGustavo F. Padovan /* Exact match. */ 1390c2287681SIdo Yariv src_match = !bacmp(&bt_sk(sk)->src, src); 1391c2287681SIdo Yariv dst_match = !bacmp(&bt_sk(sk)->dst, dst); 1392c2287681SIdo Yariv if (src_match && dst_match) { 1393a7567b20SJohannes Berg read_unlock(&chan_list_lock); 139423691d75SGustavo F. Padovan return c; 139523691d75SGustavo F. Padovan } 13960a708f8fSGustavo F. Padovan 13970a708f8fSGustavo F. Padovan /* Closest match */ 1398c2287681SIdo Yariv src_any = !bacmp(&bt_sk(sk)->src, BDADDR_ANY); 1399c2287681SIdo Yariv dst_any = !bacmp(&bt_sk(sk)->dst, BDADDR_ANY); 1400c2287681SIdo Yariv if ((src_match && dst_any) || (src_any && dst_match) || 1401c2287681SIdo Yariv (src_any && dst_any)) 140223691d75SGustavo F. Padovan c1 = c; 14030a708f8fSGustavo F. Padovan } 14040a708f8fSGustavo F. Padovan } 14050a708f8fSGustavo F. Padovan 140623691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 14070a708f8fSGustavo F. Padovan 140823691d75SGustavo F. Padovan return c1; 14090a708f8fSGustavo F. Padovan } 14100a708f8fSGustavo F. Padovan 14118e9f9892SAndre Guedes int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, 14128e9f9892SAndre Guedes bdaddr_t *dst, u8 dst_type) 14130a708f8fSGustavo F. Padovan { 14145d41ce1dSGustavo F. Padovan struct sock *sk = chan->sk; 14150a708f8fSGustavo F. Padovan bdaddr_t *src = &bt_sk(sk)->src; 14160a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 14170a708f8fSGustavo F. Padovan struct hci_conn *hcon; 14180a708f8fSGustavo F. Padovan struct hci_dev *hdev; 14190a708f8fSGustavo F. Padovan __u8 auth_type; 14200a708f8fSGustavo F. Padovan int err; 14210a708f8fSGustavo F. Padovan 14228e9f9892SAndre Guedes BT_DBG("%s -> %s (type %u) psm 0x%2.2x", batostr(src), batostr(dst), 14238e9f9892SAndre Guedes dst_type, __le16_to_cpu(chan->psm)); 14240a708f8fSGustavo F. Padovan 14250a708f8fSGustavo F. Padovan hdev = hci_get_route(dst, src); 14260a708f8fSGustavo F. Padovan if (!hdev) 14270a708f8fSGustavo F. Padovan return -EHOSTUNREACH; 14280a708f8fSGustavo F. Padovan 142909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14300a708f8fSGustavo F. Padovan 14316be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 143203a00194SGustavo F. Padovan 143303a00194SGustavo F. Padovan /* PSM must be odd and lsb of upper byte must be 0 */ 143403a00194SGustavo F. Padovan if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid && 143503a00194SGustavo F. Padovan chan->chan_type != L2CAP_CHAN_RAW) { 143603a00194SGustavo F. Padovan err = -EINVAL; 143703a00194SGustavo F. Padovan goto done; 143803a00194SGustavo F. Padovan } 143903a00194SGustavo F. Padovan 144003a00194SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) { 144103a00194SGustavo F. Padovan err = -EINVAL; 144203a00194SGustavo F. Padovan goto done; 144303a00194SGustavo F. Padovan } 144403a00194SGustavo F. Padovan 144503a00194SGustavo F. Padovan switch (chan->mode) { 144603a00194SGustavo F. Padovan case L2CAP_MODE_BASIC: 144703a00194SGustavo F. Padovan break; 144803a00194SGustavo F. Padovan case L2CAP_MODE_ERTM: 144903a00194SGustavo F. Padovan case L2CAP_MODE_STREAMING: 145003a00194SGustavo F. Padovan if (!disable_ertm) 145103a00194SGustavo F. Padovan break; 145203a00194SGustavo F. Padovan /* fall through */ 145303a00194SGustavo F. Padovan default: 145403a00194SGustavo F. Padovan err = -ENOTSUPP; 145503a00194SGustavo F. Padovan goto done; 145603a00194SGustavo F. Padovan } 145703a00194SGustavo F. Padovan 14580797e01dSGustavo Padovan switch (chan->state) { 145903a00194SGustavo F. Padovan case BT_CONNECT: 146003a00194SGustavo F. Padovan case BT_CONNECT2: 146103a00194SGustavo F. Padovan case BT_CONFIG: 146203a00194SGustavo F. Padovan /* Already connecting */ 146303a00194SGustavo F. Padovan err = 0; 146403a00194SGustavo F. Padovan goto done; 146503a00194SGustavo F. Padovan 146603a00194SGustavo F. Padovan case BT_CONNECTED: 146703a00194SGustavo F. Padovan /* Already connected */ 146803a00194SGustavo F. Padovan err = -EISCONN; 146903a00194SGustavo F. Padovan goto done; 147003a00194SGustavo F. Padovan 147103a00194SGustavo F. Padovan case BT_OPEN: 147203a00194SGustavo F. Padovan case BT_BOUND: 147303a00194SGustavo F. Padovan /* Can connect */ 147403a00194SGustavo F. Padovan break; 147503a00194SGustavo F. Padovan 147603a00194SGustavo F. Padovan default: 147703a00194SGustavo F. Padovan err = -EBADFD; 147803a00194SGustavo F. Padovan goto done; 147903a00194SGustavo F. Padovan } 148003a00194SGustavo F. Padovan 148103a00194SGustavo F. Padovan /* Set destination address and psm */ 14820797e01dSGustavo Padovan lock_sock(sk); 14839219b2a0SGustavo F. Padovan bacpy(&bt_sk(sk)->dst, dst); 14846be36555SAndrei Emeltchenko release_sock(sk); 14856be36555SAndrei Emeltchenko 148603a00194SGustavo F. Padovan chan->psm = psm; 148703a00194SGustavo F. Padovan chan->dcid = cid; 14880a708f8fSGustavo F. Padovan 14894343478fSGustavo F. Padovan auth_type = l2cap_get_auth_type(chan); 14900a708f8fSGustavo F. Padovan 1491fe4128e0SGustavo F. Padovan if (chan->dcid == L2CAP_CID_LE_DATA) 14928e9f9892SAndre Guedes hcon = hci_connect(hdev, LE_LINK, dst, dst_type, 14934343478fSGustavo F. Padovan chan->sec_level, auth_type); 1494acd7d370SVille Tervo else 14958e9f9892SAndre Guedes hcon = hci_connect(hdev, ACL_LINK, dst, dst_type, 14964343478fSGustavo F. Padovan chan->sec_level, auth_type); 1497acd7d370SVille Tervo 149830e76272SVille Tervo if (IS_ERR(hcon)) { 149930e76272SVille Tervo err = PTR_ERR(hcon); 15000a708f8fSGustavo F. Padovan goto done; 150130e76272SVille Tervo } 15020a708f8fSGustavo F. Padovan 15030a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 15040a708f8fSGustavo F. Padovan if (!conn) { 15050a708f8fSGustavo F. Padovan hci_conn_put(hcon); 150630e76272SVille Tervo err = -ENOMEM; 15070a708f8fSGustavo F. Padovan goto done; 15080a708f8fSGustavo F. Padovan } 15090a708f8fSGustavo F. Padovan 15109f0caeb1SVinicius Costa Gomes if (hcon->type == LE_LINK) { 15119f0caeb1SVinicius Costa Gomes err = 0; 15129f0caeb1SVinicius Costa Gomes 15139f0caeb1SVinicius Costa Gomes if (!list_empty(&conn->chan_l)) { 15149f0caeb1SVinicius Costa Gomes err = -EBUSY; 15159f0caeb1SVinicius Costa Gomes hci_conn_put(hcon); 15169f0caeb1SVinicius Costa Gomes } 15179f0caeb1SVinicius Costa Gomes 15189f0caeb1SVinicius Costa Gomes if (err) 15199f0caeb1SVinicius Costa Gomes goto done; 15209f0caeb1SVinicius Costa Gomes } 15219f0caeb1SVinicius Costa Gomes 15220a708f8fSGustavo F. Padovan /* Update source addr of the socket */ 15230a708f8fSGustavo F. Padovan bacpy(src, conn->src); 15240a708f8fSGustavo F. Padovan 15256be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 152648454079SGustavo F. Padovan l2cap_chan_add(conn, chan); 15276be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 152848454079SGustavo F. Padovan 15296be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECT); 1530c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 15310a708f8fSGustavo F. Padovan 15320a708f8fSGustavo F. Padovan if (hcon->state == BT_CONNECTED) { 1533715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) { 1534c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 1535d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) 15366be36555SAndrei Emeltchenko l2cap_state_change(chan, BT_CONNECTED); 15370a708f8fSGustavo F. Padovan } else 1538fc7f8a7eSGustavo F. Padovan l2cap_do_start(chan); 15390a708f8fSGustavo F. Padovan } 15400a708f8fSGustavo F. Padovan 154130e76272SVille Tervo err = 0; 154230e76272SVille Tervo 15430a708f8fSGustavo F. Padovan done: 15446be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 154509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15460a708f8fSGustavo F. Padovan hci_dev_put(hdev); 15470a708f8fSGustavo F. Padovan return err; 15480a708f8fSGustavo F. Padovan } 15490a708f8fSGustavo F. Padovan 1550dcba0dbaSGustavo F. Padovan int __l2cap_wait_ack(struct sock *sk) 15510a708f8fSGustavo F. Padovan { 15528c1d787bSGustavo F. Padovan struct l2cap_chan *chan = l2cap_pi(sk)->chan; 15530a708f8fSGustavo F. Padovan DECLARE_WAITQUEUE(wait, current); 15540a708f8fSGustavo F. Padovan int err = 0; 15550a708f8fSGustavo F. Padovan int timeo = HZ/5; 15560a708f8fSGustavo F. Padovan 15570a708f8fSGustavo F. Padovan add_wait_queue(sk_sleep(sk), &wait); 15580a708f8fSGustavo F. Padovan set_current_state(TASK_INTERRUPTIBLE); 1559a71a0cf4SPeter Hurley while (chan->unacked_frames > 0 && chan->conn) { 15600a708f8fSGustavo F. Padovan if (!timeo) 15610a708f8fSGustavo F. Padovan timeo = HZ/5; 15620a708f8fSGustavo F. Padovan 15630a708f8fSGustavo F. Padovan if (signal_pending(current)) { 15640a708f8fSGustavo F. Padovan err = sock_intr_errno(timeo); 15650a708f8fSGustavo F. Padovan break; 15660a708f8fSGustavo F. Padovan } 15670a708f8fSGustavo F. Padovan 15680a708f8fSGustavo F. Padovan release_sock(sk); 15690a708f8fSGustavo F. Padovan timeo = schedule_timeout(timeo); 15700a708f8fSGustavo F. Padovan lock_sock(sk); 1571a71a0cf4SPeter Hurley set_current_state(TASK_INTERRUPTIBLE); 15720a708f8fSGustavo F. Padovan 15730a708f8fSGustavo F. Padovan err = sock_error(sk); 15740a708f8fSGustavo F. Padovan if (err) 15750a708f8fSGustavo F. Padovan break; 15760a708f8fSGustavo F. Padovan } 15770a708f8fSGustavo F. Padovan set_current_state(TASK_RUNNING); 15780a708f8fSGustavo F. Padovan remove_wait_queue(sk_sleep(sk), &wait); 15790a708f8fSGustavo F. Padovan return err; 15800a708f8fSGustavo F. Padovan } 15810a708f8fSGustavo F. Padovan 1582721c4181SGustavo F. Padovan static void l2cap_monitor_timeout(struct work_struct *work) 15830a708f8fSGustavo F. Padovan { 1584721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1585721c4181SGustavo F. Padovan monitor_timer.work); 15860a708f8fSGustavo F. Padovan 1587525cd185SGustavo F. Padovan BT_DBG("chan %p", chan); 15880a708f8fSGustavo F. Padovan 15896be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 15906be36555SAndrei Emeltchenko 159180909e04SMat Martineau if (!chan->conn) { 15926be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 15938d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 15940a708f8fSGustavo F. Padovan return; 15950a708f8fSGustavo F. Padovan } 15960a708f8fSGustavo F. Padovan 1597401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO); 15980a708f8fSGustavo F. Padovan 15996be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16008d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16010a708f8fSGustavo F. Padovan } 16020a708f8fSGustavo F. Padovan 1603721c4181SGustavo F. Padovan static void l2cap_retrans_timeout(struct work_struct *work) 16040a708f8fSGustavo F. Padovan { 1605721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 1606721c4181SGustavo F. Padovan retrans_timer.work); 16070a708f8fSGustavo F. Padovan 160849208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 16090a708f8fSGustavo F. Padovan 16106be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 16116be36555SAndrei Emeltchenko 161280909e04SMat Martineau if (!chan->conn) { 161380909e04SMat Martineau l2cap_chan_unlock(chan); 161480909e04SMat Martineau l2cap_chan_put(chan); 161580909e04SMat Martineau return; 161680909e04SMat Martineau } 16170a708f8fSGustavo F. Padovan 1618401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO); 16196be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 16208d7e1c7fSAndrei Emeltchenko l2cap_chan_put(chan); 16210a708f8fSGustavo F. Padovan } 16220a708f8fSGustavo F. Padovan 1623d660366dSGustavo Padovan static void l2cap_streaming_send(struct l2cap_chan *chan, 16243733937dSMat Martineau struct sk_buff_head *skbs) 16250a708f8fSGustavo F. Padovan { 16260a708f8fSGustavo F. Padovan struct sk_buff *skb; 16273733937dSMat Martineau struct l2cap_ctrl *control; 16280a708f8fSGustavo F. Padovan 16293733937dSMat Martineau BT_DBG("chan %p, skbs %p", chan, skbs); 16303733937dSMat Martineau 16313733937dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 16323733937dSMat Martineau 16333733937dSMat Martineau while (!skb_queue_empty(&chan->tx_q)) { 16343733937dSMat Martineau 16353733937dSMat Martineau skb = skb_dequeue(&chan->tx_q); 16363733937dSMat Martineau 16373733937dSMat Martineau bt_cb(skb)->control.retries = 1; 16383733937dSMat Martineau control = &bt_cb(skb)->control; 16393733937dSMat Martineau 16403733937dSMat Martineau control->reqseq = 0; 16413733937dSMat Martineau control->txseq = chan->next_tx_seq; 16423733937dSMat Martineau 16433733937dSMat Martineau __pack_control(chan, control, skb); 16440a708f8fSGustavo F. Padovan 164547d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 16463733937dSMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 16473733937dSMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 16480a708f8fSGustavo F. Padovan } 16490a708f8fSGustavo F. Padovan 16504343478fSGustavo F. Padovan l2cap_do_send(chan, skb); 16510a708f8fSGustavo F. Padovan 16523733937dSMat Martineau BT_DBG("Sent txseq %d", (int)control->txseq); 16533733937dSMat Martineau 1654836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 16553733937dSMat Martineau chan->frames_sent++; 16560a708f8fSGustavo F. Padovan } 16570a708f8fSGustavo F. Padovan } 16580a708f8fSGustavo F. Padovan 165967c9e840SSzymon Janc static int l2cap_ertm_send(struct l2cap_chan *chan) 16600a708f8fSGustavo F. Padovan { 16610a708f8fSGustavo F. Padovan struct sk_buff *skb, *tx_skb; 166218a48e76SMat Martineau struct l2cap_ctrl *control; 166318a48e76SMat Martineau int sent = 0; 166418a48e76SMat Martineau 166518a48e76SMat Martineau BT_DBG("chan %p", chan); 16660a708f8fSGustavo F. Padovan 166789bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 16680a708f8fSGustavo F. Padovan return -ENOTCONN; 16690a708f8fSGustavo F. Padovan 167094122bbeSMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 167194122bbeSMat Martineau return 0; 167294122bbeSMat Martineau 167318a48e76SMat Martineau while (chan->tx_send_head && 167418a48e76SMat Martineau chan->unacked_frames < chan->remote_tx_win && 167518a48e76SMat Martineau chan->tx_state == L2CAP_TX_STATE_XMIT) { 16760a708f8fSGustavo F. Padovan 167718a48e76SMat Martineau skb = chan->tx_send_head; 16780a708f8fSGustavo F. Padovan 167918a48e76SMat Martineau bt_cb(skb)->control.retries = 1; 168018a48e76SMat Martineau control = &bt_cb(skb)->control; 16810a708f8fSGustavo F. Padovan 1682e2ab4353SGustavo F. Padovan if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 168318a48e76SMat Martineau control->final = 1; 1684e2ab4353SGustavo F. Padovan 168518a48e76SMat Martineau control->reqseq = chan->buffer_seq; 168618a48e76SMat Martineau chan->last_acked_seq = chan->buffer_seq; 168718a48e76SMat Martineau control->txseq = chan->next_tx_seq; 16880a708f8fSGustavo F. Padovan 168918a48e76SMat Martineau __pack_control(chan, control, skb); 16900a708f8fSGustavo F. Padovan 169147d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 169218a48e76SMat Martineau u16 fcs = crc16(0, (u8 *) skb->data, skb->len); 169318a48e76SMat Martineau put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE)); 16940a708f8fSGustavo F. Padovan } 16950a708f8fSGustavo F. Padovan 169618a48e76SMat Martineau /* Clone after data has been modified. Data is assumed to be 169718a48e76SMat Martineau read-only (for locking purposes) on cloned sk_buffs. 169818a48e76SMat Martineau */ 169918a48e76SMat Martineau tx_skb = skb_clone(skb, GFP_KERNEL); 170018a48e76SMat Martineau 170118a48e76SMat Martineau if (!tx_skb) 170218a48e76SMat Martineau break; 17030a708f8fSGustavo F. Padovan 17041a09bcb9SGustavo F. Padovan __set_retrans_timer(chan); 17050a708f8fSGustavo F. Padovan 1706836be934SAndrei Emeltchenko chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq); 17076a026610SGustavo F. Padovan chan->unacked_frames++; 17086a026610SGustavo F. Padovan chan->frames_sent++; 170918a48e76SMat Martineau sent++; 17100a708f8fSGustavo F. Padovan 171158d35f87SGustavo F. Padovan if (skb_queue_is_last(&chan->tx_q, skb)) 171258d35f87SGustavo F. Padovan chan->tx_send_head = NULL; 17130a708f8fSGustavo F. Padovan else 171458d35f87SGustavo F. Padovan chan->tx_send_head = skb_queue_next(&chan->tx_q, skb); 171518a48e76SMat Martineau 171618a48e76SMat Martineau l2cap_do_send(chan, tx_skb); 171718a48e76SMat Martineau BT_DBG("Sent txseq %d", (int)control->txseq); 17180a708f8fSGustavo F. Padovan } 17190a708f8fSGustavo F. Padovan 172018a48e76SMat Martineau BT_DBG("Sent %d, %d unacked, %d in ERTM queue", sent, 172118a48e76SMat Martineau (int) chan->unacked_frames, skb_queue_len(&chan->tx_q)); 172218a48e76SMat Martineau 172318a48e76SMat Martineau return sent; 17240a708f8fSGustavo F. Padovan } 17250a708f8fSGustavo F. Padovan 1726e1fbd4c1SMat Martineau static void l2cap_ertm_resend(struct l2cap_chan *chan) 1727e1fbd4c1SMat Martineau { 1728e1fbd4c1SMat Martineau struct l2cap_ctrl control; 1729e1fbd4c1SMat Martineau struct sk_buff *skb; 1730e1fbd4c1SMat Martineau struct sk_buff *tx_skb; 1731e1fbd4c1SMat Martineau u16 seq; 1732e1fbd4c1SMat Martineau 1733e1fbd4c1SMat Martineau BT_DBG("chan %p", chan); 1734e1fbd4c1SMat Martineau 1735e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1736e1fbd4c1SMat Martineau return; 1737e1fbd4c1SMat Martineau 1738e1fbd4c1SMat Martineau while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) { 1739e1fbd4c1SMat Martineau seq = l2cap_seq_list_pop(&chan->retrans_list); 1740e1fbd4c1SMat Martineau 1741e1fbd4c1SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq); 1742e1fbd4c1SMat Martineau if (!skb) { 1743e1fbd4c1SMat Martineau BT_DBG("Error: Can't retransmit seq %d, frame missing", 1744e1fbd4c1SMat Martineau seq); 1745e1fbd4c1SMat Martineau continue; 1746e1fbd4c1SMat Martineau } 1747e1fbd4c1SMat Martineau 1748e1fbd4c1SMat Martineau bt_cb(skb)->control.retries++; 1749e1fbd4c1SMat Martineau control = bt_cb(skb)->control; 1750e1fbd4c1SMat Martineau 1751e1fbd4c1SMat Martineau if (chan->max_tx != 0 && 1752e1fbd4c1SMat Martineau bt_cb(skb)->control.retries > chan->max_tx) { 1753e1fbd4c1SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 1754e1fbd4c1SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 1755e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1756e1fbd4c1SMat Martineau break; 1757e1fbd4c1SMat Martineau } 1758e1fbd4c1SMat Martineau 1759e1fbd4c1SMat Martineau control.reqseq = chan->buffer_seq; 1760e1fbd4c1SMat Martineau if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state)) 1761e1fbd4c1SMat Martineau control.final = 1; 1762e1fbd4c1SMat Martineau else 1763e1fbd4c1SMat Martineau control.final = 0; 1764e1fbd4c1SMat Martineau 1765e1fbd4c1SMat Martineau if (skb_cloned(skb)) { 1766e1fbd4c1SMat Martineau /* Cloned sk_buffs are read-only, so we need a 1767e1fbd4c1SMat Martineau * writeable copy 1768e1fbd4c1SMat Martineau */ 1769e1fbd4c1SMat Martineau tx_skb = skb_copy(skb, GFP_ATOMIC); 1770e1fbd4c1SMat Martineau } else { 1771e1fbd4c1SMat Martineau tx_skb = skb_clone(skb, GFP_ATOMIC); 1772e1fbd4c1SMat Martineau } 1773e1fbd4c1SMat Martineau 1774e1fbd4c1SMat Martineau if (!tx_skb) { 1775e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1776e1fbd4c1SMat Martineau break; 1777e1fbd4c1SMat Martineau } 1778e1fbd4c1SMat Martineau 1779e1fbd4c1SMat Martineau /* Update skb contents */ 1780e1fbd4c1SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) { 1781e1fbd4c1SMat Martineau put_unaligned_le32(__pack_extended_control(&control), 1782e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1783e1fbd4c1SMat Martineau } else { 1784e1fbd4c1SMat Martineau put_unaligned_le16(__pack_enhanced_control(&control), 1785e1fbd4c1SMat Martineau tx_skb->data + L2CAP_HDR_SIZE); 1786e1fbd4c1SMat Martineau } 1787e1fbd4c1SMat Martineau 1788e1fbd4c1SMat Martineau if (chan->fcs == L2CAP_FCS_CRC16) { 1789e1fbd4c1SMat Martineau u16 fcs = crc16(0, (u8 *) tx_skb->data, tx_skb->len); 1790e1fbd4c1SMat Martineau put_unaligned_le16(fcs, skb_put(tx_skb, 1791e1fbd4c1SMat Martineau L2CAP_FCS_SIZE)); 1792e1fbd4c1SMat Martineau } 1793e1fbd4c1SMat Martineau 1794e1fbd4c1SMat Martineau l2cap_do_send(chan, tx_skb); 1795e1fbd4c1SMat Martineau 1796e1fbd4c1SMat Martineau BT_DBG("Resent txseq %d", control.txseq); 1797e1fbd4c1SMat Martineau 1798e1fbd4c1SMat Martineau chan->last_acked_seq = chan->buffer_seq; 1799e1fbd4c1SMat Martineau } 1800e1fbd4c1SMat Martineau } 1801e1fbd4c1SMat Martineau 1802f80842a8SMat Martineau static void l2cap_retransmit(struct l2cap_chan *chan, 1803f80842a8SMat Martineau struct l2cap_ctrl *control) 1804f80842a8SMat Martineau { 1805f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1806f80842a8SMat Martineau 1807f80842a8SMat Martineau l2cap_seq_list_append(&chan->retrans_list, control->reqseq); 1808f80842a8SMat Martineau l2cap_ertm_resend(chan); 1809f80842a8SMat Martineau } 1810f80842a8SMat Martineau 1811d2a7ac5dSMat Martineau static void l2cap_retransmit_all(struct l2cap_chan *chan, 1812d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 1813d2a7ac5dSMat Martineau { 1814e1fbd4c1SMat Martineau struct sk_buff *skb; 1815e1fbd4c1SMat Martineau 1816e1fbd4c1SMat Martineau BT_DBG("chan %p, control %p", chan, control); 1817e1fbd4c1SMat Martineau 1818e1fbd4c1SMat Martineau if (control->poll) 1819e1fbd4c1SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 1820e1fbd4c1SMat Martineau 1821e1fbd4c1SMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 1822e1fbd4c1SMat Martineau 1823e1fbd4c1SMat Martineau if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) 1824e1fbd4c1SMat Martineau return; 1825e1fbd4c1SMat Martineau 1826e1fbd4c1SMat Martineau if (chan->unacked_frames) { 1827e1fbd4c1SMat Martineau skb_queue_walk(&chan->tx_q, skb) { 1828e1fbd4c1SMat Martineau if (bt_cb(skb)->control.txseq == control->reqseq || 1829e1fbd4c1SMat Martineau skb == chan->tx_send_head) 1830e1fbd4c1SMat Martineau break; 1831e1fbd4c1SMat Martineau } 1832e1fbd4c1SMat Martineau 1833e1fbd4c1SMat Martineau skb_queue_walk_from(&chan->tx_q, skb) { 1834e1fbd4c1SMat Martineau if (skb == chan->tx_send_head) 1835e1fbd4c1SMat Martineau break; 1836e1fbd4c1SMat Martineau 1837e1fbd4c1SMat Martineau l2cap_seq_list_append(&chan->retrans_list, 1838e1fbd4c1SMat Martineau bt_cb(skb)->control.txseq); 1839e1fbd4c1SMat Martineau } 1840e1fbd4c1SMat Martineau 1841e1fbd4c1SMat Martineau l2cap_ertm_resend(chan); 1842e1fbd4c1SMat Martineau } 1843d2a7ac5dSMat Martineau } 1844d2a7ac5dSMat Martineau 1845b17e73bbSSzymon Janc static void l2cap_send_ack(struct l2cap_chan *chan) 1846b17e73bbSSzymon Janc { 18470a0aba42SMat Martineau struct l2cap_ctrl control; 18480a0aba42SMat Martineau u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq, 18490a0aba42SMat Martineau chan->last_acked_seq); 18500a0aba42SMat Martineau int threshold; 18510a0aba42SMat Martineau 18520a0aba42SMat Martineau BT_DBG("chan %p last_acked_seq %d buffer_seq %d", 18530a0aba42SMat Martineau chan, chan->last_acked_seq, chan->buffer_seq); 18540a0aba42SMat Martineau 18550a0aba42SMat Martineau memset(&control, 0, sizeof(control)); 18560a0aba42SMat Martineau control.sframe = 1; 18570a0aba42SMat Martineau 18580a0aba42SMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 18590a0aba42SMat Martineau chan->rx_state == L2CAP_RX_STATE_RECV) { 1860b17e73bbSSzymon Janc __clear_ack_timer(chan); 18610a0aba42SMat Martineau control.super = L2CAP_SUPER_RNR; 18620a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18630a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18640a0aba42SMat Martineau } else { 18650a0aba42SMat Martineau if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) { 18660a0aba42SMat Martineau l2cap_ertm_send(chan); 18670a0aba42SMat Martineau /* If any i-frames were sent, they included an ack */ 18680a0aba42SMat Martineau if (chan->buffer_seq == chan->last_acked_seq) 18690a0aba42SMat Martineau frames_to_ack = 0; 18700a0aba42SMat Martineau } 18710a0aba42SMat Martineau 18720a0aba42SMat Martineau /* Ack now if the tx window is 3/4ths full. 18730a0aba42SMat Martineau * Calculate without mul or div 18740a0aba42SMat Martineau */ 18750a0aba42SMat Martineau threshold = chan->tx_win; 18760a0aba42SMat Martineau threshold += threshold << 1; 18770a0aba42SMat Martineau threshold >>= 2; 18780a0aba42SMat Martineau 18790a0aba42SMat Martineau BT_DBG("frames_to_ack %d, threshold %d", (int)frames_to_ack, 18800a0aba42SMat Martineau threshold); 18810a0aba42SMat Martineau 18820a0aba42SMat Martineau if (frames_to_ack >= threshold) { 18830a0aba42SMat Martineau __clear_ack_timer(chan); 18840a0aba42SMat Martineau control.super = L2CAP_SUPER_RR; 18850a0aba42SMat Martineau control.reqseq = chan->buffer_seq; 18860a0aba42SMat Martineau l2cap_send_sframe(chan, &control); 18870a0aba42SMat Martineau frames_to_ack = 0; 18880a0aba42SMat Martineau } 18890a0aba42SMat Martineau 18900a0aba42SMat Martineau if (frames_to_ack) 18910a0aba42SMat Martineau __set_ack_timer(chan); 18920a0aba42SMat Martineau } 1893b17e73bbSSzymon Janc } 1894b17e73bbSSzymon Janc 189504124681SGustavo F. Padovan static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan, 189604124681SGustavo F. Padovan struct msghdr *msg, int len, 189704124681SGustavo F. Padovan int count, struct sk_buff *skb) 18980a708f8fSGustavo F. Padovan { 18990952a57aSAndrei Emeltchenko struct l2cap_conn *conn = chan->conn; 19000a708f8fSGustavo F. Padovan struct sk_buff **frag; 190190338947SGustavo Padovan int sent = 0; 19020a708f8fSGustavo F. Padovan 19030a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) 19040a708f8fSGustavo F. Padovan return -EFAULT; 19050a708f8fSGustavo F. Padovan 19060a708f8fSGustavo F. Padovan sent += count; 19070a708f8fSGustavo F. Padovan len -= count; 19080a708f8fSGustavo F. Padovan 19090a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 19100a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 19110a708f8fSGustavo F. Padovan while (len) { 1912fbe00700SGustavo Padovan struct sk_buff *tmp; 1913fbe00700SGustavo Padovan 19140a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 19150a708f8fSGustavo F. Padovan 1916fbe00700SGustavo Padovan tmp = chan->ops->alloc_skb(chan, count, 191790338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 1918fbe00700SGustavo Padovan if (IS_ERR(tmp)) 1919fbe00700SGustavo Padovan return PTR_ERR(tmp); 19202f7719ceSAndrei Emeltchenko 1921fbe00700SGustavo Padovan *frag = tmp; 1922fbe00700SGustavo Padovan 19230a708f8fSGustavo F. Padovan if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) 19240a708f8fSGustavo F. Padovan return -EFAULT; 19250a708f8fSGustavo F. Padovan 19265e59b791SLuiz Augusto von Dentz (*frag)->priority = skb->priority; 19275e59b791SLuiz Augusto von Dentz 19280a708f8fSGustavo F. Padovan sent += count; 19290a708f8fSGustavo F. Padovan len -= count; 19300a708f8fSGustavo F. Padovan 19312d0ed3d5SGustavo Padovan skb->len += (*frag)->len; 19322d0ed3d5SGustavo Padovan skb->data_len += (*frag)->len; 19332d0ed3d5SGustavo Padovan 19340a708f8fSGustavo F. Padovan frag = &(*frag)->next; 19350a708f8fSGustavo F. Padovan } 19360a708f8fSGustavo F. Padovan 19370a708f8fSGustavo F. Padovan return sent; 19380a708f8fSGustavo F. Padovan } 19390a708f8fSGustavo F. Padovan 19405e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, 19415e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19425e59b791SLuiz Augusto von Dentz u32 priority) 19430a708f8fSGustavo F. Padovan { 19448c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19450a708f8fSGustavo F. Padovan struct sk_buff *skb; 194603a51213SAndrei Emeltchenko int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE; 19470a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19480a708f8fSGustavo F. Padovan 19496d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d priority %u", chan, (int)len, priority); 19500a708f8fSGustavo F. Padovan 19510a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 19522f7719ceSAndrei Emeltchenko 19532f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 195490338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 195590338947SGustavo Padovan if (IS_ERR(skb)) 195690338947SGustavo Padovan return skb; 19570a708f8fSGustavo F. Padovan 19585e59b791SLuiz Augusto von Dentz skb->priority = priority; 19595e59b791SLuiz Augusto von Dentz 19600a708f8fSGustavo F. Padovan /* Create L2CAP header */ 19610a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 1962fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 1963daf6a78cSAndrei Emeltchenko lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE); 1964daf6a78cSAndrei Emeltchenko put_unaligned(chan->psm, skb_put(skb, L2CAP_PSMLEN_SIZE)); 19650a708f8fSGustavo F. Padovan 19660952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 19670a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 19680a708f8fSGustavo F. Padovan kfree_skb(skb); 19690a708f8fSGustavo F. Padovan return ERR_PTR(err); 19700a708f8fSGustavo F. Padovan } 19710a708f8fSGustavo F. Padovan return skb; 19720a708f8fSGustavo F. Padovan } 19730a708f8fSGustavo F. Padovan 19745e59b791SLuiz Augusto von Dentz static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, 19755e59b791SLuiz Augusto von Dentz struct msghdr *msg, size_t len, 19765e59b791SLuiz Augusto von Dentz u32 priority) 19770a708f8fSGustavo F. Padovan { 19788c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 19790a708f8fSGustavo F. Padovan struct sk_buff *skb; 1980f2ba7faeSGustavo Padovan int err, count; 19810a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 19820a708f8fSGustavo F. Padovan 19836d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d", chan, (int)len); 19840a708f8fSGustavo F. Padovan 1985f2ba7faeSGustavo Padovan count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len); 19862f7719ceSAndrei Emeltchenko 1987f2ba7faeSGustavo Padovan skb = chan->ops->alloc_skb(chan, count + L2CAP_HDR_SIZE, 198890338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 198990338947SGustavo Padovan if (IS_ERR(skb)) 199090338947SGustavo Padovan return skb; 19910a708f8fSGustavo F. Padovan 19925e59b791SLuiz Augusto von Dentz skb->priority = priority; 19935e59b791SLuiz Augusto von Dentz 19940a708f8fSGustavo F. Padovan /* Create L2CAP header */ 19950a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 1996fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 19976ff9b5efSGustavo Padovan lh->len = cpu_to_le16(len); 19980a708f8fSGustavo F. Padovan 19990952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20000a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20010a708f8fSGustavo F. Padovan kfree_skb(skb); 20020a708f8fSGustavo F. Padovan return ERR_PTR(err); 20030a708f8fSGustavo F. Padovan } 20040a708f8fSGustavo F. Padovan return skb; 20050a708f8fSGustavo F. Padovan } 20060a708f8fSGustavo F. Padovan 2007ab0ff76dSLuiz Augusto von Dentz static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, 2008ab0ff76dSLuiz Augusto von Dentz struct msghdr *msg, size_t len, 200994122bbeSMat Martineau u16 sdulen) 20100a708f8fSGustavo F. Padovan { 20118c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 20120a708f8fSGustavo F. Padovan struct sk_buff *skb; 2013e4ca6d98SAndrei Emeltchenko int err, count, hlen; 20140a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 20150a708f8fSGustavo F. Padovan 20166d5922b0SAndrei Emeltchenko BT_DBG("chan %p len %d", chan, (int)len); 20170a708f8fSGustavo F. Padovan 20180a708f8fSGustavo F. Padovan if (!conn) 20190a708f8fSGustavo F. Padovan return ERR_PTR(-ENOTCONN); 20200a708f8fSGustavo F. Padovan 2021e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 2022e4ca6d98SAndrei Emeltchenko hlen = L2CAP_EXT_HDR_SIZE; 2023e4ca6d98SAndrei Emeltchenko else 2024e4ca6d98SAndrei Emeltchenko hlen = L2CAP_ENH_HDR_SIZE; 2025e4ca6d98SAndrei Emeltchenko 20260a708f8fSGustavo F. Padovan if (sdulen) 202703a51213SAndrei Emeltchenko hlen += L2CAP_SDULEN_SIZE; 20280a708f8fSGustavo F. Padovan 202947d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 203003a51213SAndrei Emeltchenko hlen += L2CAP_FCS_SIZE; 20310a708f8fSGustavo F. Padovan 20320a708f8fSGustavo F. Padovan count = min_t(unsigned int, (conn->mtu - hlen), len); 20332f7719ceSAndrei Emeltchenko 20342f7719ceSAndrei Emeltchenko skb = chan->ops->alloc_skb(chan, count + hlen, 203590338947SGustavo Padovan msg->msg_flags & MSG_DONTWAIT); 203690338947SGustavo Padovan if (IS_ERR(skb)) 203790338947SGustavo Padovan return skb; 20380a708f8fSGustavo F. Padovan 20390a708f8fSGustavo F. Padovan /* Create L2CAP header */ 20400a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 2041fe4128e0SGustavo F. Padovan lh->cid = cpu_to_le16(chan->dcid); 20420a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE)); 204388843ab0SAndrei Emeltchenko 204418a48e76SMat Martineau /* Control header is populated later */ 204518a48e76SMat Martineau if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 204618a48e76SMat Martineau put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE)); 204718a48e76SMat Martineau else 204818a48e76SMat Martineau put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE)); 204988843ab0SAndrei Emeltchenko 20500a708f8fSGustavo F. Padovan if (sdulen) 205103a51213SAndrei Emeltchenko put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE)); 20520a708f8fSGustavo F. Padovan 20530952a57aSAndrei Emeltchenko err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb); 20540a708f8fSGustavo F. Padovan if (unlikely(err < 0)) { 20550a708f8fSGustavo F. Padovan kfree_skb(skb); 20560a708f8fSGustavo F. Padovan return ERR_PTR(err); 20570a708f8fSGustavo F. Padovan } 20580a708f8fSGustavo F. Padovan 205918a48e76SMat Martineau bt_cb(skb)->control.fcs = chan->fcs; 20603ce3514fSMat Martineau bt_cb(skb)->control.retries = 0; 20610a708f8fSGustavo F. Padovan return skb; 20620a708f8fSGustavo F. Padovan } 20630a708f8fSGustavo F. Padovan 206494122bbeSMat Martineau static int l2cap_segment_sdu(struct l2cap_chan *chan, 206594122bbeSMat Martineau struct sk_buff_head *seg_queue, 206694122bbeSMat Martineau struct msghdr *msg, size_t len) 20670a708f8fSGustavo F. Padovan { 20680a708f8fSGustavo F. Padovan struct sk_buff *skb; 206994122bbeSMat Martineau u16 sdu_len; 207094122bbeSMat Martineau size_t pdu_len; 207194122bbeSMat Martineau int err = 0; 207294122bbeSMat Martineau u8 sar; 20730a708f8fSGustavo F. Padovan 207494122bbeSMat Martineau BT_DBG("chan %p, msg %p, len %d", chan, msg, (int)len); 20750a708f8fSGustavo F. Padovan 207694122bbeSMat Martineau /* It is critical that ERTM PDUs fit in a single HCI fragment, 207794122bbeSMat Martineau * so fragmented skbs are not used. The HCI layer's handling 207894122bbeSMat Martineau * of fragmented skbs is not compatible with ERTM's queueing. 207994122bbeSMat Martineau */ 208094122bbeSMat Martineau 208194122bbeSMat Martineau /* PDU size is derived from the HCI MTU */ 208294122bbeSMat Martineau pdu_len = chan->conn->mtu; 208394122bbeSMat Martineau 208494122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD); 208594122bbeSMat Martineau 208694122bbeSMat Martineau /* Adjust for largest possible L2CAP overhead. */ 208735d401dfSGustavo Padovan if (chan->fcs) 208835d401dfSGustavo Padovan pdu_len -= L2CAP_FCS_SIZE; 208935d401dfSGustavo Padovan 209035d401dfSGustavo Padovan if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 209135d401dfSGustavo Padovan pdu_len -= L2CAP_EXT_HDR_SIZE; 209235d401dfSGustavo Padovan else 209335d401dfSGustavo Padovan pdu_len -= L2CAP_ENH_HDR_SIZE; 209494122bbeSMat Martineau 209594122bbeSMat Martineau /* Remote device may have requested smaller PDUs */ 209694122bbeSMat Martineau pdu_len = min_t(size_t, pdu_len, chan->remote_mps); 209794122bbeSMat Martineau 209894122bbeSMat Martineau if (len <= pdu_len) { 209994122bbeSMat Martineau sar = L2CAP_SAR_UNSEGMENTED; 210094122bbeSMat Martineau sdu_len = 0; 210194122bbeSMat Martineau pdu_len = len; 210294122bbeSMat Martineau } else { 210394122bbeSMat Martineau sar = L2CAP_SAR_START; 210494122bbeSMat Martineau sdu_len = len; 210594122bbeSMat Martineau pdu_len -= L2CAP_SDULEN_SIZE; 210694122bbeSMat Martineau } 21070a708f8fSGustavo F. Padovan 21080a708f8fSGustavo F. Padovan while (len > 0) { 210994122bbeSMat Martineau skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len); 21100a708f8fSGustavo F. Padovan 21110a708f8fSGustavo F. Padovan if (IS_ERR(skb)) { 211294122bbeSMat Martineau __skb_queue_purge(seg_queue); 21130a708f8fSGustavo F. Padovan return PTR_ERR(skb); 21140a708f8fSGustavo F. Padovan } 21150a708f8fSGustavo F. Padovan 211694122bbeSMat Martineau bt_cb(skb)->control.sar = sar; 211794122bbeSMat Martineau __skb_queue_tail(seg_queue, skb); 21180a708f8fSGustavo F. Padovan 211994122bbeSMat Martineau len -= pdu_len; 212094122bbeSMat Martineau if (sdu_len) { 212194122bbeSMat Martineau sdu_len = 0; 212294122bbeSMat Martineau pdu_len += L2CAP_SDULEN_SIZE; 212394122bbeSMat Martineau } 212494122bbeSMat Martineau 212594122bbeSMat Martineau if (len <= pdu_len) { 212694122bbeSMat Martineau sar = L2CAP_SAR_END; 212794122bbeSMat Martineau pdu_len = len; 212894122bbeSMat Martineau } else { 212994122bbeSMat Martineau sar = L2CAP_SAR_CONTINUE; 213094122bbeSMat Martineau } 213194122bbeSMat Martineau } 213294122bbeSMat Martineau 213394122bbeSMat Martineau return err; 21340a708f8fSGustavo F. Padovan } 21350a708f8fSGustavo F. Padovan 21365e59b791SLuiz Augusto von Dentz int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len, 21375e59b791SLuiz Augusto von Dentz u32 priority) 21389a91a04aSGustavo F. Padovan { 21399a91a04aSGustavo F. Padovan struct sk_buff *skb; 21409a91a04aSGustavo F. Padovan int err; 214194122bbeSMat Martineau struct sk_buff_head seg_queue; 21429a91a04aSGustavo F. Padovan 21439a91a04aSGustavo F. Padovan /* Connectionless channel */ 2144715ec005SGustavo F. Padovan if (chan->chan_type == L2CAP_CHAN_CONN_LESS) { 21455e59b791SLuiz Augusto von Dentz skb = l2cap_create_connless_pdu(chan, msg, len, priority); 21469a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 21479a91a04aSGustavo F. Padovan return PTR_ERR(skb); 21489a91a04aSGustavo F. Padovan 21499a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 21509a91a04aSGustavo F. Padovan return len; 21519a91a04aSGustavo F. Padovan } 21529a91a04aSGustavo F. Padovan 21539a91a04aSGustavo F. Padovan switch (chan->mode) { 21549a91a04aSGustavo F. Padovan case L2CAP_MODE_BASIC: 21559a91a04aSGustavo F. Padovan /* Check outgoing MTU */ 21569a91a04aSGustavo F. Padovan if (len > chan->omtu) 21579a91a04aSGustavo F. Padovan return -EMSGSIZE; 21589a91a04aSGustavo F. Padovan 21599a91a04aSGustavo F. Padovan /* Create a basic PDU */ 21605e59b791SLuiz Augusto von Dentz skb = l2cap_create_basic_pdu(chan, msg, len, priority); 21619a91a04aSGustavo F. Padovan if (IS_ERR(skb)) 21629a91a04aSGustavo F. Padovan return PTR_ERR(skb); 21639a91a04aSGustavo F. Padovan 21649a91a04aSGustavo F. Padovan l2cap_do_send(chan, skb); 21659a91a04aSGustavo F. Padovan err = len; 21669a91a04aSGustavo F. Padovan break; 21679a91a04aSGustavo F. Padovan 21689a91a04aSGustavo F. Padovan case L2CAP_MODE_ERTM: 21699a91a04aSGustavo F. Padovan case L2CAP_MODE_STREAMING: 217094122bbeSMat Martineau /* Check outgoing MTU */ 217194122bbeSMat Martineau if (len > chan->omtu) { 217294122bbeSMat Martineau err = -EMSGSIZE; 21739a91a04aSGustavo F. Padovan break; 21749a91a04aSGustavo F. Padovan } 21759a91a04aSGustavo F. Padovan 217694122bbeSMat Martineau __skb_queue_head_init(&seg_queue); 217794122bbeSMat Martineau 217894122bbeSMat Martineau /* Do segmentation before calling in to the state machine, 217994122bbeSMat Martineau * since it's possible to block while waiting for memory 218094122bbeSMat Martineau * allocation. 218194122bbeSMat Martineau */ 218294122bbeSMat Martineau err = l2cap_segment_sdu(chan, &seg_queue, msg, len); 218394122bbeSMat Martineau 218494122bbeSMat Martineau /* The channel could have been closed while segmenting, 218594122bbeSMat Martineau * check that it is still connected. 218694122bbeSMat Martineau */ 218794122bbeSMat Martineau if (chan->state != BT_CONNECTED) { 218894122bbeSMat Martineau __skb_queue_purge(&seg_queue); 218994122bbeSMat Martineau err = -ENOTCONN; 21909a91a04aSGustavo F. Padovan } 21919a91a04aSGustavo F. Padovan 219294122bbeSMat Martineau if (err) 219394122bbeSMat Martineau break; 219494122bbeSMat Martineau 21953733937dSMat Martineau if (chan->mode == L2CAP_MODE_ERTM) 2196d660366dSGustavo Padovan l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST); 21973733937dSMat Martineau else 2198d660366dSGustavo Padovan l2cap_streaming_send(chan, &seg_queue); 219994122bbeSMat Martineau 22009a91a04aSGustavo F. Padovan err = len; 22019a91a04aSGustavo F. Padovan 220294122bbeSMat Martineau /* If the skbs were not queued for sending, they'll still be in 220394122bbeSMat Martineau * seg_queue and need to be purged. 220494122bbeSMat Martineau */ 220594122bbeSMat Martineau __skb_queue_purge(&seg_queue); 22069a91a04aSGustavo F. Padovan break; 22079a91a04aSGustavo F. Padovan 22089a91a04aSGustavo F. Padovan default: 22099a91a04aSGustavo F. Padovan BT_DBG("bad state %1.1x", chan->mode); 22109a91a04aSGustavo F. Padovan err = -EBADFD; 22119a91a04aSGustavo F. Padovan } 22129a91a04aSGustavo F. Padovan 22139a91a04aSGustavo F. Padovan return err; 22149a91a04aSGustavo F. Padovan } 22159a91a04aSGustavo F. Padovan 2216d2a7ac5dSMat Martineau static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq) 2217d2a7ac5dSMat Martineau { 2218bed68bdeSMat Martineau struct l2cap_ctrl control; 2219bed68bdeSMat Martineau u16 seq; 2220bed68bdeSMat Martineau 2221bed68bdeSMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 2222bed68bdeSMat Martineau 2223bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2224bed68bdeSMat Martineau control.sframe = 1; 2225bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2226bed68bdeSMat Martineau 2227bed68bdeSMat Martineau for (seq = chan->expected_tx_seq; seq != txseq; 2228bed68bdeSMat Martineau seq = __next_seq(chan, seq)) { 2229bed68bdeSMat Martineau if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) { 2230bed68bdeSMat Martineau control.reqseq = seq; 2231bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2232bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2233bed68bdeSMat Martineau } 2234bed68bdeSMat Martineau } 2235bed68bdeSMat Martineau 2236bed68bdeSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 2237d2a7ac5dSMat Martineau } 2238d2a7ac5dSMat Martineau 2239d2a7ac5dSMat Martineau static void l2cap_send_srej_tail(struct l2cap_chan *chan) 2240d2a7ac5dSMat Martineau { 2241bed68bdeSMat Martineau struct l2cap_ctrl control; 2242bed68bdeSMat Martineau 2243bed68bdeSMat Martineau BT_DBG("chan %p", chan); 2244bed68bdeSMat Martineau 2245bed68bdeSMat Martineau if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR) 2246bed68bdeSMat Martineau return; 2247bed68bdeSMat Martineau 2248bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2249bed68bdeSMat Martineau control.sframe = 1; 2250bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2251bed68bdeSMat Martineau control.reqseq = chan->srej_list.tail; 2252bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2253d2a7ac5dSMat Martineau } 2254d2a7ac5dSMat Martineau 2255d2a7ac5dSMat Martineau static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq) 2256d2a7ac5dSMat Martineau { 2257bed68bdeSMat Martineau struct l2cap_ctrl control; 2258bed68bdeSMat Martineau u16 initial_head; 2259bed68bdeSMat Martineau u16 seq; 2260bed68bdeSMat Martineau 2261bed68bdeSMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 2262bed68bdeSMat Martineau 2263bed68bdeSMat Martineau memset(&control, 0, sizeof(control)); 2264bed68bdeSMat Martineau control.sframe = 1; 2265bed68bdeSMat Martineau control.super = L2CAP_SUPER_SREJ; 2266bed68bdeSMat Martineau 2267bed68bdeSMat Martineau /* Capture initial list head to allow only one pass through the list. */ 2268bed68bdeSMat Martineau initial_head = chan->srej_list.head; 2269bed68bdeSMat Martineau 2270bed68bdeSMat Martineau do { 2271bed68bdeSMat Martineau seq = l2cap_seq_list_pop(&chan->srej_list); 2272bed68bdeSMat Martineau if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR) 2273bed68bdeSMat Martineau break; 2274bed68bdeSMat Martineau 2275bed68bdeSMat Martineau control.reqseq = seq; 2276bed68bdeSMat Martineau l2cap_send_sframe(chan, &control); 2277bed68bdeSMat Martineau l2cap_seq_list_append(&chan->srej_list, seq); 2278bed68bdeSMat Martineau } while (chan->srej_list.head != initial_head); 2279d2a7ac5dSMat Martineau } 2280d2a7ac5dSMat Martineau 2281608bcc6dSMat Martineau static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq) 2282608bcc6dSMat Martineau { 2283608bcc6dSMat Martineau struct sk_buff *acked_skb; 2284608bcc6dSMat Martineau u16 ackseq; 2285608bcc6dSMat Martineau 2286608bcc6dSMat Martineau BT_DBG("chan %p, reqseq %d", chan, reqseq); 2287608bcc6dSMat Martineau 2288608bcc6dSMat Martineau if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq) 2289608bcc6dSMat Martineau return; 2290608bcc6dSMat Martineau 2291608bcc6dSMat Martineau BT_DBG("expected_ack_seq %d, unacked_frames %d", 2292608bcc6dSMat Martineau chan->expected_ack_seq, chan->unacked_frames); 2293608bcc6dSMat Martineau 2294608bcc6dSMat Martineau for (ackseq = chan->expected_ack_seq; ackseq != reqseq; 2295608bcc6dSMat Martineau ackseq = __next_seq(chan, ackseq)) { 2296608bcc6dSMat Martineau 2297608bcc6dSMat Martineau acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq); 2298608bcc6dSMat Martineau if (acked_skb) { 2299608bcc6dSMat Martineau skb_unlink(acked_skb, &chan->tx_q); 2300608bcc6dSMat Martineau kfree_skb(acked_skb); 2301608bcc6dSMat Martineau chan->unacked_frames--; 2302608bcc6dSMat Martineau } 2303608bcc6dSMat Martineau } 2304608bcc6dSMat Martineau 2305608bcc6dSMat Martineau chan->expected_ack_seq = reqseq; 2306608bcc6dSMat Martineau 2307608bcc6dSMat Martineau if (chan->unacked_frames == 0) 2308608bcc6dSMat Martineau __clear_retrans_timer(chan); 2309608bcc6dSMat Martineau 2310608bcc6dSMat Martineau BT_DBG("unacked_frames %d", (int) chan->unacked_frames); 2311608bcc6dSMat Martineau } 2312608bcc6dSMat Martineau 2313608bcc6dSMat Martineau static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan) 2314608bcc6dSMat Martineau { 2315608bcc6dSMat Martineau BT_DBG("chan %p", chan); 2316608bcc6dSMat Martineau 2317608bcc6dSMat Martineau chan->expected_tx_seq = chan->buffer_seq; 2318608bcc6dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 2319608bcc6dSMat Martineau skb_queue_purge(&chan->srej_q); 2320608bcc6dSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2321608bcc6dSMat Martineau } 2322608bcc6dSMat Martineau 2323d660366dSGustavo Padovan static void l2cap_tx_state_xmit(struct l2cap_chan *chan, 2324608bcc6dSMat Martineau struct l2cap_ctrl *control, 2325608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2326608bcc6dSMat Martineau { 2327608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2328608bcc6dSMat Martineau event); 2329608bcc6dSMat Martineau 2330608bcc6dSMat Martineau switch (event) { 2331608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2332608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2333608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2334608bcc6dSMat Martineau 2335608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2336608bcc6dSMat Martineau l2cap_ertm_send(chan); 2337608bcc6dSMat Martineau break; 2338608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2339608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2340608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2341608bcc6dSMat Martineau 2342608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2343608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2344608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2345608bcc6dSMat Martineau */ 2346608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2347608bcc6dSMat Martineau } 2348608bcc6dSMat Martineau 2349608bcc6dSMat Martineau l2cap_send_ack(chan); 2350608bcc6dSMat Martineau 2351608bcc6dSMat Martineau break; 2352608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2353608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2354608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2355608bcc6dSMat Martineau 2356608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2357608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2358608bcc6dSMat Martineau 2359608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2360608bcc6dSMat Martineau local_control.sframe = 1; 2361608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2362608bcc6dSMat Martineau local_control.poll = 1; 2363608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2364a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2365608bcc6dSMat Martineau 2366608bcc6dSMat Martineau chan->retry_count = 1; 2367608bcc6dSMat Martineau __set_monitor_timer(chan); 2368608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2369608bcc6dSMat Martineau } 2370608bcc6dSMat Martineau break; 2371608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2372608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2373608bcc6dSMat Martineau break; 2374608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2375608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2376608bcc6dSMat Martineau chan->retry_count = 1; 2377608bcc6dSMat Martineau __set_monitor_timer(chan); 2378608bcc6dSMat Martineau __clear_ack_timer(chan); 2379608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2380608bcc6dSMat Martineau break; 2381608bcc6dSMat Martineau case L2CAP_EV_RETRANS_TO: 2382608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2383608bcc6dSMat Martineau chan->retry_count = 1; 2384608bcc6dSMat Martineau __set_monitor_timer(chan); 2385608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2386608bcc6dSMat Martineau break; 2387608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2388608bcc6dSMat Martineau /* Nothing to process */ 2389608bcc6dSMat Martineau break; 2390608bcc6dSMat Martineau default: 2391608bcc6dSMat Martineau break; 2392608bcc6dSMat Martineau } 2393608bcc6dSMat Martineau } 2394608bcc6dSMat Martineau 2395d660366dSGustavo Padovan static void l2cap_tx_state_wait_f(struct l2cap_chan *chan, 2396608bcc6dSMat Martineau struct l2cap_ctrl *control, 2397608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2398608bcc6dSMat Martineau { 2399608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs, 2400608bcc6dSMat Martineau event); 2401608bcc6dSMat Martineau 2402608bcc6dSMat Martineau switch (event) { 2403608bcc6dSMat Martineau case L2CAP_EV_DATA_REQUEST: 2404608bcc6dSMat Martineau if (chan->tx_send_head == NULL) 2405608bcc6dSMat Martineau chan->tx_send_head = skb_peek(skbs); 2406608bcc6dSMat Martineau /* Queue data, but don't send. */ 2407608bcc6dSMat Martineau skb_queue_splice_tail_init(skbs, &chan->tx_q); 2408608bcc6dSMat Martineau break; 2409608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_DETECTED: 2410608bcc6dSMat Martineau BT_DBG("Enter LOCAL_BUSY"); 2411608bcc6dSMat Martineau set_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2412608bcc6dSMat Martineau 2413608bcc6dSMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 2414608bcc6dSMat Martineau /* The SREJ_SENT state must be aborted if we are to 2415608bcc6dSMat Martineau * enter the LOCAL_BUSY state. 2416608bcc6dSMat Martineau */ 2417608bcc6dSMat Martineau l2cap_abort_rx_srej_sent(chan); 2418608bcc6dSMat Martineau } 2419608bcc6dSMat Martineau 2420608bcc6dSMat Martineau l2cap_send_ack(chan); 2421608bcc6dSMat Martineau 2422608bcc6dSMat Martineau break; 2423608bcc6dSMat Martineau case L2CAP_EV_LOCAL_BUSY_CLEAR: 2424608bcc6dSMat Martineau BT_DBG("Exit LOCAL_BUSY"); 2425608bcc6dSMat Martineau clear_bit(CONN_LOCAL_BUSY, &chan->conn_state); 2426608bcc6dSMat Martineau 2427608bcc6dSMat Martineau if (test_bit(CONN_RNR_SENT, &chan->conn_state)) { 2428608bcc6dSMat Martineau struct l2cap_ctrl local_control; 2429608bcc6dSMat Martineau memset(&local_control, 0, sizeof(local_control)); 2430608bcc6dSMat Martineau local_control.sframe = 1; 2431608bcc6dSMat Martineau local_control.super = L2CAP_SUPER_RR; 2432608bcc6dSMat Martineau local_control.poll = 1; 2433608bcc6dSMat Martineau local_control.reqseq = chan->buffer_seq; 2434a67d7f6fSMat Martineau l2cap_send_sframe(chan, &local_control); 2435608bcc6dSMat Martineau 2436608bcc6dSMat Martineau chan->retry_count = 1; 2437608bcc6dSMat Martineau __set_monitor_timer(chan); 2438608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_WAIT_F; 2439608bcc6dSMat Martineau } 2440608bcc6dSMat Martineau break; 2441608bcc6dSMat Martineau case L2CAP_EV_RECV_REQSEQ_AND_FBIT: 2442608bcc6dSMat Martineau l2cap_process_reqseq(chan, control->reqseq); 2443608bcc6dSMat Martineau 2444608bcc6dSMat Martineau /* Fall through */ 2445608bcc6dSMat Martineau 2446608bcc6dSMat Martineau case L2CAP_EV_RECV_FBIT: 2447608bcc6dSMat Martineau if (control && control->final) { 2448608bcc6dSMat Martineau __clear_monitor_timer(chan); 2449608bcc6dSMat Martineau if (chan->unacked_frames > 0) 2450608bcc6dSMat Martineau __set_retrans_timer(chan); 2451608bcc6dSMat Martineau chan->retry_count = 0; 2452608bcc6dSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 2453608bcc6dSMat Martineau BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state); 2454608bcc6dSMat Martineau } 2455608bcc6dSMat Martineau break; 2456608bcc6dSMat Martineau case L2CAP_EV_EXPLICIT_POLL: 2457608bcc6dSMat Martineau /* Ignore */ 2458608bcc6dSMat Martineau break; 2459608bcc6dSMat Martineau case L2CAP_EV_MONITOR_TO: 2460608bcc6dSMat Martineau if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) { 2461608bcc6dSMat Martineau l2cap_send_rr_or_rnr(chan, 1); 2462608bcc6dSMat Martineau __set_monitor_timer(chan); 2463608bcc6dSMat Martineau chan->retry_count++; 2464608bcc6dSMat Martineau } else { 2465608bcc6dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED); 2466608bcc6dSMat Martineau } 2467608bcc6dSMat Martineau break; 2468608bcc6dSMat Martineau default: 2469608bcc6dSMat Martineau break; 2470608bcc6dSMat Martineau } 2471608bcc6dSMat Martineau } 2472608bcc6dSMat Martineau 2473d660366dSGustavo Padovan static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 2474608bcc6dSMat Martineau struct sk_buff_head *skbs, u8 event) 2475608bcc6dSMat Martineau { 2476608bcc6dSMat Martineau BT_DBG("chan %p, control %p, skbs %p, event %d, state %d", 2477608bcc6dSMat Martineau chan, control, skbs, event, chan->tx_state); 2478608bcc6dSMat Martineau 2479608bcc6dSMat Martineau switch (chan->tx_state) { 2480608bcc6dSMat Martineau case L2CAP_TX_STATE_XMIT: 2481d660366dSGustavo Padovan l2cap_tx_state_xmit(chan, control, skbs, event); 2482608bcc6dSMat Martineau break; 2483608bcc6dSMat Martineau case L2CAP_TX_STATE_WAIT_F: 2484d660366dSGustavo Padovan l2cap_tx_state_wait_f(chan, control, skbs, event); 2485608bcc6dSMat Martineau break; 2486608bcc6dSMat Martineau default: 2487608bcc6dSMat Martineau /* Ignore event */ 2488608bcc6dSMat Martineau break; 2489608bcc6dSMat Martineau } 2490608bcc6dSMat Martineau } 2491608bcc6dSMat Martineau 24924b51dae9SMat Martineau static void l2cap_pass_to_tx(struct l2cap_chan *chan, 24934b51dae9SMat Martineau struct l2cap_ctrl *control) 24944b51dae9SMat Martineau { 24954b51dae9SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2496401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT); 24974b51dae9SMat Martineau } 24984b51dae9SMat Martineau 2499f80842a8SMat Martineau static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan, 2500f80842a8SMat Martineau struct l2cap_ctrl *control) 2501f80842a8SMat Martineau { 2502f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 2503401bb1f7SAndrei Emeltchenko l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT); 2504f80842a8SMat Martineau } 2505f80842a8SMat Martineau 25060a708f8fSGustavo F. Padovan /* Copy frame to all raw sockets on that connection */ 25070a708f8fSGustavo F. Padovan static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb) 25080a708f8fSGustavo F. Padovan { 25090a708f8fSGustavo F. Padovan struct sk_buff *nskb; 251048454079SGustavo F. Padovan struct l2cap_chan *chan; 25110a708f8fSGustavo F. Padovan 25120a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 25130a708f8fSGustavo F. Padovan 25143df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 25153d57dc68SGustavo F. Padovan 25163df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 251748454079SGustavo F. Padovan struct sock *sk = chan->sk; 2518715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_RAW) 25190a708f8fSGustavo F. Padovan continue; 25200a708f8fSGustavo F. Padovan 25210a708f8fSGustavo F. Padovan /* Don't send frame to the socket it came from */ 25220a708f8fSGustavo F. Padovan if (skb->sk == sk) 25230a708f8fSGustavo F. Padovan continue; 25240a708f8fSGustavo F. Padovan nskb = skb_clone(skb, GFP_ATOMIC); 25250a708f8fSGustavo F. Padovan if (!nskb) 25260a708f8fSGustavo F. Padovan continue; 25270a708f8fSGustavo F. Padovan 252880b98027SGustavo Padovan if (chan->ops->recv(chan, nskb)) 25290a708f8fSGustavo F. Padovan kfree_skb(nskb); 25300a708f8fSGustavo F. Padovan } 25313d57dc68SGustavo F. Padovan 25323df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 25330a708f8fSGustavo F. Padovan } 25340a708f8fSGustavo F. Padovan 25350a708f8fSGustavo F. Padovan /* ---- L2CAP signalling commands ---- */ 25360a708f8fSGustavo F. Padovan static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, 25370a708f8fSGustavo F. Padovan u8 code, u8 ident, u16 dlen, void *data) 25380a708f8fSGustavo F. Padovan { 25390a708f8fSGustavo F. Padovan struct sk_buff *skb, **frag; 25400a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr *cmd; 25410a708f8fSGustavo F. Padovan struct l2cap_hdr *lh; 25420a708f8fSGustavo F. Padovan int len, count; 25430a708f8fSGustavo F. Padovan 25440a708f8fSGustavo F. Padovan BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d", 25450a708f8fSGustavo F. Padovan conn, code, ident, dlen); 25460a708f8fSGustavo F. Padovan 25470a708f8fSGustavo F. Padovan len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen; 25480a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25490a708f8fSGustavo F. Padovan 25500a708f8fSGustavo F. Padovan skb = bt_skb_alloc(count, GFP_ATOMIC); 25510a708f8fSGustavo F. Padovan if (!skb) 25520a708f8fSGustavo F. Padovan return NULL; 25530a708f8fSGustavo F. Padovan 25540a708f8fSGustavo F. Padovan lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE); 25550a708f8fSGustavo F. Padovan lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen); 25563300d9a9SClaudio Takahasi 25573300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 2558ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_LE_SIGNALING); 25593300d9a9SClaudio Takahasi else 2560ac73498cSAndrei Emeltchenko lh->cid = __constant_cpu_to_le16(L2CAP_CID_SIGNALING); 25610a708f8fSGustavo F. Padovan 25620a708f8fSGustavo F. Padovan cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE); 25630a708f8fSGustavo F. Padovan cmd->code = code; 25640a708f8fSGustavo F. Padovan cmd->ident = ident; 25650a708f8fSGustavo F. Padovan cmd->len = cpu_to_le16(dlen); 25660a708f8fSGustavo F. Padovan 25670a708f8fSGustavo F. Padovan if (dlen) { 25680a708f8fSGustavo F. Padovan count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE; 25690a708f8fSGustavo F. Padovan memcpy(skb_put(skb, count), data, count); 25700a708f8fSGustavo F. Padovan data += count; 25710a708f8fSGustavo F. Padovan } 25720a708f8fSGustavo F. Padovan 25730a708f8fSGustavo F. Padovan len -= skb->len; 25740a708f8fSGustavo F. Padovan 25750a708f8fSGustavo F. Padovan /* Continuation fragments (no L2CAP header) */ 25760a708f8fSGustavo F. Padovan frag = &skb_shinfo(skb)->frag_list; 25770a708f8fSGustavo F. Padovan while (len) { 25780a708f8fSGustavo F. Padovan count = min_t(unsigned int, conn->mtu, len); 25790a708f8fSGustavo F. Padovan 25800a708f8fSGustavo F. Padovan *frag = bt_skb_alloc(count, GFP_ATOMIC); 25810a708f8fSGustavo F. Padovan if (!*frag) 25820a708f8fSGustavo F. Padovan goto fail; 25830a708f8fSGustavo F. Padovan 25840a708f8fSGustavo F. Padovan memcpy(skb_put(*frag, count), data, count); 25850a708f8fSGustavo F. Padovan 25860a708f8fSGustavo F. Padovan len -= count; 25870a708f8fSGustavo F. Padovan data += count; 25880a708f8fSGustavo F. Padovan 25890a708f8fSGustavo F. Padovan frag = &(*frag)->next; 25900a708f8fSGustavo F. Padovan } 25910a708f8fSGustavo F. Padovan 25920a708f8fSGustavo F. Padovan return skb; 25930a708f8fSGustavo F. Padovan 25940a708f8fSGustavo F. Padovan fail: 25950a708f8fSGustavo F. Padovan kfree_skb(skb); 25960a708f8fSGustavo F. Padovan return NULL; 25970a708f8fSGustavo F. Padovan } 25980a708f8fSGustavo F. Padovan 25990a708f8fSGustavo F. Padovan static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val) 26000a708f8fSGustavo F. Padovan { 26010a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26020a708f8fSGustavo F. Padovan int len; 26030a708f8fSGustavo F. Padovan 26040a708f8fSGustavo F. Padovan len = L2CAP_CONF_OPT_SIZE + opt->len; 26050a708f8fSGustavo F. Padovan *ptr += len; 26060a708f8fSGustavo F. Padovan 26070a708f8fSGustavo F. Padovan *type = opt->type; 26080a708f8fSGustavo F. Padovan *olen = opt->len; 26090a708f8fSGustavo F. Padovan 26100a708f8fSGustavo F. Padovan switch (opt->len) { 26110a708f8fSGustavo F. Padovan case 1: 26120a708f8fSGustavo F. Padovan *val = *((u8 *) opt->val); 26130a708f8fSGustavo F. Padovan break; 26140a708f8fSGustavo F. Padovan 26150a708f8fSGustavo F. Padovan case 2: 26160a708f8fSGustavo F. Padovan *val = get_unaligned_le16(opt->val); 26170a708f8fSGustavo F. Padovan break; 26180a708f8fSGustavo F. Padovan 26190a708f8fSGustavo F. Padovan case 4: 26200a708f8fSGustavo F. Padovan *val = get_unaligned_le32(opt->val); 26210a708f8fSGustavo F. Padovan break; 26220a708f8fSGustavo F. Padovan 26230a708f8fSGustavo F. Padovan default: 26240a708f8fSGustavo F. Padovan *val = (unsigned long) opt->val; 26250a708f8fSGustavo F. Padovan break; 26260a708f8fSGustavo F. Padovan } 26270a708f8fSGustavo F. Padovan 26280a708f8fSGustavo F. Padovan BT_DBG("type 0x%2.2x len %d val 0x%lx", *type, opt->len, *val); 26290a708f8fSGustavo F. Padovan return len; 26300a708f8fSGustavo F. Padovan } 26310a708f8fSGustavo F. Padovan 26320a708f8fSGustavo F. Padovan static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val) 26330a708f8fSGustavo F. Padovan { 26340a708f8fSGustavo F. Padovan struct l2cap_conf_opt *opt = *ptr; 26350a708f8fSGustavo F. Padovan 26360a708f8fSGustavo F. Padovan BT_DBG("type 0x%2.2x len %d val 0x%lx", type, len, val); 26370a708f8fSGustavo F. Padovan 26380a708f8fSGustavo F. Padovan opt->type = type; 26390a708f8fSGustavo F. Padovan opt->len = len; 26400a708f8fSGustavo F. Padovan 26410a708f8fSGustavo F. Padovan switch (len) { 26420a708f8fSGustavo F. Padovan case 1: 26430a708f8fSGustavo F. Padovan *((u8 *) opt->val) = val; 26440a708f8fSGustavo F. Padovan break; 26450a708f8fSGustavo F. Padovan 26460a708f8fSGustavo F. Padovan case 2: 26470a708f8fSGustavo F. Padovan put_unaligned_le16(val, opt->val); 26480a708f8fSGustavo F. Padovan break; 26490a708f8fSGustavo F. Padovan 26500a708f8fSGustavo F. Padovan case 4: 26510a708f8fSGustavo F. Padovan put_unaligned_le32(val, opt->val); 26520a708f8fSGustavo F. Padovan break; 26530a708f8fSGustavo F. Padovan 26540a708f8fSGustavo F. Padovan default: 26550a708f8fSGustavo F. Padovan memcpy(opt->val, (void *) val, len); 26560a708f8fSGustavo F. Padovan break; 26570a708f8fSGustavo F. Padovan } 26580a708f8fSGustavo F. Padovan 26590a708f8fSGustavo F. Padovan *ptr += L2CAP_CONF_OPT_SIZE + len; 26600a708f8fSGustavo F. Padovan } 26610a708f8fSGustavo F. Padovan 2662f89cef09SAndrei Emeltchenko static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan) 2663f89cef09SAndrei Emeltchenko { 2664f89cef09SAndrei Emeltchenko struct l2cap_conf_efs efs; 2665f89cef09SAndrei Emeltchenko 2666f89cef09SAndrei Emeltchenko switch (chan->mode) { 2667f89cef09SAndrei Emeltchenko case L2CAP_MODE_ERTM: 2668f89cef09SAndrei Emeltchenko efs.id = chan->local_id; 2669f89cef09SAndrei Emeltchenko efs.stype = chan->local_stype; 2670f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2671f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2672ac73498cSAndrei Emeltchenko efs.acc_lat = __constant_cpu_to_le32(L2CAP_DEFAULT_ACC_LAT); 2673ac73498cSAndrei Emeltchenko efs.flush_to = __constant_cpu_to_le32(L2CAP_DEFAULT_FLUSH_TO); 2674f89cef09SAndrei Emeltchenko break; 2675f89cef09SAndrei Emeltchenko 2676f89cef09SAndrei Emeltchenko case L2CAP_MODE_STREAMING: 2677f89cef09SAndrei Emeltchenko efs.id = 1; 2678f89cef09SAndrei Emeltchenko efs.stype = L2CAP_SERV_BESTEFFORT; 2679f89cef09SAndrei Emeltchenko efs.msdu = cpu_to_le16(chan->local_msdu); 2680f89cef09SAndrei Emeltchenko efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime); 2681f89cef09SAndrei Emeltchenko efs.acc_lat = 0; 2682f89cef09SAndrei Emeltchenko efs.flush_to = 0; 2683f89cef09SAndrei Emeltchenko break; 2684f89cef09SAndrei Emeltchenko 2685f89cef09SAndrei Emeltchenko default: 2686f89cef09SAndrei Emeltchenko return; 2687f89cef09SAndrei Emeltchenko } 2688f89cef09SAndrei Emeltchenko 2689f89cef09SAndrei Emeltchenko l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs), 2690f89cef09SAndrei Emeltchenko (unsigned long) &efs); 2691f89cef09SAndrei Emeltchenko } 2692f89cef09SAndrei Emeltchenko 2693721c4181SGustavo F. Padovan static void l2cap_ack_timeout(struct work_struct *work) 26940a708f8fSGustavo F. Padovan { 2695721c4181SGustavo F. Padovan struct l2cap_chan *chan = container_of(work, struct l2cap_chan, 2696721c4181SGustavo F. Padovan ack_timer.work); 26970362520bSMat Martineau u16 frames_to_ack; 26980a708f8fSGustavo F. Padovan 26992fb9b3d4SGustavo F. Padovan BT_DBG("chan %p", chan); 27002fb9b3d4SGustavo F. Padovan 27016be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 27026be36555SAndrei Emeltchenko 27030362520bSMat Martineau frames_to_ack = __seq_offset(chan, chan->buffer_seq, 27040362520bSMat Martineau chan->last_acked_seq); 27050362520bSMat Martineau 27060362520bSMat Martineau if (frames_to_ack) 27070362520bSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 27086be36555SAndrei Emeltchenko 27096be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 271009bfb2eeSSzymon Janc l2cap_chan_put(chan); 27110a708f8fSGustavo F. Padovan } 27120a708f8fSGustavo F. Padovan 2713466f8004SAndrei Emeltchenko int l2cap_ertm_init(struct l2cap_chan *chan) 27140a708f8fSGustavo F. Padovan { 27153c588192SMat Martineau int err; 27163c588192SMat Martineau 2717105bdf9eSMat Martineau chan->next_tx_seq = 0; 2718105bdf9eSMat Martineau chan->expected_tx_seq = 0; 271942e5c802SGustavo F. Padovan chan->expected_ack_seq = 0; 27206a026610SGustavo F. Padovan chan->unacked_frames = 0; 272142e5c802SGustavo F. Padovan chan->buffer_seq = 0; 27226a026610SGustavo F. Padovan chan->frames_sent = 0; 2723105bdf9eSMat Martineau chan->last_acked_seq = 0; 2724105bdf9eSMat Martineau chan->sdu = NULL; 2725105bdf9eSMat Martineau chan->sdu_last_frag = NULL; 2726105bdf9eSMat Martineau chan->sdu_len = 0; 2727105bdf9eSMat Martineau 2728d34c34fbSMat Martineau skb_queue_head_init(&chan->tx_q); 2729d34c34fbSMat Martineau 2730105bdf9eSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 2731105bdf9eSMat Martineau return 0; 2732105bdf9eSMat Martineau 2733105bdf9eSMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 2734105bdf9eSMat Martineau chan->tx_state = L2CAP_TX_STATE_XMIT; 27350a708f8fSGustavo F. Padovan 2736721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout); 2737721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout); 2738721c4181SGustavo F. Padovan INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout); 27390a708f8fSGustavo F. Padovan 2740f1c6775bSGustavo F. Padovan skb_queue_head_init(&chan->srej_q); 27410a708f8fSGustavo F. Padovan 27423c588192SMat Martineau err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win); 27433c588192SMat Martineau if (err < 0) 27443c588192SMat Martineau return err; 27453c588192SMat Martineau 27469dc9affcSMat Martineau err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win); 27479dc9affcSMat Martineau if (err < 0) 27489dc9affcSMat Martineau l2cap_seq_list_free(&chan->srej_list); 27499dc9affcSMat Martineau 27509dc9affcSMat Martineau return err; 27510a708f8fSGustavo F. Padovan } 27520a708f8fSGustavo F. Padovan 27530a708f8fSGustavo F. Padovan static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask) 27540a708f8fSGustavo F. Padovan { 27550a708f8fSGustavo F. Padovan switch (mode) { 27560a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 27570a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 27580a708f8fSGustavo F. Padovan if (l2cap_mode_supported(mode, remote_feat_mask)) 27590a708f8fSGustavo F. Padovan return mode; 27600a708f8fSGustavo F. Padovan /* fall through */ 27610a708f8fSGustavo F. Padovan default: 27620a708f8fSGustavo F. Padovan return L2CAP_MODE_BASIC; 27630a708f8fSGustavo F. Padovan } 27640a708f8fSGustavo F. Padovan } 27650a708f8fSGustavo F. Padovan 27666327eb98SAndrei Emeltchenko static inline bool __l2cap_ews_supported(struct l2cap_chan *chan) 27676327eb98SAndrei Emeltchenko { 27686327eb98SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_WINDOW; 27696327eb98SAndrei Emeltchenko } 27706327eb98SAndrei Emeltchenko 2771f89cef09SAndrei Emeltchenko static inline bool __l2cap_efs_supported(struct l2cap_chan *chan) 2772f89cef09SAndrei Emeltchenko { 2773f89cef09SAndrei Emeltchenko return enable_hs && chan->conn->feat_mask & L2CAP_FEAT_EXT_FLOW; 2774f89cef09SAndrei Emeltchenko } 2775f89cef09SAndrei Emeltchenko 27766327eb98SAndrei Emeltchenko static inline void l2cap_txwin_setup(struct l2cap_chan *chan) 27776327eb98SAndrei Emeltchenko { 27786327eb98SAndrei Emeltchenko if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW && 2779836be934SAndrei Emeltchenko __l2cap_ews_supported(chan)) { 27806327eb98SAndrei Emeltchenko /* use extended control field */ 27816327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 2782836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 2783836be934SAndrei Emeltchenko } else { 27846327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, chan->tx_win, 27856327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 2786836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW; 2787836be934SAndrei Emeltchenko } 27886327eb98SAndrei Emeltchenko } 27896327eb98SAndrei Emeltchenko 2790710f9b0aSGustavo F. Padovan static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data) 27910a708f8fSGustavo F. Padovan { 27920a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 27930c1bc5c6SGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = chan->mode }; 27940a708f8fSGustavo F. Padovan void *ptr = req->data; 2795c8f79162SAndrei Emeltchenko u16 size; 27960a708f8fSGustavo F. Padovan 279749208c9cSGustavo F. Padovan BT_DBG("chan %p", chan); 27980a708f8fSGustavo F. Padovan 279973ffa904SGustavo F. Padovan if (chan->num_conf_req || chan->num_conf_rsp) 28000a708f8fSGustavo F. Padovan goto done; 28010a708f8fSGustavo F. Padovan 28020c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28030a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 28040a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2805c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) 28060a708f8fSGustavo F. Padovan break; 28070a708f8fSGustavo F. Padovan 2808f89cef09SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 2809f89cef09SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 2810f89cef09SAndrei Emeltchenko 28110a708f8fSGustavo F. Padovan /* fall through */ 28120a708f8fSGustavo F. Padovan default: 28138c1d787bSGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask); 28140a708f8fSGustavo F. Padovan break; 28150a708f8fSGustavo F. Padovan } 28160a708f8fSGustavo F. Padovan 28170a708f8fSGustavo F. Padovan done: 28180c1bc5c6SGustavo F. Padovan if (chan->imtu != L2CAP_DEFAULT_MTU) 28190c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 28200a708f8fSGustavo F. Padovan 28210c1bc5c6SGustavo F. Padovan switch (chan->mode) { 28220a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 28238c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) && 28248c1d787bSGustavo F. Padovan !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING)) 28250a708f8fSGustavo F. Padovan break; 28260a708f8fSGustavo F. Padovan 28270a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_BASIC; 28280a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28290a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28300a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28310a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 28320a708f8fSGustavo F. Padovan rfc.max_pdu_size = 0; 28330a708f8fSGustavo F. Padovan 28340a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28350a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28360a708f8fSGustavo F. Padovan break; 28370a708f8fSGustavo F. Padovan 28380a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 28390a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_ERTM; 284047d1ec61SGustavo F. Padovan rfc.max_transmit = chan->max_tx; 28410a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28420a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2843c8f79162SAndrei Emeltchenko 2844c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2845c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2846c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2847c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2848c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28490a708f8fSGustavo F. Padovan 28506327eb98SAndrei Emeltchenko l2cap_txwin_setup(chan); 28516327eb98SAndrei Emeltchenko 28526327eb98SAndrei Emeltchenko rfc.txwin_size = min_t(u16, chan->tx_win, 28536327eb98SAndrei Emeltchenko L2CAP_DEFAULT_TX_WINDOW); 28540a708f8fSGustavo F. Padovan 28550a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28560a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28570a708f8fSGustavo F. Padovan 2858f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2859f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2860f89cef09SAndrei Emeltchenko 28618c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 28620a708f8fSGustavo F. Padovan break; 28630a708f8fSGustavo F. Padovan 286447d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2865c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 286647d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 286747d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 28680a708f8fSGustavo F. Padovan } 28696327eb98SAndrei Emeltchenko 28706327eb98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 28716327eb98SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 28726327eb98SAndrei Emeltchenko chan->tx_win); 28730a708f8fSGustavo F. Padovan break; 28740a708f8fSGustavo F. Padovan 28750a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 2876273759e2SMat Martineau l2cap_txwin_setup(chan); 28770a708f8fSGustavo F. Padovan rfc.mode = L2CAP_MODE_STREAMING; 28780a708f8fSGustavo F. Padovan rfc.txwin_size = 0; 28790a708f8fSGustavo F. Padovan rfc.max_transmit = 0; 28800a708f8fSGustavo F. Padovan rfc.retrans_timeout = 0; 28810a708f8fSGustavo F. Padovan rfc.monitor_timeout = 0; 2882c8f79162SAndrei Emeltchenko 2883c8f79162SAndrei Emeltchenko size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu - 2884c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 2885c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 2886c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 2887c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 28880a708f8fSGustavo F. Padovan 28890a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc), 28900a708f8fSGustavo F. Padovan (unsigned long) &rfc); 28910a708f8fSGustavo F. Padovan 2892f89cef09SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) 2893f89cef09SAndrei Emeltchenko l2cap_add_opt_efs(&ptr, chan); 2894f89cef09SAndrei Emeltchenko 28958c1d787bSGustavo F. Padovan if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS)) 28960a708f8fSGustavo F. Padovan break; 28970a708f8fSGustavo F. Padovan 289847d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_NONE || 2899c1360a1cSGustavo F. Padovan test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) { 290047d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 290147d1ec61SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs); 29020a708f8fSGustavo F. Padovan } 29030a708f8fSGustavo F. Padovan break; 29040a708f8fSGustavo F. Padovan } 29050a708f8fSGustavo F. Padovan 2906fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 290759e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 29080a708f8fSGustavo F. Padovan 29090a708f8fSGustavo F. Padovan return ptr - data; 29100a708f8fSGustavo F. Padovan } 29110a708f8fSGustavo F. Padovan 291273ffa904SGustavo F. Padovan static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data) 29130a708f8fSGustavo F. Padovan { 29140a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 29150a708f8fSGustavo F. Padovan void *ptr = rsp->data; 291673ffa904SGustavo F. Padovan void *req = chan->conf_req; 291773ffa904SGustavo F. Padovan int len = chan->conf_len; 29180a708f8fSGustavo F. Padovan int type, hint, olen; 29190a708f8fSGustavo F. Padovan unsigned long val; 29200a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 292142dceae2SAndrei Emeltchenko struct l2cap_conf_efs efs; 292242dceae2SAndrei Emeltchenko u8 remote_efs = 0; 29230a708f8fSGustavo F. Padovan u16 mtu = L2CAP_DEFAULT_MTU; 29240a708f8fSGustavo F. Padovan u16 result = L2CAP_CONF_SUCCESS; 2925c8f79162SAndrei Emeltchenko u16 size; 29260a708f8fSGustavo F. Padovan 292773ffa904SGustavo F. Padovan BT_DBG("chan %p", chan); 29280a708f8fSGustavo F. Padovan 29290a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 29300a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&req, &type, &olen, &val); 29310a708f8fSGustavo F. Padovan 29320a708f8fSGustavo F. Padovan hint = type & L2CAP_CONF_HINT; 29330a708f8fSGustavo F. Padovan type &= L2CAP_CONF_MASK; 29340a708f8fSGustavo F. Padovan 29350a708f8fSGustavo F. Padovan switch (type) { 29360a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 29370a708f8fSGustavo F. Padovan mtu = val; 29380a708f8fSGustavo F. Padovan break; 29390a708f8fSGustavo F. Padovan 29400a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 29410c1bc5c6SGustavo F. Padovan chan->flush_to = val; 29420a708f8fSGustavo F. Padovan break; 29430a708f8fSGustavo F. Padovan 29440a708f8fSGustavo F. Padovan case L2CAP_CONF_QOS: 29450a708f8fSGustavo F. Padovan break; 29460a708f8fSGustavo F. Padovan 29470a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 29480a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 29490a708f8fSGustavo F. Padovan memcpy(&rfc, (void *) val, olen); 29500a708f8fSGustavo F. Padovan break; 29510a708f8fSGustavo F. Padovan 29520a708f8fSGustavo F. Padovan case L2CAP_CONF_FCS: 29530a708f8fSGustavo F. Padovan if (val == L2CAP_FCS_NONE) 2954c1360a1cSGustavo F. Padovan set_bit(CONF_NO_FCS_RECV, &chan->conf_state); 295542dceae2SAndrei Emeltchenko break; 29560a708f8fSGustavo F. Padovan 295742dceae2SAndrei Emeltchenko case L2CAP_CONF_EFS: 295842dceae2SAndrei Emeltchenko remote_efs = 1; 295942dceae2SAndrei Emeltchenko if (olen == sizeof(efs)) 296042dceae2SAndrei Emeltchenko memcpy(&efs, (void *) val, olen); 29610a708f8fSGustavo F. Padovan break; 29620a708f8fSGustavo F. Padovan 29636327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 29646327eb98SAndrei Emeltchenko if (!enable_hs) 29656327eb98SAndrei Emeltchenko return -ECONNREFUSED; 29666327eb98SAndrei Emeltchenko 29676327eb98SAndrei Emeltchenko set_bit(FLAG_EXT_CTRL, &chan->flags); 29686327eb98SAndrei Emeltchenko set_bit(CONF_EWS_RECV, &chan->conf_state); 2969836be934SAndrei Emeltchenko chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW; 29706327eb98SAndrei Emeltchenko chan->remote_tx_win = val; 29710a708f8fSGustavo F. Padovan break; 29720a708f8fSGustavo F. Padovan 29730a708f8fSGustavo F. Padovan default: 29740a708f8fSGustavo F. Padovan if (hint) 29750a708f8fSGustavo F. Padovan break; 29760a708f8fSGustavo F. Padovan 29770a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNKNOWN; 29780a708f8fSGustavo F. Padovan *((u8 *) ptr++) = type; 29790a708f8fSGustavo F. Padovan break; 29800a708f8fSGustavo F. Padovan } 29810a708f8fSGustavo F. Padovan } 29820a708f8fSGustavo F. Padovan 298373ffa904SGustavo F. Padovan if (chan->num_conf_rsp || chan->num_conf_req > 1) 29840a708f8fSGustavo F. Padovan goto done; 29850a708f8fSGustavo F. Padovan 29860c1bc5c6SGustavo F. Padovan switch (chan->mode) { 29870a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 29880a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 2989c1360a1cSGustavo F. Padovan if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) { 29900c1bc5c6SGustavo F. Padovan chan->mode = l2cap_select_mode(rfc.mode, 29918c1d787bSGustavo F. Padovan chan->conn->feat_mask); 29920a708f8fSGustavo F. Padovan break; 29930a708f8fSGustavo F. Padovan } 29940a708f8fSGustavo F. Padovan 299542dceae2SAndrei Emeltchenko if (remote_efs) { 299642dceae2SAndrei Emeltchenko if (__l2cap_efs_supported(chan)) 299742dceae2SAndrei Emeltchenko set_bit(FLAG_EFS_ENABLE, &chan->flags); 299842dceae2SAndrei Emeltchenko else 299942dceae2SAndrei Emeltchenko return -ECONNREFUSED; 300042dceae2SAndrei Emeltchenko } 300142dceae2SAndrei Emeltchenko 30020c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) 30030a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30040a708f8fSGustavo F. Padovan 30050a708f8fSGustavo F. Padovan break; 30060a708f8fSGustavo F. Padovan } 30070a708f8fSGustavo F. Padovan 30080a708f8fSGustavo F. Padovan done: 30090c1bc5c6SGustavo F. Padovan if (chan->mode != rfc.mode) { 30100a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30110c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 30120a708f8fSGustavo F. Padovan 301373ffa904SGustavo F. Padovan if (chan->num_conf_rsp == 1) 30140a708f8fSGustavo F. Padovan return -ECONNREFUSED; 30150a708f8fSGustavo F. Padovan 30160a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30170a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30180a708f8fSGustavo F. Padovan } 30190a708f8fSGustavo F. Padovan 30200a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) { 30210a708f8fSGustavo F. Padovan /* Configure output options and let the other side know 30220a708f8fSGustavo F. Padovan * which ones we don't like. */ 30230a708f8fSGustavo F. Padovan 30240a708f8fSGustavo F. Padovan if (mtu < L2CAP_DEFAULT_MIN_MTU) 30250a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 30260a708f8fSGustavo F. Padovan else { 30270c1bc5c6SGustavo F. Padovan chan->omtu = mtu; 3028c1360a1cSGustavo F. Padovan set_bit(CONF_MTU_DONE, &chan->conf_state); 30290a708f8fSGustavo F. Padovan } 30300c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu); 30310a708f8fSGustavo F. Padovan 303242dceae2SAndrei Emeltchenko if (remote_efs) { 303342dceae2SAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 303442dceae2SAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 303542dceae2SAndrei Emeltchenko efs.stype != chan->local_stype) { 303642dceae2SAndrei Emeltchenko 303742dceae2SAndrei Emeltchenko result = L2CAP_CONF_UNACCEPT; 303842dceae2SAndrei Emeltchenko 303942dceae2SAndrei Emeltchenko if (chan->num_conf_req >= 1) 304042dceae2SAndrei Emeltchenko return -ECONNREFUSED; 304142dceae2SAndrei Emeltchenko 304242dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 304342dceae2SAndrei Emeltchenko sizeof(efs), 304442dceae2SAndrei Emeltchenko (unsigned long) &efs); 30450e8b207eSAndrei Emeltchenko } else { 30463e6b3b95SGustavo F. Padovan /* Send PENDING Conf Rsp */ 30470e8b207eSAndrei Emeltchenko result = L2CAP_CONF_PENDING; 30480e8b207eSAndrei Emeltchenko set_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 304942dceae2SAndrei Emeltchenko } 305042dceae2SAndrei Emeltchenko } 305142dceae2SAndrei Emeltchenko 30520a708f8fSGustavo F. Padovan switch (rfc.mode) { 30530a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 305447d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3055c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30560a708f8fSGustavo F. Padovan break; 30570a708f8fSGustavo F. Padovan 30580a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 30596327eb98SAndrei Emeltchenko if (!test_bit(CONF_EWS_RECV, &chan->conf_state)) 30602c03a7a4SGustavo F. Padovan chan->remote_tx_win = rfc.txwin_size; 30616327eb98SAndrei Emeltchenko else 30626327eb98SAndrei Emeltchenko rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW; 30636327eb98SAndrei Emeltchenko 30642c03a7a4SGustavo F. Padovan chan->remote_max_tx = rfc.max_transmit; 30650a708f8fSGustavo F. Padovan 3066c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3067c8f79162SAndrei Emeltchenko chan->conn->mtu - 3068c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3069c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3070c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3071c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3072c8f79162SAndrei Emeltchenko chan->remote_mps = size; 30730a708f8fSGustavo F. Padovan 30740a708f8fSGustavo F. Padovan rfc.retrans_timeout = 30754fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 30760a708f8fSGustavo F. Padovan rfc.monitor_timeout = 30774fd21a88SAndrei Emeltchenko __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 30780a708f8fSGustavo F. Padovan 3079c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 30800a708f8fSGustavo F. Padovan 30810a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 30820a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 30830a708f8fSGustavo F. Padovan 308442dceae2SAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 308542dceae2SAndrei Emeltchenko chan->remote_id = efs.id; 308642dceae2SAndrei Emeltchenko chan->remote_stype = efs.stype; 308742dceae2SAndrei Emeltchenko chan->remote_msdu = le16_to_cpu(efs.msdu); 308842dceae2SAndrei Emeltchenko chan->remote_flush_to = 308942dceae2SAndrei Emeltchenko le32_to_cpu(efs.flush_to); 309042dceae2SAndrei Emeltchenko chan->remote_acc_lat = 309142dceae2SAndrei Emeltchenko le32_to_cpu(efs.acc_lat); 309242dceae2SAndrei Emeltchenko chan->remote_sdu_itime = 309342dceae2SAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 309442dceae2SAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 309542dceae2SAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 309642dceae2SAndrei Emeltchenko } 30970a708f8fSGustavo F. Padovan break; 30980a708f8fSGustavo F. Padovan 30990a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 3100c8f79162SAndrei Emeltchenko size = min_t(u16, le16_to_cpu(rfc.max_pdu_size), 3101c8f79162SAndrei Emeltchenko chan->conn->mtu - 3102c8f79162SAndrei Emeltchenko L2CAP_EXT_HDR_SIZE - 3103c8f79162SAndrei Emeltchenko L2CAP_SDULEN_SIZE - 3104c8f79162SAndrei Emeltchenko L2CAP_FCS_SIZE); 3105c8f79162SAndrei Emeltchenko rfc.max_pdu_size = cpu_to_le16(size); 3106c8f79162SAndrei Emeltchenko chan->remote_mps = size; 31070a708f8fSGustavo F. Padovan 3108c1360a1cSGustavo F. Padovan set_bit(CONF_MODE_DONE, &chan->conf_state); 31090a708f8fSGustavo F. Padovan 31100a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31110a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31120a708f8fSGustavo F. Padovan 31130a708f8fSGustavo F. Padovan break; 31140a708f8fSGustavo F. Padovan 31150a708f8fSGustavo F. Padovan default: 31160a708f8fSGustavo F. Padovan result = L2CAP_CONF_UNACCEPT; 31170a708f8fSGustavo F. Padovan 31180a708f8fSGustavo F. Padovan memset(&rfc, 0, sizeof(rfc)); 31190c1bc5c6SGustavo F. Padovan rfc.mode = chan->mode; 31200a708f8fSGustavo F. Padovan } 31210a708f8fSGustavo F. Padovan 31220a708f8fSGustavo F. Padovan if (result == L2CAP_CONF_SUCCESS) 3123c1360a1cSGustavo F. Padovan set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 31240a708f8fSGustavo F. Padovan } 3125fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 31260a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 312759e54bd1SAndrei Emeltchenko rsp->flags = __constant_cpu_to_le16(0); 31280a708f8fSGustavo F. Padovan 31290a708f8fSGustavo F. Padovan return ptr - data; 31300a708f8fSGustavo F. Padovan } 31310a708f8fSGustavo F. Padovan 3132b4450035SGustavo F. Padovan static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, void *data, u16 *result) 31330a708f8fSGustavo F. Padovan { 31340a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = data; 31350a708f8fSGustavo F. Padovan void *ptr = req->data; 31360a708f8fSGustavo F. Padovan int type, olen; 31370a708f8fSGustavo F. Padovan unsigned long val; 313836e999a8SMat Martineau struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC }; 313966af7aafSAndrei Emeltchenko struct l2cap_conf_efs efs; 31400a708f8fSGustavo F. Padovan 3141fe4128e0SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data); 31420a708f8fSGustavo F. Padovan 31430a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 31440a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 31450a708f8fSGustavo F. Padovan 31460a708f8fSGustavo F. Padovan switch (type) { 31470a708f8fSGustavo F. Padovan case L2CAP_CONF_MTU: 31480a708f8fSGustavo F. Padovan if (val < L2CAP_DEFAULT_MIN_MTU) { 31490a708f8fSGustavo F. Padovan *result = L2CAP_CONF_UNACCEPT; 31500c1bc5c6SGustavo F. Padovan chan->imtu = L2CAP_DEFAULT_MIN_MTU; 31510a708f8fSGustavo F. Padovan } else 31520c1bc5c6SGustavo F. Padovan chan->imtu = val; 31530c1bc5c6SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu); 31540a708f8fSGustavo F. Padovan break; 31550a708f8fSGustavo F. Padovan 31560a708f8fSGustavo F. Padovan case L2CAP_CONF_FLUSH_TO: 31570c1bc5c6SGustavo F. Padovan chan->flush_to = val; 31580a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 31590c1bc5c6SGustavo F. Padovan 2, chan->flush_to); 31600a708f8fSGustavo F. Padovan break; 31610a708f8fSGustavo F. Padovan 31620a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 31630a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 31640a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 31650a708f8fSGustavo F. Padovan 3166c1360a1cSGustavo F. Padovan if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) && 31670c1bc5c6SGustavo F. Padovan rfc.mode != chan->mode) 31680a708f8fSGustavo F. Padovan return -ECONNREFUSED; 31690a708f8fSGustavo F. Padovan 317047d1ec61SGustavo F. Padovan chan->fcs = 0; 31710a708f8fSGustavo F. Padovan 31720a708f8fSGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, 31730a708f8fSGustavo F. Padovan sizeof(rfc), (unsigned long) &rfc); 31740a708f8fSGustavo F. Padovan break; 31756327eb98SAndrei Emeltchenko 31766327eb98SAndrei Emeltchenko case L2CAP_CONF_EWS: 31776327eb98SAndrei Emeltchenko chan->tx_win = min_t(u16, val, 31786327eb98SAndrei Emeltchenko L2CAP_DEFAULT_EXT_WINDOW); 31793e6b3b95SGustavo F. Padovan l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2, 31803e6b3b95SGustavo F. Padovan chan->tx_win); 31816327eb98SAndrei Emeltchenko break; 318266af7aafSAndrei Emeltchenko 318366af7aafSAndrei Emeltchenko case L2CAP_CONF_EFS: 318466af7aafSAndrei Emeltchenko if (olen == sizeof(efs)) 318566af7aafSAndrei Emeltchenko memcpy(&efs, (void *)val, olen); 318666af7aafSAndrei Emeltchenko 318766af7aafSAndrei Emeltchenko if (chan->local_stype != L2CAP_SERV_NOTRAFIC && 318866af7aafSAndrei Emeltchenko efs.stype != L2CAP_SERV_NOTRAFIC && 318966af7aafSAndrei Emeltchenko efs.stype != chan->local_stype) 319066af7aafSAndrei Emeltchenko return -ECONNREFUSED; 319166af7aafSAndrei Emeltchenko 319266af7aafSAndrei Emeltchenko l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, 319366af7aafSAndrei Emeltchenko sizeof(efs), (unsigned long) &efs); 319466af7aafSAndrei Emeltchenko break; 31950a708f8fSGustavo F. Padovan } 31960a708f8fSGustavo F. Padovan } 31970a708f8fSGustavo F. Padovan 31980c1bc5c6SGustavo F. Padovan if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode) 31990a708f8fSGustavo F. Padovan return -ECONNREFUSED; 32000a708f8fSGustavo F. Padovan 32010c1bc5c6SGustavo F. Padovan chan->mode = rfc.mode; 32020a708f8fSGustavo F. Padovan 32030e8b207eSAndrei Emeltchenko if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) { 32040a708f8fSGustavo F. Padovan switch (rfc.mode) { 32050a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 320647d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 320747d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 320847d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 320966af7aafSAndrei Emeltchenko 321066af7aafSAndrei Emeltchenko if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) { 321166af7aafSAndrei Emeltchenko chan->local_msdu = le16_to_cpu(efs.msdu); 321266af7aafSAndrei Emeltchenko chan->local_sdu_itime = 321366af7aafSAndrei Emeltchenko le32_to_cpu(efs.sdu_itime); 321466af7aafSAndrei Emeltchenko chan->local_acc_lat = le32_to_cpu(efs.acc_lat); 321566af7aafSAndrei Emeltchenko chan->local_flush_to = 321666af7aafSAndrei Emeltchenko le32_to_cpu(efs.flush_to); 321766af7aafSAndrei Emeltchenko } 32180a708f8fSGustavo F. Padovan break; 321966af7aafSAndrei Emeltchenko 32200a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 322147d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 32220a708f8fSGustavo F. Padovan } 32230a708f8fSGustavo F. Padovan } 32240a708f8fSGustavo F. Padovan 3225fe4128e0SGustavo F. Padovan req->dcid = cpu_to_le16(chan->dcid); 322659e54bd1SAndrei Emeltchenko req->flags = __constant_cpu_to_le16(0); 32270a708f8fSGustavo F. Padovan 32280a708f8fSGustavo F. Padovan return ptr - data; 32290a708f8fSGustavo F. Padovan } 32300a708f8fSGustavo F. Padovan 3231fe4128e0SGustavo F. Padovan static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, u16 result, u16 flags) 32320a708f8fSGustavo F. Padovan { 32330a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = data; 32340a708f8fSGustavo F. Padovan void *ptr = rsp->data; 32350a708f8fSGustavo F. Padovan 3236fe4128e0SGustavo F. Padovan BT_DBG("chan %p", chan); 32370a708f8fSGustavo F. Padovan 3238fe4128e0SGustavo F. Padovan rsp->scid = cpu_to_le16(chan->dcid); 32390a708f8fSGustavo F. Padovan rsp->result = cpu_to_le16(result); 32400a708f8fSGustavo F. Padovan rsp->flags = cpu_to_le16(flags); 32410a708f8fSGustavo F. Padovan 32420a708f8fSGustavo F. Padovan return ptr - data; 32430a708f8fSGustavo F. Padovan } 32440a708f8fSGustavo F. Padovan 32458c1d787bSGustavo F. Padovan void __l2cap_connect_rsp_defer(struct l2cap_chan *chan) 3246710f9b0aSGustavo F. Padovan { 3247710f9b0aSGustavo F. Padovan struct l2cap_conn_rsp rsp; 32488c1d787bSGustavo F. Padovan struct l2cap_conn *conn = chan->conn; 3249710f9b0aSGustavo F. Padovan u8 buf[128]; 3250710f9b0aSGustavo F. Padovan 3251fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 3252fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3253ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_SUCCESS); 3254ac73498cSAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3255710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, 3256710f9b0aSGustavo F. Padovan L2CAP_CONN_RSP, sizeof(rsp), &rsp); 3257710f9b0aSGustavo F. Padovan 3258c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 3259710f9b0aSGustavo F. Padovan return; 3260710f9b0aSGustavo F. Padovan 3261710f9b0aSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 3262710f9b0aSGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 3263710f9b0aSGustavo F. Padovan chan->num_conf_req++; 3264710f9b0aSGustavo F. Padovan } 3265710f9b0aSGustavo F. Padovan 326647d1ec61SGustavo F. Padovan static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len) 32670a708f8fSGustavo F. Padovan { 32680a708f8fSGustavo F. Padovan int type, olen; 32690a708f8fSGustavo F. Padovan unsigned long val; 32700a708f8fSGustavo F. Padovan struct l2cap_conf_rfc rfc; 32710a708f8fSGustavo F. Padovan 327247d1ec61SGustavo F. Padovan BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len); 32730a708f8fSGustavo F. Padovan 32740c1bc5c6SGustavo F. Padovan if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING)) 32750a708f8fSGustavo F. Padovan return; 32760a708f8fSGustavo F. Padovan 32770a708f8fSGustavo F. Padovan while (len >= L2CAP_CONF_OPT_SIZE) { 32780a708f8fSGustavo F. Padovan len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val); 32790a708f8fSGustavo F. Padovan 32800a708f8fSGustavo F. Padovan switch (type) { 32810a708f8fSGustavo F. Padovan case L2CAP_CONF_RFC: 32820a708f8fSGustavo F. Padovan if (olen == sizeof(rfc)) 32830a708f8fSGustavo F. Padovan memcpy(&rfc, (void *)val, olen); 32840a708f8fSGustavo F. Padovan goto done; 32850a708f8fSGustavo F. Padovan } 32860a708f8fSGustavo F. Padovan } 32870a708f8fSGustavo F. Padovan 328836e999a8SMat Martineau /* Use sane default values in case a misbehaving remote device 328936e999a8SMat Martineau * did not send an RFC option. 329036e999a8SMat Martineau */ 329136e999a8SMat Martineau rfc.mode = chan->mode; 3292ac73498cSAndrei Emeltchenko rfc.retrans_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO); 3293ac73498cSAndrei Emeltchenko rfc.monitor_timeout = __constant_cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO); 329436e999a8SMat Martineau rfc.max_pdu_size = cpu_to_le16(chan->imtu); 329536e999a8SMat Martineau 329636e999a8SMat Martineau BT_ERR("Expected RFC option was not found, using defaults"); 329736e999a8SMat Martineau 32980a708f8fSGustavo F. Padovan done: 32990a708f8fSGustavo F. Padovan switch (rfc.mode) { 33000a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 330147d1ec61SGustavo F. Padovan chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout); 330247d1ec61SGustavo F. Padovan chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout); 330347d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 33040a708f8fSGustavo F. Padovan break; 33050a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 330647d1ec61SGustavo F. Padovan chan->mps = le16_to_cpu(rfc.max_pdu_size); 33070a708f8fSGustavo F. Padovan } 33080a708f8fSGustavo F. Padovan } 33090a708f8fSGustavo F. Padovan 33100a708f8fSGustavo F. Padovan static inline int l2cap_command_rej(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 33110a708f8fSGustavo F. Padovan { 3312e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data; 33130a708f8fSGustavo F. Padovan 3314e2fd318eSIlia Kolomisnky if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD) 33150a708f8fSGustavo F. Padovan return 0; 33160a708f8fSGustavo F. Padovan 33170a708f8fSGustavo F. Padovan if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) && 33180a708f8fSGustavo F. Padovan cmd->ident == conn->info_ident) { 331917cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 33200a708f8fSGustavo F. Padovan 33210a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 33220a708f8fSGustavo F. Padovan conn->info_ident = 0; 33230a708f8fSGustavo F. Padovan 33240a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 33250a708f8fSGustavo F. Padovan } 33260a708f8fSGustavo F. Padovan 33270a708f8fSGustavo F. Padovan return 0; 33280a708f8fSGustavo F. Padovan } 33290a708f8fSGustavo F. Padovan 33300a708f8fSGustavo F. Padovan static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 33310a708f8fSGustavo F. Padovan { 33320a708f8fSGustavo F. Padovan struct l2cap_conn_req *req = (struct l2cap_conn_req *) data; 33330a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 333423691d75SGustavo F. Padovan struct l2cap_chan *chan = NULL, *pchan; 33350a708f8fSGustavo F. Padovan struct sock *parent, *sk = NULL; 33360a708f8fSGustavo F. Padovan int result, status = L2CAP_CS_NO_INFO; 33370a708f8fSGustavo F. Padovan 33380a708f8fSGustavo F. Padovan u16 dcid = 0, scid = __le16_to_cpu(req->scid); 33390a708f8fSGustavo F. Padovan __le16 psm = req->psm; 33400a708f8fSGustavo F. Padovan 3341097db76cSAndrei Emeltchenko BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid); 33420a708f8fSGustavo F. Padovan 33430a708f8fSGustavo F. Padovan /* Check if we have socket listening on psm */ 3344c2287681SIdo Yariv pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src, conn->dst); 334523691d75SGustavo F. Padovan if (!pchan) { 33460a708f8fSGustavo F. Padovan result = L2CAP_CR_BAD_PSM; 33470a708f8fSGustavo F. Padovan goto sendresp; 33480a708f8fSGustavo F. Padovan } 33490a708f8fSGustavo F. Padovan 335023691d75SGustavo F. Padovan parent = pchan->sk; 335123691d75SGustavo F. Padovan 33523df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 3353aa2ac881SGustavo F. Padovan lock_sock(parent); 33540a708f8fSGustavo F. Padovan 33550a708f8fSGustavo F. Padovan /* Check if the ACL is secure enough (if not SDP) */ 33562983fd68SAndrei Emeltchenko if (psm != __constant_cpu_to_le16(L2CAP_PSM_SDP) && 33570a708f8fSGustavo F. Padovan !hci_conn_check_link_mode(conn->hcon)) { 33589f5a0d7bSAndrei Emeltchenko conn->disc_reason = HCI_ERROR_AUTH_FAILURE; 33590a708f8fSGustavo F. Padovan result = L2CAP_CR_SEC_BLOCK; 33600a708f8fSGustavo F. Padovan goto response; 33610a708f8fSGustavo F. Padovan } 33620a708f8fSGustavo F. Padovan 33630a708f8fSGustavo F. Padovan result = L2CAP_CR_NO_MEM; 33640a708f8fSGustavo F. Padovan 33652dfa1003SGustavo Padovan /* Check if we already have channel with that dcid */ 33662dfa1003SGustavo Padovan if (__l2cap_get_chan_by_dcid(conn, scid)) 33672dfa1003SGustavo Padovan goto response; 33682dfa1003SGustavo Padovan 336980b98027SGustavo Padovan chan = pchan->ops->new_connection(pchan); 337080808e43SGustavo F. Padovan if (!chan) 33710a708f8fSGustavo F. Padovan goto response; 33720a708f8fSGustavo F. Padovan 337380808e43SGustavo F. Padovan sk = chan->sk; 337480808e43SGustavo F. Padovan 33750a708f8fSGustavo F. Padovan hci_conn_hold(conn->hcon); 33760a708f8fSGustavo F. Padovan 33770a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->src, conn->src); 33780a708f8fSGustavo F. Padovan bacpy(&bt_sk(sk)->dst, conn->dst); 3379fe4128e0SGustavo F. Padovan chan->psm = psm; 3380fe4128e0SGustavo F. Padovan chan->dcid = scid; 33810a708f8fSGustavo F. Padovan 3382d1010240SGustavo F. Padovan bt_accept_enqueue(parent, sk); 3383d1010240SGustavo F. Padovan 33846be36555SAndrei Emeltchenko __l2cap_chan_add(conn, chan); 338548454079SGustavo F. Padovan 3386fe4128e0SGustavo F. Padovan dcid = chan->scid; 33870a708f8fSGustavo F. Padovan 3388c9b66675SGustavo F. Padovan __set_chan_timer(chan, sk->sk_sndtimeo); 33890a708f8fSGustavo F. Padovan 3390fc7f8a7eSGustavo F. Padovan chan->ident = cmd->ident; 33910a708f8fSGustavo F. Padovan 33920a708f8fSGustavo F. Padovan if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) { 3393d45fc423SGustavo F. Padovan if (l2cap_chan_check_security(chan)) { 3394c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) { 33950e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 33960a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 33970a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHOR_PEND; 33980a708f8fSGustavo F. Padovan parent->sk_data_ready(parent, 0); 33990a708f8fSGustavo F. Padovan } else { 34000e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 34010a708f8fSGustavo F. Padovan result = L2CAP_CR_SUCCESS; 34020a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 34030a708f8fSGustavo F. Padovan } 34040a708f8fSGustavo F. Padovan } else { 34050e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34060a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34070a708f8fSGustavo F. Padovan status = L2CAP_CS_AUTHEN_PEND; 34080a708f8fSGustavo F. Padovan } 34090a708f8fSGustavo F. Padovan } else { 34100e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONNECT2); 34110a708f8fSGustavo F. Padovan result = L2CAP_CR_PEND; 34120a708f8fSGustavo F. Padovan status = L2CAP_CS_NO_INFO; 34130a708f8fSGustavo F. Padovan } 34140a708f8fSGustavo F. Padovan 34150a708f8fSGustavo F. Padovan response: 3416aa2ac881SGustavo F. Padovan release_sock(parent); 34173df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 34180a708f8fSGustavo F. Padovan 34190a708f8fSGustavo F. Padovan sendresp: 34200a708f8fSGustavo F. Padovan rsp.scid = cpu_to_le16(scid); 34210a708f8fSGustavo F. Padovan rsp.dcid = cpu_to_le16(dcid); 34220a708f8fSGustavo F. Padovan rsp.result = cpu_to_le16(result); 34230a708f8fSGustavo F. Padovan rsp.status = cpu_to_le16(status); 34240a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp); 34250a708f8fSGustavo F. Padovan 34260a708f8fSGustavo F. Padovan if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) { 34270a708f8fSGustavo F. Padovan struct l2cap_info_req info; 3428ac73498cSAndrei Emeltchenko info.type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 34290a708f8fSGustavo F. Padovan 34300a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT; 34310a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 34320a708f8fSGustavo F. Padovan 3433ba13ccd9SMarcel Holtmann schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT); 34340a708f8fSGustavo F. Padovan 34350a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 34360a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(info), &info); 34370a708f8fSGustavo F. Padovan } 34380a708f8fSGustavo F. Padovan 3439c1360a1cSGustavo F. Padovan if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) && 34400a708f8fSGustavo F. Padovan result == L2CAP_CR_SUCCESS) { 34410a708f8fSGustavo F. Padovan u8 buf[128]; 3442c1360a1cSGustavo F. Padovan set_bit(CONF_REQ_SENT, &chan->conf_state); 34430a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 344473ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 344573ffa904SGustavo F. Padovan chan->num_conf_req++; 34460a708f8fSGustavo F. Padovan } 34470a708f8fSGustavo F. Padovan 34480a708f8fSGustavo F. Padovan return 0; 34490a708f8fSGustavo F. Padovan } 34500a708f8fSGustavo F. Padovan 34510a708f8fSGustavo F. Padovan static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 34520a708f8fSGustavo F. Padovan { 34530a708f8fSGustavo F. Padovan struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data; 34540a708f8fSGustavo F. Padovan u16 scid, dcid, result, status; 345548454079SGustavo F. Padovan struct l2cap_chan *chan; 34560a708f8fSGustavo F. Padovan u8 req[128]; 34573df91ea2SAndrei Emeltchenko int err; 34580a708f8fSGustavo F. Padovan 34590a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 34600a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 34610a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 34620a708f8fSGustavo F. Padovan status = __le16_to_cpu(rsp->status); 34630a708f8fSGustavo F. Padovan 34641b009c98SAndrei Emeltchenko BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", 34651b009c98SAndrei Emeltchenko dcid, scid, result, status); 34660a708f8fSGustavo F. Padovan 34673df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 34683df91ea2SAndrei Emeltchenko 34690a708f8fSGustavo F. Padovan if (scid) { 34703df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 34713df91ea2SAndrei Emeltchenko if (!chan) { 34723df91ea2SAndrei Emeltchenko err = -EFAULT; 34733df91ea2SAndrei Emeltchenko goto unlock; 34743df91ea2SAndrei Emeltchenko } 34750a708f8fSGustavo F. Padovan } else { 34763df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_ident(conn, cmd->ident); 34773df91ea2SAndrei Emeltchenko if (!chan) { 34783df91ea2SAndrei Emeltchenko err = -EFAULT; 34793df91ea2SAndrei Emeltchenko goto unlock; 34803df91ea2SAndrei Emeltchenko } 34810a708f8fSGustavo F. Padovan } 34820a708f8fSGustavo F. Padovan 34833df91ea2SAndrei Emeltchenko err = 0; 34843df91ea2SAndrei Emeltchenko 34856be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 348648454079SGustavo F. Padovan 34870a708f8fSGustavo F. Padovan switch (result) { 34880a708f8fSGustavo F. Padovan case L2CAP_CR_SUCCESS: 348989bc500eSGustavo F. Padovan l2cap_state_change(chan, BT_CONFIG); 3490fc7f8a7eSGustavo F. Padovan chan->ident = 0; 3491fe4128e0SGustavo F. Padovan chan->dcid = dcid; 3492c1360a1cSGustavo F. Padovan clear_bit(CONF_CONNECT_PEND, &chan->conf_state); 34930a708f8fSGustavo F. Padovan 3494c1360a1cSGustavo F. Padovan if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) 34950a708f8fSGustavo F. Padovan break; 34960a708f8fSGustavo F. Padovan 34970a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 349873ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, req), req); 349973ffa904SGustavo F. Padovan chan->num_conf_req++; 35000a708f8fSGustavo F. Padovan break; 35010a708f8fSGustavo F. Padovan 35020a708f8fSGustavo F. Padovan case L2CAP_CR_PEND: 3503c1360a1cSGustavo F. Padovan set_bit(CONF_CONNECT_PEND, &chan->conf_state); 35040a708f8fSGustavo F. Padovan break; 35050a708f8fSGustavo F. Padovan 35060a708f8fSGustavo F. Padovan default: 350748454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNREFUSED); 35080a708f8fSGustavo F. Padovan break; 35090a708f8fSGustavo F. Padovan } 35100a708f8fSGustavo F. Padovan 35116be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 35123df91ea2SAndrei Emeltchenko 35133df91ea2SAndrei Emeltchenko unlock: 35143df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 35153df91ea2SAndrei Emeltchenko 35163df91ea2SAndrei Emeltchenko return err; 35170a708f8fSGustavo F. Padovan } 35180a708f8fSGustavo F. Padovan 351947d1ec61SGustavo F. Padovan static inline void set_default_fcs(struct l2cap_chan *chan) 35200a708f8fSGustavo F. Padovan { 35210a708f8fSGustavo F. Padovan /* FCS is enabled only in ERTM or streaming mode, if one or both 35220a708f8fSGustavo F. Padovan * sides request it. 35230a708f8fSGustavo F. Padovan */ 35240c1bc5c6SGustavo F. Padovan if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING) 352547d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_NONE; 3526c1360a1cSGustavo F. Padovan else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) 352747d1ec61SGustavo F. Padovan chan->fcs = L2CAP_FCS_CRC16; 35280a708f8fSGustavo F. Padovan } 35290a708f8fSGustavo F. Padovan 35300a708f8fSGustavo F. Padovan static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 35310a708f8fSGustavo F. Padovan { 35320a708f8fSGustavo F. Padovan struct l2cap_conf_req *req = (struct l2cap_conf_req *) data; 35330a708f8fSGustavo F. Padovan u16 dcid, flags; 35340a708f8fSGustavo F. Padovan u8 rsp[64]; 353548454079SGustavo F. Padovan struct l2cap_chan *chan; 35363c588192SMat Martineau int len, err = 0; 35370a708f8fSGustavo F. Padovan 35380a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 35390a708f8fSGustavo F. Padovan flags = __le16_to_cpu(req->flags); 35400a708f8fSGustavo F. Padovan 35410a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags); 35420a708f8fSGustavo F. Padovan 3543baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, dcid); 354448454079SGustavo F. Padovan if (!chan) 35450a708f8fSGustavo F. Padovan return -ENOENT; 35460a708f8fSGustavo F. Padovan 3547033b1142SDavid S. Miller if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) { 3548e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_cid rej; 35490a708f8fSGustavo F. Padovan 3550ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_INVALID_CID); 3551e2fd318eSIlia Kolomisnky rej.scid = cpu_to_le16(chan->scid); 3552e2fd318eSIlia Kolomisnky rej.dcid = cpu_to_le16(chan->dcid); 3553e2fd318eSIlia Kolomisnky 35540a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ, 35550a708f8fSGustavo F. Padovan sizeof(rej), &rej); 35560a708f8fSGustavo F. Padovan goto unlock; 35570a708f8fSGustavo F. Padovan } 35580a708f8fSGustavo F. Padovan 35590a708f8fSGustavo F. Padovan /* Reject if config buffer is too small. */ 35600a708f8fSGustavo F. Padovan len = cmd_len - sizeof(*req); 35617ac28817SDan Rosenberg if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) { 35620a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3563fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35640a708f8fSGustavo F. Padovan L2CAP_CONF_REJECT, flags), rsp); 35650a708f8fSGustavo F. Padovan goto unlock; 35660a708f8fSGustavo F. Padovan } 35670a708f8fSGustavo F. Padovan 35680a708f8fSGustavo F. Padovan /* Store config. */ 356973ffa904SGustavo F. Padovan memcpy(chan->conf_req + chan->conf_len, req->data, len); 357073ffa904SGustavo F. Padovan chan->conf_len += len; 35710a708f8fSGustavo F. Padovan 357259e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) { 35730a708f8fSGustavo F. Padovan /* Incomplete config. Send empty response. */ 35740a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 3575fe4128e0SGustavo F. Padovan l2cap_build_conf_rsp(chan, rsp, 35765325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 35770a708f8fSGustavo F. Padovan goto unlock; 35780a708f8fSGustavo F. Padovan } 35790a708f8fSGustavo F. Padovan 35800a708f8fSGustavo F. Padovan /* Complete config. */ 358173ffa904SGustavo F. Padovan len = l2cap_parse_conf_req(chan, rsp); 35820a708f8fSGustavo F. Padovan if (len < 0) { 3583e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 35840a708f8fSGustavo F. Padovan goto unlock; 35850a708f8fSGustavo F. Padovan } 35860a708f8fSGustavo F. Padovan 35870a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp); 358873ffa904SGustavo F. Padovan chan->num_conf_rsp++; 35890a708f8fSGustavo F. Padovan 35900a708f8fSGustavo F. Padovan /* Reset config buffer. */ 359173ffa904SGustavo F. Padovan chan->conf_len = 0; 35920a708f8fSGustavo F. Padovan 3593c1360a1cSGustavo F. Padovan if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) 35940a708f8fSGustavo F. Padovan goto unlock; 35950a708f8fSGustavo F. Padovan 3596c1360a1cSGustavo F. Padovan if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) { 359747d1ec61SGustavo F. Padovan set_default_fcs(chan); 35980a708f8fSGustavo F. Padovan 3599105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3600105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 36013c588192SMat Martineau err = l2cap_ertm_init(chan); 36020a708f8fSGustavo F. Padovan 36033c588192SMat Martineau if (err < 0) 36043c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 36053c588192SMat Martineau else 3606cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 36073c588192SMat Martineau 36080a708f8fSGustavo F. Padovan goto unlock; 36090a708f8fSGustavo F. Padovan } 36100a708f8fSGustavo F. Padovan 3611c1360a1cSGustavo F. Padovan if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) { 36120a708f8fSGustavo F. Padovan u8 buf[64]; 36130a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ, 361473ffa904SGustavo F. Padovan l2cap_build_conf_req(chan, buf), buf); 361573ffa904SGustavo F. Padovan chan->num_conf_req++; 36160a708f8fSGustavo F. Padovan } 36170a708f8fSGustavo F. Padovan 36180e8b207eSAndrei Emeltchenko /* Got Conf Rsp PENDING from remote side and asume we sent 36190e8b207eSAndrei Emeltchenko Conf Rsp PENDING in the code above */ 36200e8b207eSAndrei Emeltchenko if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) && 36210e8b207eSAndrei Emeltchenko test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36220e8b207eSAndrei Emeltchenko 36230e8b207eSAndrei Emeltchenko /* check compatibility */ 36240e8b207eSAndrei Emeltchenko 36250e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36260e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36270e8b207eSAndrei Emeltchenko 36280e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36290e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, rsp, 36305325e5bbSAndrei Emeltchenko L2CAP_CONF_SUCCESS, flags), rsp); 36310e8b207eSAndrei Emeltchenko } 36320e8b207eSAndrei Emeltchenko 36330a708f8fSGustavo F. Padovan unlock: 36346be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 36353c588192SMat Martineau return err; 36360a708f8fSGustavo F. Padovan } 36370a708f8fSGustavo F. Padovan 36380a708f8fSGustavo F. Padovan static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 36390a708f8fSGustavo F. Padovan { 36400a708f8fSGustavo F. Padovan struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data; 36410a708f8fSGustavo F. Padovan u16 scid, flags, result; 364248454079SGustavo F. Padovan struct l2cap_chan *chan; 364361386cbaSAndrei Emeltchenko int len = le16_to_cpu(cmd->len) - sizeof(*rsp); 36443c588192SMat Martineau int err = 0; 36450a708f8fSGustavo F. Padovan 36460a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 36470a708f8fSGustavo F. Padovan flags = __le16_to_cpu(rsp->flags); 36480a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 36490a708f8fSGustavo F. Padovan 365061386cbaSAndrei Emeltchenko BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags, 365161386cbaSAndrei Emeltchenko result, len); 36520a708f8fSGustavo F. Padovan 3653baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, scid); 365448454079SGustavo F. Padovan if (!chan) 36550a708f8fSGustavo F. Padovan return 0; 36560a708f8fSGustavo F. Padovan 36570a708f8fSGustavo F. Padovan switch (result) { 36580a708f8fSGustavo F. Padovan case L2CAP_CONF_SUCCESS: 365947d1ec61SGustavo F. Padovan l2cap_conf_rfc_get(chan, rsp->data, len); 36600e8b207eSAndrei Emeltchenko clear_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36610a708f8fSGustavo F. Padovan break; 36620a708f8fSGustavo F. Padovan 36630e8b207eSAndrei Emeltchenko case L2CAP_CONF_PENDING: 36640e8b207eSAndrei Emeltchenko set_bit(CONF_REM_CONF_PEND, &chan->conf_state); 36650e8b207eSAndrei Emeltchenko 36660e8b207eSAndrei Emeltchenko if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) { 36670e8b207eSAndrei Emeltchenko char buf[64]; 36680e8b207eSAndrei Emeltchenko 36690e8b207eSAndrei Emeltchenko len = l2cap_parse_conf_rsp(chan, rsp->data, len, 36700e8b207eSAndrei Emeltchenko buf, &result); 36710e8b207eSAndrei Emeltchenko if (len < 0) { 36720e8b207eSAndrei Emeltchenko l2cap_send_disconn_req(conn, chan, ECONNRESET); 36730e8b207eSAndrei Emeltchenko goto done; 36740e8b207eSAndrei Emeltchenko } 36750e8b207eSAndrei Emeltchenko 36760e8b207eSAndrei Emeltchenko /* check compatibility */ 36770e8b207eSAndrei Emeltchenko 36780e8b207eSAndrei Emeltchenko clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state); 36790e8b207eSAndrei Emeltchenko set_bit(CONF_OUTPUT_DONE, &chan->conf_state); 36800e8b207eSAndrei Emeltchenko 36810e8b207eSAndrei Emeltchenko l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, 36820e8b207eSAndrei Emeltchenko l2cap_build_conf_rsp(chan, buf, 36830e8b207eSAndrei Emeltchenko L2CAP_CONF_SUCCESS, 0x0000), buf); 36840e8b207eSAndrei Emeltchenko } 36850e8b207eSAndrei Emeltchenko goto done; 36860e8b207eSAndrei Emeltchenko 36870a708f8fSGustavo F. Padovan case L2CAP_CONF_UNACCEPT: 368873ffa904SGustavo F. Padovan if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) { 36890a708f8fSGustavo F. Padovan char req[64]; 36900a708f8fSGustavo F. Padovan 36910a708f8fSGustavo F. Padovan if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) { 3692e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 36930a708f8fSGustavo F. Padovan goto done; 36940a708f8fSGustavo F. Padovan } 36950a708f8fSGustavo F. Padovan 36960a708f8fSGustavo F. Padovan /* throw out any old stored conf requests */ 36970a708f8fSGustavo F. Padovan result = L2CAP_CONF_SUCCESS; 3698b4450035SGustavo F. Padovan len = l2cap_parse_conf_rsp(chan, rsp->data, len, 3699b4450035SGustavo F. Padovan req, &result); 37000a708f8fSGustavo F. Padovan if (len < 0) { 3701e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 37020a708f8fSGustavo F. Padovan goto done; 37030a708f8fSGustavo F. Padovan } 37040a708f8fSGustavo F. Padovan 37050a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, l2cap_get_ident(conn), 37060a708f8fSGustavo F. Padovan L2CAP_CONF_REQ, len, req); 370773ffa904SGustavo F. Padovan chan->num_conf_req++; 37080a708f8fSGustavo F. Padovan if (result != L2CAP_CONF_SUCCESS) 37090a708f8fSGustavo F. Padovan goto done; 37100a708f8fSGustavo F. Padovan break; 37110a708f8fSGustavo F. Padovan } 37120a708f8fSGustavo F. Padovan 37130a708f8fSGustavo F. Padovan default: 37146be36555SAndrei Emeltchenko l2cap_chan_set_err(chan, ECONNRESET); 37152e0052e4SAndrei Emeltchenko 3716ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT); 3717e92c8e70SGustavo F. Padovan l2cap_send_disconn_req(conn, chan, ECONNRESET); 37180a708f8fSGustavo F. Padovan goto done; 37190a708f8fSGustavo F. Padovan } 37200a708f8fSGustavo F. Padovan 372159e54bd1SAndrei Emeltchenko if (flags & L2CAP_CONF_FLAG_CONTINUATION) 37220a708f8fSGustavo F. Padovan goto done; 37230a708f8fSGustavo F. Padovan 3724c1360a1cSGustavo F. Padovan set_bit(CONF_INPUT_DONE, &chan->conf_state); 37250a708f8fSGustavo F. Padovan 3726c1360a1cSGustavo F. Padovan if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) { 372747d1ec61SGustavo F. Padovan set_default_fcs(chan); 37280a708f8fSGustavo F. Padovan 3729105bdf9eSMat Martineau if (chan->mode == L2CAP_MODE_ERTM || 3730105bdf9eSMat Martineau chan->mode == L2CAP_MODE_STREAMING) 37313c588192SMat Martineau err = l2cap_ertm_init(chan); 37320a708f8fSGustavo F. Padovan 37333c588192SMat Martineau if (err < 0) 37343c588192SMat Martineau l2cap_send_disconn_req(chan->conn, chan, -err); 37353c588192SMat Martineau else 3736cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 37370a708f8fSGustavo F. Padovan } 37380a708f8fSGustavo F. Padovan 37390a708f8fSGustavo F. Padovan done: 37406be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37413c588192SMat Martineau return err; 37420a708f8fSGustavo F. Padovan } 37430a708f8fSGustavo F. Padovan 37440a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 37450a708f8fSGustavo F. Padovan { 37460a708f8fSGustavo F. Padovan struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data; 37470a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp rsp; 37480a708f8fSGustavo F. Padovan u16 dcid, scid; 374948454079SGustavo F. Padovan struct l2cap_chan *chan; 37500a708f8fSGustavo F. Padovan struct sock *sk; 37510a708f8fSGustavo F. Padovan 37520a708f8fSGustavo F. Padovan scid = __le16_to_cpu(req->scid); 37530a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(req->dcid); 37540a708f8fSGustavo F. Padovan 37550a708f8fSGustavo F. Padovan BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid); 37560a708f8fSGustavo F. Padovan 37573df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 37583df91ea2SAndrei Emeltchenko 37593df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, dcid); 37603df91ea2SAndrei Emeltchenko if (!chan) { 37613df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37620a708f8fSGustavo F. Padovan return 0; 37633df91ea2SAndrei Emeltchenko } 37640a708f8fSGustavo F. Padovan 37656be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 37666be36555SAndrei Emeltchenko 376748454079SGustavo F. Padovan sk = chan->sk; 376848454079SGustavo F. Padovan 3769fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 3770fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 37710a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp); 37720a708f8fSGustavo F. Padovan 37736be36555SAndrei Emeltchenko lock_sock(sk); 37740a708f8fSGustavo F. Padovan sk->sk_shutdown = SHUTDOWN_MASK; 37756be36555SAndrei Emeltchenko release_sock(sk); 37760a708f8fSGustavo F. Padovan 377761d6ef3eSMat Martineau l2cap_chan_hold(chan); 377848454079SGustavo F. Padovan l2cap_chan_del(chan, ECONNRESET); 37796be36555SAndrei Emeltchenko 37806be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 37810a708f8fSGustavo F. Padovan 378280b98027SGustavo Padovan chan->ops->close(chan); 378361d6ef3eSMat Martineau l2cap_chan_put(chan); 37843df91ea2SAndrei Emeltchenko 37853df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 37863df91ea2SAndrei Emeltchenko 37870a708f8fSGustavo F. Padovan return 0; 37880a708f8fSGustavo F. Padovan } 37890a708f8fSGustavo F. Padovan 37900a708f8fSGustavo F. Padovan static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 37910a708f8fSGustavo F. Padovan { 37920a708f8fSGustavo F. Padovan struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data; 37930a708f8fSGustavo F. Padovan u16 dcid, scid; 379448454079SGustavo F. Padovan struct l2cap_chan *chan; 37950a708f8fSGustavo F. Padovan 37960a708f8fSGustavo F. Padovan scid = __le16_to_cpu(rsp->scid); 37970a708f8fSGustavo F. Padovan dcid = __le16_to_cpu(rsp->dcid); 37980a708f8fSGustavo F. Padovan 37990a708f8fSGustavo F. Padovan BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid); 38000a708f8fSGustavo F. Padovan 38013df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 38023df91ea2SAndrei Emeltchenko 38033df91ea2SAndrei Emeltchenko chan = __l2cap_get_chan_by_scid(conn, scid); 38043df91ea2SAndrei Emeltchenko if (!chan) { 38053df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38060a708f8fSGustavo F. Padovan return 0; 38073df91ea2SAndrei Emeltchenko } 38080a708f8fSGustavo F. Padovan 38096be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 381048454079SGustavo F. Padovan 381161d6ef3eSMat Martineau l2cap_chan_hold(chan); 381248454079SGustavo F. Padovan l2cap_chan_del(chan, 0); 38136be36555SAndrei Emeltchenko 38146be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 38150a708f8fSGustavo F. Padovan 381680b98027SGustavo Padovan chan->ops->close(chan); 381761d6ef3eSMat Martineau l2cap_chan_put(chan); 38183df91ea2SAndrei Emeltchenko 38193df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 38203df91ea2SAndrei Emeltchenko 38210a708f8fSGustavo F. Padovan return 0; 38220a708f8fSGustavo F. Padovan } 38230a708f8fSGustavo F. Padovan 38240a708f8fSGustavo F. Padovan static inline int l2cap_information_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38250a708f8fSGustavo F. Padovan { 38260a708f8fSGustavo F. Padovan struct l2cap_info_req *req = (struct l2cap_info_req *) data; 38270a708f8fSGustavo F. Padovan u16 type; 38280a708f8fSGustavo F. Padovan 38290a708f8fSGustavo F. Padovan type = __le16_to_cpu(req->type); 38300a708f8fSGustavo F. Padovan 38310a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x", type); 38320a708f8fSGustavo F. Padovan 38330a708f8fSGustavo F. Padovan if (type == L2CAP_IT_FEAT_MASK) { 38340a708f8fSGustavo F. Padovan u8 buf[8]; 38350a708f8fSGustavo F. Padovan u32 feat_mask = l2cap_feat_mask; 38360a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 3837ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FEAT_MASK); 3838ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 38390a708f8fSGustavo F. Padovan if (!disable_ertm) 38400a708f8fSGustavo F. Padovan feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING 38410a708f8fSGustavo F. Padovan | L2CAP_FEAT_FCS; 3842a5fd6f30SAndrei Emeltchenko if (enable_hs) 38436327eb98SAndrei Emeltchenko feat_mask |= L2CAP_FEAT_EXT_FLOW 38446327eb98SAndrei Emeltchenko | L2CAP_FEAT_EXT_WINDOW; 3845a5fd6f30SAndrei Emeltchenko 38460a708f8fSGustavo F. Padovan put_unaligned_le32(feat_mask, rsp->data); 38470a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38480a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38490a708f8fSGustavo F. Padovan } else if (type == L2CAP_IT_FIXED_CHAN) { 38500a708f8fSGustavo F. Padovan u8 buf[12]; 38510a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf; 385250a147cdSMat Martineau 385350a147cdSMat Martineau if (enable_hs) 385450a147cdSMat Martineau l2cap_fixed_chan[0] |= L2CAP_FC_A2MP; 385550a147cdSMat Martineau else 385650a147cdSMat Martineau l2cap_fixed_chan[0] &= ~L2CAP_FC_A2MP; 385750a147cdSMat Martineau 3858ac73498cSAndrei Emeltchenko rsp->type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 3859ac73498cSAndrei Emeltchenko rsp->result = __constant_cpu_to_le16(L2CAP_IR_SUCCESS); 3860c6337ea6SAndrei Emeltchenko memcpy(rsp->data, l2cap_fixed_chan, sizeof(l2cap_fixed_chan)); 38610a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38620a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(buf), buf); 38630a708f8fSGustavo F. Padovan } else { 38640a708f8fSGustavo F. Padovan struct l2cap_info_rsp rsp; 38650a708f8fSGustavo F. Padovan rsp.type = cpu_to_le16(type); 3866ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_IR_NOTSUPP); 38670a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd->ident, 38680a708f8fSGustavo F. Padovan L2CAP_INFO_RSP, sizeof(rsp), &rsp); 38690a708f8fSGustavo F. Padovan } 38700a708f8fSGustavo F. Padovan 38710a708f8fSGustavo F. Padovan return 0; 38720a708f8fSGustavo F. Padovan } 38730a708f8fSGustavo F. Padovan 38740a708f8fSGustavo F. Padovan static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data) 38750a708f8fSGustavo F. Padovan { 38760a708f8fSGustavo F. Padovan struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data; 38770a708f8fSGustavo F. Padovan u16 type, result; 38780a708f8fSGustavo F. Padovan 38790a708f8fSGustavo F. Padovan type = __le16_to_cpu(rsp->type); 38800a708f8fSGustavo F. Padovan result = __le16_to_cpu(rsp->result); 38810a708f8fSGustavo F. Padovan 38820a708f8fSGustavo F. Padovan BT_DBG("type 0x%4.4x result 0x%2.2x", type, result); 38830a708f8fSGustavo F. Padovan 3884e90165beSAndrei Emeltchenko /* L2CAP Info req/rsp are unbound to channels, add extra checks */ 3885e90165beSAndrei Emeltchenko if (cmd->ident != conn->info_ident || 3886e90165beSAndrei Emeltchenko conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) 3887e90165beSAndrei Emeltchenko return 0; 3888e90165beSAndrei Emeltchenko 388917cd3f37SUlisses Furquim cancel_delayed_work(&conn->info_timer); 38900a708f8fSGustavo F. Padovan 38910a708f8fSGustavo F. Padovan if (result != L2CAP_IR_SUCCESS) { 38920a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 38930a708f8fSGustavo F. Padovan conn->info_ident = 0; 38940a708f8fSGustavo F. Padovan 38950a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 38960a708f8fSGustavo F. Padovan 38970a708f8fSGustavo F. Padovan return 0; 38980a708f8fSGustavo F. Padovan } 38990a708f8fSGustavo F. Padovan 3900978c93b9SAndrei Emeltchenko switch (type) { 3901978c93b9SAndrei Emeltchenko case L2CAP_IT_FEAT_MASK: 39020a708f8fSGustavo F. Padovan conn->feat_mask = get_unaligned_le32(rsp->data); 39030a708f8fSGustavo F. Padovan 39040a708f8fSGustavo F. Padovan if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) { 39050a708f8fSGustavo F. Padovan struct l2cap_info_req req; 3906ac73498cSAndrei Emeltchenko req.type = __constant_cpu_to_le16(L2CAP_IT_FIXED_CHAN); 39070a708f8fSGustavo F. Padovan 39080a708f8fSGustavo F. Padovan conn->info_ident = l2cap_get_ident(conn); 39090a708f8fSGustavo F. Padovan 39100a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, conn->info_ident, 39110a708f8fSGustavo F. Padovan L2CAP_INFO_REQ, sizeof(req), &req); 39120a708f8fSGustavo F. Padovan } else { 39130a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39140a708f8fSGustavo F. Padovan conn->info_ident = 0; 39150a708f8fSGustavo F. Padovan 39160a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 39170a708f8fSGustavo F. Padovan } 3918978c93b9SAndrei Emeltchenko break; 3919978c93b9SAndrei Emeltchenko 3920978c93b9SAndrei Emeltchenko case L2CAP_IT_FIXED_CHAN: 3921978c93b9SAndrei Emeltchenko conn->fixed_chan_mask = rsp->data[0]; 39220a708f8fSGustavo F. Padovan conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE; 39230a708f8fSGustavo F. Padovan conn->info_ident = 0; 39240a708f8fSGustavo F. Padovan 39250a708f8fSGustavo F. Padovan l2cap_conn_start(conn); 3926978c93b9SAndrei Emeltchenko break; 39270a708f8fSGustavo F. Padovan } 39280a708f8fSGustavo F. Padovan 39290a708f8fSGustavo F. Padovan return 0; 39300a708f8fSGustavo F. Padovan } 39310a708f8fSGustavo F. Padovan 3932f94ff6ffSMat Martineau static inline int l2cap_create_channel_req(struct l2cap_conn *conn, 3933f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, 3934f94ff6ffSMat Martineau void *data) 3935f94ff6ffSMat Martineau { 3936f94ff6ffSMat Martineau struct l2cap_create_chan_req *req = data; 3937f94ff6ffSMat Martineau struct l2cap_create_chan_rsp rsp; 3938f94ff6ffSMat Martineau u16 psm, scid; 3939f94ff6ffSMat Martineau 3940f94ff6ffSMat Martineau if (cmd_len != sizeof(*req)) 3941f94ff6ffSMat Martineau return -EPROTO; 3942f94ff6ffSMat Martineau 3943f94ff6ffSMat Martineau if (!enable_hs) 3944f94ff6ffSMat Martineau return -EINVAL; 3945f94ff6ffSMat Martineau 3946f94ff6ffSMat Martineau psm = le16_to_cpu(req->psm); 3947f94ff6ffSMat Martineau scid = le16_to_cpu(req->scid); 3948f94ff6ffSMat Martineau 3949f94ff6ffSMat Martineau BT_DBG("psm %d, scid %d, amp_id %d", psm, scid, req->amp_id); 3950f94ff6ffSMat Martineau 3951f94ff6ffSMat Martineau /* Placeholder: Always reject */ 3952f94ff6ffSMat Martineau rsp.dcid = 0; 3953f94ff6ffSMat Martineau rsp.scid = cpu_to_le16(scid); 39548ce0c498SAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CR_NO_MEM); 39558ce0c498SAndrei Emeltchenko rsp.status = __constant_cpu_to_le16(L2CAP_CS_NO_INFO); 3956f94ff6ffSMat Martineau 3957f94ff6ffSMat Martineau l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP, 3958f94ff6ffSMat Martineau sizeof(rsp), &rsp); 3959f94ff6ffSMat Martineau 3960f94ff6ffSMat Martineau return 0; 3961f94ff6ffSMat Martineau } 3962f94ff6ffSMat Martineau 3963f94ff6ffSMat Martineau static inline int l2cap_create_channel_rsp(struct l2cap_conn *conn, 3964f94ff6ffSMat Martineau struct l2cap_cmd_hdr *cmd, void *data) 3965f94ff6ffSMat Martineau { 3966f94ff6ffSMat Martineau BT_DBG("conn %p", conn); 3967f94ff6ffSMat Martineau 3968f94ff6ffSMat Martineau return l2cap_connect_rsp(conn, cmd, data); 3969f94ff6ffSMat Martineau } 3970f94ff6ffSMat Martineau 39718d5a04a1SMat Martineau static void l2cap_send_move_chan_rsp(struct l2cap_conn *conn, u8 ident, 39728d5a04a1SMat Martineau u16 icid, u16 result) 39738d5a04a1SMat Martineau { 39748d5a04a1SMat Martineau struct l2cap_move_chan_rsp rsp; 39758d5a04a1SMat Martineau 39768d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 39778d5a04a1SMat Martineau 39788d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 39798d5a04a1SMat Martineau rsp.result = cpu_to_le16(result); 39808d5a04a1SMat Martineau 39818d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_RSP, sizeof(rsp), &rsp); 39828d5a04a1SMat Martineau } 39838d5a04a1SMat Martineau 39848d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm(struct l2cap_conn *conn, 39858d5a04a1SMat Martineau struct l2cap_chan *chan, u16 icid, u16 result) 39868d5a04a1SMat Martineau { 39878d5a04a1SMat Martineau struct l2cap_move_chan_cfm cfm; 39888d5a04a1SMat Martineau u8 ident; 39898d5a04a1SMat Martineau 39908d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 39918d5a04a1SMat Martineau 39928d5a04a1SMat Martineau ident = l2cap_get_ident(conn); 39938d5a04a1SMat Martineau if (chan) 39948d5a04a1SMat Martineau chan->ident = ident; 39958d5a04a1SMat Martineau 39968d5a04a1SMat Martineau cfm.icid = cpu_to_le16(icid); 39978d5a04a1SMat Martineau cfm.result = cpu_to_le16(result); 39988d5a04a1SMat Martineau 39998d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM, sizeof(cfm), &cfm); 40008d5a04a1SMat Martineau } 40018d5a04a1SMat Martineau 40028d5a04a1SMat Martineau static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident, 40038d5a04a1SMat Martineau u16 icid) 40048d5a04a1SMat Martineau { 40058d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp rsp; 40068d5a04a1SMat Martineau 40078d5a04a1SMat Martineau BT_DBG("icid %d", icid); 40088d5a04a1SMat Martineau 40098d5a04a1SMat Martineau rsp.icid = cpu_to_le16(icid); 40108d5a04a1SMat Martineau l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp); 40118d5a04a1SMat Martineau } 40128d5a04a1SMat Martineau 40138d5a04a1SMat Martineau static inline int l2cap_move_channel_req(struct l2cap_conn *conn, 40148d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40158d5a04a1SMat Martineau { 40168d5a04a1SMat Martineau struct l2cap_move_chan_req *req = data; 40178d5a04a1SMat Martineau u16 icid = 0; 40188d5a04a1SMat Martineau u16 result = L2CAP_MR_NOT_ALLOWED; 40198d5a04a1SMat Martineau 40208d5a04a1SMat Martineau if (cmd_len != sizeof(*req)) 40218d5a04a1SMat Martineau return -EPROTO; 40228d5a04a1SMat Martineau 40238d5a04a1SMat Martineau icid = le16_to_cpu(req->icid); 40248d5a04a1SMat Martineau 40258d5a04a1SMat Martineau BT_DBG("icid %d, dest_amp_id %d", icid, req->dest_amp_id); 40268d5a04a1SMat Martineau 40278d5a04a1SMat Martineau if (!enable_hs) 40288d5a04a1SMat Martineau return -EINVAL; 40298d5a04a1SMat Martineau 40308d5a04a1SMat Martineau /* Placeholder: Always refuse */ 40318d5a04a1SMat Martineau l2cap_send_move_chan_rsp(conn, cmd->ident, icid, result); 40328d5a04a1SMat Martineau 40338d5a04a1SMat Martineau return 0; 40348d5a04a1SMat Martineau } 40358d5a04a1SMat Martineau 40368d5a04a1SMat Martineau static inline int l2cap_move_channel_rsp(struct l2cap_conn *conn, 40378d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40388d5a04a1SMat Martineau { 40398d5a04a1SMat Martineau struct l2cap_move_chan_rsp *rsp = data; 40408d5a04a1SMat Martineau u16 icid, result; 40418d5a04a1SMat Martineau 40428d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 40438d5a04a1SMat Martineau return -EPROTO; 40448d5a04a1SMat Martineau 40458d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 40468d5a04a1SMat Martineau result = le16_to_cpu(rsp->result); 40478d5a04a1SMat Martineau 40488d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 40498d5a04a1SMat Martineau 40508d5a04a1SMat Martineau /* Placeholder: Always unconfirmed */ 40518d5a04a1SMat Martineau l2cap_send_move_chan_cfm(conn, NULL, icid, L2CAP_MC_UNCONFIRMED); 40528d5a04a1SMat Martineau 40538d5a04a1SMat Martineau return 0; 40548d5a04a1SMat Martineau } 40558d5a04a1SMat Martineau 40568d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm(struct l2cap_conn *conn, 40578d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40588d5a04a1SMat Martineau { 40598d5a04a1SMat Martineau struct l2cap_move_chan_cfm *cfm = data; 40608d5a04a1SMat Martineau u16 icid, result; 40618d5a04a1SMat Martineau 40628d5a04a1SMat Martineau if (cmd_len != sizeof(*cfm)) 40638d5a04a1SMat Martineau return -EPROTO; 40648d5a04a1SMat Martineau 40658d5a04a1SMat Martineau icid = le16_to_cpu(cfm->icid); 40668d5a04a1SMat Martineau result = le16_to_cpu(cfm->result); 40678d5a04a1SMat Martineau 40688d5a04a1SMat Martineau BT_DBG("icid %d, result %d", icid, result); 40698d5a04a1SMat Martineau 40708d5a04a1SMat Martineau l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid); 40718d5a04a1SMat Martineau 40728d5a04a1SMat Martineau return 0; 40738d5a04a1SMat Martineau } 40748d5a04a1SMat Martineau 40758d5a04a1SMat Martineau static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn, 40768d5a04a1SMat Martineau struct l2cap_cmd_hdr *cmd, u16 cmd_len, void *data) 40778d5a04a1SMat Martineau { 40788d5a04a1SMat Martineau struct l2cap_move_chan_cfm_rsp *rsp = data; 40798d5a04a1SMat Martineau u16 icid; 40808d5a04a1SMat Martineau 40818d5a04a1SMat Martineau if (cmd_len != sizeof(*rsp)) 40828d5a04a1SMat Martineau return -EPROTO; 40838d5a04a1SMat Martineau 40848d5a04a1SMat Martineau icid = le16_to_cpu(rsp->icid); 40858d5a04a1SMat Martineau 40868d5a04a1SMat Martineau BT_DBG("icid %d", icid); 40878d5a04a1SMat Martineau 40888d5a04a1SMat Martineau return 0; 40898d5a04a1SMat Martineau } 40908d5a04a1SMat Martineau 4091e2174ca4SGustavo F. Padovan static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency, 4092de73115aSClaudio Takahasi u16 to_multiplier) 4093de73115aSClaudio Takahasi { 4094de73115aSClaudio Takahasi u16 max_latency; 4095de73115aSClaudio Takahasi 4096de73115aSClaudio Takahasi if (min > max || min < 6 || max > 3200) 4097de73115aSClaudio Takahasi return -EINVAL; 4098de73115aSClaudio Takahasi 4099de73115aSClaudio Takahasi if (to_multiplier < 10 || to_multiplier > 3200) 4100de73115aSClaudio Takahasi return -EINVAL; 4101de73115aSClaudio Takahasi 4102de73115aSClaudio Takahasi if (max >= to_multiplier * 8) 4103de73115aSClaudio Takahasi return -EINVAL; 4104de73115aSClaudio Takahasi 4105de73115aSClaudio Takahasi max_latency = (to_multiplier * 8 / max) - 1; 4106de73115aSClaudio Takahasi if (latency > 499 || latency > max_latency) 4107de73115aSClaudio Takahasi return -EINVAL; 4108de73115aSClaudio Takahasi 4109de73115aSClaudio Takahasi return 0; 4110de73115aSClaudio Takahasi } 4111de73115aSClaudio Takahasi 4112de73115aSClaudio Takahasi static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn, 4113de73115aSClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 4114de73115aSClaudio Takahasi { 4115de73115aSClaudio Takahasi struct hci_conn *hcon = conn->hcon; 4116de73115aSClaudio Takahasi struct l2cap_conn_param_update_req *req; 4117de73115aSClaudio Takahasi struct l2cap_conn_param_update_rsp rsp; 4118de73115aSClaudio Takahasi u16 min, max, latency, to_multiplier, cmd_len; 41192ce603ebSClaudio Takahasi int err; 4120de73115aSClaudio Takahasi 4121de73115aSClaudio Takahasi if (!(hcon->link_mode & HCI_LM_MASTER)) 4122de73115aSClaudio Takahasi return -EINVAL; 4123de73115aSClaudio Takahasi 4124de73115aSClaudio Takahasi cmd_len = __le16_to_cpu(cmd->len); 4125de73115aSClaudio Takahasi if (cmd_len != sizeof(struct l2cap_conn_param_update_req)) 4126de73115aSClaudio Takahasi return -EPROTO; 4127de73115aSClaudio Takahasi 4128de73115aSClaudio Takahasi req = (struct l2cap_conn_param_update_req *) data; 4129de73115aSClaudio Takahasi min = __le16_to_cpu(req->min); 4130de73115aSClaudio Takahasi max = __le16_to_cpu(req->max); 4131de73115aSClaudio Takahasi latency = __le16_to_cpu(req->latency); 4132de73115aSClaudio Takahasi to_multiplier = __le16_to_cpu(req->to_multiplier); 4133de73115aSClaudio Takahasi 4134de73115aSClaudio Takahasi BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x", 4135de73115aSClaudio Takahasi min, max, latency, to_multiplier); 4136de73115aSClaudio Takahasi 4137de73115aSClaudio Takahasi memset(&rsp, 0, sizeof(rsp)); 41382ce603ebSClaudio Takahasi 41392ce603ebSClaudio Takahasi err = l2cap_check_conn_param(min, max, latency, to_multiplier); 41402ce603ebSClaudio Takahasi if (err) 4141ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_REJECTED); 4142de73115aSClaudio Takahasi else 4143ac73498cSAndrei Emeltchenko rsp.result = __constant_cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED); 4144de73115aSClaudio Takahasi 4145de73115aSClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP, 4146de73115aSClaudio Takahasi sizeof(rsp), &rsp); 4147de73115aSClaudio Takahasi 41482ce603ebSClaudio Takahasi if (!err) 41492ce603ebSClaudio Takahasi hci_le_conn_update(hcon, min, max, latency, to_multiplier); 41502ce603ebSClaudio Takahasi 4151de73115aSClaudio Takahasi return 0; 4152de73115aSClaudio Takahasi } 4153de73115aSClaudio Takahasi 41543300d9a9SClaudio Takahasi static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn, 41553300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data) 41563300d9a9SClaudio Takahasi { 41573300d9a9SClaudio Takahasi int err = 0; 41583300d9a9SClaudio Takahasi 41593300d9a9SClaudio Takahasi switch (cmd->code) { 41603300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 41613300d9a9SClaudio Takahasi l2cap_command_rej(conn, cmd, data); 41623300d9a9SClaudio Takahasi break; 41633300d9a9SClaudio Takahasi 41643300d9a9SClaudio Takahasi case L2CAP_CONN_REQ: 41653300d9a9SClaudio Takahasi err = l2cap_connect_req(conn, cmd, data); 41663300d9a9SClaudio Takahasi break; 41673300d9a9SClaudio Takahasi 41683300d9a9SClaudio Takahasi case L2CAP_CONN_RSP: 41693300d9a9SClaudio Takahasi err = l2cap_connect_rsp(conn, cmd, data); 41703300d9a9SClaudio Takahasi break; 41713300d9a9SClaudio Takahasi 41723300d9a9SClaudio Takahasi case L2CAP_CONF_REQ: 41733300d9a9SClaudio Takahasi err = l2cap_config_req(conn, cmd, cmd_len, data); 41743300d9a9SClaudio Takahasi break; 41753300d9a9SClaudio Takahasi 41763300d9a9SClaudio Takahasi case L2CAP_CONF_RSP: 41773300d9a9SClaudio Takahasi err = l2cap_config_rsp(conn, cmd, data); 41783300d9a9SClaudio Takahasi break; 41793300d9a9SClaudio Takahasi 41803300d9a9SClaudio Takahasi case L2CAP_DISCONN_REQ: 41813300d9a9SClaudio Takahasi err = l2cap_disconnect_req(conn, cmd, data); 41823300d9a9SClaudio Takahasi break; 41833300d9a9SClaudio Takahasi 41843300d9a9SClaudio Takahasi case L2CAP_DISCONN_RSP: 41853300d9a9SClaudio Takahasi err = l2cap_disconnect_rsp(conn, cmd, data); 41863300d9a9SClaudio Takahasi break; 41873300d9a9SClaudio Takahasi 41883300d9a9SClaudio Takahasi case L2CAP_ECHO_REQ: 41893300d9a9SClaudio Takahasi l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data); 41903300d9a9SClaudio Takahasi break; 41913300d9a9SClaudio Takahasi 41923300d9a9SClaudio Takahasi case L2CAP_ECHO_RSP: 41933300d9a9SClaudio Takahasi break; 41943300d9a9SClaudio Takahasi 41953300d9a9SClaudio Takahasi case L2CAP_INFO_REQ: 41963300d9a9SClaudio Takahasi err = l2cap_information_req(conn, cmd, data); 41973300d9a9SClaudio Takahasi break; 41983300d9a9SClaudio Takahasi 41993300d9a9SClaudio Takahasi case L2CAP_INFO_RSP: 42003300d9a9SClaudio Takahasi err = l2cap_information_rsp(conn, cmd, data); 42013300d9a9SClaudio Takahasi break; 42023300d9a9SClaudio Takahasi 4203f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_REQ: 4204f94ff6ffSMat Martineau err = l2cap_create_channel_req(conn, cmd, cmd_len, data); 4205f94ff6ffSMat Martineau break; 4206f94ff6ffSMat Martineau 4207f94ff6ffSMat Martineau case L2CAP_CREATE_CHAN_RSP: 4208f94ff6ffSMat Martineau err = l2cap_create_channel_rsp(conn, cmd, data); 4209f94ff6ffSMat Martineau break; 4210f94ff6ffSMat Martineau 42118d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_REQ: 42128d5a04a1SMat Martineau err = l2cap_move_channel_req(conn, cmd, cmd_len, data); 42138d5a04a1SMat Martineau break; 42148d5a04a1SMat Martineau 42158d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_RSP: 42168d5a04a1SMat Martineau err = l2cap_move_channel_rsp(conn, cmd, cmd_len, data); 42178d5a04a1SMat Martineau break; 42188d5a04a1SMat Martineau 42198d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM: 42208d5a04a1SMat Martineau err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data); 42218d5a04a1SMat Martineau break; 42228d5a04a1SMat Martineau 42238d5a04a1SMat Martineau case L2CAP_MOVE_CHAN_CFM_RSP: 42248d5a04a1SMat Martineau err = l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data); 42258d5a04a1SMat Martineau break; 42268d5a04a1SMat Martineau 42273300d9a9SClaudio Takahasi default: 42283300d9a9SClaudio Takahasi BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code); 42293300d9a9SClaudio Takahasi err = -EINVAL; 42303300d9a9SClaudio Takahasi break; 42313300d9a9SClaudio Takahasi } 42323300d9a9SClaudio Takahasi 42333300d9a9SClaudio Takahasi return err; 42343300d9a9SClaudio Takahasi } 42353300d9a9SClaudio Takahasi 42363300d9a9SClaudio Takahasi static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn, 42373300d9a9SClaudio Takahasi struct l2cap_cmd_hdr *cmd, u8 *data) 42383300d9a9SClaudio Takahasi { 42393300d9a9SClaudio Takahasi switch (cmd->code) { 42403300d9a9SClaudio Takahasi case L2CAP_COMMAND_REJ: 42413300d9a9SClaudio Takahasi return 0; 42423300d9a9SClaudio Takahasi 42433300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_REQ: 4244de73115aSClaudio Takahasi return l2cap_conn_param_update_req(conn, cmd, data); 42453300d9a9SClaudio Takahasi 42463300d9a9SClaudio Takahasi case L2CAP_CONN_PARAM_UPDATE_RSP: 42473300d9a9SClaudio Takahasi return 0; 42483300d9a9SClaudio Takahasi 42493300d9a9SClaudio Takahasi default: 42503300d9a9SClaudio Takahasi BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code); 42513300d9a9SClaudio Takahasi return -EINVAL; 42523300d9a9SClaudio Takahasi } 42533300d9a9SClaudio Takahasi } 42543300d9a9SClaudio Takahasi 42553300d9a9SClaudio Takahasi static inline void l2cap_sig_channel(struct l2cap_conn *conn, 42563300d9a9SClaudio Takahasi struct sk_buff *skb) 42570a708f8fSGustavo F. Padovan { 42580a708f8fSGustavo F. Padovan u8 *data = skb->data; 42590a708f8fSGustavo F. Padovan int len = skb->len; 42600a708f8fSGustavo F. Padovan struct l2cap_cmd_hdr cmd; 42613300d9a9SClaudio Takahasi int err; 42620a708f8fSGustavo F. Padovan 42630a708f8fSGustavo F. Padovan l2cap_raw_recv(conn, skb); 42640a708f8fSGustavo F. Padovan 42650a708f8fSGustavo F. Padovan while (len >= L2CAP_CMD_HDR_SIZE) { 42660a708f8fSGustavo F. Padovan u16 cmd_len; 42670a708f8fSGustavo F. Padovan memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE); 42680a708f8fSGustavo F. Padovan data += L2CAP_CMD_HDR_SIZE; 42690a708f8fSGustavo F. Padovan len -= L2CAP_CMD_HDR_SIZE; 42700a708f8fSGustavo F. Padovan 42710a708f8fSGustavo F. Padovan cmd_len = le16_to_cpu(cmd.len); 42720a708f8fSGustavo F. Padovan 42730a708f8fSGustavo F. Padovan BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, cmd.ident); 42740a708f8fSGustavo F. Padovan 42750a708f8fSGustavo F. Padovan if (cmd_len > len || !cmd.ident) { 42760a708f8fSGustavo F. Padovan BT_DBG("corrupted command"); 42770a708f8fSGustavo F. Padovan break; 42780a708f8fSGustavo F. Padovan } 42790a708f8fSGustavo F. Padovan 42803300d9a9SClaudio Takahasi if (conn->hcon->type == LE_LINK) 42813300d9a9SClaudio Takahasi err = l2cap_le_sig_cmd(conn, &cmd, data); 42823300d9a9SClaudio Takahasi else 42833300d9a9SClaudio Takahasi err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data); 42840a708f8fSGustavo F. Padovan 42850a708f8fSGustavo F. Padovan if (err) { 4286e2fd318eSIlia Kolomisnky struct l2cap_cmd_rej_unk rej; 42872c6d1a2eSGustavo F. Padovan 42882c6d1a2eSGustavo F. Padovan BT_ERR("Wrong link type (%d)", err); 42890a708f8fSGustavo F. Padovan 42900a708f8fSGustavo F. Padovan /* FIXME: Map err to a valid reason */ 4291ac73498cSAndrei Emeltchenko rej.reason = __constant_cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD); 42920a708f8fSGustavo F. Padovan l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej); 42930a708f8fSGustavo F. Padovan } 42940a708f8fSGustavo F. Padovan 42950a708f8fSGustavo F. Padovan data += cmd_len; 42960a708f8fSGustavo F. Padovan len -= cmd_len; 42970a708f8fSGustavo F. Padovan } 42980a708f8fSGustavo F. Padovan 42990a708f8fSGustavo F. Padovan kfree_skb(skb); 43000a708f8fSGustavo F. Padovan } 43010a708f8fSGustavo F. Padovan 430247d1ec61SGustavo F. Padovan static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb) 43030a708f8fSGustavo F. Padovan { 43040a708f8fSGustavo F. Padovan u16 our_fcs, rcv_fcs; 4305e4ca6d98SAndrei Emeltchenko int hdr_size; 4306e4ca6d98SAndrei Emeltchenko 4307e4ca6d98SAndrei Emeltchenko if (test_bit(FLAG_EXT_CTRL, &chan->flags)) 4308e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_EXT_HDR_SIZE; 4309e4ca6d98SAndrei Emeltchenko else 4310e4ca6d98SAndrei Emeltchenko hdr_size = L2CAP_ENH_HDR_SIZE; 43110a708f8fSGustavo F. Padovan 431247d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) { 431303a51213SAndrei Emeltchenko skb_trim(skb, skb->len - L2CAP_FCS_SIZE); 43140a708f8fSGustavo F. Padovan rcv_fcs = get_unaligned_le16(skb->data + skb->len); 43150a708f8fSGustavo F. Padovan our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size); 43160a708f8fSGustavo F. Padovan 43170a708f8fSGustavo F. Padovan if (our_fcs != rcv_fcs) 43180a708f8fSGustavo F. Padovan return -EBADMSG; 43190a708f8fSGustavo F. Padovan } 43200a708f8fSGustavo F. Padovan return 0; 43210a708f8fSGustavo F. Padovan } 43220a708f8fSGustavo F. Padovan 43236ea00485SMat Martineau static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan) 43240a708f8fSGustavo F. Padovan { 4325e31f7633SMat Martineau struct l2cap_ctrl control; 43260a708f8fSGustavo F. Padovan 4327e31f7633SMat Martineau BT_DBG("chan %p", chan); 43280a708f8fSGustavo F. Padovan 4329e31f7633SMat Martineau memset(&control, 0, sizeof(control)); 4330e31f7633SMat Martineau control.sframe = 1; 4331e31f7633SMat Martineau control.final = 1; 4332e31f7633SMat Martineau control.reqseq = chan->buffer_seq; 4333e31f7633SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 43340a708f8fSGustavo F. Padovan 4335e2ab4353SGustavo F. Padovan if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4336e31f7633SMat Martineau control.super = L2CAP_SUPER_RNR; 4337e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43380a708f8fSGustavo F. Padovan } 43390a708f8fSGustavo F. Padovan 4340e31f7633SMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) && 4341e31f7633SMat Martineau chan->unacked_frames > 0) 4342e31f7633SMat Martineau __set_retrans_timer(chan); 43430a708f8fSGustavo F. Padovan 4344e31f7633SMat Martineau /* Send pending iframes */ 4345525cd185SGustavo F. Padovan l2cap_ertm_send(chan); 43460a708f8fSGustavo F. Padovan 4347e2ab4353SGustavo F. Padovan if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) && 4348e31f7633SMat Martineau test_bit(CONN_SEND_FBIT, &chan->conn_state)) { 4349e31f7633SMat Martineau /* F-bit wasn't sent in an s-frame or i-frame yet, so 4350e31f7633SMat Martineau * send it now. 4351e31f7633SMat Martineau */ 4352e31f7633SMat Martineau control.super = L2CAP_SUPER_RR; 4353e31f7633SMat Martineau l2cap_send_sframe(chan, &control); 43540a708f8fSGustavo F. Padovan } 43550a708f8fSGustavo F. Padovan } 43560a708f8fSGustavo F. Padovan 435784084a31SMat Martineau static void append_skb_frag(struct sk_buff *skb, 435884084a31SMat Martineau struct sk_buff *new_frag, struct sk_buff **last_frag) 43590a708f8fSGustavo F. Padovan { 436084084a31SMat Martineau /* skb->len reflects data in skb as well as all fragments 436184084a31SMat Martineau * skb->data_len reflects only data in fragments 436284084a31SMat Martineau */ 436384084a31SMat Martineau if (!skb_has_frag_list(skb)) 436484084a31SMat Martineau skb_shinfo(skb)->frag_list = new_frag; 436584084a31SMat Martineau 436684084a31SMat Martineau new_frag->next = NULL; 436784084a31SMat Martineau 436884084a31SMat Martineau (*last_frag)->next = new_frag; 436984084a31SMat Martineau *last_frag = new_frag; 437084084a31SMat Martineau 437184084a31SMat Martineau skb->len += new_frag->len; 437284084a31SMat Martineau skb->data_len += new_frag->len; 437384084a31SMat Martineau skb->truesize += new_frag->truesize; 437484084a31SMat Martineau } 437584084a31SMat Martineau 43764b51dae9SMat Martineau static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb, 43774b51dae9SMat Martineau struct l2cap_ctrl *control) 437884084a31SMat Martineau { 437984084a31SMat Martineau int err = -EINVAL; 43800a708f8fSGustavo F. Padovan 43814b51dae9SMat Martineau switch (control->sar) { 43827e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_UNSEGMENTED: 438384084a31SMat Martineau if (chan->sdu) 438484084a31SMat Martineau break; 43850a708f8fSGustavo F. Padovan 438680b98027SGustavo Padovan err = chan->ops->recv(chan, skb); 438784084a31SMat Martineau break; 43880a708f8fSGustavo F. Padovan 43897e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_START: 439084084a31SMat Martineau if (chan->sdu) 439184084a31SMat Martineau break; 43920a708f8fSGustavo F. Padovan 43936f61fd47SGustavo F. Padovan chan->sdu_len = get_unaligned_le16(skb->data); 439403a51213SAndrei Emeltchenko skb_pull(skb, L2CAP_SDULEN_SIZE); 43950a708f8fSGustavo F. Padovan 439684084a31SMat Martineau if (chan->sdu_len > chan->imtu) { 439784084a31SMat Martineau err = -EMSGSIZE; 439884084a31SMat Martineau break; 439984084a31SMat Martineau } 44000a708f8fSGustavo F. Padovan 440184084a31SMat Martineau if (skb->len >= chan->sdu_len) 440284084a31SMat Martineau break; 440384084a31SMat Martineau 440484084a31SMat Martineau chan->sdu = skb; 440584084a31SMat Martineau chan->sdu_last_frag = skb; 440684084a31SMat Martineau 440784084a31SMat Martineau skb = NULL; 440884084a31SMat Martineau err = 0; 44090a708f8fSGustavo F. Padovan break; 44100a708f8fSGustavo F. Padovan 44117e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_CONTINUE: 44126f61fd47SGustavo F. Padovan if (!chan->sdu) 441384084a31SMat Martineau break; 44140a708f8fSGustavo F. Padovan 441584084a31SMat Martineau append_skb_frag(chan->sdu, skb, 441684084a31SMat Martineau &chan->sdu_last_frag); 441784084a31SMat Martineau skb = NULL; 44180a708f8fSGustavo F. Padovan 441984084a31SMat Martineau if (chan->sdu->len >= chan->sdu_len) 442084084a31SMat Martineau break; 44210a708f8fSGustavo F. Padovan 442284084a31SMat Martineau err = 0; 44230a708f8fSGustavo F. Padovan break; 44240a708f8fSGustavo F. Padovan 44257e0ef6eeSAndrei Emeltchenko case L2CAP_SAR_END: 44266f61fd47SGustavo F. Padovan if (!chan->sdu) 442784084a31SMat Martineau break; 44280a708f8fSGustavo F. Padovan 442984084a31SMat Martineau append_skb_frag(chan->sdu, skb, 443084084a31SMat Martineau &chan->sdu_last_frag); 443184084a31SMat Martineau skb = NULL; 44320a708f8fSGustavo F. Padovan 443384084a31SMat Martineau if (chan->sdu->len != chan->sdu_len) 443484084a31SMat Martineau break; 44350a708f8fSGustavo F. Padovan 443680b98027SGustavo Padovan err = chan->ops->recv(chan, chan->sdu); 44370a708f8fSGustavo F. Padovan 443884084a31SMat Martineau if (!err) { 443984084a31SMat Martineau /* Reassembly complete */ 444084084a31SMat Martineau chan->sdu = NULL; 444184084a31SMat Martineau chan->sdu_last_frag = NULL; 444284084a31SMat Martineau chan->sdu_len = 0; 44430a708f8fSGustavo F. Padovan } 44440a708f8fSGustavo F. Padovan break; 44450a708f8fSGustavo F. Padovan } 44460a708f8fSGustavo F. Padovan 444784084a31SMat Martineau if (err) { 44480a708f8fSGustavo F. Padovan kfree_skb(skb); 44496f61fd47SGustavo F. Padovan kfree_skb(chan->sdu); 44506f61fd47SGustavo F. Padovan chan->sdu = NULL; 445184084a31SMat Martineau chan->sdu_last_frag = NULL; 445284084a31SMat Martineau chan->sdu_len = 0; 445384084a31SMat Martineau } 44540a708f8fSGustavo F. Padovan 445584084a31SMat Martineau return err; 44560a708f8fSGustavo F. Padovan } 44570a708f8fSGustavo F. Padovan 4458e328140fSMat Martineau void l2cap_chan_busy(struct l2cap_chan *chan, int busy) 44590a708f8fSGustavo F. Padovan { 446061aa4f5bSMat Martineau u8 event; 446161aa4f5bSMat Martineau 446261aa4f5bSMat Martineau if (chan->mode != L2CAP_MODE_ERTM) 446361aa4f5bSMat Martineau return; 446461aa4f5bSMat Martineau 446561aa4f5bSMat Martineau event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR; 4466401bb1f7SAndrei Emeltchenko l2cap_tx(chan, NULL, NULL, event); 44670a708f8fSGustavo F. Padovan } 44680a708f8fSGustavo F. Padovan 4469d2a7ac5dSMat Martineau static int l2cap_rx_queued_iframes(struct l2cap_chan *chan) 4470d2a7ac5dSMat Martineau { 447163838725SMat Martineau int err = 0; 447263838725SMat Martineau /* Pass sequential frames to l2cap_reassemble_sdu() 447363838725SMat Martineau * until a gap is encountered. 447463838725SMat Martineau */ 447563838725SMat Martineau 447663838725SMat Martineau BT_DBG("chan %p", chan); 447763838725SMat Martineau 447863838725SMat Martineau while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 447963838725SMat Martineau struct sk_buff *skb; 448063838725SMat Martineau BT_DBG("Searching for skb with txseq %d (queue len %d)", 448163838725SMat Martineau chan->buffer_seq, skb_queue_len(&chan->srej_q)); 448263838725SMat Martineau 448363838725SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq); 448463838725SMat Martineau 448563838725SMat Martineau if (!skb) 448663838725SMat Martineau break; 448763838725SMat Martineau 448863838725SMat Martineau skb_unlink(skb, &chan->srej_q); 448963838725SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 449063838725SMat Martineau err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->control); 449163838725SMat Martineau if (err) 449263838725SMat Martineau break; 449363838725SMat Martineau } 449463838725SMat Martineau 449563838725SMat Martineau if (skb_queue_empty(&chan->srej_q)) { 449663838725SMat Martineau chan->rx_state = L2CAP_RX_STATE_RECV; 449763838725SMat Martineau l2cap_send_ack(chan); 449863838725SMat Martineau } 449963838725SMat Martineau 450063838725SMat Martineau return err; 4501d2a7ac5dSMat Martineau } 4502d2a7ac5dSMat Martineau 4503d2a7ac5dSMat Martineau static void l2cap_handle_srej(struct l2cap_chan *chan, 4504d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4505d2a7ac5dSMat Martineau { 4506f80842a8SMat Martineau struct sk_buff *skb; 4507f80842a8SMat Martineau 4508f80842a8SMat Martineau BT_DBG("chan %p, control %p", chan, control); 4509f80842a8SMat Martineau 4510f80842a8SMat Martineau if (control->reqseq == chan->next_tx_seq) { 4511f80842a8SMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4512f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4513f80842a8SMat Martineau return; 4514f80842a8SMat Martineau } 4515f80842a8SMat Martineau 4516f80842a8SMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4517f80842a8SMat Martineau 4518f80842a8SMat Martineau if (skb == NULL) { 4519f80842a8SMat Martineau BT_DBG("Seq %d not available for retransmission", 4520f80842a8SMat Martineau control->reqseq); 4521f80842a8SMat Martineau return; 4522f80842a8SMat Martineau } 4523f80842a8SMat Martineau 4524f80842a8SMat Martineau if (chan->max_tx != 0 && bt_cb(skb)->control.retries >= chan->max_tx) { 4525f80842a8SMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4526f80842a8SMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4527f80842a8SMat Martineau return; 4528f80842a8SMat Martineau } 4529f80842a8SMat Martineau 4530f80842a8SMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4531f80842a8SMat Martineau 4532f80842a8SMat Martineau if (control->poll) { 4533f80842a8SMat Martineau l2cap_pass_to_tx(chan, control); 4534f80842a8SMat Martineau 4535f80842a8SMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4536f80842a8SMat Martineau l2cap_retransmit(chan, control); 4537f80842a8SMat Martineau l2cap_ertm_send(chan); 4538f80842a8SMat Martineau 4539f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4540f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4541f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4542f80842a8SMat Martineau } 4543f80842a8SMat Martineau } else { 4544f80842a8SMat Martineau l2cap_pass_to_tx_fbit(chan, control); 4545f80842a8SMat Martineau 4546f80842a8SMat Martineau if (control->final) { 4547f80842a8SMat Martineau if (chan->srej_save_reqseq != control->reqseq || 4548f80842a8SMat Martineau !test_and_clear_bit(CONN_SREJ_ACT, 4549f80842a8SMat Martineau &chan->conn_state)) 4550f80842a8SMat Martineau l2cap_retransmit(chan, control); 4551f80842a8SMat Martineau } else { 4552f80842a8SMat Martineau l2cap_retransmit(chan, control); 4553f80842a8SMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) { 4554f80842a8SMat Martineau set_bit(CONN_SREJ_ACT, &chan->conn_state); 4555f80842a8SMat Martineau chan->srej_save_reqseq = control->reqseq; 4556f80842a8SMat Martineau } 4557f80842a8SMat Martineau } 4558f80842a8SMat Martineau } 4559d2a7ac5dSMat Martineau } 4560d2a7ac5dSMat Martineau 4561d2a7ac5dSMat Martineau static void l2cap_handle_rej(struct l2cap_chan *chan, 4562d2a7ac5dSMat Martineau struct l2cap_ctrl *control) 4563d2a7ac5dSMat Martineau { 4564fcd289dfSMat Martineau struct sk_buff *skb; 4565fcd289dfSMat Martineau 4566fcd289dfSMat Martineau BT_DBG("chan %p, control %p", chan, control); 4567fcd289dfSMat Martineau 4568fcd289dfSMat Martineau if (control->reqseq == chan->next_tx_seq) { 4569fcd289dfSMat Martineau BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq); 4570fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4571fcd289dfSMat Martineau return; 4572fcd289dfSMat Martineau } 4573fcd289dfSMat Martineau 4574fcd289dfSMat Martineau skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq); 4575fcd289dfSMat Martineau 4576fcd289dfSMat Martineau if (chan->max_tx && skb && 4577fcd289dfSMat Martineau bt_cb(skb)->control.retries >= chan->max_tx) { 4578fcd289dfSMat Martineau BT_DBG("Retry limit exceeded (%d)", chan->max_tx); 4579fcd289dfSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4580fcd289dfSMat Martineau return; 4581fcd289dfSMat Martineau } 4582fcd289dfSMat Martineau 4583fcd289dfSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4584fcd289dfSMat Martineau 4585fcd289dfSMat Martineau l2cap_pass_to_tx(chan, control); 4586fcd289dfSMat Martineau 4587fcd289dfSMat Martineau if (control->final) { 4588fcd289dfSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state)) 4589fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4590fcd289dfSMat Martineau } else { 4591fcd289dfSMat Martineau l2cap_retransmit_all(chan, control); 4592fcd289dfSMat Martineau l2cap_ertm_send(chan); 4593fcd289dfSMat Martineau if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) 4594fcd289dfSMat Martineau set_bit(CONN_REJ_ACT, &chan->conn_state); 4595fcd289dfSMat Martineau } 4596d2a7ac5dSMat Martineau } 4597d2a7ac5dSMat Martineau 45984b51dae9SMat Martineau static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq) 45994b51dae9SMat Martineau { 46004b51dae9SMat Martineau BT_DBG("chan %p, txseq %d", chan, txseq); 46014b51dae9SMat Martineau 46024b51dae9SMat Martineau BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq, 46034b51dae9SMat Martineau chan->expected_tx_seq); 46044b51dae9SMat Martineau 46054b51dae9SMat Martineau if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) { 46064b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 46074b51dae9SMat Martineau chan->tx_win) { 46084b51dae9SMat Martineau /* See notes below regarding "double poll" and 46094b51dae9SMat Martineau * invalid packets. 46104b51dae9SMat Martineau */ 46114b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 46124b51dae9SMat Martineau BT_DBG("Invalid/Ignore - after SREJ"); 46134b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 46144b51dae9SMat Martineau } else { 46154b51dae9SMat Martineau BT_DBG("Invalid - in window after SREJ sent"); 46164b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46174b51dae9SMat Martineau } 46184b51dae9SMat Martineau } 46194b51dae9SMat Martineau 46204b51dae9SMat Martineau if (chan->srej_list.head == txseq) { 46214b51dae9SMat Martineau BT_DBG("Expected SREJ"); 46224b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED_SREJ; 46234b51dae9SMat Martineau } 46244b51dae9SMat Martineau 46254b51dae9SMat Martineau if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) { 46264b51dae9SMat Martineau BT_DBG("Duplicate SREJ - txseq already stored"); 46274b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE_SREJ; 46284b51dae9SMat Martineau } 46294b51dae9SMat Martineau 46304b51dae9SMat Martineau if (l2cap_seq_list_contains(&chan->srej_list, txseq)) { 46314b51dae9SMat Martineau BT_DBG("Unexpected SREJ - not requested"); 46324b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED_SREJ; 46334b51dae9SMat Martineau } 46344b51dae9SMat Martineau } 46354b51dae9SMat Martineau 46364b51dae9SMat Martineau if (chan->expected_tx_seq == txseq) { 46374b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= 46384b51dae9SMat Martineau chan->tx_win) { 46394b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46404b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46414b51dae9SMat Martineau } else { 46424b51dae9SMat Martineau BT_DBG("Expected"); 46434b51dae9SMat Martineau return L2CAP_TXSEQ_EXPECTED; 46444b51dae9SMat Martineau } 46454b51dae9SMat Martineau } 46464b51dae9SMat Martineau 46474b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) < 46484b51dae9SMat Martineau __seq_offset(chan, chan->expected_tx_seq, 46494b51dae9SMat Martineau chan->last_acked_seq)){ 46504b51dae9SMat Martineau BT_DBG("Duplicate - expected_tx_seq later than txseq"); 46514b51dae9SMat Martineau return L2CAP_TXSEQ_DUPLICATE; 46524b51dae9SMat Martineau } 46534b51dae9SMat Martineau 46544b51dae9SMat Martineau if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) { 46554b51dae9SMat Martineau /* A source of invalid packets is a "double poll" condition, 46564b51dae9SMat Martineau * where delays cause us to send multiple poll packets. If 46574b51dae9SMat Martineau * the remote stack receives and processes both polls, 46584b51dae9SMat Martineau * sequence numbers can wrap around in such a way that a 46594b51dae9SMat Martineau * resent frame has a sequence number that looks like new data 46604b51dae9SMat Martineau * with a sequence gap. This would trigger an erroneous SREJ 46614b51dae9SMat Martineau * request. 46624b51dae9SMat Martineau * 46634b51dae9SMat Martineau * Fortunately, this is impossible with a tx window that's 46644b51dae9SMat Martineau * less than half of the maximum sequence number, which allows 46654b51dae9SMat Martineau * invalid frames to be safely ignored. 46664b51dae9SMat Martineau * 46674b51dae9SMat Martineau * With tx window sizes greater than half of the tx window 46684b51dae9SMat Martineau * maximum, the frame is invalid and cannot be ignored. This 46694b51dae9SMat Martineau * causes a disconnect. 46704b51dae9SMat Martineau */ 46714b51dae9SMat Martineau 46724b51dae9SMat Martineau if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) { 46734b51dae9SMat Martineau BT_DBG("Invalid/Ignore - txseq outside tx window"); 46744b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID_IGNORE; 46754b51dae9SMat Martineau } else { 46764b51dae9SMat Martineau BT_DBG("Invalid - txseq outside tx window"); 46774b51dae9SMat Martineau return L2CAP_TXSEQ_INVALID; 46784b51dae9SMat Martineau } 46794b51dae9SMat Martineau } else { 46804b51dae9SMat Martineau BT_DBG("Unexpected - txseq indicates missing frames"); 46814b51dae9SMat Martineau return L2CAP_TXSEQ_UNEXPECTED; 46824b51dae9SMat Martineau } 46834b51dae9SMat Martineau } 46844b51dae9SMat Martineau 4685d2a7ac5dSMat Martineau static int l2cap_rx_state_recv(struct l2cap_chan *chan, 4686d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4687d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4688d2a7ac5dSMat Martineau { 4689d2a7ac5dSMat Martineau int err = 0; 4690d2a7ac5dSMat Martineau bool skb_in_use = 0; 4691d2a7ac5dSMat Martineau 4692d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4693d2a7ac5dSMat Martineau event); 4694d2a7ac5dSMat Martineau 4695d2a7ac5dSMat Martineau switch (event) { 4696d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4697d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, control->txseq)) { 4698d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4699d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4700d2a7ac5dSMat Martineau 4701d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4702d2a7ac5dSMat Martineau BT_DBG("Busy, discarding expected seq %d", 4703d2a7ac5dSMat Martineau control->txseq); 4704d2a7ac5dSMat Martineau break; 4705d2a7ac5dSMat Martineau } 4706d2a7ac5dSMat Martineau 4707d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, 4708d2a7ac5dSMat Martineau control->txseq); 4709d2a7ac5dSMat Martineau 4710d2a7ac5dSMat Martineau chan->buffer_seq = chan->expected_tx_seq; 4711d2a7ac5dSMat Martineau skb_in_use = 1; 4712d2a7ac5dSMat Martineau 4713d2a7ac5dSMat Martineau err = l2cap_reassemble_sdu(chan, skb, control); 4714d2a7ac5dSMat Martineau if (err) 4715d2a7ac5dSMat Martineau break; 4716d2a7ac5dSMat Martineau 4717d2a7ac5dSMat Martineau if (control->final) { 4718d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4719d2a7ac5dSMat Martineau &chan->conn_state)) { 4720d2a7ac5dSMat Martineau control->final = 0; 4721d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4722d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4723d2a7ac5dSMat Martineau } 4724d2a7ac5dSMat Martineau } 4725d2a7ac5dSMat Martineau 4726d2a7ac5dSMat Martineau if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) 4727d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4728d2a7ac5dSMat Martineau break; 4729d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4730d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4731d2a7ac5dSMat Martineau 4732d2a7ac5dSMat Martineau /* Can't issue SREJ frames in the local busy state. 4733d2a7ac5dSMat Martineau * Drop this frame, it will be seen as missing 4734d2a7ac5dSMat Martineau * when local busy is exited. 4735d2a7ac5dSMat Martineau */ 4736d2a7ac5dSMat Martineau if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) { 4737d2a7ac5dSMat Martineau BT_DBG("Busy, discarding unexpected seq %d", 4738d2a7ac5dSMat Martineau control->txseq); 4739d2a7ac5dSMat Martineau break; 4740d2a7ac5dSMat Martineau } 4741d2a7ac5dSMat Martineau 4742d2a7ac5dSMat Martineau /* There was a gap in the sequence, so an SREJ 4743d2a7ac5dSMat Martineau * must be sent for each missing frame. The 4744d2a7ac5dSMat Martineau * current frame is stored for later use. 4745d2a7ac5dSMat Martineau */ 4746d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4747d2a7ac5dSMat Martineau skb_in_use = 1; 4748d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4749d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4750d2a7ac5dSMat Martineau 4751d2a7ac5dSMat Martineau clear_bit(CONN_SREJ_ACT, &chan->conn_state); 4752d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->srej_list); 4753d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4754d2a7ac5dSMat Martineau 4755d2a7ac5dSMat Martineau chan->rx_state = L2CAP_RX_STATE_SREJ_SENT; 4756d2a7ac5dSMat Martineau break; 4757d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4758d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4759d2a7ac5dSMat Martineau break; 4760d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4761d2a7ac5dSMat Martineau break; 4762d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4763d2a7ac5dSMat Martineau default: 4764d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4765d2a7ac5dSMat Martineau ECONNRESET); 4766d2a7ac5dSMat Martineau break; 4767d2a7ac5dSMat Martineau } 4768d2a7ac5dSMat Martineau break; 4769d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4770d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4771d2a7ac5dSMat Martineau if (control->final) { 4772d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4773d2a7ac5dSMat Martineau 4774d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4775d2a7ac5dSMat Martineau &chan->conn_state)) { 4776d2a7ac5dSMat Martineau control->final = 0; 4777d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4778d2a7ac5dSMat Martineau } 4779d2a7ac5dSMat Martineau 4780d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4781d2a7ac5dSMat Martineau } else if (control->poll) { 4782d2a7ac5dSMat Martineau l2cap_send_i_or_rr_or_rnr(chan); 4783d2a7ac5dSMat Martineau } else { 4784d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4785d2a7ac5dSMat Martineau &chan->conn_state) && 4786d2a7ac5dSMat Martineau chan->unacked_frames) 4787d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4788d2a7ac5dSMat Martineau 4789d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4790d2a7ac5dSMat Martineau } 4791d2a7ac5dSMat Martineau break; 4792d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4793d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4794d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4795d2a7ac5dSMat Martineau if (control && control->poll) { 4796d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4797d2a7ac5dSMat Martineau l2cap_send_rr_or_rnr(chan, 0); 4798d2a7ac5dSMat Martineau } 4799d2a7ac5dSMat Martineau __clear_retrans_timer(chan); 4800d2a7ac5dSMat Martineau l2cap_seq_list_clear(&chan->retrans_list); 4801d2a7ac5dSMat Martineau break; 4802d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4803d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4804d2a7ac5dSMat Martineau break; 4805d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4806d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4807d2a7ac5dSMat Martineau break; 4808d2a7ac5dSMat Martineau default: 4809d2a7ac5dSMat Martineau break; 4810d2a7ac5dSMat Martineau } 4811d2a7ac5dSMat Martineau 4812d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4813d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4814d2a7ac5dSMat Martineau kfree_skb(skb); 4815d2a7ac5dSMat Martineau } 4816d2a7ac5dSMat Martineau 4817d2a7ac5dSMat Martineau return err; 4818d2a7ac5dSMat Martineau } 4819d2a7ac5dSMat Martineau 4820d2a7ac5dSMat Martineau static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan, 4821d2a7ac5dSMat Martineau struct l2cap_ctrl *control, 4822d2a7ac5dSMat Martineau struct sk_buff *skb, u8 event) 4823d2a7ac5dSMat Martineau { 4824d2a7ac5dSMat Martineau int err = 0; 4825d2a7ac5dSMat Martineau u16 txseq = control->txseq; 4826d2a7ac5dSMat Martineau bool skb_in_use = 0; 4827d2a7ac5dSMat Martineau 4828d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb, 4829d2a7ac5dSMat Martineau event); 4830d2a7ac5dSMat Martineau 4831d2a7ac5dSMat Martineau switch (event) { 4832d2a7ac5dSMat Martineau case L2CAP_EV_RECV_IFRAME: 4833d2a7ac5dSMat Martineau switch (l2cap_classify_txseq(chan, txseq)) { 4834d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED: 4835d2a7ac5dSMat Martineau /* Keep frame for reassembly later */ 4836d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4837d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4838d2a7ac5dSMat Martineau skb_in_use = 1; 4839d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4840d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4841d2a7ac5dSMat Martineau 4842d2a7ac5dSMat Martineau chan->expected_tx_seq = __next_seq(chan, txseq); 4843d2a7ac5dSMat Martineau break; 4844d2a7ac5dSMat Martineau case L2CAP_TXSEQ_EXPECTED_SREJ: 4845d2a7ac5dSMat Martineau l2cap_seq_list_pop(&chan->srej_list); 4846d2a7ac5dSMat Martineau 4847d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4848d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4849d2a7ac5dSMat Martineau skb_in_use = 1; 4850d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4851d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4852d2a7ac5dSMat Martineau 4853d2a7ac5dSMat Martineau err = l2cap_rx_queued_iframes(chan); 4854d2a7ac5dSMat Martineau if (err) 4855d2a7ac5dSMat Martineau break; 4856d2a7ac5dSMat Martineau 4857d2a7ac5dSMat Martineau break; 4858d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED: 4859d2a7ac5dSMat Martineau /* Got a frame that can't be reassembled yet. 4860d2a7ac5dSMat Martineau * Save it for later, and send SREJs to cover 4861d2a7ac5dSMat Martineau * the missing frames. 4862d2a7ac5dSMat Martineau */ 4863d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4864d2a7ac5dSMat Martineau skb_in_use = 1; 4865d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4866d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4867d2a7ac5dSMat Martineau 4868d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4869d2a7ac5dSMat Martineau l2cap_send_srej(chan, control->txseq); 4870d2a7ac5dSMat Martineau break; 4871d2a7ac5dSMat Martineau case L2CAP_TXSEQ_UNEXPECTED_SREJ: 4872d2a7ac5dSMat Martineau /* This frame was requested with an SREJ, but 4873d2a7ac5dSMat Martineau * some expected retransmitted frames are 4874d2a7ac5dSMat Martineau * missing. Request retransmission of missing 4875d2a7ac5dSMat Martineau * SREJ'd frames. 4876d2a7ac5dSMat Martineau */ 4877d2a7ac5dSMat Martineau skb_queue_tail(&chan->srej_q, skb); 4878d2a7ac5dSMat Martineau skb_in_use = 1; 4879d2a7ac5dSMat Martineau BT_DBG("Queued %p (queue len %d)", skb, 4880d2a7ac5dSMat Martineau skb_queue_len(&chan->srej_q)); 4881d2a7ac5dSMat Martineau 4882d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4883d2a7ac5dSMat Martineau l2cap_send_srej_list(chan, control->txseq); 4884d2a7ac5dSMat Martineau break; 4885d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE_SREJ: 4886d2a7ac5dSMat Martineau /* We've already queued this frame. Drop this copy. */ 4887d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4888d2a7ac5dSMat Martineau break; 4889d2a7ac5dSMat Martineau case L2CAP_TXSEQ_DUPLICATE: 4890d2a7ac5dSMat Martineau /* Expecting a later sequence number, so this frame 4891d2a7ac5dSMat Martineau * was already received. Ignore it completely. 4892d2a7ac5dSMat Martineau */ 4893d2a7ac5dSMat Martineau break; 4894d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID_IGNORE: 4895d2a7ac5dSMat Martineau break; 4896d2a7ac5dSMat Martineau case L2CAP_TXSEQ_INVALID: 4897d2a7ac5dSMat Martineau default: 4898d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 4899d2a7ac5dSMat Martineau ECONNRESET); 4900d2a7ac5dSMat Martineau break; 4901d2a7ac5dSMat Martineau } 4902d2a7ac5dSMat Martineau break; 4903d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RR: 4904d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4905d2a7ac5dSMat Martineau if (control->final) { 4906d2a7ac5dSMat Martineau clear_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4907d2a7ac5dSMat Martineau 4908d2a7ac5dSMat Martineau if (!test_and_clear_bit(CONN_REJ_ACT, 4909d2a7ac5dSMat Martineau &chan->conn_state)) { 4910d2a7ac5dSMat Martineau control->final = 0; 4911d2a7ac5dSMat Martineau l2cap_retransmit_all(chan, control); 4912d2a7ac5dSMat Martineau } 4913d2a7ac5dSMat Martineau 4914d2a7ac5dSMat Martineau l2cap_ertm_send(chan); 4915d2a7ac5dSMat Martineau } else if (control->poll) { 4916d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4917d2a7ac5dSMat Martineau &chan->conn_state) && 4918d2a7ac5dSMat Martineau chan->unacked_frames) { 4919d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4920d2a7ac5dSMat Martineau } 4921d2a7ac5dSMat Martineau 4922d2a7ac5dSMat Martineau set_bit(CONN_SEND_FBIT, &chan->conn_state); 4923d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4924d2a7ac5dSMat Martineau } else { 4925d2a7ac5dSMat Martineau if (test_and_clear_bit(CONN_REMOTE_BUSY, 4926d2a7ac5dSMat Martineau &chan->conn_state) && 4927d2a7ac5dSMat Martineau chan->unacked_frames) 4928d2a7ac5dSMat Martineau __set_retrans_timer(chan); 4929d2a7ac5dSMat Martineau 4930d2a7ac5dSMat Martineau l2cap_send_ack(chan); 4931d2a7ac5dSMat Martineau } 4932d2a7ac5dSMat Martineau break; 4933d2a7ac5dSMat Martineau case L2CAP_EV_RECV_RNR: 4934d2a7ac5dSMat Martineau set_bit(CONN_REMOTE_BUSY, &chan->conn_state); 4935d2a7ac5dSMat Martineau l2cap_pass_to_tx(chan, control); 4936d2a7ac5dSMat Martineau if (control->poll) { 4937d2a7ac5dSMat Martineau l2cap_send_srej_tail(chan); 4938d2a7ac5dSMat Martineau } else { 4939d2a7ac5dSMat Martineau struct l2cap_ctrl rr_control; 4940d2a7ac5dSMat Martineau memset(&rr_control, 0, sizeof(rr_control)); 4941d2a7ac5dSMat Martineau rr_control.sframe = 1; 4942d2a7ac5dSMat Martineau rr_control.super = L2CAP_SUPER_RR; 4943d2a7ac5dSMat Martineau rr_control.reqseq = chan->buffer_seq; 4944d2a7ac5dSMat Martineau l2cap_send_sframe(chan, &rr_control); 4945d2a7ac5dSMat Martineau } 4946d2a7ac5dSMat Martineau 4947d2a7ac5dSMat Martineau break; 4948d2a7ac5dSMat Martineau case L2CAP_EV_RECV_REJ: 4949d2a7ac5dSMat Martineau l2cap_handle_rej(chan, control); 4950d2a7ac5dSMat Martineau break; 4951d2a7ac5dSMat Martineau case L2CAP_EV_RECV_SREJ: 4952d2a7ac5dSMat Martineau l2cap_handle_srej(chan, control); 4953d2a7ac5dSMat Martineau break; 4954d2a7ac5dSMat Martineau } 4955d2a7ac5dSMat Martineau 4956d2a7ac5dSMat Martineau if (skb && !skb_in_use) { 4957d2a7ac5dSMat Martineau BT_DBG("Freeing %p", skb); 4958d2a7ac5dSMat Martineau kfree_skb(skb); 4959d2a7ac5dSMat Martineau } 4960d2a7ac5dSMat Martineau 4961d2a7ac5dSMat Martineau return err; 4962d2a7ac5dSMat Martineau } 4963d2a7ac5dSMat Martineau 4964d2a7ac5dSMat Martineau static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq) 4965d2a7ac5dSMat Martineau { 4966d2a7ac5dSMat Martineau /* Make sure reqseq is for a packet that has been sent but not acked */ 4967d2a7ac5dSMat Martineau u16 unacked; 4968d2a7ac5dSMat Martineau 4969d2a7ac5dSMat Martineau unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq); 4970d2a7ac5dSMat Martineau return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked; 4971d2a7ac5dSMat Martineau } 4972d2a7ac5dSMat Martineau 4973cec8ab6eSMat Martineau static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 4974cec8ab6eSMat Martineau struct sk_buff *skb, u8 event) 49750a708f8fSGustavo F. Padovan { 4976d2a7ac5dSMat Martineau int err = 0; 4977d2a7ac5dSMat Martineau 4978d2a7ac5dSMat Martineau BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan, 4979d2a7ac5dSMat Martineau control, skb, event, chan->rx_state); 4980d2a7ac5dSMat Martineau 4981d2a7ac5dSMat Martineau if (__valid_reqseq(chan, control->reqseq)) { 4982d2a7ac5dSMat Martineau switch (chan->rx_state) { 4983d2a7ac5dSMat Martineau case L2CAP_RX_STATE_RECV: 4984d2a7ac5dSMat Martineau err = l2cap_rx_state_recv(chan, control, skb, event); 4985d2a7ac5dSMat Martineau break; 4986d2a7ac5dSMat Martineau case L2CAP_RX_STATE_SREJ_SENT: 4987d2a7ac5dSMat Martineau err = l2cap_rx_state_srej_sent(chan, control, skb, 4988d2a7ac5dSMat Martineau event); 4989d2a7ac5dSMat Martineau break; 4990d2a7ac5dSMat Martineau default: 4991d2a7ac5dSMat Martineau /* shut it down */ 4992d2a7ac5dSMat Martineau break; 4993d2a7ac5dSMat Martineau } 4994d2a7ac5dSMat Martineau } else { 4995d2a7ac5dSMat Martineau BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d", 4996d2a7ac5dSMat Martineau control->reqseq, chan->next_tx_seq, 4997d2a7ac5dSMat Martineau chan->expected_ack_seq); 4998d2a7ac5dSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 4999d2a7ac5dSMat Martineau } 5000d2a7ac5dSMat Martineau 5001d2a7ac5dSMat Martineau return err; 5002cec8ab6eSMat Martineau } 5003cec8ab6eSMat Martineau 5004cec8ab6eSMat Martineau static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control, 5005cec8ab6eSMat Martineau struct sk_buff *skb) 5006cec8ab6eSMat Martineau { 50074b51dae9SMat Martineau int err = 0; 50084b51dae9SMat Martineau 50094b51dae9SMat Martineau BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb, 50104b51dae9SMat Martineau chan->rx_state); 50114b51dae9SMat Martineau 50124b51dae9SMat Martineau if (l2cap_classify_txseq(chan, control->txseq) == 50134b51dae9SMat Martineau L2CAP_TXSEQ_EXPECTED) { 50144b51dae9SMat Martineau l2cap_pass_to_tx(chan, control); 50154b51dae9SMat Martineau 50164b51dae9SMat Martineau BT_DBG("buffer_seq %d->%d", chan->buffer_seq, 50174b51dae9SMat Martineau __next_seq(chan, chan->buffer_seq)); 50184b51dae9SMat Martineau 50194b51dae9SMat Martineau chan->buffer_seq = __next_seq(chan, chan->buffer_seq); 50204b51dae9SMat Martineau 50214b51dae9SMat Martineau l2cap_reassemble_sdu(chan, skb, control); 50224b51dae9SMat Martineau } else { 50234b51dae9SMat Martineau if (chan->sdu) { 50244b51dae9SMat Martineau kfree_skb(chan->sdu); 50254b51dae9SMat Martineau chan->sdu = NULL; 50264b51dae9SMat Martineau } 50274b51dae9SMat Martineau chan->sdu_last_frag = NULL; 50284b51dae9SMat Martineau chan->sdu_len = 0; 50294b51dae9SMat Martineau 50304b51dae9SMat Martineau if (skb) { 50314b51dae9SMat Martineau BT_DBG("Freeing %p", skb); 50324b51dae9SMat Martineau kfree_skb(skb); 50334b51dae9SMat Martineau } 50344b51dae9SMat Martineau } 50354b51dae9SMat Martineau 50364b51dae9SMat Martineau chan->last_acked_seq = control->txseq; 50374b51dae9SMat Martineau chan->expected_tx_seq = __next_seq(chan, control->txseq); 50384b51dae9SMat Martineau 50394b51dae9SMat Martineau return err; 5040cec8ab6eSMat Martineau } 5041cec8ab6eSMat Martineau 5042cec8ab6eSMat Martineau static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb) 5043cec8ab6eSMat Martineau { 5044cec8ab6eSMat Martineau struct l2cap_ctrl *control = &bt_cb(skb)->control; 5045cec8ab6eSMat Martineau u16 len; 5046cec8ab6eSMat Martineau u8 event; 50470a708f8fSGustavo F. Padovan 5048b76bbd66SMat Martineau __unpack_control(chan, skb); 5049b76bbd66SMat Martineau 50500a708f8fSGustavo F. Padovan len = skb->len; 50510a708f8fSGustavo F. Padovan 50520a708f8fSGustavo F. Padovan /* 50530a708f8fSGustavo F. Padovan * We can just drop the corrupted I-frame here. 50540a708f8fSGustavo F. Padovan * Receiver will miss it and start proper recovery 5055cec8ab6eSMat Martineau * procedures and ask for retransmission. 50560a708f8fSGustavo F. Padovan */ 505747d1ec61SGustavo F. Padovan if (l2cap_check_fcs(chan, skb)) 50580a708f8fSGustavo F. Padovan goto drop; 50590a708f8fSGustavo F. Padovan 5060cec8ab6eSMat Martineau if (!control->sframe && control->sar == L2CAP_SAR_START) 506103a51213SAndrei Emeltchenko len -= L2CAP_SDULEN_SIZE; 50620a708f8fSGustavo F. Padovan 506347d1ec61SGustavo F. Padovan if (chan->fcs == L2CAP_FCS_CRC16) 506403a51213SAndrei Emeltchenko len -= L2CAP_FCS_SIZE; 50650a708f8fSGustavo F. Padovan 506647d1ec61SGustavo F. Padovan if (len > chan->mps) { 50678c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 50680a708f8fSGustavo F. Padovan goto drop; 50690a708f8fSGustavo F. Padovan } 50700a708f8fSGustavo F. Padovan 5071cec8ab6eSMat Martineau if (!control->sframe) { 5072cec8ab6eSMat Martineau int err; 50730a708f8fSGustavo F. Padovan 5074cec8ab6eSMat Martineau BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d", 5075cec8ab6eSMat Martineau control->sar, control->reqseq, control->final, 5076cec8ab6eSMat Martineau control->txseq); 5077836be934SAndrei Emeltchenko 5078cec8ab6eSMat Martineau /* Validate F-bit - F=0 always valid, F=1 only 5079cec8ab6eSMat Martineau * valid in TX WAIT_F 5080cec8ab6eSMat Martineau */ 5081cec8ab6eSMat Martineau if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F) 50820a708f8fSGustavo F. Padovan goto drop; 50830a708f8fSGustavo F. Padovan 5084cec8ab6eSMat Martineau if (chan->mode != L2CAP_MODE_STREAMING) { 5085cec8ab6eSMat Martineau event = L2CAP_EV_RECV_IFRAME; 5086cec8ab6eSMat Martineau err = l2cap_rx(chan, control, skb, event); 50870a708f8fSGustavo F. Padovan } else { 5088cec8ab6eSMat Martineau err = l2cap_stream_rx(chan, control, skb); 5089cec8ab6eSMat Martineau } 5090cec8ab6eSMat Martineau 5091cec8ab6eSMat Martineau if (err) 5092cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, 5093cec8ab6eSMat Martineau ECONNRESET); 5094cec8ab6eSMat Martineau } else { 5095cec8ab6eSMat Martineau const u8 rx_func_to_event[4] = { 5096cec8ab6eSMat Martineau L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ, 5097cec8ab6eSMat Martineau L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ 5098cec8ab6eSMat Martineau }; 5099cec8ab6eSMat Martineau 5100cec8ab6eSMat Martineau /* Only I-frames are expected in streaming mode */ 5101cec8ab6eSMat Martineau if (chan->mode == L2CAP_MODE_STREAMING) 5102cec8ab6eSMat Martineau goto drop; 5103cec8ab6eSMat Martineau 5104cec8ab6eSMat Martineau BT_DBG("sframe reqseq %d, final %d, poll %d, super %d", 5105cec8ab6eSMat Martineau control->reqseq, control->final, control->poll, 5106cec8ab6eSMat Martineau control->super); 5107cec8ab6eSMat Martineau 51080a708f8fSGustavo F. Padovan if (len != 0) { 51090a708f8fSGustavo F. Padovan BT_ERR("%d", len); 51108c1d787bSGustavo F. Padovan l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51110a708f8fSGustavo F. Padovan goto drop; 51120a708f8fSGustavo F. Padovan } 51130a708f8fSGustavo F. Padovan 5114cec8ab6eSMat Martineau /* Validate F and P bits */ 5115cec8ab6eSMat Martineau if (control->final && (control->poll || 5116cec8ab6eSMat Martineau chan->tx_state != L2CAP_TX_STATE_WAIT_F)) 5117cec8ab6eSMat Martineau goto drop; 5118cec8ab6eSMat Martineau 5119cec8ab6eSMat Martineau event = rx_func_to_event[control->super]; 5120cec8ab6eSMat Martineau if (l2cap_rx(chan, control, skb, event)) 5121cec8ab6eSMat Martineau l2cap_send_disconn_req(chan->conn, chan, ECONNRESET); 51220a708f8fSGustavo F. Padovan } 51230a708f8fSGustavo F. Padovan 51240a708f8fSGustavo F. Padovan return 0; 51250a708f8fSGustavo F. Padovan 51260a708f8fSGustavo F. Padovan drop: 51270a708f8fSGustavo F. Padovan kfree_skb(skb); 51280a708f8fSGustavo F. Padovan return 0; 51290a708f8fSGustavo F. Padovan } 51300a708f8fSGustavo F. Padovan 513113ca56e0SAndrei Emeltchenko static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid, 513213ca56e0SAndrei Emeltchenko struct sk_buff *skb) 51330a708f8fSGustavo F. Padovan { 513448454079SGustavo F. Padovan struct l2cap_chan *chan; 51350a708f8fSGustavo F. Padovan 5136baa7e1faSGustavo F. Padovan chan = l2cap_get_chan_by_scid(conn, cid); 513748454079SGustavo F. Padovan if (!chan) { 513897e8e89dSAndrei Emeltchenko if (cid == L2CAP_CID_A2MP) { 513997e8e89dSAndrei Emeltchenko chan = a2mp_channel_create(conn, skb); 514097e8e89dSAndrei Emeltchenko if (!chan) { 514197e8e89dSAndrei Emeltchenko kfree_skb(skb); 514213ca56e0SAndrei Emeltchenko return; 514397e8e89dSAndrei Emeltchenko } 514497e8e89dSAndrei Emeltchenko 514597e8e89dSAndrei Emeltchenko l2cap_chan_lock(chan); 514697e8e89dSAndrei Emeltchenko } else { 51470a708f8fSGustavo F. Padovan BT_DBG("unknown cid 0x%4.4x", cid); 51486be36555SAndrei Emeltchenko /* Drop packet and return */ 51493379013bSDan Carpenter kfree_skb(skb); 515013ca56e0SAndrei Emeltchenko return; 51510a708f8fSGustavo F. Padovan } 515297e8e89dSAndrei Emeltchenko } 51530a708f8fSGustavo F. Padovan 515449208c9cSGustavo F. Padovan BT_DBG("chan %p, len %d", chan, skb->len); 51550a708f8fSGustavo F. Padovan 515689bc500eSGustavo F. Padovan if (chan->state != BT_CONNECTED) 51570a708f8fSGustavo F. Padovan goto drop; 51580a708f8fSGustavo F. Padovan 51590c1bc5c6SGustavo F. Padovan switch (chan->mode) { 51600a708f8fSGustavo F. Padovan case L2CAP_MODE_BASIC: 51610a708f8fSGustavo F. Padovan /* If socket recv buffers overflows we drop data here 51620a708f8fSGustavo F. Padovan * which is *bad* because L2CAP has to be reliable. 51630a708f8fSGustavo F. Padovan * But we don't have any other choice. L2CAP doesn't 51640a708f8fSGustavo F. Padovan * provide flow control mechanism. */ 51650a708f8fSGustavo F. Padovan 51660c1bc5c6SGustavo F. Padovan if (chan->imtu < skb->len) 51670a708f8fSGustavo F. Padovan goto drop; 51680a708f8fSGustavo F. Padovan 516980b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 51700a708f8fSGustavo F. Padovan goto done; 51710a708f8fSGustavo F. Padovan break; 51720a708f8fSGustavo F. Padovan 51730a708f8fSGustavo F. Padovan case L2CAP_MODE_ERTM: 51740a708f8fSGustavo F. Padovan case L2CAP_MODE_STREAMING: 5175cec8ab6eSMat Martineau l2cap_data_rcv(chan, skb); 51760a708f8fSGustavo F. Padovan goto done; 51770a708f8fSGustavo F. Padovan 51780a708f8fSGustavo F. Padovan default: 51790c1bc5c6SGustavo F. Padovan BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode); 51800a708f8fSGustavo F. Padovan break; 51810a708f8fSGustavo F. Padovan } 51820a708f8fSGustavo F. Padovan 51830a708f8fSGustavo F. Padovan drop: 51840a708f8fSGustavo F. Padovan kfree_skb(skb); 51850a708f8fSGustavo F. Padovan 51860a708f8fSGustavo F. Padovan done: 51876be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 51880a708f8fSGustavo F. Padovan } 51890a708f8fSGustavo F. Padovan 51900a708f8fSGustavo F. Padovan static inline int l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, struct sk_buff *skb) 51910a708f8fSGustavo F. Padovan { 519223691d75SGustavo F. Padovan struct l2cap_chan *chan; 51930a708f8fSGustavo F. Padovan 5194c2287681SIdo Yariv chan = l2cap_global_chan_by_psm(0, psm, conn->src, conn->dst); 519523691d75SGustavo F. Padovan if (!chan) 51960a708f8fSGustavo F. Padovan goto drop; 51970a708f8fSGustavo F. Padovan 51985b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 51990a708f8fSGustavo F. Padovan 520089bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 52010a708f8fSGustavo F. Padovan goto drop; 52020a708f8fSGustavo F. Padovan 5203e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 52040a708f8fSGustavo F. Padovan goto drop; 52050a708f8fSGustavo F. Padovan 520680b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 52075b4cedaaSAndrei Emeltchenko return 0; 52080a708f8fSGustavo F. Padovan 52090a708f8fSGustavo F. Padovan drop: 52100a708f8fSGustavo F. Padovan kfree_skb(skb); 52110a708f8fSGustavo F. Padovan 52120a708f8fSGustavo F. Padovan return 0; 52130a708f8fSGustavo F. Padovan } 52140a708f8fSGustavo F. Padovan 5215d9b88702SAndrei Emeltchenko static inline int l2cap_att_channel(struct l2cap_conn *conn, u16 cid, 5216d9b88702SAndrei Emeltchenko struct sk_buff *skb) 52179f69bda6SGustavo F. Padovan { 521823691d75SGustavo F. Padovan struct l2cap_chan *chan; 52199f69bda6SGustavo F. Padovan 5220c2287681SIdo Yariv chan = l2cap_global_chan_by_scid(0, cid, conn->src, conn->dst); 522123691d75SGustavo F. Padovan if (!chan) 52229f69bda6SGustavo F. Padovan goto drop; 52239f69bda6SGustavo F. Padovan 52245b4cedaaSAndrei Emeltchenko BT_DBG("chan %p, len %d", chan, skb->len); 52259f69bda6SGustavo F. Padovan 522689bc500eSGustavo F. Padovan if (chan->state != BT_BOUND && chan->state != BT_CONNECTED) 52279f69bda6SGustavo F. Padovan goto drop; 52289f69bda6SGustavo F. Padovan 5229e13e21dcSVinicius Costa Gomes if (chan->imtu < skb->len) 52309f69bda6SGustavo F. Padovan goto drop; 52319f69bda6SGustavo F. Padovan 523280b98027SGustavo Padovan if (!chan->ops->recv(chan, skb)) 52335b4cedaaSAndrei Emeltchenko return 0; 52349f69bda6SGustavo F. Padovan 52359f69bda6SGustavo F. Padovan drop: 52369f69bda6SGustavo F. Padovan kfree_skb(skb); 52379f69bda6SGustavo F. Padovan 52389f69bda6SGustavo F. Padovan return 0; 52399f69bda6SGustavo F. Padovan } 52409f69bda6SGustavo F. Padovan 52410a708f8fSGustavo F. Padovan static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) 52420a708f8fSGustavo F. Padovan { 52430a708f8fSGustavo F. Padovan struct l2cap_hdr *lh = (void *) skb->data; 52440a708f8fSGustavo F. Padovan u16 cid, len; 52450a708f8fSGustavo F. Padovan __le16 psm; 52460a708f8fSGustavo F. Padovan 52470a708f8fSGustavo F. Padovan skb_pull(skb, L2CAP_HDR_SIZE); 52480a708f8fSGustavo F. Padovan cid = __le16_to_cpu(lh->cid); 52490a708f8fSGustavo F. Padovan len = __le16_to_cpu(lh->len); 52500a708f8fSGustavo F. Padovan 52510a708f8fSGustavo F. Padovan if (len != skb->len) { 52520a708f8fSGustavo F. Padovan kfree_skb(skb); 52530a708f8fSGustavo F. Padovan return; 52540a708f8fSGustavo F. Padovan } 52550a708f8fSGustavo F. Padovan 52560a708f8fSGustavo F. Padovan BT_DBG("len %d, cid 0x%4.4x", len, cid); 52570a708f8fSGustavo F. Padovan 52580a708f8fSGustavo F. Padovan switch (cid) { 52593300d9a9SClaudio Takahasi case L2CAP_CID_LE_SIGNALING: 52600a708f8fSGustavo F. Padovan case L2CAP_CID_SIGNALING: 52610a708f8fSGustavo F. Padovan l2cap_sig_channel(conn, skb); 52620a708f8fSGustavo F. Padovan break; 52630a708f8fSGustavo F. Padovan 52640a708f8fSGustavo F. Padovan case L2CAP_CID_CONN_LESS: 5265097db76cSAndrei Emeltchenko psm = get_unaligned((__le16 *) skb->data); 52660181a70fSAndrei Emeltchenko skb_pull(skb, L2CAP_PSMLEN_SIZE); 52670a708f8fSGustavo F. Padovan l2cap_conless_channel(conn, psm, skb); 52680a708f8fSGustavo F. Padovan break; 52690a708f8fSGustavo F. Padovan 52709f69bda6SGustavo F. Padovan case L2CAP_CID_LE_DATA: 52719f69bda6SGustavo F. Padovan l2cap_att_channel(conn, cid, skb); 52729f69bda6SGustavo F. Padovan break; 52739f69bda6SGustavo F. Padovan 5274b501d6a1SAnderson Briglia case L2CAP_CID_SMP: 5275b501d6a1SAnderson Briglia if (smp_sig_channel(conn, skb)) 5276b501d6a1SAnderson Briglia l2cap_conn_del(conn->hcon, EACCES); 5277b501d6a1SAnderson Briglia break; 5278b501d6a1SAnderson Briglia 52790a708f8fSGustavo F. Padovan default: 52800a708f8fSGustavo F. Padovan l2cap_data_channel(conn, cid, skb); 52810a708f8fSGustavo F. Padovan break; 52820a708f8fSGustavo F. Padovan } 52830a708f8fSGustavo F. Padovan } 52840a708f8fSGustavo F. Padovan 52850a708f8fSGustavo F. Padovan /* ---- L2CAP interface with lower layer (HCI) ---- */ 52860a708f8fSGustavo F. Padovan 5287686ebf28SUlisses Furquim int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr) 52880a708f8fSGustavo F. Padovan { 52890a708f8fSGustavo F. Padovan int exact = 0, lm1 = 0, lm2 = 0; 529023691d75SGustavo F. Padovan struct l2cap_chan *c; 52910a708f8fSGustavo F. Padovan 52920a708f8fSGustavo F. Padovan BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr)); 52930a708f8fSGustavo F. Padovan 52940a708f8fSGustavo F. Padovan /* Find listening sockets and check their link_mode */ 529523691d75SGustavo F. Padovan read_lock(&chan_list_lock); 529623691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 529723691d75SGustavo F. Padovan struct sock *sk = c->sk; 52984343478fSGustavo F. Padovan 529989bc500eSGustavo F. Padovan if (c->state != BT_LISTEN) 53000a708f8fSGustavo F. Padovan continue; 53010a708f8fSGustavo F. Padovan 53020a708f8fSGustavo F. Padovan if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) { 53030a708f8fSGustavo F. Padovan lm1 |= HCI_LM_ACCEPT; 530443bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 53050a708f8fSGustavo F. Padovan lm1 |= HCI_LM_MASTER; 53060a708f8fSGustavo F. Padovan exact++; 53070a708f8fSGustavo F. Padovan } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) { 53080a708f8fSGustavo F. Padovan lm2 |= HCI_LM_ACCEPT; 530943bd0f32SAndrei Emeltchenko if (test_bit(FLAG_ROLE_SWITCH, &c->flags)) 53100a708f8fSGustavo F. Padovan lm2 |= HCI_LM_MASTER; 53110a708f8fSGustavo F. Padovan } 53120a708f8fSGustavo F. Padovan } 531323691d75SGustavo F. Padovan read_unlock(&chan_list_lock); 53140a708f8fSGustavo F. Padovan 53150a708f8fSGustavo F. Padovan return exact ? lm1 : lm2; 53160a708f8fSGustavo F. Padovan } 53170a708f8fSGustavo F. Padovan 5318686ebf28SUlisses Furquim int l2cap_connect_cfm(struct hci_conn *hcon, u8 status) 53190a708f8fSGustavo F. Padovan { 53200a708f8fSGustavo F. Padovan struct l2cap_conn *conn; 53210a708f8fSGustavo F. Padovan 53220a708f8fSGustavo F. Padovan BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status); 53230a708f8fSGustavo F. Padovan 53240a708f8fSGustavo F. Padovan if (!status) { 53250a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, status); 53260a708f8fSGustavo F. Padovan if (conn) 53270a708f8fSGustavo F. Padovan l2cap_conn_ready(conn); 53280a708f8fSGustavo F. Padovan } else 5329e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(status)); 53300a708f8fSGustavo F. Padovan 53310a708f8fSGustavo F. Padovan return 0; 53320a708f8fSGustavo F. Padovan } 53330a708f8fSGustavo F. Padovan 5334686ebf28SUlisses Furquim int l2cap_disconn_ind(struct hci_conn *hcon) 53350a708f8fSGustavo F. Padovan { 53360a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 53370a708f8fSGustavo F. Padovan 53380a708f8fSGustavo F. Padovan BT_DBG("hcon %p", hcon); 53390a708f8fSGustavo F. Padovan 5340686ebf28SUlisses Furquim if (!conn) 53419f5a0d7bSAndrei Emeltchenko return HCI_ERROR_REMOTE_USER_TERM; 53420a708f8fSGustavo F. Padovan return conn->disc_reason; 53430a708f8fSGustavo F. Padovan } 53440a708f8fSGustavo F. Padovan 5345686ebf28SUlisses Furquim int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason) 53460a708f8fSGustavo F. Padovan { 53470a708f8fSGustavo F. Padovan BT_DBG("hcon %p reason %d", hcon, reason); 53480a708f8fSGustavo F. Padovan 5349e175072fSJoe Perches l2cap_conn_del(hcon, bt_to_errno(reason)); 53500a708f8fSGustavo F. Padovan return 0; 53510a708f8fSGustavo F. Padovan } 53520a708f8fSGustavo F. Padovan 53534343478fSGustavo F. Padovan static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt) 53540a708f8fSGustavo F. Padovan { 5355715ec005SGustavo F. Padovan if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) 53560a708f8fSGustavo F. Padovan return; 53570a708f8fSGustavo F. Padovan 53580a708f8fSGustavo F. Padovan if (encrypt == 0x00) { 53594343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) { 5360ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_ENC_TIMEOUT); 53614343478fSGustavo F. Padovan } else if (chan->sec_level == BT_SECURITY_HIGH) 53620f852724SGustavo F. Padovan l2cap_chan_close(chan, ECONNREFUSED); 53630a708f8fSGustavo F. Padovan } else { 53644343478fSGustavo F. Padovan if (chan->sec_level == BT_SECURITY_MEDIUM) 5365c9b66675SGustavo F. Padovan __clear_chan_timer(chan); 53660a708f8fSGustavo F. Padovan } 53670a708f8fSGustavo F. Padovan } 53680a708f8fSGustavo F. Padovan 5369686ebf28SUlisses Furquim int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt) 53700a708f8fSGustavo F. Padovan { 53710a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 537248454079SGustavo F. Padovan struct l2cap_chan *chan; 53730a708f8fSGustavo F. Padovan 53740a708f8fSGustavo F. Padovan if (!conn) 53750a708f8fSGustavo F. Padovan return 0; 53760a708f8fSGustavo F. Padovan 53770a708f8fSGustavo F. Padovan BT_DBG("conn %p", conn); 53780a708f8fSGustavo F. Padovan 5379160dc6acSVinicius Costa Gomes if (hcon->type == LE_LINK) { 538035d4adccSHemant Gupta if (!status && encrypt) 5381160dc6acSVinicius Costa Gomes smp_distribute_keys(conn, 0); 538217cd3f37SUlisses Furquim cancel_delayed_work(&conn->security_timer); 5383160dc6acSVinicius Costa Gomes } 5384160dc6acSVinicius Costa Gomes 53853df91ea2SAndrei Emeltchenko mutex_lock(&conn->chan_lock); 53860a708f8fSGustavo F. Padovan 53873df91ea2SAndrei Emeltchenko list_for_each_entry(chan, &conn->chan_l, list) { 53886be36555SAndrei Emeltchenko l2cap_chan_lock(chan); 53890a708f8fSGustavo F. Padovan 5390f1cb9af5SVinicius Costa Gomes BT_DBG("chan->scid %d", chan->scid); 5391f1cb9af5SVinicius Costa Gomes 5392f1cb9af5SVinicius Costa Gomes if (chan->scid == L2CAP_CID_LE_DATA) { 5393f1cb9af5SVinicius Costa Gomes if (!status && encrypt) { 5394f1cb9af5SVinicius Costa Gomes chan->sec_level = hcon->sec_level; 5395cf4cd009SAndrei Emeltchenko l2cap_chan_ready(chan); 5396f1cb9af5SVinicius Costa Gomes } 5397f1cb9af5SVinicius Costa Gomes 53986be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 5399f1cb9af5SVinicius Costa Gomes continue; 5400f1cb9af5SVinicius Costa Gomes } 5401f1cb9af5SVinicius Costa Gomes 5402c1360a1cSGustavo F. Padovan if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) { 54036be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54040a708f8fSGustavo F. Padovan continue; 54050a708f8fSGustavo F. Padovan } 54060a708f8fSGustavo F. Padovan 540789bc500eSGustavo F. Padovan if (!status && (chan->state == BT_CONNECTED || 540889bc500eSGustavo F. Padovan chan->state == BT_CONFIG)) { 5409a7d7723aSGustavo Padovan struct sock *sk = chan->sk; 5410a7d7723aSGustavo Padovan 5411c5daa683SGustavo Padovan clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags); 5412a7d7723aSGustavo Padovan sk->sk_state_change(sk); 5413a7d7723aSGustavo Padovan 54144343478fSGustavo F. Padovan l2cap_check_encryption(chan, encrypt); 54156be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54160a708f8fSGustavo F. Padovan continue; 54170a708f8fSGustavo F. Padovan } 54180a708f8fSGustavo F. Padovan 541989bc500eSGustavo F. Padovan if (chan->state == BT_CONNECT) { 54200a708f8fSGustavo F. Padovan if (!status) { 54219b27f350SAndrei Emeltchenko l2cap_send_conn_req(chan); 54220a708f8fSGustavo F. Padovan } else { 5423ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 54240a708f8fSGustavo F. Padovan } 542589bc500eSGustavo F. Padovan } else if (chan->state == BT_CONNECT2) { 54266be36555SAndrei Emeltchenko struct sock *sk = chan->sk; 54270a708f8fSGustavo F. Padovan struct l2cap_conn_rsp rsp; 5428df3c3931SJohan Hedberg __u16 res, stat; 54290a708f8fSGustavo F. Padovan 54306be36555SAndrei Emeltchenko lock_sock(sk); 54316be36555SAndrei Emeltchenko 54320a708f8fSGustavo F. Padovan if (!status) { 5433c5daa683SGustavo Padovan if (test_bit(BT_SK_DEFER_SETUP, 5434c5daa683SGustavo Padovan &bt_sk(sk)->flags)) { 5435df3c3931SJohan Hedberg struct sock *parent = bt_sk(sk)->parent; 5436df3c3931SJohan Hedberg res = L2CAP_CR_PEND; 5437df3c3931SJohan Hedberg stat = L2CAP_CS_AUTHOR_PEND; 543805e9a2f6SIlia Kolomisnky if (parent) 5439df3c3931SJohan Hedberg parent->sk_data_ready(parent, 0); 5440df3c3931SJohan Hedberg } else { 54410e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_CONFIG); 5442df3c3931SJohan Hedberg res = L2CAP_CR_SUCCESS; 5443df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 5444df3c3931SJohan Hedberg } 54450a708f8fSGustavo F. Padovan } else { 54460e587be7SAndrei Emeltchenko __l2cap_state_change(chan, BT_DISCONN); 5447ba13ccd9SMarcel Holtmann __set_chan_timer(chan, L2CAP_DISC_TIMEOUT); 5448df3c3931SJohan Hedberg res = L2CAP_CR_SEC_BLOCK; 5449df3c3931SJohan Hedberg stat = L2CAP_CS_NO_INFO; 54500a708f8fSGustavo F. Padovan } 54510a708f8fSGustavo F. Padovan 54526be36555SAndrei Emeltchenko release_sock(sk); 54536be36555SAndrei Emeltchenko 5454fe4128e0SGustavo F. Padovan rsp.scid = cpu_to_le16(chan->dcid); 5455fe4128e0SGustavo F. Padovan rsp.dcid = cpu_to_le16(chan->scid); 5456df3c3931SJohan Hedberg rsp.result = cpu_to_le16(res); 5457df3c3931SJohan Hedberg rsp.status = cpu_to_le16(stat); 5458fc7f8a7eSGustavo F. Padovan l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, 5459fc7f8a7eSGustavo F. Padovan sizeof(rsp), &rsp); 54602d369359SMat Martineau 54612d369359SMat Martineau if (!test_bit(CONF_REQ_SENT, &chan->conf_state) && 54622d369359SMat Martineau res == L2CAP_CR_SUCCESS) { 54632d369359SMat Martineau char buf[128]; 54642d369359SMat Martineau set_bit(CONF_REQ_SENT, &chan->conf_state); 54652d369359SMat Martineau l2cap_send_cmd(conn, l2cap_get_ident(conn), 54662d369359SMat Martineau L2CAP_CONF_REQ, 54672d369359SMat Martineau l2cap_build_conf_req(chan, buf), 54682d369359SMat Martineau buf); 54692d369359SMat Martineau chan->num_conf_req++; 54702d369359SMat Martineau } 54710a708f8fSGustavo F. Padovan } 54720a708f8fSGustavo F. Padovan 54736be36555SAndrei Emeltchenko l2cap_chan_unlock(chan); 54740a708f8fSGustavo F. Padovan } 54750a708f8fSGustavo F. Padovan 54763df91ea2SAndrei Emeltchenko mutex_unlock(&conn->chan_lock); 54770a708f8fSGustavo F. Padovan 54780a708f8fSGustavo F. Padovan return 0; 54790a708f8fSGustavo F. Padovan } 54800a708f8fSGustavo F. Padovan 5481686ebf28SUlisses Furquim int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags) 54820a708f8fSGustavo F. Padovan { 54830a708f8fSGustavo F. Padovan struct l2cap_conn *conn = hcon->l2cap_data; 54840a708f8fSGustavo F. Padovan 54850a708f8fSGustavo F. Padovan if (!conn) 54860a708f8fSGustavo F. Padovan conn = l2cap_conn_add(hcon, 0); 54870a708f8fSGustavo F. Padovan 54880a708f8fSGustavo F. Padovan if (!conn) 54890a708f8fSGustavo F. Padovan goto drop; 54900a708f8fSGustavo F. Padovan 54910a708f8fSGustavo F. Padovan BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags); 54920a708f8fSGustavo F. Padovan 54930a708f8fSGustavo F. Padovan if (!(flags & ACL_CONT)) { 54940a708f8fSGustavo F. Padovan struct l2cap_hdr *hdr; 54950a708f8fSGustavo F. Padovan int len; 54960a708f8fSGustavo F. Padovan 54970a708f8fSGustavo F. Padovan if (conn->rx_len) { 54980a708f8fSGustavo F. Padovan BT_ERR("Unexpected start frame (len %d)", skb->len); 54990a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 55000a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55010a708f8fSGustavo F. Padovan conn->rx_len = 0; 55020a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55030a708f8fSGustavo F. Padovan } 55040a708f8fSGustavo F. Padovan 55050a708f8fSGustavo F. Padovan /* Start fragment always begin with Basic L2CAP header */ 55060a708f8fSGustavo F. Padovan if (skb->len < L2CAP_HDR_SIZE) { 55070a708f8fSGustavo F. Padovan BT_ERR("Frame is too short (len %d)", skb->len); 55080a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55090a708f8fSGustavo F. Padovan goto drop; 55100a708f8fSGustavo F. Padovan } 55110a708f8fSGustavo F. Padovan 55120a708f8fSGustavo F. Padovan hdr = (struct l2cap_hdr *) skb->data; 55130a708f8fSGustavo F. Padovan len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE; 55140a708f8fSGustavo F. Padovan 55150a708f8fSGustavo F. Padovan if (len == skb->len) { 55160a708f8fSGustavo F. Padovan /* Complete frame received */ 55170a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, skb); 55180a708f8fSGustavo F. Padovan return 0; 55190a708f8fSGustavo F. Padovan } 55200a708f8fSGustavo F. Padovan 55210a708f8fSGustavo F. Padovan BT_DBG("Start: total len %d, frag len %d", len, skb->len); 55220a708f8fSGustavo F. Padovan 55230a708f8fSGustavo F. Padovan if (skb->len > len) { 55240a708f8fSGustavo F. Padovan BT_ERR("Frame is too long (len %d, expected len %d)", 55250a708f8fSGustavo F. Padovan skb->len, len); 55260a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55270a708f8fSGustavo F. Padovan goto drop; 55280a708f8fSGustavo F. Padovan } 55290a708f8fSGustavo F. Padovan 55300a708f8fSGustavo F. Padovan /* Allocate skb for the complete frame (with header) */ 55310a708f8fSGustavo F. Padovan conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC); 55320a708f8fSGustavo F. Padovan if (!conn->rx_skb) 55330a708f8fSGustavo F. Padovan goto drop; 55340a708f8fSGustavo F. Padovan 55350a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55360a708f8fSGustavo F. Padovan skb->len); 55370a708f8fSGustavo F. Padovan conn->rx_len = len - skb->len; 55380a708f8fSGustavo F. Padovan } else { 55390a708f8fSGustavo F. Padovan BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len); 55400a708f8fSGustavo F. Padovan 55410a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55420a708f8fSGustavo F. Padovan BT_ERR("Unexpected continuation frame (len %d)", skb->len); 55430a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55440a708f8fSGustavo F. Padovan goto drop; 55450a708f8fSGustavo F. Padovan } 55460a708f8fSGustavo F. Padovan 55470a708f8fSGustavo F. Padovan if (skb->len > conn->rx_len) { 55480a708f8fSGustavo F. Padovan BT_ERR("Fragment is too long (len %d, expected %d)", 55490a708f8fSGustavo F. Padovan skb->len, conn->rx_len); 55500a708f8fSGustavo F. Padovan kfree_skb(conn->rx_skb); 55510a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55520a708f8fSGustavo F. Padovan conn->rx_len = 0; 55530a708f8fSGustavo F. Padovan l2cap_conn_unreliable(conn, ECOMM); 55540a708f8fSGustavo F. Padovan goto drop; 55550a708f8fSGustavo F. Padovan } 55560a708f8fSGustavo F. Padovan 55570a708f8fSGustavo F. Padovan skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len), 55580a708f8fSGustavo F. Padovan skb->len); 55590a708f8fSGustavo F. Padovan conn->rx_len -= skb->len; 55600a708f8fSGustavo F. Padovan 55610a708f8fSGustavo F. Padovan if (!conn->rx_len) { 55620a708f8fSGustavo F. Padovan /* Complete frame received */ 55630a708f8fSGustavo F. Padovan l2cap_recv_frame(conn, conn->rx_skb); 55640a708f8fSGustavo F. Padovan conn->rx_skb = NULL; 55650a708f8fSGustavo F. Padovan } 55660a708f8fSGustavo F. Padovan } 55670a708f8fSGustavo F. Padovan 55680a708f8fSGustavo F. Padovan drop: 55690a708f8fSGustavo F. Padovan kfree_skb(skb); 55700a708f8fSGustavo F. Padovan return 0; 55710a708f8fSGustavo F. Padovan } 55720a708f8fSGustavo F. Padovan 55730a708f8fSGustavo F. Padovan static int l2cap_debugfs_show(struct seq_file *f, void *p) 55740a708f8fSGustavo F. Padovan { 557523691d75SGustavo F. Padovan struct l2cap_chan *c; 55760a708f8fSGustavo F. Padovan 5577333055f2SGustavo F. Padovan read_lock(&chan_list_lock); 55780a708f8fSGustavo F. Padovan 557923691d75SGustavo F. Padovan list_for_each_entry(c, &chan_list, global_l) { 558023691d75SGustavo F. Padovan struct sock *sk = c->sk; 55810a708f8fSGustavo F. Padovan 5582903d343eSGustavo F. Padovan seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n", 55830a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->src), 55840a708f8fSGustavo F. Padovan batostr(&bt_sk(sk)->dst), 558589bc500eSGustavo F. Padovan c->state, __le16_to_cpu(c->psm), 558623691d75SGustavo F. Padovan c->scid, c->dcid, c->imtu, c->omtu, 558723691d75SGustavo F. Padovan c->sec_level, c->mode); 55880a708f8fSGustavo F. Padovan } 55890a708f8fSGustavo F. Padovan 5590333055f2SGustavo F. Padovan read_unlock(&chan_list_lock); 55910a708f8fSGustavo F. Padovan 55920a708f8fSGustavo F. Padovan return 0; 55930a708f8fSGustavo F. Padovan } 55940a708f8fSGustavo F. Padovan 55950a708f8fSGustavo F. Padovan static int l2cap_debugfs_open(struct inode *inode, struct file *file) 55960a708f8fSGustavo F. Padovan { 55970a708f8fSGustavo F. Padovan return single_open(file, l2cap_debugfs_show, inode->i_private); 55980a708f8fSGustavo F. Padovan } 55990a708f8fSGustavo F. Padovan 56000a708f8fSGustavo F. Padovan static const struct file_operations l2cap_debugfs_fops = { 56010a708f8fSGustavo F. Padovan .open = l2cap_debugfs_open, 56020a708f8fSGustavo F. Padovan .read = seq_read, 56030a708f8fSGustavo F. Padovan .llseek = seq_lseek, 56040a708f8fSGustavo F. Padovan .release = single_release, 56050a708f8fSGustavo F. Padovan }; 56060a708f8fSGustavo F. Padovan 56070a708f8fSGustavo F. Padovan static struct dentry *l2cap_debugfs; 56080a708f8fSGustavo F. Padovan 560964274518SGustavo F. Padovan int __init l2cap_init(void) 56100a708f8fSGustavo F. Padovan { 56110a708f8fSGustavo F. Padovan int err; 56120a708f8fSGustavo F. Padovan 5613bb58f747SGustavo F. Padovan err = l2cap_init_sockets(); 56140a708f8fSGustavo F. Padovan if (err < 0) 56150a708f8fSGustavo F. Padovan return err; 56160a708f8fSGustavo F. Padovan 56170a708f8fSGustavo F. Padovan if (bt_debugfs) { 56180a708f8fSGustavo F. Padovan l2cap_debugfs = debugfs_create_file("l2cap", 0444, 56190a708f8fSGustavo F. Padovan bt_debugfs, NULL, &l2cap_debugfs_fops); 56200a708f8fSGustavo F. Padovan if (!l2cap_debugfs) 56210a708f8fSGustavo F. Padovan BT_ERR("Failed to create L2CAP debug file"); 56220a708f8fSGustavo F. Padovan } 56230a708f8fSGustavo F. Padovan 56240a708f8fSGustavo F. Padovan return 0; 56250a708f8fSGustavo F. Padovan } 56260a708f8fSGustavo F. Padovan 562764274518SGustavo F. Padovan void l2cap_exit(void) 56280a708f8fSGustavo F. Padovan { 56290a708f8fSGustavo F. Padovan debugfs_remove(l2cap_debugfs); 5630bb58f747SGustavo F. Padovan l2cap_cleanup_sockets(); 56310a708f8fSGustavo F. Padovan } 56320a708f8fSGustavo F. Padovan 56330a708f8fSGustavo F. Padovan module_param(disable_ertm, bool, 0644); 56340a708f8fSGustavo F. Padovan MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode"); 5635