blob: 9bdffc4e79b046d516855624da6fed0a8e0f25e4 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 BlueZ - Bluetooth protocol stack for Linux
Ron Shaffer2d0a0342010-05-28 11:53:46 -04003 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI connection handling. */
26
Gustavo Padovan8c520a52012-05-23 04:04:22 -030027#include <linux/export.h>
Marcel Holtmann23b9ceb2014-12-20 17:13:41 +010028#include <linux/debugfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#include <net/bluetooth/bluetooth.h>
31#include <net/bluetooth/hci_core.h>
Johan Hedberg4bc58f52014-05-20 09:45:47 +030032#include <net/bluetooth/l2cap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Johan Hedberg0857dd32014-12-19 13:40:20 +020034#include "hci_request.h"
Marcel Holtmannac4b7232013-10-10 14:54:16 -070035#include "smp.h"
Marcel Holtmann70247282013-10-10 14:54:15 -070036#include "a2mp.h"
37
Frédéric Dalleau2dea6322013-08-19 14:24:03 +020038struct sco_param {
39 u16 pkt_type;
40 u16 max_latency;
Johan Hedbergc7da5792014-09-24 22:41:46 +030041 u8 retrans_effort;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +020042};
43
Bernhard Thaler48e68ff2014-09-23 11:01:07 +020044static const struct sco_param esco_param_cvsd[] = {
Johan Hedbergc7da5792014-09-24 22:41:46 +030045 { EDR_ESCO_MASK & ~ESCO_2EV3, 0x000a, 0x01 }, /* S3 */
46 { EDR_ESCO_MASK & ~ESCO_2EV3, 0x0007, 0x01 }, /* S2 */
47 { EDR_ESCO_MASK | ESCO_EV3, 0x0007, 0x01 }, /* S1 */
48 { EDR_ESCO_MASK | ESCO_HV3, 0xffff, 0x01 }, /* D1 */
49 { EDR_ESCO_MASK | ESCO_HV1, 0xffff, 0x01 }, /* D0 */
Frédéric Dalleau2dea6322013-08-19 14:24:03 +020050};
51
Bernhard Thaler48e68ff2014-09-23 11:01:07 +020052static const struct sco_param sco_param_cvsd[] = {
Johan Hedbergc7da5792014-09-24 22:41:46 +030053 { EDR_ESCO_MASK | ESCO_HV3, 0xffff, 0xff }, /* D1 */
54 { EDR_ESCO_MASK | ESCO_HV1, 0xffff, 0xff }, /* D0 */
Bernhard Thaler48e68ff2014-09-23 11:01:07 +020055};
56
Johan Hedberg565766b2014-09-25 09:48:01 +030057static const struct sco_param esco_param_msbc[] = {
Johan Hedbergc7da5792014-09-24 22:41:46 +030058 { EDR_ESCO_MASK & ~ESCO_2EV3, 0x000d, 0x02 }, /* T2 */
59 { EDR_ESCO_MASK | ESCO_EV3, 0x0008, 0x02 }, /* T1 */
Frédéric Dalleau2dea6322013-08-19 14:24:03 +020060};
61
Jakub Pawlowskif75113a2015-08-07 20:22:53 +020062/* This function requires the caller holds hdev->lock */
63static void hci_connect_le_scan_cleanup(struct hci_conn *conn)
64{
65 struct hci_conn_params *params;
Johan Hedbergb5c2b622015-10-21 18:03:09 +030066 struct hci_dev *hdev = conn->hdev;
Jakub Pawlowskif75113a2015-08-07 20:22:53 +020067 struct smp_irk *irk;
68 bdaddr_t *bdaddr;
69 u8 bdaddr_type;
70
71 bdaddr = &conn->dst;
72 bdaddr_type = conn->dst_type;
73
74 /* Check if we need to convert to identity address */
Johan Hedbergb5c2b622015-10-21 18:03:09 +030075 irk = hci_get_irk(hdev, bdaddr, bdaddr_type);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +020076 if (irk) {
77 bdaddr = &irk->bdaddr;
78 bdaddr_type = irk->addr_type;
79 }
80
Johan Hedberg17bc08f2015-10-21 18:03:10 +030081 params = hci_pend_le_action_lookup(&hdev->pend_le_conns, bdaddr,
82 bdaddr_type);
83 if (!params || !params->explicit_connect)
Jakub Pawlowskif75113a2015-08-07 20:22:53 +020084 return;
85
86 /* The connection attempt was doing scan for new RPA, and is
87 * in scan phase. If params are not associated with any other
88 * autoconnect action, remove them completely. If they are, just unmark
89 * them as waiting for connection, by clearing explicit_connect field.
90 */
Johan Hedberg9ad3e6f2015-10-16 10:07:53 +030091 params->explicit_connect = false;
92
93 list_del_init(&params->action);
94
95 switch (params->auto_connect) {
96 case HCI_AUTO_CONN_EXPLICIT:
Johan Hedbergb5c2b622015-10-21 18:03:09 +030097 hci_conn_params_del(hdev, bdaddr, bdaddr_type);
Johan Hedberg9ad3e6f2015-10-16 10:07:53 +030098 /* return instead of break to avoid duplicate scan update */
99 return;
100 case HCI_AUTO_CONN_DIRECT:
101 case HCI_AUTO_CONN_ALWAYS:
Johan Hedbergb5c2b622015-10-21 18:03:09 +0300102 list_add(&params->action, &hdev->pend_le_conns);
Johan Hedberg9ad3e6f2015-10-16 10:07:53 +0300103 break;
104 case HCI_AUTO_CONN_REPORT:
Johan Hedbergb5c2b622015-10-21 18:03:09 +0300105 list_add(&params->action, &hdev->pend_le_reports);
Johan Hedberg9ad3e6f2015-10-16 10:07:53 +0300106 break;
107 default:
108 break;
Jakub Pawlowski168b8a22015-10-16 10:07:49 +0300109 }
Johan Hedberg9ad3e6f2015-10-16 10:07:53 +0300110
Johan Hedbergb5c2b622015-10-21 18:03:09 +0300111 hci_update_background_scan(hdev);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200112}
113
Johan Hedbergb958f9a2015-10-16 10:07:50 +0300114static void hci_conn_cleanup(struct hci_conn *conn)
115{
116 struct hci_dev *hdev = conn->hdev;
117
118 if (test_bit(HCI_CONN_PARAM_REMOVAL_PEND, &conn->flags))
119 hci_conn_params_del(conn->hdev, &conn->dst, conn->dst_type);
120
121 hci_chan_list_flush(conn);
122
123 hci_conn_hash_del(hdev, conn);
124
Sathish Narsimman1f8330e2020-04-03 21:43:58 +0200125 if (conn->type == SCO_LINK || conn->type == ESCO_LINK) {
126 switch (conn->setting & SCO_AIRMODE_MASK) {
127 case SCO_AIRMODE_CVSD:
128 case SCO_AIRMODE_TRANSP:
129 if (hdev->notify)
130 hdev->notify(hdev, HCI_NOTIFY_DISABLE_SCO);
131 break;
132 }
133 } else {
134 if (hdev->notify)
135 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
136 }
Johan Hedbergb958f9a2015-10-16 10:07:50 +0300137
138 hci_conn_del_sysfs(conn);
139
140 debugfs_remove_recursive(conn->debugfs);
141
142 hci_dev_put(hdev);
143
144 hci_conn_put(conn);
145}
146
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300147static void le_scan_cleanup(struct work_struct *work)
148{
149 struct hci_conn *conn = container_of(work, struct hci_conn,
150 le_scan_cleanup);
151 struct hci_dev *hdev = conn->hdev;
152 struct hci_conn *c = NULL;
153
154 BT_DBG("%s hcon %p", hdev->name, conn);
155
156 hci_dev_lock(hdev);
157
158 /* Check that the hci_conn is still around */
159 rcu_read_lock();
160 list_for_each_entry_rcu(c, &hdev->conn_hash.list, list) {
161 if (c == conn)
162 break;
163 }
164 rcu_read_unlock();
165
166 if (c == conn) {
167 hci_connect_le_scan_cleanup(conn);
168 hci_conn_cleanup(conn);
169 }
170
171 hci_dev_unlock(hdev);
172 hci_dev_put(hdev);
173 hci_conn_put(conn);
174}
175
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200176static void hci_connect_le_scan_remove(struct hci_conn *conn)
177{
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300178 BT_DBG("%s hcon %p", conn->hdev->name, conn);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200179
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300180 /* We can't call hci_conn_del/hci_conn_cleanup here since that
181 * could deadlock with another hci_conn_del() call that's holding
182 * hci_dev_lock and doing cancel_delayed_work_sync(&conn->disc_work).
183 * Instead, grab temporary extra references to the hci_dev and
184 * hci_conn and perform the necessary cleanup in a separate work
185 * callback.
Johan Hedbergb958f9a2015-10-16 10:07:50 +0300186 */
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300187
188 hci_dev_hold(conn->hdev);
189 hci_conn_get(conn);
190
Johan Hedberg0ebc1812015-11-06 13:35:33 +0200191 /* Even though we hold a reference to the hdev, many other
192 * things might get cleaned up meanwhile, including the hdev's
193 * own workqueue, so we can't use that for scheduling.
194 */
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300195 schedule_work(&conn->le_scan_cleanup);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200196}
197
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300198static void hci_acl_create_connection(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199{
200 struct hci_dev *hdev = conn->hdev;
201 struct inquiry_entry *ie;
202 struct hci_cp_create_conn cp;
203
Andrei Emeltchenko42d2d872012-02-17 11:40:57 +0200204 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200207 conn->out = true;
Johan Hedberg40bef302014-07-16 11:42:27 +0300208 conn->role = HCI_ROLE_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200210 conn->attempt++;
211
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200212 conn->link_policy = hdev->link_policy;
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 memset(&cp, 0, sizeof(cp));
215 bacpy(&cp.bdaddr, &conn->dst);
216 cp.pscan_rep_mode = 0x02;
217
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200218 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
219 if (ie) {
Marcel Holtmann41a96212008-07-14 20:13:48 +0200220 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
221 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
222 cp.pscan_mode = ie->data.pscan_mode;
223 cp.clock_offset = ie->data.clock_offset |
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700224 cpu_to_le16(0x8000);
Marcel Holtmann41a96212008-07-14 20:13:48 +0200225 }
226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 memcpy(conn->dev_class, ie->data.dev_class, 3);
228 }
229
Marcel Holtmanna8746412008-07-14 20:13:46 +0200230 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200232 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200234 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200235
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200236 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}
238
Johan Hedberge3b679d2014-08-18 20:33:32 +0300239int hci_disconnect(struct hci_conn *conn, __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300241 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
Johan Hedberg839035a2014-08-18 20:33:34 +0300243 /* When we are master of an established connection and it enters
244 * the disconnect timeout, then go ahead and try to read the
245 * current clock offset. Processing of the result is done
246 * within the event handling and hci_clock_offset_evt function.
247 */
Johan Hedberg88d07fe2015-10-22 10:49:39 +0300248 if (conn->type == ACL_LINK && conn->role == HCI_ROLE_MASTER &&
249 (conn->state == BT_CONNECTED || conn->state == BT_CONFIG)) {
Johan Hedberg839035a2014-08-18 20:33:34 +0300250 struct hci_dev *hdev = conn->hdev;
Fabian Frederick4f639ed2014-10-25 10:48:58 +0200251 struct hci_cp_read_clock_offset clkoff_cp;
Johan Hedberg839035a2014-08-18 20:33:34 +0300252
Fabian Frederick4f639ed2014-10-25 10:48:58 +0200253 clkoff_cp.handle = cpu_to_le16(conn->handle);
254 hci_send_cmd(hdev, HCI_OP_READ_CLOCK_OFFSET, sizeof(clkoff_cp),
255 &clkoff_cp);
Johan Hedberg839035a2014-08-18 20:33:34 +0300256 }
257
Johan Hedberg88d07fe2015-10-22 10:49:39 +0300258 return hci_abort_conn(conn, reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259}
260
Vinicius Costa Gomes57f5d0d2012-07-27 19:32:54 -0300261static void hci_add_sco(struct hci_conn *conn, __u16 handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 struct hci_dev *hdev = conn->hdev;
264 struct hci_cp_add_sco cp;
265
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300266 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200269 conn->out = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Marcel Holtmannefc76882009-02-06 09:13:37 +0100271 conn->attempt++;
272
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700273 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200274 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200276 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277}
278
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200279bool hci_setup_sync(struct hci_conn *conn, __u16 handle)
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200280{
281 struct hci_dev *hdev = conn->hdev;
282 struct hci_cp_setup_sync_conn cp;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200283 const struct sco_param *param;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200284
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300285 BT_DBG("hcon %p", conn);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200286
287 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200288 conn->out = true;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200289
Marcel Holtmannefc76882009-02-06 09:13:37 +0100290 conn->attempt++;
291
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200292 cp.handle = cpu_to_le16(handle);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200293
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700294 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
295 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200296 cp.voice_setting = cpu_to_le16(conn->setting);
297
298 switch (conn->setting & SCO_AIRMODE_MASK) {
299 case SCO_AIRMODE_TRANSP:
Johan Hedberg565766b2014-09-25 09:48:01 +0300300 if (conn->attempt > ARRAY_SIZE(esco_param_msbc))
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200301 return false;
Johan Hedberg565766b2014-09-25 09:48:01 +0300302 param = &esco_param_msbc[conn->attempt - 1];
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200303 break;
304 case SCO_AIRMODE_CVSD:
Bernhard Thaler48e68ff2014-09-23 11:01:07 +0200305 if (lmp_esco_capable(conn->link)) {
306 if (conn->attempt > ARRAY_SIZE(esco_param_cvsd))
307 return false;
Bernhard Thaler48e68ff2014-09-23 11:01:07 +0200308 param = &esco_param_cvsd[conn->attempt - 1];
309 } else {
310 if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
311 return false;
Bernhard Thaler48e68ff2014-09-23 11:01:07 +0200312 param = &sco_param_cvsd[conn->attempt - 1];
313 }
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200314 break;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200315 default:
316 return false;
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200317 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200318
Johan Hedbergc7da5792014-09-24 22:41:46 +0300319 cp.retrans_effort = param->retrans_effort;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200320 cp.pkt_type = __cpu_to_le16(param->pkt_type);
321 cp.max_latency = __cpu_to_le16(param->max_latency);
322
323 if (hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp) < 0)
324 return false;
325
326 return true;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200327}
328
Johan Hedberg7d6ca692014-07-02 17:37:31 +0300329u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
330 u16 to_multiplier)
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200331{
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200332 struct hci_dev *hdev = conn->hdev;
Marcel Holtmannf044eb02014-06-29 16:43:26 +0200333 struct hci_conn_params *params;
334 struct hci_cp_le_conn_update cp;
335
336 hci_dev_lock(hdev);
337
338 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
339 if (params) {
340 params->conn_min_interval = min;
341 params->conn_max_interval = max;
342 params->conn_latency = latency;
343 params->supervision_timeout = to_multiplier;
344 }
345
346 hci_dev_unlock(hdev);
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200347
348 memset(&cp, 0, sizeof(cp));
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200349 cp.handle = cpu_to_le16(conn->handle);
350 cp.conn_interval_min = cpu_to_le16(min);
351 cp.conn_interval_max = cpu_to_le16(max);
352 cp.conn_latency = cpu_to_le16(latency);
353 cp.supervision_timeout = cpu_to_le16(to_multiplier);
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700354 cp.min_ce_len = cpu_to_le16(0x0000);
355 cp.max_ce_len = cpu_to_le16(0x0000);
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200356
357 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
Johan Hedberg7d6ca692014-07-02 17:37:31 +0300358
359 if (params)
360 return 0x01;
361
362 return 0x00;
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200363}
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200364
Marcel Holtmannfe39c7b2014-02-27 16:00:28 -0800365void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
Johan Hedberg8b76ce32015-06-08 18:14:39 +0300366 __u8 ltk[16], __u8 key_size)
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300367{
368 struct hci_dev *hdev = conn->hdev;
369 struct hci_cp_le_start_enc cp;
370
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300371 BT_DBG("hcon %p", conn);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300372
373 memset(&cp, 0, sizeof(cp));
374
375 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmannfe39c7b2014-02-27 16:00:28 -0800376 cp.rand = rand;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300377 cp.ediv = ediv;
Johan Hedberg8b76ce32015-06-08 18:14:39 +0300378 memcpy(cp.ltk, ltk, key_size);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300379
380 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
381}
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300382
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400383/* Device _must_ be locked */
384void hci_sco_setup(struct hci_conn *conn, __u8 status)
385{
386 struct hci_conn *sco = conn->link;
387
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400388 if (!sco)
389 return;
390
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300391 BT_DBG("hcon %p", conn);
392
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400393 if (!status) {
394 if (lmp_esco_capable(conn->hdev))
395 hci_setup_sync(sco, conn->handle);
396 else
397 hci_add_sco(sco, conn->handle);
398 } else {
Johan Hedberg539c4962015-02-18 14:53:57 +0200399 hci_connect_cfm(sco, status);
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400400 hci_conn_del(sco);
401 }
402}
403
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300404static void hci_conn_timeout(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300406 struct hci_conn *conn = container_of(work, struct hci_conn,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300407 disc_work.work);
Lukasz Rymanowski1d56dc42014-06-17 13:04:20 +0200408 int refcnt = atomic_read(&conn->refcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300410 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
Lukasz Rymanowski1d56dc42014-06-17 13:04:20 +0200412 WARN_ON(refcnt < 0);
413
414 /* FIXME: It was observed that in pairing failed scenario, refcnt
415 * drops below 0. Probably this is because l2cap_conn_del calls
416 * l2cap_chan_del for each channel, and inside l2cap_chan_del conn is
417 * dropped. After that loop hci_chan_del is called which also drops
418 * conn. For now make sure that ACL is alive if refcnt is higher then 0,
419 * otherwise drop it.
420 */
421 if (refcnt > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 return;
423
Johan Hedberg89e0ccc2015-10-22 10:49:38 +0300424 /* LE connections in scanning state need special handling */
425 if (conn->state == BT_CONNECT && conn->type == LE_LINK &&
426 test_bit(HCI_CONN_SCANNING, &conn->flags)) {
427 hci_connect_le_scan_remove(conn);
428 return;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200429 }
Johan Hedberg89e0ccc2015-10-22 10:49:38 +0300430
431 hci_abort_conn(conn, hci_proto_disconn_ind(conn));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432}
433
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200434/* Enter sniff mode */
Johan Hedberga74a84f2013-10-16 18:11:40 +0300435static void hci_conn_idle(struct work_struct *work)
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200436{
Johan Hedberga74a84f2013-10-16 18:11:40 +0300437 struct hci_conn *conn = container_of(work, struct hci_conn,
438 idle_work.work);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200439 struct hci_dev *hdev = conn->hdev;
440
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300441 BT_DBG("hcon %p mode %d", conn, conn->mode);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200442
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200443 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
444 return;
445
446 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
447 return;
448
449 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
450 struct hci_cp_sniff_subrate cp;
451 cp.handle = cpu_to_le16(conn->handle);
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700452 cp.max_latency = cpu_to_le16(0);
453 cp.min_remote_timeout = cpu_to_le16(0);
454 cp.min_local_timeout = cpu_to_le16(0);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200455 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
456 }
457
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200458 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200459 struct hci_cp_sniff_mode cp;
460 cp.handle = cpu_to_le16(conn->handle);
461 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
462 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700463 cp.attempt = cpu_to_le16(4);
464 cp.timeout = cpu_to_le16(1);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200465 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
466 }
467}
468
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300469static void hci_conn_auto_accept(struct work_struct *work)
Johan Hedberg9f616562011-04-28 11:28:54 -0700470{
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300471 struct hci_conn *conn = container_of(work, struct hci_conn,
472 auto_accept_work.work);
Johan Hedberg9f616562011-04-28 11:28:54 -0700473
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300474 hci_send_cmd(conn->hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300475 &conn->dst);
Johan Hedberg9f616562011-04-28 11:28:54 -0700476}
477
Sathish Narsimmanc3bed4d2020-02-24 10:53:40 +0530478static void le_disable_advertising(struct hci_dev *hdev)
479{
480 if (ext_adv_capable(hdev)) {
481 struct hci_cp_le_set_ext_adv_enable cp;
482
483 cp.enable = 0x00;
484 cp.num_of_sets = 0x00;
485
486 hci_send_cmd(hdev, HCI_OP_LE_SET_EXT_ADV_ENABLE, sizeof(cp),
487 &cp);
488 } else {
489 u8 enable = 0x00;
490 hci_send_cmd(hdev, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable),
491 &enable);
492 }
493}
494
Johan Hedberg9489eca2014-02-28 17:45:46 +0200495static void le_conn_timeout(struct work_struct *work)
496{
497 struct hci_conn *conn = container_of(work, struct hci_conn,
498 le_conn_timeout.work);
Johan Hedberg3c857752014-03-25 10:30:49 +0200499 struct hci_dev *hdev = conn->hdev;
Johan Hedberg9489eca2014-02-28 17:45:46 +0200500
501 BT_DBG("");
502
Johan Hedberg3c857752014-03-25 10:30:49 +0200503 /* We could end up here due to having done directed advertising,
504 * so clean up the state if necessary. This should however only
505 * happen with broken hardware or if low duty cycle was used
506 * (which doesn't have a timeout of its own).
507 */
Johan Hedberg0b1db38c2014-10-28 22:23:27 +0100508 if (conn->role == HCI_ROLE_SLAVE) {
Sathish Narsimmanc3bed4d2020-02-24 10:53:40 +0530509 /* Disable LE Advertising */
510 le_disable_advertising(hdev);
Johan Hedberg3c857752014-03-25 10:30:49 +0200511 hci_le_conn_failed(conn, HCI_ERROR_ADVERTISING_TIMEOUT);
512 return;
513 }
514
Johan Hedberg89e0ccc2015-10-22 10:49:38 +0300515 hci_abort_conn(conn, HCI_ERROR_REMOTE_USER_TERM);
Johan Hedberg9489eca2014-02-28 17:45:46 +0200516}
517
Johan Hedberga5c4e302014-07-16 11:56:07 +0300518struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
519 u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520{
521 struct hci_conn *conn;
522
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300523 BT_DBG("%s dst %pMR", hdev->name, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524
Johan Hedberg27f70f32014-07-21 10:50:06 +0300525 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200526 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529 bacpy(&conn->dst, dst);
Marcel Holtmann662e8822013-10-13 05:23:59 -0700530 bacpy(&conn->src, &hdev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200531 conn->hdev = hdev;
532 conn->type = type;
Johan Hedberga5c4e302014-07-16 11:56:07 +0300533 conn->role = role;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200534 conn->mode = HCI_CM_ACTIVE;
535 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300536 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200537 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300538 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200539 conn->key_type = 0xff;
Johan Hedbergebf86aa2014-12-05 13:36:08 +0200540 conn->rssi = HCI_RSSI_INVALID;
Andrzej Kaczmarek5a134fa2014-05-09 21:35:28 +0200541 conn->tx_power = HCI_TX_POWER_INVALID;
Andrzej Kaczmarekd0455ed2014-05-14 13:43:05 +0200542 conn->max_tx_power = HCI_TX_POWER_INVALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Johan Hedberg58a681e2012-01-16 06:47:28 +0200544 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200545 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200546
Spoorthi Ravishankar Koppad302975c2019-06-21 14:51:56 +0530547 /* Set Default Authenticated payload timeout to 30s */
548 conn->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT;
549
Johan Hedberga5c4e302014-07-16 11:56:07 +0300550 if (conn->role == HCI_ROLE_MASTER)
551 conn->out = true;
552
Marcel Holtmanna8746412008-07-14 20:13:46 +0200553 switch (type) {
554 case ACL_LINK:
555 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
556 break;
Johan Hedberg9c84d1d2014-03-24 20:21:50 +0200557 case LE_LINK:
558 /* conn->src should reflect the local identity address */
559 hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
560 break;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200561 case SCO_LINK:
562 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100563 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
564 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200565 else
566 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
567 break;
568 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100569 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200570 break;
571 }
572
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200574
Marcel Holtmann70c1f202012-02-22 12:06:43 +0100575 INIT_LIST_HEAD(&conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200576
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300577 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300578 INIT_DELAYED_WORK(&conn->auto_accept_work, hci_conn_auto_accept);
Johan Hedberga74a84f2013-10-16 18:11:40 +0300579 INIT_DELAYED_WORK(&conn->idle_work, hci_conn_idle);
Johan Hedberg9489eca2014-02-28 17:45:46 +0200580 INIT_DELAYED_WORK(&conn->le_conn_timeout, le_conn_timeout);
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300581 INIT_WORK(&conn->le_scan_cleanup, le_scan_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
583 atomic_set(&conn->refcnt, 0);
584
585 hci_dev_hold(hdev);
586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 hci_conn_hash_add(hdev, conn);
Sathish Narsimman1f8330e2020-04-03 21:43:58 +0200588
589 /* The SCO and eSCO connections will only be notified when their
590 * setup has been completed. This is different to ACL links which
591 * can be notified right away.
592 */
593 if (conn->type != SCO_LINK && conn->type != ESCO_LINK) {
594 if (hdev->notify)
595 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
596 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700598 hci_conn_init_sysfs(conn);
599
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 return conn;
601}
602
603int hci_conn_del(struct hci_conn *conn)
604{
605 struct hci_dev *hdev = conn->hdev;
606
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300607 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300609 cancel_delayed_work_sync(&conn->disc_work);
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300610 cancel_delayed_work_sync(&conn->auto_accept_work);
Johan Hedberga74a84f2013-10-16 18:11:40 +0300611 cancel_delayed_work_sync(&conn->idle_work);
Johan Hedberg9f616562011-04-28 11:28:54 -0700612
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200613 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 struct hci_conn *sco = conn->link;
615 if (sco)
616 sco->link = NULL;
617
618 /* Unacked frames */
619 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300620 } else if (conn->type == LE_LINK) {
Johan Hedberg980ffc02014-10-28 22:23:26 +0100621 cancel_delayed_work(&conn->le_conn_timeout);
Johan Hedberg9489eca2014-02-28 17:45:46 +0200622
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300623 if (hdev->le_pkts)
624 hdev->le_cnt += conn->sent;
625 else
626 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200627 } else {
628 struct hci_conn *acl = conn->link;
629 if (acl) {
630 acl->link = NULL;
David Herrmann76a68ba2013-04-06 20:28:37 +0200631 hci_conn_drop(acl);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200632 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 }
634
Andrei Emeltchenko9740e492012-05-29 13:59:02 +0300635 if (conn->amp_mgr)
636 amp_mgr_put(conn->amp_mgr);
637
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Johan Hedbergb958f9a2015-10-16 10:07:50 +0300640 /* Remove the connection from the list and cleanup its remaining
641 * state. This is a separate function since for some cases like
642 * BT_CONNECT_SCAN we *only* want the cleanup part without the
643 * rest of hci_conn_del.
644 */
645 hci_conn_cleanup(conn);
Tomas Targownik163f4da2011-06-30 16:30:44 -0300646
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 return 0;
648}
649
Johan Hedberg39385cb2016-11-12 17:03:07 +0200650struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, uint8_t src_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651{
652 int use_src = bacmp(src, BDADDR_ANY);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200653 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300655 BT_DBG("%pMR -> %pMR", src, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200657 read_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200659 list_for_each_entry(d, &hci_dev_list, list) {
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300660 if (!test_bit(HCI_UP, &d->flags) ||
Marcel Holtmannd7a5a112015-03-13 02:11:00 -0700661 hci_dev_test_flag(d, HCI_USER_CHANNEL) ||
Marcel Holtmannca8bee52016-07-05 14:30:14 +0200662 d->dev_type != HCI_PRIMARY)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 continue;
664
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900665 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 * No source address - find interface with bdaddr != dst
667 * Source address - find interface with bdaddr == src
668 */
669
670 if (use_src) {
Johan Hedberg39385cb2016-11-12 17:03:07 +0200671 bdaddr_t id_addr;
672 u8 id_addr_type;
673
674 if (src_type == BDADDR_BREDR) {
675 if (!lmp_bredr_capable(d))
676 continue;
677 bacpy(&id_addr, &d->bdaddr);
678 id_addr_type = BDADDR_BREDR;
679 } else {
680 if (!lmp_le_capable(d))
681 continue;
682
683 hci_copy_identity_address(d, &id_addr,
684 &id_addr_type);
685
686 /* Convert from HCI to three-value type */
687 if (id_addr_type == ADDR_LE_DEV_PUBLIC)
688 id_addr_type = BDADDR_LE_PUBLIC;
689 else
690 id_addr_type = BDADDR_LE_RANDOM;
691 }
692
693 if (!bacmp(&id_addr, src) && id_addr_type == src_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 hdev = d; break;
695 }
696 } else {
697 if (bacmp(&d->bdaddr, dst)) {
698 hdev = d; break;
699 }
700 }
701 }
702
703 if (hdev)
704 hdev = hci_dev_hold(hdev);
705
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200706 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 return hdev;
708}
709EXPORT_SYMBOL(hci_get_route);
710
Andre Guedes9bb3c012014-01-30 18:22:08 -0300711/* This function requires the caller holds hdev->lock */
Andre Guedes06c053f2014-02-26 20:21:41 -0300712void hci_le_conn_failed(struct hci_conn *conn, u8 status)
Andre Guedes9bb3c012014-01-30 18:22:08 -0300713{
714 struct hci_dev *hdev = conn->hdev;
Johan Hedbergf161dd42014-08-15 21:06:54 +0300715 struct hci_conn_params *params;
716
717 params = hci_pend_le_action_lookup(&hdev->pend_le_conns, &conn->dst,
718 conn->dst_type);
719 if (params && params->conn) {
720 hci_conn_drop(params->conn);
Johan Hedbergf8aaf9b2014-08-17 23:28:57 +0300721 hci_conn_put(params->conn);
Johan Hedbergf161dd42014-08-15 21:06:54 +0300722 params->conn = NULL;
723 }
Andre Guedes9bb3c012014-01-30 18:22:08 -0300724
725 conn->state = BT_CLOSED;
726
Johan Hedbergacb9f912015-12-03 12:45:20 +0200727 /* If the status indicates successful cancellation of
728 * the attempt (i.e. Unkown Connection Id) there's no point of
729 * notifying failure since we'll go back to keep trying to
730 * connect. The only exception is explicit connect requests
731 * where a timeout + cancel does indicate an actual failure.
732 */
733 if (status != HCI_ERROR_UNKNOWN_CONN_ID ||
734 (params && params->explicit_connect))
735 mgmt_connect_failed(hdev, &conn->dst, conn->type,
736 conn->dst_type, status);
Andre Guedes9bb3c012014-01-30 18:22:08 -0300737
Johan Hedberg539c4962015-02-18 14:53:57 +0200738 hci_connect_cfm(conn, status);
Andre Guedes9bb3c012014-01-30 18:22:08 -0300739
740 hci_conn_del(conn);
Andre Guedesa4790db2014-02-26 20:21:47 -0300741
742 /* Since we may have temporarily stopped the background scanning in
743 * favor of connection establishment, we should restart it.
744 */
745 hci_update_background_scan(hdev);
Johan Hedberg3c857752014-03-25 10:30:49 +0200746
747 /* Re-enable advertising in case this was a failed connection
748 * attempt as a peripheral.
749 */
Johan Hedbergf2252572015-11-18 12:49:20 +0200750 hci_req_reenable_advertising(hdev);
Andre Guedes9bb3c012014-01-30 18:22:08 -0300751}
752
Marcel Holtmann1904a852015-01-11 13:50:44 -0800753static void create_le_conn_complete(struct hci_dev *hdev, u8 status, u16 opcode)
Andre Guedes1d399ae2013-10-08 08:21:17 -0300754{
755 struct hci_conn *conn;
756
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200757 hci_dev_lock(hdev);
758
759 conn = hci_lookup_le_connect(hdev);
760
761 if (!status) {
762 hci_connect_le_scan_cleanup(conn);
763 goto done;
764 }
Andre Guedes1d399ae2013-10-08 08:21:17 -0300765
Marcel Holtmann2064ee32017-10-30 10:42:59 +0100766 bt_dev_err(hdev, "request failed to create LE connection: "
767 "status 0x%2.2x", status);
Andre Guedes1d399ae2013-10-08 08:21:17 -0300768
Andre Guedes1d399ae2013-10-08 08:21:17 -0300769 if (!conn)
770 goto done;
771
Andre Guedes06c053f2014-02-26 20:21:41 -0300772 hci_le_conn_failed(conn, status);
Andre Guedes1d399ae2013-10-08 08:21:17 -0300773
774done:
775 hci_dev_unlock(hdev);
776}
777
Johan Hedberg82a37ad2016-03-09 17:30:34 +0200778static bool conn_use_rpa(struct hci_conn *conn)
779{
780 struct hci_dev *hdev = conn->hdev;
781
782 return hci_dev_test_flag(hdev, HCI_PRIVACY);
783}
784
Jaganath Kanakkassery4e6e99e2018-07-19 17:09:39 +0530785static void set_ext_conn_params(struct hci_conn *conn,
786 struct hci_cp_le_ext_conn_param *p)
787{
788 struct hci_dev *hdev = conn->hdev;
789
790 memset(p, 0, sizeof(*p));
791
Alain Michaud10873f92020-06-11 02:01:56 +0000792 p->scan_interval = cpu_to_le16(hdev->le_scan_int_connect);
793 p->scan_window = cpu_to_le16(hdev->le_scan_window_connect);
Jaganath Kanakkassery4e6e99e2018-07-19 17:09:39 +0530794 p->conn_interval_min = cpu_to_le16(conn->le_conn_min_interval);
795 p->conn_interval_max = cpu_to_le16(conn->le_conn_max_interval);
796 p->conn_latency = cpu_to_le16(conn->le_conn_latency);
797 p->supervision_timeout = cpu_to_le16(conn->le_supv_timeout);
798 p->min_ce_len = cpu_to_le16(0x0000);
799 p->max_ce_len = cpu_to_le16(0x0000);
800}
801
Andre Guedes2acf3d92014-02-26 20:21:42 -0300802static void hci_req_add_le_create_conn(struct hci_request *req,
Szymon Janc082f2302018-04-03 13:40:06 +0200803 struct hci_conn *conn,
804 bdaddr_t *direct_rpa)
Andre Guedes2acf3d92014-02-26 20:21:42 -0300805{
Andre Guedes2acf3d92014-02-26 20:21:42 -0300806 struct hci_dev *hdev = conn->hdev;
807 u8 own_addr_type;
808
Szymon Janc082f2302018-04-03 13:40:06 +0200809 /* If direct address was provided we use it instead of current
810 * address.
Andre Guedes2acf3d92014-02-26 20:21:42 -0300811 */
Szymon Janc082f2302018-04-03 13:40:06 +0200812 if (direct_rpa) {
813 if (bacmp(&req->hdev->random_addr, direct_rpa))
814 hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6,
815 direct_rpa);
816
817 /* direct address is always RPA */
818 own_addr_type = ADDR_LE_DEV_RANDOM;
819 } else {
820 /* Update random address, but set require_privacy to false so
821 * that we never connect with an non-resolvable address.
822 */
823 if (hci_update_random_address(req, false, conn_use_rpa(conn),
824 &own_addr_type))
825 return;
826 }
Andre Guedes2acf3d92014-02-26 20:21:42 -0300827
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200828 if (use_ext_conn(hdev)) {
829 struct hci_cp_le_ext_create_conn *cp;
830 struct hci_cp_le_ext_conn_param *p;
Jaganath Kanakkassery4e6e99e2018-07-19 17:09:39 +0530831 u8 data[sizeof(*cp) + sizeof(*p) * 3];
832 u32 plen;
Johan Hedbergeec7a012016-03-09 17:30:32 +0200833
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200834 cp = (void *) data;
835 p = (void *) cp->data;
Johan Hedberg2f995362015-12-03 12:45:19 +0200836
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200837 memset(cp, 0, sizeof(*cp));
Andre Guedes2acf3d92014-02-26 20:21:42 -0300838
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200839 bacpy(&cp->peer_addr, &conn->dst);
840 cp->peer_addr_type = conn->dst_type;
841 cp->own_addr_type = own_addr_type;
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200842
Jaganath Kanakkassery4e6e99e2018-07-19 17:09:39 +0530843 plen = sizeof(*cp);
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200844
Jaganath Kanakkassery4e6e99e2018-07-19 17:09:39 +0530845 if (scan_1m(hdev)) {
846 cp->phys |= LE_SCAN_PHY_1M;
847 set_ext_conn_params(conn, p);
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200848
Jaganath Kanakkassery4e6e99e2018-07-19 17:09:39 +0530849 p++;
850 plen += sizeof(*p);
851 }
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200852
Jaganath Kanakkassery4e6e99e2018-07-19 17:09:39 +0530853 if (scan_2m(hdev)) {
854 cp->phys |= LE_SCAN_PHY_2M;
855 set_ext_conn_params(conn, p);
856
857 p++;
858 plen += sizeof(*p);
859 }
860
861 if (scan_coded(hdev)) {
862 cp->phys |= LE_SCAN_PHY_CODED;
863 set_ext_conn_params(conn, p);
864
865 plen += sizeof(*p);
866 }
867
868 hci_req_add(req, HCI_OP_LE_EXT_CREATE_CONN, plen, data);
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200869
870 } else {
871 struct hci_cp_le_create_conn cp;
872
873 memset(&cp, 0, sizeof(cp));
874
Alain Michaud10873f92020-06-11 02:01:56 +0000875 cp.scan_interval = cpu_to_le16(hdev->le_scan_int_connect);
876 cp.scan_window = cpu_to_le16(hdev->le_scan_window_connect);
Jaganath Kanakkassery4d94f952018-07-06 22:50:32 +0200877
878 bacpy(&cp.peer_addr, &conn->dst);
879 cp.peer_addr_type = conn->dst_type;
880 cp.own_address_type = own_addr_type;
881 cp.conn_interval_min = cpu_to_le16(conn->le_conn_min_interval);
882 cp.conn_interval_max = cpu_to_le16(conn->le_conn_max_interval);
883 cp.conn_latency = cpu_to_le16(conn->le_conn_latency);
884 cp.supervision_timeout = cpu_to_le16(conn->le_supv_timeout);
885 cp.min_ce_len = cpu_to_le16(0x0000);
886 cp.max_ce_len = cpu_to_le16(0x0000);
887
888 hci_req_add(req, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
889 }
Johan Hedbergb46e0032014-02-28 12:54:15 +0200890
891 conn->state = BT_CONNECT;
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200892 clear_bit(HCI_CONN_SCANNING, &conn->flags);
Andre Guedes2acf3d92014-02-26 20:21:42 -0300893}
894
Johan Hedberg3c857752014-03-25 10:30:49 +0200895static void hci_req_directed_advertising(struct hci_request *req,
896 struct hci_conn *conn)
897{
898 struct hci_dev *hdev = req->hdev;
Johan Hedberg3c857752014-03-25 10:30:49 +0200899 u8 own_addr_type;
900 u8 enable;
901
Jaganath Kanakkassery075e40b2018-07-19 17:09:44 +0530902 if (ext_adv_capable(hdev)) {
903 struct hci_cp_le_set_ext_adv_params cp;
Jaganath Kanakkasserya73c0462018-07-19 17:09:45 +0530904 bdaddr_t random_addr;
905
906 /* Set require_privacy to false so that the remote device has a
907 * chance of identifying us.
908 */
909 if (hci_get_random_address(hdev, false, conn_use_rpa(conn), NULL,
910 &own_addr_type, &random_addr) < 0)
911 return;
Johan Hedberg3c857752014-03-25 10:30:49 +0200912
Jaganath Kanakkassery075e40b2018-07-19 17:09:44 +0530913 memset(&cp, 0, sizeof(cp));
Johan Hedberg3c857752014-03-25 10:30:49 +0200914
Jaganath Kanakkassery075e40b2018-07-19 17:09:44 +0530915 cp.evt_properties = cpu_to_le16(LE_LEGACY_ADV_DIRECT_IND);
916 cp.own_addr_type = own_addr_type;
917 cp.channel_map = hdev->le_adv_channel_map;
918 cp.tx_power = HCI_TX_POWER_INVALID;
919 cp.primary_phy = HCI_ADV_PHY_1M;
920 cp.secondary_phy = HCI_ADV_PHY_1M;
921 cp.handle = 0; /* Use instance 0 for directed adv */
922 cp.own_addr_type = own_addr_type;
923 cp.peer_addr_type = conn->dst_type;
924 bacpy(&cp.peer_addr, &conn->dst);
Johan Hedberg3c857752014-03-25 10:30:49 +0200925
Sathish Narsimmana9e45692020-02-24 11:02:24 +0530926 /* As per Core Spec 5.2 Vol 2, PART E, Sec 7.8.53, for
927 * advertising_event_property LE_LEGACY_ADV_DIRECT_IND
928 * does not supports advertising data when the advertising set already
929 * contains some, the controller shall return erroc code 'Invalid
930 * HCI Command Parameters(0x12).
931 * So it is required to remove adv set for handle 0x00. since we use
932 * instance 0 for directed adv.
933 */
934 hci_req_add(req, HCI_OP_LE_REMOVE_ADV_SET, sizeof(cp.handle), &cp.handle);
935
Jaganath Kanakkassery075e40b2018-07-19 17:09:44 +0530936 hci_req_add(req, HCI_OP_LE_SET_EXT_ADV_PARAMS, sizeof(cp), &cp);
Johan Hedberg3c857752014-03-25 10:30:49 +0200937
Jaganath Kanakkasserya73c0462018-07-19 17:09:45 +0530938 if (own_addr_type == ADDR_LE_DEV_RANDOM &&
939 bacmp(&random_addr, BDADDR_ANY) &&
940 bacmp(&random_addr, &hdev->random_addr)) {
941 struct hci_cp_le_set_adv_set_rand_addr cp;
942
943 memset(&cp, 0, sizeof(cp));
944
945 cp.handle = 0;
946 bacpy(&cp.bdaddr, &random_addr);
947
948 hci_req_add(req,
949 HCI_OP_LE_SET_ADV_SET_RAND_ADDR,
950 sizeof(cp), &cp);
951 }
952
Luiz Augusto von Dentz1d0fac22019-06-03 13:48:42 +0300953 __hci_req_enable_ext_advertising(req, 0x00);
Jaganath Kanakkassery075e40b2018-07-19 17:09:44 +0530954 } else {
955 struct hci_cp_le_set_adv_param cp;
956
957 /* Clear the HCI_LE_ADV bit temporarily so that the
958 * hci_update_random_address knows that it's safe to go ahead
959 * and write a new random address. The flag will be set back on
960 * as soon as the SET_ADV_ENABLE HCI command completes.
961 */
962 hci_dev_clear_flag(hdev, HCI_LE_ADV);
963
964 /* Set require_privacy to false so that the remote device has a
965 * chance of identifying us.
966 */
967 if (hci_update_random_address(req, false, conn_use_rpa(conn),
968 &own_addr_type) < 0)
969 return;
970
971 memset(&cp, 0, sizeof(cp));
Szymon Janc4c371bb2019-10-02 14:22:43 +0200972
973 /* Some controllers might reject command if intervals are not
974 * within range for undirected advertising.
975 * BCM20702A0 is known to be affected by this.
976 */
977 cp.min_interval = cpu_to_le16(0x0020);
978 cp.max_interval = cpu_to_le16(0x0020);
979
Jaganath Kanakkassery075e40b2018-07-19 17:09:44 +0530980 cp.type = LE_ADV_DIRECT_IND;
981 cp.own_address_type = own_addr_type;
982 cp.direct_addr_type = conn->dst_type;
983 bacpy(&cp.direct_addr, &conn->dst);
984 cp.channel_map = hdev->le_adv_channel_map;
985
986 hci_req_add(req, HCI_OP_LE_SET_ADV_PARAM, sizeof(cp), &cp);
987
988 enable = 0x01;
989 hci_req_add(req, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable),
990 &enable);
991 }
Johan Hedberg3c857752014-03-25 10:30:49 +0200992
993 conn->state = BT_CONNECT;
994}
995
Andre Guedes04a6c582014-02-26 20:21:44 -0300996struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
Johan Hedbergcdd62752014-07-07 15:02:28 +0300997 u8 dst_type, u8 sec_level, u16 conn_timeout,
Szymon Janc082f2302018-04-03 13:40:06 +0200998 u8 role, bdaddr_t *direct_rpa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999{
Andre Guedes4292f1f2014-02-03 13:56:19 -03001000 struct hci_conn_params *params;
Johan Hedberge2caced2015-11-11 14:44:59 +02001001 struct hci_conn *conn;
Johan Hedberg1ebfcc12014-02-18 21:41:36 +02001002 struct smp_irk *irk;
Andre Guedes2acf3d92014-02-26 20:21:42 -03001003 struct hci_request req;
Andre Guedes1d399ae2013-10-08 08:21:17 -03001004 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
Lukasz Rymanowski152d3862015-02-11 12:31:40 +01001006 /* Let's make sure that le is enabled.*/
Marcel Holtmannd7a5a112015-03-13 02:11:00 -07001007 if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
Lukasz Rymanowski152d3862015-02-11 12:31:40 +01001008 if (lmp_le_capable(hdev))
1009 return ERR_PTR(-ECONNREFUSED);
1010
1011 return ERR_PTR(-EOPNOTSUPP);
1012 }
1013
Johan Hedberg658aead2015-11-11 14:44:58 +02001014 /* Since the controller supports only one LE connection attempt at a
1015 * time, we return -EBUSY if there is any connection attempt running.
1016 */
1017 if (hci_lookup_le_connect(hdev))
1018 return ERR_PTR(-EBUSY);
1019
Johan Hedberge2caced2015-11-11 14:44:59 +02001020 /* If there's already a connection object but it's not in
1021 * scanning state it means it must already be established, in
1022 * which case we can't do anything else except report a failure
1023 * to connect.
Andre Guedes620ad522013-10-08 08:21:18 -03001024 */
Johan Hedberg9d4c1cc2015-10-21 18:03:01 +03001025 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
Johan Hedberge2caced2015-11-11 14:44:59 +02001026 if (conn && !test_bit(HCI_CONN_SCANNING, &conn->flags)) {
1027 return ERR_PTR(-EBUSY);
Ville Tervofcd89c02011-02-10 22:38:47 -03001028 }
1029
Marcel Holtmannedb4b462014-02-18 15:13:43 -08001030 /* When given an identity address with existing identity
1031 * resolving key, the connection needs to be established
1032 * to a resolvable random address.
1033 *
Marcel Holtmannedb4b462014-02-18 15:13:43 -08001034 * Storing the resolvable random address is required here
1035 * to handle connection failures. The address will later
1036 * be resolved back into the original identity address
1037 * from the connect request.
1038 */
Johan Hedberg1ebfcc12014-02-18 21:41:36 +02001039 irk = hci_find_irk_by_addr(hdev, dst, dst_type);
1040 if (irk && bacmp(&irk->rpa, BDADDR_ANY)) {
1041 dst = &irk->rpa;
1042 dst_type = ADDR_LE_DEV_RANDOM;
1043 }
1044
Johan Hedberge2caced2015-11-11 14:44:59 +02001045 if (conn) {
Jakub Pawlowski28a667c2015-08-07 20:22:54 +02001046 bacpy(&conn->dst, dst);
1047 } else {
1048 conn = hci_conn_add(hdev, LE_LINK, dst, role);
Johan Hedberge2caced2015-11-11 14:44:59 +02001049 if (!conn)
1050 return ERR_PTR(-ENOMEM);
1051 hci_conn_hold(conn);
1052 conn->pending_sec_level = sec_level;
Jakub Pawlowski28a667c2015-08-07 20:22:54 +02001053 }
1054
Johan Hedberg1ebfcc12014-02-18 21:41:36 +02001055 conn->dst_type = dst_type;
Andre Guedes620ad522013-10-08 08:21:18 -03001056 conn->sec_level = BT_SECURITY_LOW;
Johan Hedberg09ae2602014-07-06 13:41:15 +03001057 conn->conn_timeout = conn_timeout;
Andre Guedes4292f1f2014-02-03 13:56:19 -03001058
Johan Hedberg3c857752014-03-25 10:30:49 +02001059 hci_req_init(&req, hdev);
1060
Johan Hedberg376f54c2014-07-08 15:07:52 +03001061 /* Disable advertising if we're active. For master role
1062 * connections most controllers will refuse to connect if
1063 * advertising is enabled, and for slave role connections we
1064 * anyway have to disable it in order to start directed
1065 * advertising.
1066 */
Sathish Narsimman05bd80a2020-02-17 14:37:44 +05301067 if (hci_dev_test_flag(hdev, HCI_LE_ADV))
1068 __hci_req_disable_advertising(&req);
Johan Hedberg376f54c2014-07-08 15:07:52 +03001069
Johan Hedbergcdd62752014-07-07 15:02:28 +03001070 /* If requested to connect as slave use directed advertising */
Johan Hedberge804d252014-07-16 11:42:28 +03001071 if (conn->role == HCI_ROLE_SLAVE) {
Johan Hedberge8bb6b92014-07-08 15:07:53 +03001072 /* If we're active scanning most controllers are unable
1073 * to initiate advertising. Simply reject the attempt.
1074 */
Marcel Holtmannd7a5a112015-03-13 02:11:00 -07001075 if (hci_dev_test_flag(hdev, HCI_LE_SCAN) &&
Johan Hedberge8bb6b92014-07-08 15:07:53 +03001076 hdev->le_scan_type == LE_SCAN_ACTIVE) {
Jaganath Kanakkasseryf17d8582017-10-25 10:58:48 +05301077 hci_req_purge(&req);
Johan Hedberge8bb6b92014-07-08 15:07:53 +03001078 hci_conn_del(conn);
1079 return ERR_PTR(-EBUSY);
1080 }
1081
Johan Hedberg3c857752014-03-25 10:30:49 +02001082 hci_req_directed_advertising(&req, conn);
1083 goto create_conn;
1084 }
1085
Andre Guedes4292f1f2014-02-03 13:56:19 -03001086 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
1087 if (params) {
1088 conn->le_conn_min_interval = params->conn_min_interval;
1089 conn->le_conn_max_interval = params->conn_max_interval;
Marcel Holtmann037fc412014-06-29 16:43:27 +02001090 conn->le_conn_latency = params->conn_latency;
1091 conn->le_supv_timeout = params->supervision_timeout;
Andre Guedes4292f1f2014-02-03 13:56:19 -03001092 } else {
1093 conn->le_conn_min_interval = hdev->le_conn_min_interval;
1094 conn->le_conn_max_interval = hdev->le_conn_max_interval;
Marcel Holtmann04fb7d92014-06-30 12:34:36 +02001095 conn->le_conn_latency = hdev->le_conn_latency;
1096 conn->le_supv_timeout = hdev->le_supv_timeout;
Andre Guedes4292f1f2014-02-03 13:56:19 -03001097 }
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -03001098
Andre Guedes2acf3d92014-02-26 20:21:42 -03001099 /* If controller is scanning, we stop it since some controllers are
Johan Hedberg81ad6fd2014-02-28 20:26:13 +02001100 * not able to scan and connect at the same time. Also set the
1101 * HCI_LE_SCAN_INTERRUPTED flag so that the command complete
1102 * handler for scan disabling knows to set the correct discovery
1103 * state.
Andre Guedes2acf3d92014-02-26 20:21:42 -03001104 */
Marcel Holtmannd7a5a112015-03-13 02:11:00 -07001105 if (hci_dev_test_flag(hdev, HCI_LE_SCAN)) {
Andre Guedes2acf3d92014-02-26 20:21:42 -03001106 hci_req_add_le_scan_disable(&req);
Marcel Holtmanna1536da2015-03-13 02:11:01 -07001107 hci_dev_set_flag(hdev, HCI_LE_SCAN_INTERRUPTED);
Andre Guedes2acf3d92014-02-26 20:21:42 -03001108 }
1109
Szymon Janc082f2302018-04-03 13:40:06 +02001110 hci_req_add_le_create_conn(&req, conn, direct_rpa);
Johan Hedberg81ad6fd2014-02-28 20:26:13 +02001111
Johan Hedberg3c857752014-03-25 10:30:49 +02001112create_conn:
Johan Hedberg81ad6fd2014-02-28 20:26:13 +02001113 err = hci_req_run(&req, create_le_conn_complete);
Andre Guedes2acf3d92014-02-26 20:21:42 -03001114 if (err) {
1115 hci_conn_del(conn);
Andre Guedes620ad522013-10-08 08:21:18 -03001116 return ERR_PTR(err);
Andre Guedes2acf3d92014-02-26 20:21:42 -03001117 }
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -03001118
Andre Guedesf1e5d542013-10-03 18:25:44 -03001119 return conn;
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -03001120}
1121
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001122static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type)
1123{
1124 struct hci_conn *conn;
1125
Johan Hedberg9d4c1cc2015-10-21 18:03:01 +03001126 conn = hci_conn_hash_lookup_le(hdev, addr, type);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001127 if (!conn)
1128 return false;
1129
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001130 if (conn->state != BT_CONNECTED)
1131 return false;
1132
1133 return true;
1134}
1135
1136/* This function requires the caller holds hdev->lock */
Johan Hedberg84235d22015-11-11 08:11:20 +02001137static int hci_explicit_conn_params_set(struct hci_dev *hdev,
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001138 bdaddr_t *addr, u8 addr_type)
1139{
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001140 struct hci_conn_params *params;
1141
1142 if (is_connected(hdev, addr, addr_type))
1143 return -EISCONN;
1144
Jakub Pawlowski5157b8a2015-10-16 10:07:54 +03001145 params = hci_conn_params_lookup(hdev, addr, addr_type);
1146 if (!params) {
1147 params = hci_conn_params_add(hdev, addr, addr_type);
1148 if (!params)
1149 return -ENOMEM;
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001150
Jakub Pawlowski5157b8a2015-10-16 10:07:54 +03001151 /* If we created new params, mark them to be deleted in
1152 * hci_connect_le_scan_cleanup. It's different case than
1153 * existing disabled params, those will stay after cleanup.
1154 */
1155 params->auto_connect = HCI_AUTO_CONN_EXPLICIT;
1156 }
1157
1158 /* We're trying to connect, so make sure params are at pend_le_conns */
Johan Hedberg49c50922015-10-16 10:07:51 +03001159 if (params->auto_connect == HCI_AUTO_CONN_DISABLED ||
Jakub Pawlowski5157b8a2015-10-16 10:07:54 +03001160 params->auto_connect == HCI_AUTO_CONN_REPORT ||
1161 params->auto_connect == HCI_AUTO_CONN_EXPLICIT) {
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001162 list_del_init(&params->action);
1163 list_add(&params->action, &hdev->pend_le_conns);
1164 }
1165
1166 params->explicit_connect = true;
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001167
1168 BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type,
1169 params->auto_connect);
1170
1171 return 0;
1172}
1173
1174/* This function requires the caller holds hdev->lock */
1175struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1176 u8 dst_type, u8 sec_level,
Johan Hedberg0ad06aa2015-11-11 14:44:57 +02001177 u16 conn_timeout)
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001178{
1179 struct hci_conn *conn;
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001180
1181 /* Let's make sure that le is enabled.*/
1182 if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
1183 if (lmp_le_capable(hdev))
1184 return ERR_PTR(-ECONNREFUSED);
1185
1186 return ERR_PTR(-EOPNOTSUPP);
1187 }
1188
1189 /* Some devices send ATT messages as soon as the physical link is
1190 * established. To be able to handle these ATT messages, the user-
1191 * space first establishes the connection and then starts the pairing
1192 * process.
1193 *
1194 * So if a hci_conn object already exists for the following connection
1195 * attempt, we simply update pending_sec_level and auth_type fields
1196 * and return the object found.
1197 */
Johan Hedberg9d4c1cc2015-10-21 18:03:01 +03001198 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001199 if (conn) {
1200 if (conn->pending_sec_level < sec_level)
1201 conn->pending_sec_level = sec_level;
1202 goto done;
1203 }
1204
1205 BT_DBG("requesting refresh of dst_addr");
1206
Johan Hedberg0ad06aa2015-11-11 14:44:57 +02001207 conn = hci_conn_add(hdev, LE_LINK, dst, HCI_ROLE_MASTER);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001208 if (!conn)
1209 return ERR_PTR(-ENOMEM);
1210
Navid Emamdoostd0883372019-11-21 14:20:36 -06001211 if (hci_explicit_conn_params_set(hdev, dst, dst_type) < 0) {
1212 hci_conn_del(conn);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001213 return ERR_PTR(-EBUSY);
Navid Emamdoostd0883372019-11-21 14:20:36 -06001214 }
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001215
1216 conn->state = BT_CONNECT;
1217 set_bit(HCI_CONN_SCANNING, &conn->flags);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001218 conn->dst_type = dst_type;
1219 conn->sec_level = BT_SECURITY_LOW;
1220 conn->pending_sec_level = sec_level;
1221 conn->conn_timeout = conn_timeout;
1222
Johan Hedberg84235d22015-11-11 08:11:20 +02001223 hci_update_background_scan(hdev);
1224
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001225done:
1226 hci_conn_hold(conn);
1227 return conn;
1228}
1229
Andre Guedes04a6c582014-02-26 20:21:44 -03001230struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1231 u8 sec_level, u8 auth_type)
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001232{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 struct hci_conn *acl;
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001234
Marcel Holtmannd7a5a112015-03-13 02:11:00 -07001235 if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) {
Lukasz Rymanowskic4111102015-02-11 12:31:41 +01001236 if (lmp_bredr_capable(hdev))
1237 return ERR_PTR(-ECONNREFUSED);
1238
Johan Hedbergbeb19e42014-07-18 11:15:26 +03001239 return ERR_PTR(-EOPNOTSUPP);
Lukasz Rymanowskic4111102015-02-11 12:31:41 +01001240 }
Johan Hedberg56f87902013-10-02 13:43:13 +03001241
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
1243 if (!acl) {
Johan Hedberga5c4e302014-07-16 11:56:07 +03001244 acl = hci_conn_add(hdev, ACL_LINK, dst, HCI_ROLE_MASTER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 if (!acl)
Johan Hedberg48c7aba2012-02-19 14:06:48 +02001246 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 }
1248
1249 hci_conn_hold(acl);
1250
1251 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
1252 acl->sec_level = BT_SECURITY_LOW;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001253 acl->pending_sec_level = sec_level;
1254 acl->auth_type = auth_type;
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -03001255 hci_acl_create_connection(acl);
Nick Pellyc3902162009-11-13 14:16:32 -08001256 }
1257
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -03001258 return acl;
1259}
1260
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +02001261struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1262 __u16 setting)
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -03001263{
1264 struct hci_conn *acl;
1265 struct hci_conn *sco;
1266
Frédéric Dalleaue660ed62013-08-19 14:23:54 +02001267 acl = hci_connect_acl(hdev, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -03001268 if (IS_ERR(acl))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001269 return acl;
1270
1271 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
1272 if (!sco) {
Johan Hedberga5c4e302014-07-16 11:56:07 +03001273 sco = hci_conn_add(hdev, type, dst, HCI_ROLE_MASTER);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001274 if (!sco) {
David Herrmann76a68ba2013-04-06 20:28:37 +02001275 hci_conn_drop(acl);
Johan Hedberg48c7aba2012-02-19 14:06:48 +02001276 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 }
1278 }
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001279
1280 acl->link = sco;
1281 sco->link = acl;
1282
1283 hci_conn_hold(sco);
1284
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +02001285 sco->setting = setting;
1286
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001287 if (acl->state == BT_CONNECTED &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001288 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Johan Hedberg58a681e2012-01-16 06:47:28 +02001289 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07001290 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001291
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001292 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001293 /* defer SCO setup until mode change completed */
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001294 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
Marcel Holtmann0684e5f2009-02-09 02:48:38 +01001295 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 }
1297
1298 hci_sco_setup(acl, 0x00);
Marcel Holtmann96a31832009-02-12 16:23:03 +01001299 }
Marcel Holtmann0684e5f2009-02-09 02:48:38 +01001300
Marcel Holtmann96a31832009-02-12 16:23:03 +01001301 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
1304/* Check link security requirement */
1305int hci_conn_check_link_mode(struct hci_conn *conn)
1306{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001307 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Marcel Holtmann40b552a2014-03-19 14:10:25 -07001309 /* In Secure Connections Only mode, it is required that Secure
1310 * Connections is used and the link is encrypted with AES-CCM
1311 * using a P-256 authenticated combination key.
1312 */
Marcel Holtmannd7a5a112015-03-13 02:11:00 -07001313 if (hci_dev_test_flag(conn->hdev, HCI_SC_ONLY)) {
Marcel Holtmann40b552a2014-03-19 14:10:25 -07001314 if (!hci_conn_sc_enabled(conn) ||
1315 !test_bit(HCI_CONN_AES_CCM, &conn->flags) ||
1316 conn->key_type != HCI_LK_AUTH_COMBINATION_P256)
1317 return 0;
1318 }
1319
Johan Hedberg4dae2792014-06-24 17:03:50 +03001320 if (hci_conn_ssp_enabled(conn) &&
1321 !test_bit(HCI_CONN_ENCRYPT, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 return 0;
1323
1324 return 1;
1325}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
1327/* Authenticate remote device */
1328static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
1329{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001330 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
Johan Hedberg765c2a92011-01-19 12:06:52 +05301332 if (conn->pending_sec_level > sec_level)
1333 sec_level = conn->pending_sec_level;
1334
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 if (sec_level > conn->sec_level)
Johan Hedberg765c2a92011-01-19 12:06:52 +05301336 conn->pending_sec_level = sec_level;
Johan Hedberg4dae2792014-06-24 17:03:50 +03001337 else if (test_bit(HCI_CONN_AUTH, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 return 1;
1339
Johan Hedberg65cf6862011-01-19 12:06:49 +05301340 /* Make sure we preserve an existing MITM requirement*/
1341 auth_type |= (conn->auth_type & 0x01);
1342
Marcel Holtmann96a31832009-02-12 16:23:03 +01001343 conn->auth_type = auth_type;
1344
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001345 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 struct hci_cp_auth_requested cp;
Peter Hurleyb7d05ba2012-01-13 15:11:30 +01001347
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07001348 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +02001349 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001350 sizeof(cp), &cp);
Johan Hedberg09da1f32014-04-11 12:02:32 -07001351
1352 /* If we're already encrypted set the REAUTH_PEND flag,
1353 * otherwise set the ENCRYPT_PEND.
1354 */
Johan Hedberg4dae2792014-06-24 17:03:50 +03001355 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001356 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Johan Hedberg09da1f32014-04-11 12:02:32 -07001357 else
1358 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001360
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 return 0;
1362}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001364/* Encrypt the the link */
1365static void hci_conn_encrypt(struct hci_conn *conn)
1366{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001367 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001368
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001369 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001370 struct hci_cp_set_conn_encrypt cp;
1371 cp.handle = cpu_to_le16(conn->handle);
1372 cp.encrypt = 0x01;
1373 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001374 &cp);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001375 }
1376}
1377
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001378/* Enable security */
Johan Hedberge7cafc42014-07-17 15:35:38 +03001379int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1380 bool initiator)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001382 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383
Vinicius Costa Gomesd8343f12012-08-23 21:32:44 -03001384 if (conn->type == LE_LINK)
1385 return smp_conn_security(conn, sec_level);
1386
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001387 /* For sdp we don't need the link key. */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001388 if (sec_level == BT_SECURITY_SDP)
1389 return 1;
1390
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001391 /* For non 2.1 devices and low security level we don't need the link
1392 key. */
Johan Hedbergaa64a8b2012-01-18 21:33:12 +02001393 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -07001394 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001395
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001396 /* For other security levels we need the link key. */
Johan Hedberg4dae2792014-06-24 17:03:50 +03001397 if (!test_bit(HCI_CONN_AUTH, &conn->flags))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001398 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Marcel Holtmann7b5a9242014-01-15 22:37:39 -08001400 /* An authenticated FIPS approved combination key has sufficient
1401 * security for security level 4. */
1402 if (conn->key_type == HCI_LK_AUTH_COMBINATION_P256 &&
1403 sec_level == BT_SECURITY_FIPS)
1404 goto encrypt;
1405
1406 /* An authenticated combination key has sufficient security for
1407 security level 3. */
1408 if ((conn->key_type == HCI_LK_AUTH_COMBINATION_P192 ||
1409 conn->key_type == HCI_LK_AUTH_COMBINATION_P256) &&
1410 sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001411 goto encrypt;
1412
1413 /* An unauthenticated combination key has sufficient security for
1414 security level 1 and 2. */
Marcel Holtmann66138ce2014-01-10 02:07:20 -08001415 if ((conn->key_type == HCI_LK_UNAUTH_COMBINATION_P192 ||
1416 conn->key_type == HCI_LK_UNAUTH_COMBINATION_P256) &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001417 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001418 goto encrypt;
1419
1420 /* A combination key has always sufficient security for the security
1421 levels 1 or 2. High security level requires the combination key
1422 is generated using maximum PIN code length (16).
1423 For pre 2.1 units. */
1424 if (conn->key_type == HCI_LK_COMBINATION &&
Marcel Holtmann7b5a9242014-01-15 22:37:39 -08001425 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW ||
1426 conn->pin_length == 16))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001427 goto encrypt;
1428
1429auth:
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001430 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 return 0;
1432
Johan Hedberg977f8fc2014-07-17 15:35:39 +03001433 if (initiator)
1434 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
1435
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +03001436 if (!hci_conn_auth(conn, sec_level, auth_type))
1437 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001438
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001439encrypt:
Marcel Holtmann693cd8c2019-06-22 15:47:01 +02001440 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags)) {
1441 /* Ensure that the encryption key size has been read,
1442 * otherwise stall the upper layer responses.
1443 */
1444 if (!conn->enc_key_size)
1445 return 0;
1446
1447 /* Nothing else needed, all requirements are met */
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001448 return 1;
Marcel Holtmann693cd8c2019-06-22 15:47:01 +02001449 }
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001450
1451 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 return 0;
1453}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001454EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001456/* Check secure link requirement */
1457int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
1458{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001459 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001460
Marcel Holtmann9cb2e032014-02-01 11:32:25 -08001461 /* Accept if non-secure or higher security level is required */
1462 if (sec_level != BT_SECURITY_HIGH && sec_level != BT_SECURITY_FIPS)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001463 return 1;
1464
Marcel Holtmann9cb2e032014-02-01 11:32:25 -08001465 /* Accept if secure or higher security level is already present */
1466 if (conn->sec_level == BT_SECURITY_HIGH ||
1467 conn->sec_level == BT_SECURITY_FIPS)
1468 return 1;
1469
1470 /* Reject not secure link */
1471 return 0;
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001472}
1473EXPORT_SYMBOL(hci_conn_check_secure);
1474
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001476int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001478 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
Johan Hedberg40bef302014-07-16 11:42:27 +03001480 if (role == conn->role)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 return 1;
1482
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001483 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 struct hci_cp_switch_role cp;
1485 bacpy(&cp.bdaddr, &conn->dst);
1486 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001487 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001489
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 return 0;
1491}
1492EXPORT_SYMBOL(hci_conn_switch_role);
1493
Marcel Holtmann04837f62006-07-03 10:02:33 +02001494/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07001495void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +02001496{
1497 struct hci_dev *hdev = conn->hdev;
1498
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001499 BT_DBG("hcon %p mode %d", conn, conn->mode);
Marcel Holtmann04837f62006-07-03 10:02:33 +02001500
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07001501 if (conn->mode != HCI_CM_SNIFF)
1502 goto timer;
1503
Johan Hedberg58a681e2012-01-16 06:47:28 +02001504 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +02001505 goto timer;
1506
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001507 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +02001508 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07001509 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001510 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +02001511 }
1512
1513timer:
1514 if (hdev->idle_timeout > 0)
Johan Hedberga74a84f2013-10-16 18:11:40 +03001515 queue_delayed_work(hdev->workqueue, &conn->idle_work,
1516 msecs_to_jiffies(hdev->idle_timeout));
Marcel Holtmann04837f62006-07-03 10:02:33 +02001517}
1518
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519/* Drop all connection on the device */
1520void hci_conn_hash_flush(struct hci_dev *hdev)
1521{
1522 struct hci_conn_hash *h = &hdev->conn_hash;
Andrei Emeltchenko3c4e0df02012-02-02 10:32:17 +02001523 struct hci_conn *c, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
1525 BT_DBG("hdev %s", hdev->name);
1526
Andrei Emeltchenko3c4e0df02012-02-02 10:32:17 +02001527 list_for_each_entry_safe(c, n, &h->list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 c->state = BT_CLOSED;
1529
Johan Hedberg3a6d5762015-02-18 14:53:58 +02001530 hci_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 hci_conn_del(c);
1532 }
1533}
1534
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001535/* Check pending connect attempts */
1536void hci_conn_check_pending(struct hci_dev *hdev)
1537{
1538 struct hci_conn *conn;
1539
1540 BT_DBG("hdev %s", hdev->name);
1541
1542 hci_dev_lock(hdev);
1543
1544 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
1545 if (conn)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -03001546 hci_acl_create_connection(conn);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001547
1548 hci_dev_unlock(hdev);
1549}
1550
Johan Hedberg4dae2792014-06-24 17:03:50 +03001551static u32 get_link_mode(struct hci_conn *conn)
1552{
1553 u32 link_mode = 0;
1554
Johan Hedberg40bef302014-07-16 11:42:27 +03001555 if (conn->role == HCI_ROLE_MASTER)
Johan Hedberg4dae2792014-06-24 17:03:50 +03001556 link_mode |= HCI_LM_MASTER;
1557
1558 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1559 link_mode |= HCI_LM_ENCRYPT;
1560
1561 if (test_bit(HCI_CONN_AUTH, &conn->flags))
1562 link_mode |= HCI_LM_AUTH;
1563
1564 if (test_bit(HCI_CONN_SECURE, &conn->flags))
1565 link_mode |= HCI_LM_SECURE;
1566
1567 if (test_bit(HCI_CONN_FIPS, &conn->flags))
1568 link_mode |= HCI_LM_FIPS;
1569
1570 return link_mode;
1571}
1572
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573int hci_get_conn_list(void __user *arg)
1574{
Gustavo Padovanfc5fef62012-05-23 04:04:19 -03001575 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 struct hci_conn_list_req req, *cl;
1577 struct hci_conn_info *ci;
1578 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 int n = 0, size, err;
1580
1581 if (copy_from_user(&req, arg, sizeof(req)))
1582 return -EFAULT;
1583
1584 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
1585 return -EINVAL;
1586
1587 size = sizeof(req) + req.conn_num * sizeof(*ci);
1588
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001589 cl = kmalloc(size, GFP_KERNEL);
1590 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 return -ENOMEM;
1592
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001593 hdev = hci_dev_get(req.dev_id);
1594 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 kfree(cl);
1596 return -ENODEV;
1597 }
1598
1599 ci = cl->conn_info;
1600
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001601 hci_dev_lock(hdev);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001602 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 bacpy(&(ci + n)->bdaddr, &c->dst);
1604 (ci + n)->handle = c->handle;
1605 (ci + n)->type = c->type;
1606 (ci + n)->out = c->out;
1607 (ci + n)->state = c->state;
Johan Hedberg4dae2792014-06-24 17:03:50 +03001608 (ci + n)->link_mode = get_link_mode(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 if (++n >= req.conn_num)
1610 break;
1611 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001612 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
1614 cl->dev_id = hdev->id;
1615 cl->conn_num = n;
1616 size = sizeof(req) + n * sizeof(*ci);
1617
1618 hci_dev_put(hdev);
1619
1620 err = copy_to_user(arg, cl, size);
1621 kfree(cl);
1622
1623 return err ? -EFAULT : 0;
1624}
1625
1626int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
1627{
1628 struct hci_conn_info_req req;
1629 struct hci_conn_info ci;
1630 struct hci_conn *conn;
1631 char __user *ptr = arg + sizeof(req);
1632
1633 if (copy_from_user(&req, arg, sizeof(req)))
1634 return -EFAULT;
1635
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001636 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
1638 if (conn) {
1639 bacpy(&ci.bdaddr, &conn->dst);
1640 ci.handle = conn->handle;
1641 ci.type = conn->type;
1642 ci.out = conn->out;
1643 ci.state = conn->state;
Johan Hedberg4dae2792014-06-24 17:03:50 +03001644 ci.link_mode = get_link_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001646 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648 if (!conn)
1649 return -ENOENT;
1650
1651 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
1652}
Marcel Holtmann40be4922008-07-14 20:13:50 +02001653
1654int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
1655{
1656 struct hci_auth_info_req req;
1657 struct hci_conn *conn;
1658
1659 if (copy_from_user(&req, arg, sizeof(req)))
1660 return -EFAULT;
1661
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001662 hci_dev_lock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +02001663 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
1664 if (conn)
1665 req.type = conn->auth_type;
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001666 hci_dev_unlock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +02001667
1668 if (!conn)
1669 return -ENOENT;
1670
1671 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
1672}
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001673
1674struct hci_chan *hci_chan_create(struct hci_conn *conn)
1675{
1676 struct hci_dev *hdev = conn->hdev;
1677 struct hci_chan *chan;
1678
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001679 BT_DBG("%s hcon %p", hdev->name, conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001680
Johan Hedbergf94b6652014-08-18 00:41:44 +03001681 if (test_bit(HCI_CONN_DROP, &conn->flags)) {
1682 BT_DBG("Refusing to create new hci_chan");
1683 return NULL;
1684 }
1685
Johan Hedberg27f70f32014-07-21 10:50:06 +03001686 chan = kzalloc(sizeof(*chan), GFP_KERNEL);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001687 if (!chan)
1688 return NULL;
1689
Johan Hedberg6c388d32014-08-18 00:41:42 +03001690 chan->conn = hci_conn_get(conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001691 skb_queue_head_init(&chan->data_q);
Mat Martineau168df8e2012-10-23 15:24:13 -07001692 chan->state = BT_CONNECTED;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001693
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02001694 list_add_rcu(&chan->list, &conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001695
1696 return chan;
1697}
1698
Andrei Emeltchenko94720072012-09-06 15:05:43 +03001699void hci_chan_del(struct hci_chan *chan)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001700{
1701 struct hci_conn *conn = chan->conn;
1702 struct hci_dev *hdev = conn->hdev;
1703
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001704 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001705
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02001706 list_del_rcu(&chan->list);
1707
1708 synchronize_rcu();
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001709
Johan Hedbergbcbb6552014-08-18 20:33:27 +03001710 /* Prevent new hci_chan's to be created for this hci_conn */
Johan Hedbergf94b6652014-08-18 00:41:44 +03001711 set_bit(HCI_CONN_DROP, &conn->flags);
Johan Hedbergb3ff6702014-08-18 00:41:43 +03001712
Johan Hedberg6c388d32014-08-18 00:41:42 +03001713 hci_conn_put(conn);
Andrei Emeltchenkoe9b02742012-10-25 15:20:51 +03001714
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001715 skb_queue_purge(&chan->data_q);
1716 kfree(chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001717}
1718
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -02001719void hci_chan_list_flush(struct hci_conn *conn)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001720{
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +02001721 struct hci_chan *chan, *n;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001722
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001723 BT_DBG("hcon %p", conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001724
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +02001725 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001726 hci_chan_del(chan);
1727}
Andrei Emeltchenko42c4e532012-10-10 17:38:28 +03001728
1729static struct hci_chan *__hci_chan_lookup_handle(struct hci_conn *hcon,
1730 __u16 handle)
1731{
1732 struct hci_chan *hchan;
1733
1734 list_for_each_entry(hchan, &hcon->chan_list, list) {
1735 if (hchan->handle == handle)
1736 return hchan;
1737 }
1738
1739 return NULL;
1740}
1741
1742struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle)
1743{
1744 struct hci_conn_hash *h = &hdev->conn_hash;
1745 struct hci_conn *hcon;
1746 struct hci_chan *hchan = NULL;
1747
1748 rcu_read_lock();
1749
1750 list_for_each_entry_rcu(hcon, &h->list, list) {
1751 hchan = __hci_chan_lookup_handle(hcon, handle);
1752 if (hchan)
1753 break;
1754 }
1755
1756 rcu_read_unlock();
1757
1758 return hchan;
1759}
Luiz Augusto von Dentzeab24042020-02-14 10:08:57 -08001760
1761u32 hci_conn_get_phy(struct hci_conn *conn)
1762{
1763 u32 phys = 0;
1764
1765 hci_dev_lock(conn->hdev);
1766
1767 /* BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 2, Part B page 471:
1768 * Table 6.2: Packets defined for synchronous, asynchronous, and
1769 * CSB logical transport types.
1770 */
1771 switch (conn->type) {
1772 case SCO_LINK:
1773 /* SCO logical transport (1 Mb/s):
1774 * HV1, HV2, HV3 and DV.
1775 */
1776 phys |= BT_PHY_BR_1M_1SLOT;
1777
1778 break;
1779
1780 case ACL_LINK:
1781 /* ACL logical transport (1 Mb/s) ptt=0:
1782 * DH1, DM3, DH3, DM5 and DH5.
1783 */
1784 phys |= BT_PHY_BR_1M_1SLOT;
1785
1786 if (conn->pkt_type & (HCI_DM3 | HCI_DH3))
1787 phys |= BT_PHY_BR_1M_3SLOT;
1788
1789 if (conn->pkt_type & (HCI_DM5 | HCI_DH5))
1790 phys |= BT_PHY_BR_1M_5SLOT;
1791
1792 /* ACL logical transport (2 Mb/s) ptt=1:
1793 * 2-DH1, 2-DH3 and 2-DH5.
1794 */
1795 if (!(conn->pkt_type & HCI_2DH1))
1796 phys |= BT_PHY_EDR_2M_1SLOT;
1797
1798 if (!(conn->pkt_type & HCI_2DH3))
1799 phys |= BT_PHY_EDR_2M_3SLOT;
1800
1801 if (!(conn->pkt_type & HCI_2DH5))
1802 phys |= BT_PHY_EDR_2M_5SLOT;
1803
1804 /* ACL logical transport (3 Mb/s) ptt=1:
1805 * 3-DH1, 3-DH3 and 3-DH5.
1806 */
1807 if (!(conn->pkt_type & HCI_3DH1))
1808 phys |= BT_PHY_EDR_3M_1SLOT;
1809
1810 if (!(conn->pkt_type & HCI_3DH3))
1811 phys |= BT_PHY_EDR_3M_3SLOT;
1812
1813 if (!(conn->pkt_type & HCI_3DH5))
1814 phys |= BT_PHY_EDR_3M_5SLOT;
1815
1816 break;
1817
1818 case ESCO_LINK:
1819 /* eSCO logical transport (1 Mb/s): EV3, EV4 and EV5 */
1820 phys |= BT_PHY_BR_1M_1SLOT;
1821
1822 if (!(conn->pkt_type & (ESCO_EV4 | ESCO_EV5)))
1823 phys |= BT_PHY_BR_1M_3SLOT;
1824
1825 /* eSCO logical transport (2 Mb/s): 2-EV3, 2-EV5 */
1826 if (!(conn->pkt_type & ESCO_2EV3))
1827 phys |= BT_PHY_EDR_2M_1SLOT;
1828
1829 if (!(conn->pkt_type & ESCO_2EV5))
1830 phys |= BT_PHY_EDR_2M_3SLOT;
1831
1832 /* eSCO logical transport (3 Mb/s): 3-EV3, 3-EV5 */
1833 if (!(conn->pkt_type & ESCO_3EV3))
1834 phys |= BT_PHY_EDR_3M_1SLOT;
1835
1836 if (!(conn->pkt_type & ESCO_3EV5))
1837 phys |= BT_PHY_EDR_3M_3SLOT;
1838
1839 break;
1840
1841 case LE_LINK:
1842 if (conn->le_tx_phy & HCI_LE_SET_PHY_1M)
1843 phys |= BT_PHY_LE_1M_TX;
1844
1845 if (conn->le_rx_phy & HCI_LE_SET_PHY_1M)
1846 phys |= BT_PHY_LE_1M_RX;
1847
1848 if (conn->le_tx_phy & HCI_LE_SET_PHY_2M)
1849 phys |= BT_PHY_LE_2M_TX;
1850
1851 if (conn->le_rx_phy & HCI_LE_SET_PHY_2M)
1852 phys |= BT_PHY_LE_2M_RX;
1853
1854 if (conn->le_tx_phy & HCI_LE_SET_PHY_CODED)
1855 phys |= BT_PHY_LE_CODED_TX;
1856
1857 if (conn->le_rx_phy & HCI_LE_SET_PHY_CODED)
1858 phys |= BT_PHY_LE_CODED_RX;
1859
1860 break;
1861 }
1862
1863 hci_dev_unlock(conn->hdev);
1864
1865 return phys;
1866}