Lines Matching refs:conn
53 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
55 static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len,
90 static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn,
95 list_for_each_entry(c, &conn->chan_l, list) {
102 static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn,
107 list_for_each_entry(c, &conn->chan_l, list) {
117 static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn,
122 mutex_lock(&conn->chan_lock);
123 c = __l2cap_get_chan_by_scid(conn, cid);
130 mutex_unlock(&conn->chan_lock);
138 static struct l2cap_chan *l2cap_get_chan_by_dcid(struct l2cap_conn *conn,
143 mutex_lock(&conn->chan_lock);
144 c = __l2cap_get_chan_by_dcid(conn, cid);
151 mutex_unlock(&conn->chan_lock);
156 static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn,
161 list_for_each_entry(c, &conn->chan_l, list) {
235 /* Override the defaults (which are for conn-oriented) */
246 static u16 l2cap_alloc_cid(struct l2cap_conn *conn)
250 if (conn->hcon->type == LE_LINK)
256 if (!__l2cap_get_chan_by_scid(conn, cid))
413 struct l2cap_conn *conn = chan->conn;
418 if (!conn)
421 mutex_lock(&conn->chan_lock);
442 mutex_unlock(&conn->chan_lock);
573 chan->mps = min_t(u16, chan->imtu, chan->conn->mtu - L2CAP_HDR_SIZE);
590 void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
592 BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn,
595 conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;
597 chan->conn = conn;
602 chan->scid = l2cap_alloc_cid(conn);
603 if (conn->hcon->type == ACL_LINK)
637 hci_conn_hold(conn->hcon);
639 list_add(&chan->list, &conn->chan_l);
642 void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
644 mutex_lock(&conn->chan_lock);
645 __l2cap_chan_add(conn, chan);
646 mutex_unlock(&conn->chan_lock);
651 struct l2cap_conn *conn = chan->conn;
655 BT_DBG("chan %p, conn %p, err %d, state %s", chan, conn, err,
660 if (conn) {
666 chan->conn = NULL;
674 hci_conn_drop(conn->hcon);
707 static void __l2cap_chan_list_id(struct l2cap_conn *conn, u16 id,
712 list_for_each_entry_safe(chan, l, &conn->chan_l, list) {
718 static void __l2cap_chan_list(struct l2cap_conn *conn, l2cap_chan_func_t func,
723 list_for_each_entry(chan, &conn->chan_l, list) {
728 void l2cap_chan_list(struct l2cap_conn *conn, l2cap_chan_func_t func,
731 if (!conn)
734 mutex_lock(&conn->chan_lock);
735 __l2cap_chan_list(conn, func, data);
736 mutex_unlock(&conn->chan_lock);
743 struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
745 struct hci_conn *hcon = conn->hcon;
748 mutex_lock(&conn->chan_lock);
750 list_for_each_entry(chan, &conn->chan_l, list) {
757 mutex_unlock(&conn->chan_lock);
762 struct l2cap_conn *conn = chan->conn;
779 l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CONN_RSP, sizeof(rsp),
792 struct l2cap_conn *conn = chan->conn;
808 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp);
813 struct l2cap_conn *conn = chan->conn;
833 if (conn->hcon->type == ACL_LINK)
835 else if (conn->hcon->type == LE_LINK) {
917 struct l2cap_conn *conn = chan->conn;
920 if (conn->hcon->type == LE_LINK)
921 return smp_conn_security(conn->hcon, chan->sec_level);
925 return hci_conn_security(conn->hcon, chan->sec_level, auth_type,
929 static u8 l2cap_get_ident(struct l2cap_conn *conn)
939 mutex_lock(&conn->ident_lock);
941 if (++conn->tx_ident > 128)
942 conn->tx_ident = 1;
944 id = conn->tx_ident;
946 mutex_unlock(&conn->ident_lock);
951 static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len,
954 struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
964 if (lmp_no_flush_capable(conn->hcon->hdev) ||
965 conn->hcon->type == LE_LINK)
973 hci_send_acl(conn->hchan, skb, flags);
978 struct hci_conn *hcon = chan->conn->hcon;
996 hci_send_acl(chan->conn->hchan, skb, flags);
1220 struct l2cap_conn *conn = chan->conn;
1226 chan->ident = l2cap_get_ident(conn);
1230 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ, sizeof(req), &req);
1261 struct l2cap_conn *conn = chan->conn;
1268 chan->imtu = chan->conn->mtu;
1279 chan->ident = l2cap_get_ident(conn);
1281 l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CONN_REQ,
1297 struct l2cap_ecred_conn_data *conn = data;
1300 if (chan == conn->chan)
1309 if (conn->pid != pid || chan->psm != conn->chan->psm || chan->ident ||
1319 chan->ident = conn->chan->ident;
1322 conn->pdu.scid[conn->count] = cpu_to_le16(chan->scid);
1324 conn->count++;
1329 struct l2cap_conn *conn = chan->conn;
1347 chan->ident = l2cap_get_ident(conn);
1353 __l2cap_chan_list(conn, l2cap_ecred_defer_connect, &data);
1355 l2cap_send_cmd(conn, chan->ident, L2CAP_ECRED_CONN_REQ,
1362 struct l2cap_conn *conn = chan->conn;
1364 if (!smp_conn_security(conn->hcon, chan->sec_level))
1382 if (chan->conn->hcon->type == LE_LINK) {
1389 static void l2cap_request_info(struct l2cap_conn *conn)
1393 if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)
1398 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
1399 conn->info_ident = l2cap_get_ident(conn);
1401 schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT);
1403 l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ,
1430 struct l2cap_conn *conn = chan->conn;
1432 if (conn->hcon->type == LE_LINK) {
1437 if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)) {
1438 l2cap_request_info(conn);
1442 if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
1449 if (l2cap_check_enc_key_size(conn->hcon))
1473 struct l2cap_conn *conn = chan->conn;
1476 if (!conn)
1487 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_DISCONN_REQ,
1494 static void l2cap_conn_start(struct l2cap_conn *conn)
1498 BT_DBG("conn %p", conn);
1500 mutex_lock(&conn->chan_lock);
1502 list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) {
1518 if (!l2cap_mode_supported(chan->mode, conn->feat_mask)
1526 if (l2cap_check_enc_key_size(conn->hcon))
1553 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
1563 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
1571 mutex_unlock(&conn->chan_lock);
1574 static void l2cap_le_conn_ready(struct l2cap_conn *conn)
1576 struct hci_conn *hcon = conn->hcon;
1579 BT_DBG("%s conn %p", hdev->name, conn);
1602 l2cap_send_cmd(conn, l2cap_get_ident(conn),
1607 static void l2cap_conn_ready(struct l2cap_conn *conn)
1610 struct hci_conn *hcon = conn->hcon;
1612 BT_DBG("conn %p", conn);
1615 l2cap_request_info(conn);
1617 mutex_lock(&conn->chan_lock);
1619 list_for_each_entry(chan, &conn->chan_l, list) {
1626 if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)
1635 mutex_unlock(&conn->chan_lock);
1638 l2cap_le_conn_ready(conn);
1640 queue_work(hcon->hdev->workqueue, &conn->pending_rx_work);
1644 static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err)
1648 BT_DBG("conn %p", conn);
1650 mutex_lock(&conn->chan_lock);
1652 list_for_each_entry(chan, &conn->chan_l, list) {
1657 mutex_unlock(&conn->chan_lock);
1662 struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
1665 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
1666 conn->info_ident = 0;
1668 l2cap_conn_start(conn);
1684 int l2cap_register_user(struct l2cap_conn *conn, struct l2cap_user *user)
1686 struct hci_dev *hdev = conn->hcon->hdev;
1703 /* conn->hchan is NULL after l2cap_conn_del() was called */
1704 if (!conn->hchan) {
1709 ret = user->probe(conn, user);
1713 list_add(&user->list, &conn->users);
1722 void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user)
1724 struct hci_dev *hdev = conn->hcon->hdev;
1732 user->remove(conn, user);
1739 static void l2cap_unregister_all_users(struct l2cap_conn *conn)
1743 while (!list_empty(&conn->users)) {
1744 user = list_first_entry(&conn->users, struct l2cap_user, list);
1746 user->remove(conn, user);
1752 struct l2cap_conn *conn = hcon->l2cap_data;
1755 if (!conn)
1758 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
1760 kfree_skb(conn->rx_skb);
1762 skb_queue_purge(&conn->pending_rx);
1764 /* We can not call flush_work(&conn->pending_rx_work) here since we
1768 if (work_pending(&conn->pending_rx_work))
1769 cancel_work_sync(&conn->pending_rx_work);
1771 cancel_delayed_work_sync(&conn->id_addr_timer);
1773 l2cap_unregister_all_users(conn);
1778 mutex_lock(&conn->chan_lock);
1781 list_for_each_entry_safe(chan, l, &conn->chan_l, list) {
1793 mutex_unlock(&conn->chan_lock);
1795 hci_chan_del(conn->hchan);
1797 if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)
1798 cancel_delayed_work_sync(&conn->info_timer);
1801 conn->hchan = NULL;
1802 l2cap_conn_put(conn);
1807 struct l2cap_conn *conn = container_of(ref, struct l2cap_conn, ref);
1809 hci_conn_put(conn->hcon);
1810 kfree(conn);
1813 struct l2cap_conn *l2cap_conn_get(struct l2cap_conn *conn)
1815 kref_get(&conn->ref);
1816 return conn;
1820 void l2cap_conn_put(struct l2cap_conn *conn)
1822 kref_put(&conn->ref, l2cap_conn_free);
1891 if (!chan->conn) {
1912 if (!chan->conn) {
2201 struct l2cap_conn *conn = chan->conn;
2216 count = min_t(unsigned int, conn->mtu, len);
2244 struct l2cap_conn *conn = chan->conn;
2252 count = min_t(unsigned int, (conn->mtu - hlen), len);
2276 struct l2cap_conn *conn = chan->conn;
2283 count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len);
2307 struct l2cap_conn *conn = chan->conn;
2314 if (!conn)
2325 count = min_t(unsigned int, (conn->mtu - hlen), len);
2374 pdu_len = chan->conn->mtu;
2427 struct l2cap_conn *conn = chan->conn;
2434 if (!conn)
2442 count = min_t(unsigned int, (conn->mtu - hlen), len);
2524 if (!chan->conn)
2912 static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
2917 BT_DBG("conn %p", conn);
2919 mutex_lock(&conn->chan_lock);
2921 list_for_each_entry(chan, &conn->chan_l, list) {
2936 mutex_unlock(&conn->chan_lock);
2940 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code,
2948 BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u",
2949 conn, code, ident, dlen);
2951 if (conn->mtu < L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE)
2955 count = min_t(unsigned int, conn->mtu, len);
2964 if (conn->hcon->type == LE_LINK)
2985 count = min_t(unsigned int, conn->mtu, len);
3173 static inline bool __l2cap_ews_supported(struct l2cap_conn *conn)
3175 return (conn->feat_mask & L2CAP_FEAT_EXT_WINDOW);
3178 static inline bool __l2cap_efs_supported(struct l2cap_conn *conn)
3180 return (conn->feat_mask & L2CAP_FEAT_EXT_FLOW);
3193 __l2cap_ews_supported(chan->conn)) {
3207 struct hci_conn *conn = chan->conn->hcon;
3214 if (!(conn->pkt_type & HCI_2DH1))
3220 if (!(conn->pkt_type & HCI_3DH1))
3226 if (!(conn->pkt_type & HCI_2DH3))
3232 if (!(conn->pkt_type & HCI_3DH3))
3238 if (!(conn->pkt_type & HCI_2DH5))
3244 if (!(conn->pkt_type & HCI_3DH5))
3267 if (__l2cap_efs_supported(chan->conn))
3272 chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask);
3289 if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) &&
3290 !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING))
3310 size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu -
3330 if (chan->conn->feat_mask & L2CAP_FEAT_FCS)
3347 size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu -
3358 if (chan->conn->feat_mask & L2CAP_FEAT_FCS)
3458 chan->conn->feat_mask);
3463 if (__l2cap_efs_supported(chan->conn))
3534 chan->conn->mtu - L2CAP_EXT_HDR_SIZE -
3565 chan->conn->mtu - L2CAP_EXT_HDR_SIZE -
3730 struct l2cap_conn *conn = chan->conn;
3740 l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CONN_RSP, sizeof(rsp),
3794 struct l2cap_conn *conn = chan->conn;
3812 __l2cap_chan_list_id(conn, id, l2cap_ecred_list_defer, &result);
3821 __l2cap_chan_list_id(conn, id, l2cap_ecred_rsp_defer, &data);
3823 l2cap_send_cmd(conn, id, L2CAP_ECRED_CONN_RSP,
3831 struct l2cap_conn *conn = chan->conn;
3843 l2cap_send_cmd(conn, chan->ident, rsp_code, sizeof(rsp), &rsp);
3848 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
3909 static inline int l2cap_command_rej(struct l2cap_conn *conn,
3921 if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) &&
3922 cmd->ident == conn->info_ident) {
3923 cancel_delayed_work(&conn->info_timer);
3925 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
3926 conn->info_ident = 0;
3928 l2cap_conn_start(conn);
3934 static void l2cap_connect(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd,
3948 pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, &conn->hcon->src,
3949 &conn->hcon->dst, ACL_LINK);
3955 mutex_lock(&conn->chan_lock);
3960 !hci_conn_check_link_mode(conn->hcon)) {
3961 conn->disc_reason = HCI_ERROR_AUTH_FAILURE;
3975 if (__l2cap_get_chan_by_dcid(conn, scid)) {
3989 conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT;
3991 bacpy(&chan->src, &conn->hcon->src);
3992 bacpy(&chan->dst, &conn->hcon->dst);
3993 chan->src_type = bdaddr_src_type(conn->hcon);
3994 chan->dst_type = bdaddr_dst_type(conn->hcon);
3998 __l2cap_chan_add(conn, chan);
4006 if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) {
4034 l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp);
4043 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
4044 conn->info_ident = l2cap_get_ident(conn);
4046 schedule_delayed_work(&conn->info_timer, L2CAP_INFO_TIMEOUT);
4048 l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ,
4056 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
4062 mutex_unlock(&conn->chan_lock);
4066 static int l2cap_connect_req(struct l2cap_conn *conn,
4069 struct hci_dev *hdev = conn->hcon->hdev;
4070 struct hci_conn *hcon = conn->hcon;
4080 l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP);
4084 static int l2cap_connect_create_rsp(struct l2cap_conn *conn,
4109 mutex_lock(&conn->chan_lock);
4112 chan = __l2cap_get_chan_by_scid(conn, scid);
4118 chan = __l2cap_get_chan_by_ident(conn, cmd->ident);
4137 if (__l2cap_get_chan_by_dcid(conn, dcid)) {
4150 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
4168 mutex_unlock(&conn->chan_lock);
4187 struct l2cap_conn *conn = chan->conn;
4189 BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident,
4195 l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP,
4200 static void cmd_reject_invalid_cid(struct l2cap_conn *conn, u8 ident,
4209 l2cap_send_cmd(conn, ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej);
4212 static inline int l2cap_config_req(struct l2cap_conn *conn,
4230 chan = l2cap_get_chan_by_scid(conn, dcid);
4232 cmd_reject_invalid_cid(conn, cmd->ident, dcid, 0);
4238 cmd_reject_invalid_cid(conn, cmd->ident, chan->scid,
4246 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
4258 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
4272 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp);
4299 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
4321 static inline int l2cap_config_rsp(struct l2cap_conn *conn,
4341 chan = l2cap_get_chan_by_scid(conn, scid);
4387 l2cap_send_cmd(conn, l2cap_get_ident(conn),
4428 static inline int l2cap_disconnect_req(struct l2cap_conn *conn,
4445 chan = l2cap_get_chan_by_scid(conn, dcid);
4447 cmd_reject_invalid_cid(conn, cmd->ident, dcid, scid);
4453 l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
4458 mutex_lock(&conn->chan_lock);
4461 mutex_unlock(&conn->chan_lock);
4471 static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn,
4487 chan = l2cap_get_chan_by_scid(conn, scid);
4499 mutex_lock(&conn->chan_lock);
4502 mutex_unlock(&conn->chan_lock);
4512 static inline int l2cap_information_req(struct l2cap_conn *conn,
4537 l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf),
4545 rsp->data[0] = conn->local_fixed_chan;
4547 l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf),
4553 l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp),
4560 static inline int l2cap_information_rsp(struct l2cap_conn *conn,
4576 if (cmd->ident != conn->info_ident ||
4577 conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)
4580 cancel_delayed_work(&conn->info_timer);
4583 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
4584 conn->info_ident = 0;
4586 l2cap_conn_start(conn);
4593 conn->feat_mask = get_unaligned_le32(rsp->data);
4595 if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) {
4599 conn->info_ident = l2cap_get_ident(conn);
4601 l2cap_send_cmd(conn, conn->info_ident,
4604 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
4605 conn->info_ident = 0;
4607 l2cap_conn_start(conn);
4612 conn->remote_fixed_chan = rsp->data[0];
4613 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
4614 conn->info_ident = 0;
4616 l2cap_conn_start(conn);
4623 static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn,
4627 struct hci_conn *hcon = conn->hcon;
4662 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP,
4679 static int l2cap_le_connect_rsp(struct l2cap_conn *conn,
4684 struct hci_conn *hcon = conn->hcon;
4706 mutex_lock(&conn->chan_lock);
4708 chan = __l2cap_get_chan_by_ident(conn, cmd->ident);
4720 if (__l2cap_get_chan_by_dcid(conn, dcid)) {
4761 mutex_unlock(&conn->chan_lock);
4766 static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn,
4774 l2cap_command_rej(conn, cmd, cmd_len, data);
4778 err = l2cap_connect_req(conn, cmd, cmd_len, data);
4782 l2cap_connect_create_rsp(conn, cmd, cmd_len, data);
4786 err = l2cap_config_req(conn, cmd, cmd_len, data);
4790 l2cap_config_rsp(conn, cmd, cmd_len, data);
4794 err = l2cap_disconnect_req(conn, cmd, cmd_len, data);
4798 l2cap_disconnect_rsp(conn, cmd, cmd_len, data);
4802 l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data);
4809 err = l2cap_information_req(conn, cmd, cmd_len, data);
4813 l2cap_information_rsp(conn, cmd, cmd_len, data);
4825 static int l2cap_le_connect_req(struct l2cap_conn *conn,
4866 pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, &conn->hcon->src,
4867 &conn->hcon->dst, LE_LINK);
4874 mutex_lock(&conn->chan_lock);
4877 if (!smp_sufficient_security(conn->hcon, pchan->sec_level,
4892 if (__l2cap_get_chan_by_dcid(conn, scid)) {
4904 bacpy(&chan->src, &conn->hcon->src);
4905 bacpy(&chan->dst, &conn->hcon->dst);
4906 chan->src_type = bdaddr_src_type(conn->hcon);
4907 chan->dst_type = bdaddr_dst_type(conn->hcon);
4913 __l2cap_chan_add(conn, chan);
4940 mutex_unlock(&conn->chan_lock);
4959 l2cap_send_cmd(conn, cmd->ident, L2CAP_LE_CONN_RSP, sizeof(rsp), &rsp);
4964 static inline int l2cap_le_credits(struct l2cap_conn *conn,
4981 chan = l2cap_get_chan_by_dcid(conn, cid);
5011 static inline int l2cap_ecred_conn_req(struct l2cap_conn *conn,
5067 pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, &conn->hcon->src,
5068 &conn->hcon->dst, LE_LINK);
5074 mutex_lock(&conn->chan_lock);
5077 if (!smp_sufficient_security(conn->hcon, pchan->sec_level,
5100 if (__l2cap_get_chan_by_dcid(conn, scid)) {
5111 bacpy(&chan->src, &conn->hcon->src);
5112 bacpy(&chan->dst, &conn->hcon->dst);
5113 chan->src_type = bdaddr_src_type(conn->hcon);
5114 chan->dst_type = bdaddr_dst_type(conn->hcon);
5120 __l2cap_chan_add(conn, chan);
5149 mutex_unlock(&conn->chan_lock);
5158 l2cap_send_cmd(conn, cmd->ident, L2CAP_ECRED_CONN_RSP,
5164 static inline int l2cap_ecred_conn_rsp(struct l2cap_conn *conn,
5169 struct hci_conn *hcon = conn->hcon;
5186 mutex_lock(&conn->chan_lock);
5190 list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) {
5213 if (dcid && __l2cap_get_chan_by_dcid(conn, dcid)) {
5222 chan = __l2cap_get_chan_by_dcid(conn, dcid);
5273 mutex_unlock(&conn->chan_lock);
5278 static inline int l2cap_ecred_reconf_req(struct l2cap_conn *conn,
5322 chan = __l2cap_get_chan_by_dcid(conn, scid);
5343 l2cap_send_cmd(conn, cmd->ident, L2CAP_ECRED_RECONF_RSP, sizeof(rsp),
5349 static inline int l2cap_ecred_reconf_rsp(struct l2cap_conn *conn,
5367 list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) {
5377 static inline int l2cap_le_command_rej(struct l2cap_conn *conn,
5387 mutex_lock(&conn->chan_lock);
5389 chan = __l2cap_get_chan_by_ident(conn, cmd->ident);
5403 mutex_unlock(&conn->chan_lock);
5407 static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn,
5415 l2cap_le_command_rej(conn, cmd, cmd_len, data);
5419 err = l2cap_conn_param_update_req(conn, cmd, cmd_len, data);
5426 l2cap_le_connect_rsp(conn, cmd, cmd_len, data);
5430 err = l2cap_le_connect_req(conn, cmd, cmd_len, data);
5434 err = l2cap_le_credits(conn, cmd, cmd_len, data);
5438 err = l2cap_ecred_conn_req(conn, cmd, cmd_len, data);
5442 err = l2cap_ecred_conn_rsp(conn, cmd, cmd_len, data);
5446 err = l2cap_ecred_reconf_req(conn, cmd, cmd_len, data);
5450 err = l2cap_ecred_reconf_rsp(conn, cmd, cmd_len, data);
5454 err = l2cap_disconnect_req(conn, cmd, cmd_len, data);
5458 l2cap_disconnect_rsp(conn, cmd, cmd_len, data);
5470 static inline void l2cap_le_sig_channel(struct l2cap_conn *conn,
5473 struct hci_conn *hcon = conn->hcon;
5496 err = l2cap_le_sig_cmd(conn, cmd, len, skb->data);
5503 l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ,
5511 static inline void l2cap_sig_send_rej(struct l2cap_conn *conn, u16 ident)
5516 l2cap_send_cmd(conn, ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej);
5519 static inline void l2cap_sig_channel(struct l2cap_conn *conn,
5522 struct hci_conn *hcon = conn->hcon;
5526 l2cap_raw_recv(conn, skb);
5544 l2cap_sig_send_rej(conn, cmd->ident);
5549 err = l2cap_bredr_sig_cmd(conn, cmd, len, skb->data);
5552 l2cap_sig_send_rej(conn, cmd->ident);
5560 l2cap_sig_send_rej(conn, 0);
6258 chan->conn->mtu = chan->conn->hcon->mtu;
6325 chan->conn->mtu = chan->conn->hcon->mtu;
6528 struct l2cap_conn *conn = chan->conn;
6544 chan->ident = l2cap_get_ident(conn);
6546 l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CREDITS, sizeof(pkt), &pkt);
6688 static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid,
6693 chan = l2cap_get_chan_by_scid(conn, cid);
6754 static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm,
6757 struct hci_conn *hcon = conn->hcon;
6791 static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
6794 struct hci_conn *hcon = conn->hcon;
6800 skb_queue_tail(&conn->pending_rx, skb);
6827 l2cap_sig_channel(conn, skb);
6833 l2cap_conless_channel(conn, psm, skb);
6837 l2cap_le_sig_channel(conn, skb);
6841 l2cap_data_channel(conn, cid, skb);
6848 struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
6854 while ((skb = skb_dequeue(&conn->pending_rx)))
6855 l2cap_recv_frame(conn, skb);
6860 struct l2cap_conn *conn = hcon->l2cap_data;
6863 if (conn)
6864 return conn;
6870 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
6871 if (!conn) {
6876 kref_init(&conn->ref);
6877 hcon->l2cap_data = conn;
6878 conn->hcon = hci_conn_get(hcon);
6879 conn->hchan = hchan;
6881 BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan);
6883 conn->mtu = hcon->mtu;
6884 conn->feat_mask = 0;
6886 conn->local_fixed_chan = L2CAP_FC_SIG_BREDR | L2CAP_FC_CONNLESS;
6891 conn->local_fixed_chan |= L2CAP_FC_SMP_BREDR;
6893 mutex_init(&conn->ident_lock);
6894 mutex_init(&conn->chan_lock);
6896 INIT_LIST_HEAD(&conn->chan_l);
6897 INIT_LIST_HEAD(&conn->users);
6899 INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout);
6901 skb_queue_head_init(&conn->pending_rx);
6902 INIT_WORK(&conn->pending_rx_work, process_pending_rx);
6903 INIT_DELAYED_WORK(&conn->id_addr_timer, l2cap_conn_update_id_addr);
6905 conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;
6907 return conn;
6952 struct l2cap_conn *conn;
7061 conn = l2cap_conn_add(hcon);
7062 if (!conn) {
7075 l2cap_chan_list(conn, l2cap_chan_by_pid, &data);
7085 mutex_lock(&conn->chan_lock);
7088 if (cid && __l2cap_get_chan_by_dcid(conn, cid)) {
7098 __l2cap_chan_add(conn, chan);
7126 mutex_unlock(&conn->chan_lock);
7136 struct l2cap_conn *conn = chan->conn;
7143 chan->ident = l2cap_get_ident(conn);
7145 l2cap_send_cmd(conn, chan->ident, L2CAP_ECRED_RECONF_REQ,
7233 struct l2cap_conn *conn;
7247 conn = l2cap_conn_add(hcon);
7248 if (!conn)
7267 if (__l2cap_get_chan_by_dcid(conn, pchan->scid))
7278 __l2cap_chan_add(conn, chan);
7288 l2cap_conn_ready(conn);
7293 struct l2cap_conn *conn = hcon->l2cap_data;
7297 if (!conn)
7299 return conn->disc_reason;
7331 struct l2cap_conn *conn = hcon->l2cap_data;
7334 if (!conn)
7337 BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt);
7339 mutex_lock(&conn->chan_lock);
7341 list_for_each_entry(chan, &conn->chan_l, list) {
7395 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
7402 l2cap_send_cmd(conn, l2cap_get_ident(conn),
7413 mutex_unlock(&conn->chan_lock);
7417 static int l2cap_recv_frag(struct l2cap_conn *conn, struct sk_buff *skb,
7420 if (!conn->rx_skb) {
7422 conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL);
7423 if (!conn->rx_skb)
7426 conn->rx_len = len;
7431 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, len), len);
7433 conn->rx_len -= len;
7438 static int l2cap_recv_len(struct l2cap_conn *conn, struct sk_buff *skb)
7444 len = l2cap_recv_frag(conn, skb, L2CAP_LEN_SIZE - conn->rx_skb->len);
7447 if (len < 0 || conn->rx_skb->len < L2CAP_LEN_SIZE)
7450 rx_skb = conn->rx_skb;
7456 conn->rx_len = len + (L2CAP_HDR_SIZE - L2CAP_LEN_SIZE);
7460 /* Reset conn->rx_skb since it will need to be reallocated in order to
7463 conn->rx_skb = NULL;
7466 len = l2cap_recv_frag(conn, rx_skb,
7473 static void l2cap_recv_reset(struct l2cap_conn *conn)
7475 kfree_skb(conn->rx_skb);
7476 conn->rx_skb = NULL;
7477 conn->rx_len = 0;
7482 struct l2cap_conn *conn = hcon->l2cap_data;
7485 if (!conn)
7486 conn = l2cap_conn_add(hcon);
7488 if (!conn)
7491 BT_DBG("conn %p len %u flags 0x%x", conn, skb->len, flags);
7497 if (conn->rx_skb) {
7499 l2cap_recv_reset(conn);
7500 l2cap_conn_unreliable(conn, ECOMM);
7504 * copy the initial byte when that happens and use conn->mtu as
7508 l2cap_recv_frag(conn, skb, conn->mtu);
7516 l2cap_recv_frame(conn, skb);
7525 l2cap_conn_unreliable(conn, ECOMM);
7530 if (l2cap_recv_frag(conn, skb, len) < 0)
7536 BT_DBG("Cont: frag len %u (expecting %u)", skb->len, conn->rx_len);
7538 if (!conn->rx_skb) {
7540 l2cap_conn_unreliable(conn, ECOMM);
7545 if (conn->rx_skb->len < L2CAP_LEN_SIZE) {
7546 if (l2cap_recv_len(conn, skb) < 0) {
7547 l2cap_conn_unreliable(conn, ECOMM);
7552 if (conn->rx_skb->len < L2CAP_LEN_SIZE)
7556 if (skb->len > conn->rx_len) {
7558 skb->len, conn->rx_len);
7559 l2cap_recv_reset(conn);
7560 l2cap_conn_unreliable(conn, ECOMM);
7565 l2cap_recv_frag(conn, skb, skb->len);
7567 if (!conn->rx_len) {
7572 struct sk_buff *rx_skb = conn->rx_skb;
7573 conn->rx_skb = NULL;
7574 l2cap_recv_frame(conn, rx_skb);