blob: 1ed1e153b3fade0d67f6e7e06b5931906dd927ad [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
125 if (hdev->notify)
126 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
127
128 hci_conn_del_sysfs(conn);
129
130 debugfs_remove_recursive(conn->debugfs);
131
132 hci_dev_put(hdev);
133
134 hci_conn_put(conn);
135}
136
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300137static void le_scan_cleanup(struct work_struct *work)
138{
139 struct hci_conn *conn = container_of(work, struct hci_conn,
140 le_scan_cleanup);
141 struct hci_dev *hdev = conn->hdev;
142 struct hci_conn *c = NULL;
143
144 BT_DBG("%s hcon %p", hdev->name, conn);
145
146 hci_dev_lock(hdev);
147
148 /* Check that the hci_conn is still around */
149 rcu_read_lock();
150 list_for_each_entry_rcu(c, &hdev->conn_hash.list, list) {
151 if (c == conn)
152 break;
153 }
154 rcu_read_unlock();
155
156 if (c == conn) {
157 hci_connect_le_scan_cleanup(conn);
158 hci_conn_cleanup(conn);
159 }
160
161 hci_dev_unlock(hdev);
162 hci_dev_put(hdev);
163 hci_conn_put(conn);
164}
165
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200166static void hci_connect_le_scan_remove(struct hci_conn *conn)
167{
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300168 BT_DBG("%s hcon %p", conn->hdev->name, conn);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200169
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300170 /* We can't call hci_conn_del/hci_conn_cleanup here since that
171 * could deadlock with another hci_conn_del() call that's holding
172 * hci_dev_lock and doing cancel_delayed_work_sync(&conn->disc_work).
173 * Instead, grab temporary extra references to the hci_dev and
174 * hci_conn and perform the necessary cleanup in a separate work
175 * callback.
Johan Hedbergb958f9a2015-10-16 10:07:50 +0300176 */
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300177
178 hci_dev_hold(conn->hdev);
179 hci_conn_get(conn);
180
Johan Hedberg0ebc1812015-11-06 13:35:33 +0200181 /* Even though we hold a reference to the hdev, many other
182 * things might get cleaned up meanwhile, including the hdev's
183 * own workqueue, so we can't use that for scheduling.
184 */
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300185 schedule_work(&conn->le_scan_cleanup);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200186}
187
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300188static void hci_acl_create_connection(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
190 struct hci_dev *hdev = conn->hdev;
191 struct inquiry_entry *ie;
192 struct hci_cp_create_conn cp;
193
Andrei Emeltchenko42d2d872012-02-17 11:40:57 +0200194 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
196 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200197 conn->out = true;
Johan Hedberg40bef302014-07-16 11:42:27 +0300198 conn->role = HCI_ROLE_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200200 conn->attempt++;
201
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200202 conn->link_policy = hdev->link_policy;
203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 memset(&cp, 0, sizeof(cp));
205 bacpy(&cp.bdaddr, &conn->dst);
206 cp.pscan_rep_mode = 0x02;
207
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200208 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
209 if (ie) {
Marcel Holtmann41a96212008-07-14 20:13:48 +0200210 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
211 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
212 cp.pscan_mode = ie->data.pscan_mode;
213 cp.clock_offset = ie->data.clock_offset |
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700214 cpu_to_le16(0x8000);
Marcel Holtmann41a96212008-07-14 20:13:48 +0200215 }
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 memcpy(conn->dev_class, ie->data.dev_class, 3);
Johan Hedberg58a681e2012-01-16 06:47:28 +0200218 if (ie->data.ssp_mode > 0)
219 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 }
221
Marcel Holtmanna8746412008-07-14 20:13:46 +0200222 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200224 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200226 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200227
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200228 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
230
Johan Hedberge3b679d2014-08-18 20:33:32 +0300231int hci_disconnect(struct hci_conn *conn, __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300233 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Johan Hedberg839035a2014-08-18 20:33:34 +0300235 /* When we are master of an established connection and it enters
236 * the disconnect timeout, then go ahead and try to read the
237 * current clock offset. Processing of the result is done
238 * within the event handling and hci_clock_offset_evt function.
239 */
Johan Hedberg88d07fe2015-10-22 10:49:39 +0300240 if (conn->type == ACL_LINK && conn->role == HCI_ROLE_MASTER &&
241 (conn->state == BT_CONNECTED || conn->state == BT_CONFIG)) {
Johan Hedberg839035a2014-08-18 20:33:34 +0300242 struct hci_dev *hdev = conn->hdev;
Fabian Frederick4f639ed2014-10-25 10:48:58 +0200243 struct hci_cp_read_clock_offset clkoff_cp;
Johan Hedberg839035a2014-08-18 20:33:34 +0300244
Fabian Frederick4f639ed2014-10-25 10:48:58 +0200245 clkoff_cp.handle = cpu_to_le16(conn->handle);
246 hci_send_cmd(hdev, HCI_OP_READ_CLOCK_OFFSET, sizeof(clkoff_cp),
247 &clkoff_cp);
Johan Hedberg839035a2014-08-18 20:33:34 +0300248 }
249
Johan Hedberg88d07fe2015-10-22 10:49:39 +0300250 return hci_abort_conn(conn, reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251}
252
Vinicius Costa Gomes57f5d0d2012-07-27 19:32:54 -0300253static void hci_add_sco(struct hci_conn *conn, __u16 handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
255 struct hci_dev *hdev = conn->hdev;
256 struct hci_cp_add_sco cp;
257
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300258 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200261 conn->out = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Marcel Holtmannefc76882009-02-06 09:13:37 +0100263 conn->attempt++;
264
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700265 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200266 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200268 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200271bool hci_setup_sync(struct hci_conn *conn, __u16 handle)
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200272{
273 struct hci_dev *hdev = conn->hdev;
274 struct hci_cp_setup_sync_conn cp;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200275 const struct sco_param *param;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200276
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300277 BT_DBG("hcon %p", conn);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200278
279 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200280 conn->out = true;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200281
Marcel Holtmannefc76882009-02-06 09:13:37 +0100282 conn->attempt++;
283
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200284 cp.handle = cpu_to_le16(handle);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200285
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700286 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
287 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200288 cp.voice_setting = cpu_to_le16(conn->setting);
289
290 switch (conn->setting & SCO_AIRMODE_MASK) {
291 case SCO_AIRMODE_TRANSP:
Johan Hedberg565766b2014-09-25 09:48:01 +0300292 if (conn->attempt > ARRAY_SIZE(esco_param_msbc))
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200293 return false;
Johan Hedberg565766b2014-09-25 09:48:01 +0300294 param = &esco_param_msbc[conn->attempt - 1];
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200295 break;
296 case SCO_AIRMODE_CVSD:
Bernhard Thaler48e68ff2014-09-23 11:01:07 +0200297 if (lmp_esco_capable(conn->link)) {
298 if (conn->attempt > ARRAY_SIZE(esco_param_cvsd))
299 return false;
Bernhard Thaler48e68ff2014-09-23 11:01:07 +0200300 param = &esco_param_cvsd[conn->attempt - 1];
301 } else {
302 if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
303 return false;
Bernhard Thaler48e68ff2014-09-23 11:01:07 +0200304 param = &sco_param_cvsd[conn->attempt - 1];
305 }
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200306 break;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200307 default:
308 return false;
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200309 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200310
Johan Hedbergc7da5792014-09-24 22:41:46 +0300311 cp.retrans_effort = param->retrans_effort;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200312 cp.pkt_type = __cpu_to_le16(param->pkt_type);
313 cp.max_latency = __cpu_to_le16(param->max_latency);
314
315 if (hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp) < 0)
316 return false;
317
318 return true;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200319}
320
Johan Hedberg7d6ca692014-07-02 17:37:31 +0300321u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
322 u16 to_multiplier)
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200323{
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200324 struct hci_dev *hdev = conn->hdev;
Marcel Holtmannf044eb02014-06-29 16:43:26 +0200325 struct hci_conn_params *params;
326 struct hci_cp_le_conn_update cp;
327
328 hci_dev_lock(hdev);
329
330 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
331 if (params) {
332 params->conn_min_interval = min;
333 params->conn_max_interval = max;
334 params->conn_latency = latency;
335 params->supervision_timeout = to_multiplier;
336 }
337
338 hci_dev_unlock(hdev);
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200339
340 memset(&cp, 0, sizeof(cp));
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200341 cp.handle = cpu_to_le16(conn->handle);
342 cp.conn_interval_min = cpu_to_le16(min);
343 cp.conn_interval_max = cpu_to_le16(max);
344 cp.conn_latency = cpu_to_le16(latency);
345 cp.supervision_timeout = cpu_to_le16(to_multiplier);
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700346 cp.min_ce_len = cpu_to_le16(0x0000);
347 cp.max_ce_len = cpu_to_le16(0x0000);
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200348
349 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
Johan Hedberg7d6ca692014-07-02 17:37:31 +0300350
351 if (params)
352 return 0x01;
353
354 return 0x00;
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200355}
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200356
Marcel Holtmannfe39c7b2014-02-27 16:00:28 -0800357void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
Johan Hedberg8b76ce32015-06-08 18:14:39 +0300358 __u8 ltk[16], __u8 key_size)
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300359{
360 struct hci_dev *hdev = conn->hdev;
361 struct hci_cp_le_start_enc cp;
362
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300363 BT_DBG("hcon %p", conn);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300364
365 memset(&cp, 0, sizeof(cp));
366
367 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmannfe39c7b2014-02-27 16:00:28 -0800368 cp.rand = rand;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300369 cp.ediv = ediv;
Johan Hedberg8b76ce32015-06-08 18:14:39 +0300370 memcpy(cp.ltk, ltk, key_size);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300371
372 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
373}
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300374
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400375/* Device _must_ be locked */
376void hci_sco_setup(struct hci_conn *conn, __u8 status)
377{
378 struct hci_conn *sco = conn->link;
379
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400380 if (!sco)
381 return;
382
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300383 BT_DBG("hcon %p", conn);
384
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400385 if (!status) {
386 if (lmp_esco_capable(conn->hdev))
387 hci_setup_sync(sco, conn->handle);
388 else
389 hci_add_sco(sco, conn->handle);
390 } else {
Johan Hedberg539c4962015-02-18 14:53:57 +0200391 hci_connect_cfm(sco, status);
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400392 hci_conn_del(sco);
393 }
394}
395
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300396static void hci_conn_timeout(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397{
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300398 struct hci_conn *conn = container_of(work, struct hci_conn,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300399 disc_work.work);
Lukasz Rymanowski1d56dc42014-06-17 13:04:20 +0200400 int refcnt = atomic_read(&conn->refcnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300402 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Lukasz Rymanowski1d56dc42014-06-17 13:04:20 +0200404 WARN_ON(refcnt < 0);
405
406 /* FIXME: It was observed that in pairing failed scenario, refcnt
407 * drops below 0. Probably this is because l2cap_conn_del calls
408 * l2cap_chan_del for each channel, and inside l2cap_chan_del conn is
409 * dropped. After that loop hci_chan_del is called which also drops
410 * conn. For now make sure that ACL is alive if refcnt is higher then 0,
411 * otherwise drop it.
412 */
413 if (refcnt > 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return;
415
Johan Hedberg89e0ccc2015-10-22 10:49:38 +0300416 /* LE connections in scanning state need special handling */
417 if (conn->state == BT_CONNECT && conn->type == LE_LINK &&
418 test_bit(HCI_CONN_SCANNING, &conn->flags)) {
419 hci_connect_le_scan_remove(conn);
420 return;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200421 }
Johan Hedberg89e0ccc2015-10-22 10:49:38 +0300422
423 hci_abort_conn(conn, hci_proto_disconn_ind(conn));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424}
425
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200426/* Enter sniff mode */
Johan Hedberga74a84f2013-10-16 18:11:40 +0300427static void hci_conn_idle(struct work_struct *work)
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200428{
Johan Hedberga74a84f2013-10-16 18:11:40 +0300429 struct hci_conn *conn = container_of(work, struct hci_conn,
430 idle_work.work);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200431 struct hci_dev *hdev = conn->hdev;
432
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300433 BT_DBG("hcon %p mode %d", conn, conn->mode);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200434
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200435 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
436 return;
437
438 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
439 return;
440
441 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
442 struct hci_cp_sniff_subrate cp;
443 cp.handle = cpu_to_le16(conn->handle);
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700444 cp.max_latency = cpu_to_le16(0);
445 cp.min_remote_timeout = cpu_to_le16(0);
446 cp.min_local_timeout = cpu_to_le16(0);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200447 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
448 }
449
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200450 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200451 struct hci_cp_sniff_mode cp;
452 cp.handle = cpu_to_le16(conn->handle);
453 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
454 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700455 cp.attempt = cpu_to_le16(4);
456 cp.timeout = cpu_to_le16(1);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200457 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
458 }
459}
460
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300461static void hci_conn_auto_accept(struct work_struct *work)
Johan Hedberg9f616562011-04-28 11:28:54 -0700462{
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300463 struct hci_conn *conn = container_of(work, struct hci_conn,
464 auto_accept_work.work);
Johan Hedberg9f616562011-04-28 11:28:54 -0700465
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300466 hci_send_cmd(conn->hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300467 &conn->dst);
Johan Hedberg9f616562011-04-28 11:28:54 -0700468}
469
Johan Hedberg9489eca2014-02-28 17:45:46 +0200470static void le_conn_timeout(struct work_struct *work)
471{
472 struct hci_conn *conn = container_of(work, struct hci_conn,
473 le_conn_timeout.work);
Johan Hedberg3c857752014-03-25 10:30:49 +0200474 struct hci_dev *hdev = conn->hdev;
Johan Hedberg9489eca2014-02-28 17:45:46 +0200475
476 BT_DBG("");
477
Johan Hedberg3c857752014-03-25 10:30:49 +0200478 /* We could end up here due to having done directed advertising,
479 * so clean up the state if necessary. This should however only
480 * happen with broken hardware or if low duty cycle was used
481 * (which doesn't have a timeout of its own).
482 */
Johan Hedberg0b1db38c2014-10-28 22:23:27 +0100483 if (conn->role == HCI_ROLE_SLAVE) {
Johan Hedberg3c857752014-03-25 10:30:49 +0200484 u8 enable = 0x00;
485 hci_send_cmd(hdev, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable),
486 &enable);
487 hci_le_conn_failed(conn, HCI_ERROR_ADVERTISING_TIMEOUT);
488 return;
489 }
490
Johan Hedberg89e0ccc2015-10-22 10:49:38 +0300491 hci_abort_conn(conn, HCI_ERROR_REMOTE_USER_TERM);
Johan Hedberg9489eca2014-02-28 17:45:46 +0200492}
493
Johan Hedberga5c4e302014-07-16 11:56:07 +0300494struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
495 u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
497 struct hci_conn *conn;
498
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300499 BT_DBG("%s dst %pMR", hdev->name, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Johan Hedberg27f70f32014-07-21 10:50:06 +0300501 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200502 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 bacpy(&conn->dst, dst);
Marcel Holtmann662e8822013-10-13 05:23:59 -0700506 bacpy(&conn->src, &hdev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200507 conn->hdev = hdev;
508 conn->type = type;
Johan Hedberga5c4e302014-07-16 11:56:07 +0300509 conn->role = role;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200510 conn->mode = HCI_CM_ACTIVE;
511 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300512 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200513 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300514 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200515 conn->key_type = 0xff;
Johan Hedbergebf86aa2014-12-05 13:36:08 +0200516 conn->rssi = HCI_RSSI_INVALID;
Andrzej Kaczmarek5a134fa2014-05-09 21:35:28 +0200517 conn->tx_power = HCI_TX_POWER_INVALID;
Andrzej Kaczmarekd0455ed2014-05-14 13:43:05 +0200518 conn->max_tx_power = HCI_TX_POWER_INVALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Johan Hedberg58a681e2012-01-16 06:47:28 +0200520 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200521 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200522
Johan Hedberga5c4e302014-07-16 11:56:07 +0300523 if (conn->role == HCI_ROLE_MASTER)
524 conn->out = true;
525
Marcel Holtmanna8746412008-07-14 20:13:46 +0200526 switch (type) {
527 case ACL_LINK:
528 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
529 break;
Johan Hedberg9c84d1d2014-03-24 20:21:50 +0200530 case LE_LINK:
531 /* conn->src should reflect the local identity address */
532 hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
533 break;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200534 case SCO_LINK:
535 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100536 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
537 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200538 else
539 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
540 break;
541 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100542 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200543 break;
544 }
545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200547
Marcel Holtmann70c1f202012-02-22 12:06:43 +0100548 INIT_LIST_HEAD(&conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200549
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300550 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300551 INIT_DELAYED_WORK(&conn->auto_accept_work, hci_conn_auto_accept);
Johan Hedberga74a84f2013-10-16 18:11:40 +0300552 INIT_DELAYED_WORK(&conn->idle_work, hci_conn_idle);
Johan Hedberg9489eca2014-02-28 17:45:46 +0200553 INIT_DELAYED_WORK(&conn->le_conn_timeout, le_conn_timeout);
Johan Hedberg8ce783d2015-10-21 15:21:31 +0300554 INIT_WORK(&conn->le_scan_cleanup, le_scan_cleanup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556 atomic_set(&conn->refcnt, 0);
557
558 hci_dev_hold(hdev);
559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 hci_conn_hash_add(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200561 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
563
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700564 hci_conn_init_sysfs(conn);
565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 return conn;
567}
568
569int hci_conn_del(struct hci_conn *conn)
570{
571 struct hci_dev *hdev = conn->hdev;
572
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300573 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300575 cancel_delayed_work_sync(&conn->disc_work);
Johan Hedberg7bc18d92013-10-16 18:11:39 +0300576 cancel_delayed_work_sync(&conn->auto_accept_work);
Johan Hedberga74a84f2013-10-16 18:11:40 +0300577 cancel_delayed_work_sync(&conn->idle_work);
Johan Hedberg9f616562011-04-28 11:28:54 -0700578
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200579 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 struct hci_conn *sco = conn->link;
581 if (sco)
582 sco->link = NULL;
583
584 /* Unacked frames */
585 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300586 } else if (conn->type == LE_LINK) {
Johan Hedberg980ffc02014-10-28 22:23:26 +0100587 cancel_delayed_work(&conn->le_conn_timeout);
Johan Hedberg9489eca2014-02-28 17:45:46 +0200588
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300589 if (hdev->le_pkts)
590 hdev->le_cnt += conn->sent;
591 else
592 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200593 } else {
594 struct hci_conn *acl = conn->link;
595 if (acl) {
596 acl->link = NULL;
David Herrmann76a68ba2013-04-06 20:28:37 +0200597 hci_conn_drop(acl);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200598 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 }
600
Andrei Emeltchenko9740e492012-05-29 13:59:02 +0300601 if (conn->amp_mgr)
602 amp_mgr_put(conn->amp_mgr);
603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Johan Hedbergb958f9a2015-10-16 10:07:50 +0300606 /* Remove the connection from the list and cleanup its remaining
607 * state. This is a separate function since for some cases like
608 * BT_CONNECT_SCAN we *only* want the cleanup part without the
609 * rest of hci_conn_del.
610 */
611 hci_conn_cleanup(conn);
Tomas Targownik163f4da2011-06-30 16:30:44 -0300612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 return 0;
614}
615
616struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
617{
618 int use_src = bacmp(src, BDADDR_ANY);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200619 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300621 BT_DBG("%pMR -> %pMR", src, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200623 read_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200625 list_for_each_entry(d, &hci_dev_list, list) {
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300626 if (!test_bit(HCI_UP, &d->flags) ||
Marcel Holtmannd7a5a112015-03-13 02:11:00 -0700627 hci_dev_test_flag(d, HCI_USER_CHANNEL) ||
Andrei Emeltchenkod300fa92012-06-19 15:21:21 +0300628 d->dev_type != HCI_BREDR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 continue;
630
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900631 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 * No source address - find interface with bdaddr != dst
633 * Source address - find interface with bdaddr == src
634 */
635
636 if (use_src) {
637 if (!bacmp(&d->bdaddr, src)) {
638 hdev = d; break;
639 }
640 } else {
641 if (bacmp(&d->bdaddr, dst)) {
642 hdev = d; break;
643 }
644 }
645 }
646
647 if (hdev)
648 hdev = hci_dev_hold(hdev);
649
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200650 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 return hdev;
652}
653EXPORT_SYMBOL(hci_get_route);
654
Andre Guedes9bb3c012014-01-30 18:22:08 -0300655/* This function requires the caller holds hdev->lock */
Andre Guedes06c053f2014-02-26 20:21:41 -0300656void hci_le_conn_failed(struct hci_conn *conn, u8 status)
Andre Guedes9bb3c012014-01-30 18:22:08 -0300657{
658 struct hci_dev *hdev = conn->hdev;
Johan Hedbergf161dd42014-08-15 21:06:54 +0300659 struct hci_conn_params *params;
660
661 params = hci_pend_le_action_lookup(&hdev->pend_le_conns, &conn->dst,
662 conn->dst_type);
663 if (params && params->conn) {
664 hci_conn_drop(params->conn);
Johan Hedbergf8aaf9b2014-08-17 23:28:57 +0300665 hci_conn_put(params->conn);
Johan Hedbergf161dd42014-08-15 21:06:54 +0300666 params->conn = NULL;
667 }
Andre Guedes9bb3c012014-01-30 18:22:08 -0300668
669 conn->state = BT_CLOSED;
670
671 mgmt_connect_failed(hdev, &conn->dst, conn->type, conn->dst_type,
672 status);
673
Johan Hedberg539c4962015-02-18 14:53:57 +0200674 hci_connect_cfm(conn, status);
Andre Guedes9bb3c012014-01-30 18:22:08 -0300675
676 hci_conn_del(conn);
Andre Guedesa4790db2014-02-26 20:21:47 -0300677
678 /* Since we may have temporarily stopped the background scanning in
679 * favor of connection establishment, we should restart it.
680 */
681 hci_update_background_scan(hdev);
Johan Hedberg3c857752014-03-25 10:30:49 +0200682
683 /* Re-enable advertising in case this was a failed connection
684 * attempt as a peripheral.
685 */
686 mgmt_reenable_advertising(hdev);
Andre Guedes9bb3c012014-01-30 18:22:08 -0300687}
688
Marcel Holtmann1904a852015-01-11 13:50:44 -0800689static void create_le_conn_complete(struct hci_dev *hdev, u8 status, u16 opcode)
Andre Guedes1d399ae2013-10-08 08:21:17 -0300690{
691 struct hci_conn *conn;
692
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200693 hci_dev_lock(hdev);
694
695 conn = hci_lookup_le_connect(hdev);
696
697 if (!status) {
698 hci_connect_le_scan_cleanup(conn);
699 goto done;
700 }
Andre Guedes1d399ae2013-10-08 08:21:17 -0300701
702 BT_ERR("HCI request failed to create LE connection: status 0x%2.2x",
703 status);
704
Andre Guedes1d399ae2013-10-08 08:21:17 -0300705 if (!conn)
706 goto done;
707
Andre Guedes06c053f2014-02-26 20:21:41 -0300708 hci_le_conn_failed(conn, status);
Andre Guedes1d399ae2013-10-08 08:21:17 -0300709
710done:
711 hci_dev_unlock(hdev);
712}
713
Andre Guedes2acf3d92014-02-26 20:21:42 -0300714static void hci_req_add_le_create_conn(struct hci_request *req,
715 struct hci_conn *conn)
716{
717 struct hci_cp_le_create_conn cp;
718 struct hci_dev *hdev = conn->hdev;
719 u8 own_addr_type;
720
721 memset(&cp, 0, sizeof(cp));
722
723 /* Update random address, but set require_privacy to false so
Marcel Holtmann9437d2e2014-12-07 20:13:17 +0100724 * that we never connect with an non-resolvable address.
Andre Guedes2acf3d92014-02-26 20:21:42 -0300725 */
726 if (hci_update_random_address(req, false, &own_addr_type))
727 return;
728
Andre Guedes2acf3d92014-02-26 20:21:42 -0300729 cp.scan_interval = cpu_to_le16(hdev->le_scan_interval);
730 cp.scan_window = cpu_to_le16(hdev->le_scan_window);
731 bacpy(&cp.peer_addr, &conn->dst);
732 cp.peer_addr_type = conn->dst_type;
733 cp.own_address_type = own_addr_type;
734 cp.conn_interval_min = cpu_to_le16(conn->le_conn_min_interval);
735 cp.conn_interval_max = cpu_to_le16(conn->le_conn_max_interval);
Marcel Holtmann037fc412014-06-29 16:43:27 +0200736 cp.conn_latency = cpu_to_le16(conn->le_conn_latency);
737 cp.supervision_timeout = cpu_to_le16(conn->le_supv_timeout);
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700738 cp.min_ce_len = cpu_to_le16(0x0000);
739 cp.max_ce_len = cpu_to_le16(0x0000);
Andre Guedes2acf3d92014-02-26 20:21:42 -0300740
741 hci_req_add(req, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
Johan Hedbergb46e0032014-02-28 12:54:15 +0200742
743 conn->state = BT_CONNECT;
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200744 clear_bit(HCI_CONN_SCANNING, &conn->flags);
Andre Guedes2acf3d92014-02-26 20:21:42 -0300745}
746
Johan Hedberg3c857752014-03-25 10:30:49 +0200747static void hci_req_directed_advertising(struct hci_request *req,
748 struct hci_conn *conn)
749{
750 struct hci_dev *hdev = req->hdev;
751 struct hci_cp_le_set_adv_param cp;
752 u8 own_addr_type;
753 u8 enable;
754
Johan Hedberg5ce194c2014-07-08 15:07:49 +0300755 /* Clear the HCI_LE_ADV bit temporarily so that the
Johan Hedberg3c857752014-03-25 10:30:49 +0200756 * hci_update_random_address knows that it's safe to go ahead
757 * and write a new random address. The flag will be set back on
758 * as soon as the SET_ADV_ENABLE HCI command completes.
759 */
Marcel Holtmanna358dc12015-03-13 02:11:02 -0700760 hci_dev_clear_flag(hdev, HCI_LE_ADV);
Johan Hedberg3c857752014-03-25 10:30:49 +0200761
762 /* Set require_privacy to false so that the remote device has a
763 * chance of identifying us.
764 */
765 if (hci_update_random_address(req, false, &own_addr_type) < 0)
766 return;
767
768 memset(&cp, 0, sizeof(cp));
769 cp.type = LE_ADV_DIRECT_IND;
770 cp.own_address_type = own_addr_type;
771 cp.direct_addr_type = conn->dst_type;
772 bacpy(&cp.direct_addr, &conn->dst);
773 cp.channel_map = hdev->le_adv_channel_map;
774
775 hci_req_add(req, HCI_OP_LE_SET_ADV_PARAM, sizeof(cp), &cp);
776
777 enable = 0x01;
778 hci_req_add(req, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable), &enable);
779
780 conn->state = BT_CONNECT;
781}
782
Andre Guedes04a6c582014-02-26 20:21:44 -0300783struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
Johan Hedbergcdd62752014-07-07 15:02:28 +0300784 u8 dst_type, u8 sec_level, u16 conn_timeout,
Johan Hedberge804d252014-07-16 11:42:28 +0300785 u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
Andre Guedes4292f1f2014-02-03 13:56:19 -0300787 struct hci_conn_params *params;
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200788 struct hci_conn *conn, *conn_unfinished;
Johan Hedberg1ebfcc12014-02-18 21:41:36 +0200789 struct smp_irk *irk;
Andre Guedes2acf3d92014-02-26 20:21:42 -0300790 struct hci_request req;
Andre Guedes1d399ae2013-10-08 08:21:17 -0300791 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Lukasz Rymanowski152d3862015-02-11 12:31:40 +0100793 /* Let's make sure that le is enabled.*/
Marcel Holtmannd7a5a112015-03-13 02:11:00 -0700794 if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
Lukasz Rymanowski152d3862015-02-11 12:31:40 +0100795 if (lmp_le_capable(hdev))
796 return ERR_PTR(-ECONNREFUSED);
797
798 return ERR_PTR(-EOPNOTSUPP);
799 }
800
Andre Guedes620ad522013-10-08 08:21:18 -0300801 /* Some devices send ATT messages as soon as the physical link is
802 * established. To be able to handle these ATT messages, the user-
803 * space first establishes the connection and then starts the pairing
804 * process.
805 *
806 * So if a hci_conn object already exists for the following connection
807 * attempt, we simply update pending_sec_level and auth_type fields
808 * and return the object found.
809 */
Johan Hedberg9d4c1cc2015-10-21 18:03:01 +0300810 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200811 conn_unfinished = NULL;
Andre Guedes620ad522013-10-08 08:21:18 -0300812 if (conn) {
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200813 if (conn->state == BT_CONNECT &&
814 test_bit(HCI_CONN_SCANNING, &conn->flags)) {
815 BT_DBG("will continue unfinished conn %pMR", dst);
816 conn_unfinished = conn;
817 } else {
818 if (conn->pending_sec_level < sec_level)
819 conn->pending_sec_level = sec_level;
820 goto done;
821 }
Ville Tervofcd89c02011-02-10 22:38:47 -0300822 }
823
Andre Guedes620ad522013-10-08 08:21:18 -0300824 /* Since the controller supports only one LE connection attempt at a
825 * time, we return -EBUSY if there is any connection attempt running.
826 */
Jakub Pawlowskie7d9ab72015-08-07 20:22:52 +0200827 if (hci_lookup_le_connect(hdev))
Andre Guedes620ad522013-10-08 08:21:18 -0300828 return ERR_PTR(-EBUSY);
829
Marcel Holtmannedb4b462014-02-18 15:13:43 -0800830 /* When given an identity address with existing identity
831 * resolving key, the connection needs to be established
832 * to a resolvable random address.
833 *
Marcel Holtmannedb4b462014-02-18 15:13:43 -0800834 * Storing the resolvable random address is required here
835 * to handle connection failures. The address will later
836 * be resolved back into the original identity address
837 * from the connect request.
838 */
Johan Hedberg1ebfcc12014-02-18 21:41:36 +0200839 irk = hci_find_irk_by_addr(hdev, dst, dst_type);
840 if (irk && bacmp(&irk->rpa, BDADDR_ANY)) {
841 dst = &irk->rpa;
842 dst_type = ADDR_LE_DEV_RANDOM;
843 }
844
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200845 if (conn_unfinished) {
846 conn = conn_unfinished;
847 bacpy(&conn->dst, dst);
848 } else {
849 conn = hci_conn_add(hdev, LE_LINK, dst, role);
850 }
851
Andre Guedes620ad522013-10-08 08:21:18 -0300852 if (!conn)
853 return ERR_PTR(-ENOMEM);
854
Johan Hedberg1ebfcc12014-02-18 21:41:36 +0200855 conn->dst_type = dst_type;
Andre Guedes620ad522013-10-08 08:21:18 -0300856 conn->sec_level = BT_SECURITY_LOW;
Johan Hedberg09ae2602014-07-06 13:41:15 +0300857 conn->conn_timeout = conn_timeout;
Andre Guedes4292f1f2014-02-03 13:56:19 -0300858
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200859 if (!conn_unfinished)
860 conn->pending_sec_level = sec_level;
861
Johan Hedberg3c857752014-03-25 10:30:49 +0200862 hci_req_init(&req, hdev);
863
Johan Hedberg376f54c2014-07-08 15:07:52 +0300864 /* Disable advertising if we're active. For master role
865 * connections most controllers will refuse to connect if
866 * advertising is enabled, and for slave role connections we
867 * anyway have to disable it in order to start directed
868 * advertising.
869 */
Marcel Holtmannd7a5a112015-03-13 02:11:00 -0700870 if (hci_dev_test_flag(hdev, HCI_LE_ADV)) {
Johan Hedberg376f54c2014-07-08 15:07:52 +0300871 u8 enable = 0x00;
872 hci_req_add(&req, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable),
873 &enable);
874 }
875
Johan Hedbergcdd62752014-07-07 15:02:28 +0300876 /* If requested to connect as slave use directed advertising */
Johan Hedberge804d252014-07-16 11:42:28 +0300877 if (conn->role == HCI_ROLE_SLAVE) {
Johan Hedberge8bb6b92014-07-08 15:07:53 +0300878 /* If we're active scanning most controllers are unable
879 * to initiate advertising. Simply reject the attempt.
880 */
Marcel Holtmannd7a5a112015-03-13 02:11:00 -0700881 if (hci_dev_test_flag(hdev, HCI_LE_SCAN) &&
Johan Hedberge8bb6b92014-07-08 15:07:53 +0300882 hdev->le_scan_type == LE_SCAN_ACTIVE) {
883 skb_queue_purge(&req.cmd_q);
884 hci_conn_del(conn);
885 return ERR_PTR(-EBUSY);
886 }
887
Johan Hedberg3c857752014-03-25 10:30:49 +0200888 hci_req_directed_advertising(&req, conn);
889 goto create_conn;
890 }
891
Andre Guedes4292f1f2014-02-03 13:56:19 -0300892 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
893 if (params) {
894 conn->le_conn_min_interval = params->conn_min_interval;
895 conn->le_conn_max_interval = params->conn_max_interval;
Marcel Holtmann037fc412014-06-29 16:43:27 +0200896 conn->le_conn_latency = params->conn_latency;
897 conn->le_supv_timeout = params->supervision_timeout;
Andre Guedes4292f1f2014-02-03 13:56:19 -0300898 } else {
899 conn->le_conn_min_interval = hdev->le_conn_min_interval;
900 conn->le_conn_max_interval = hdev->le_conn_max_interval;
Marcel Holtmann04fb7d92014-06-30 12:34:36 +0200901 conn->le_conn_latency = hdev->le_conn_latency;
902 conn->le_supv_timeout = hdev->le_supv_timeout;
Andre Guedes4292f1f2014-02-03 13:56:19 -0300903 }
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300904
Andre Guedes2acf3d92014-02-26 20:21:42 -0300905 /* If controller is scanning, we stop it since some controllers are
Johan Hedberg81ad6fd2014-02-28 20:26:13 +0200906 * not able to scan and connect at the same time. Also set the
907 * HCI_LE_SCAN_INTERRUPTED flag so that the command complete
908 * handler for scan disabling knows to set the correct discovery
909 * state.
Andre Guedes2acf3d92014-02-26 20:21:42 -0300910 */
Marcel Holtmannd7a5a112015-03-13 02:11:00 -0700911 if (hci_dev_test_flag(hdev, HCI_LE_SCAN)) {
Andre Guedes2acf3d92014-02-26 20:21:42 -0300912 hci_req_add_le_scan_disable(&req);
Marcel Holtmanna1536da2015-03-13 02:11:01 -0700913 hci_dev_set_flag(hdev, HCI_LE_SCAN_INTERRUPTED);
Andre Guedes2acf3d92014-02-26 20:21:42 -0300914 }
915
Johan Hedberg81ad6fd2014-02-28 20:26:13 +0200916 hci_req_add_le_create_conn(&req, conn);
917
Johan Hedberg3c857752014-03-25 10:30:49 +0200918create_conn:
Johan Hedberg81ad6fd2014-02-28 20:26:13 +0200919 err = hci_req_run(&req, create_le_conn_complete);
Andre Guedes2acf3d92014-02-26 20:21:42 -0300920 if (err) {
921 hci_conn_del(conn);
Andre Guedes620ad522013-10-08 08:21:18 -0300922 return ERR_PTR(err);
Andre Guedes2acf3d92014-02-26 20:21:42 -0300923 }
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300924
Andre Guedes620ad522013-10-08 08:21:18 -0300925done:
Jakub Pawlowski28a667c2015-08-07 20:22:54 +0200926 /* If this is continuation of connect started by hci_connect_le_scan,
927 * it already called hci_conn_hold and calling it again would mess the
928 * counter.
929 */
930 if (!conn_unfinished)
931 hci_conn_hold(conn);
932
Andre Guedesf1e5d542013-10-03 18:25:44 -0300933 return conn;
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300934}
935
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200936static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type)
937{
938 struct hci_conn *conn;
939
Johan Hedberg9d4c1cc2015-10-21 18:03:01 +0300940 conn = hci_conn_hash_lookup_le(hdev, addr, type);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200941 if (!conn)
942 return false;
943
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200944 if (conn->state != BT_CONNECTED)
945 return false;
946
947 return true;
948}
949
950/* This function requires the caller holds hdev->lock */
Johan Hedberg84235d22015-11-11 08:11:20 +0200951static int hci_explicit_conn_params_set(struct hci_dev *hdev,
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200952 bdaddr_t *addr, u8 addr_type)
953{
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200954 struct hci_conn_params *params;
955
956 if (is_connected(hdev, addr, addr_type))
957 return -EISCONN;
958
Jakub Pawlowski5157b8a2015-10-16 10:07:54 +0300959 params = hci_conn_params_lookup(hdev, addr, addr_type);
960 if (!params) {
961 params = hci_conn_params_add(hdev, addr, addr_type);
962 if (!params)
963 return -ENOMEM;
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200964
Jakub Pawlowski5157b8a2015-10-16 10:07:54 +0300965 /* If we created new params, mark them to be deleted in
966 * hci_connect_le_scan_cleanup. It's different case than
967 * existing disabled params, those will stay after cleanup.
968 */
969 params->auto_connect = HCI_AUTO_CONN_EXPLICIT;
970 }
971
972 /* We're trying to connect, so make sure params are at pend_le_conns */
Johan Hedberg49c50922015-10-16 10:07:51 +0300973 if (params->auto_connect == HCI_AUTO_CONN_DISABLED ||
Jakub Pawlowski5157b8a2015-10-16 10:07:54 +0300974 params->auto_connect == HCI_AUTO_CONN_REPORT ||
975 params->auto_connect == HCI_AUTO_CONN_EXPLICIT) {
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200976 list_del_init(&params->action);
977 list_add(&params->action, &hdev->pend_le_conns);
978 }
979
980 params->explicit_connect = true;
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200981
982 BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type,
983 params->auto_connect);
984
985 return 0;
986}
987
988/* This function requires the caller holds hdev->lock */
989struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
990 u8 dst_type, u8 sec_level,
991 u16 conn_timeout, u8 role)
992{
993 struct hci_conn *conn;
Jakub Pawlowskif75113a2015-08-07 20:22:53 +0200994
995 /* Let's make sure that le is enabled.*/
996 if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
997 if (lmp_le_capable(hdev))
998 return ERR_PTR(-ECONNREFUSED);
999
1000 return ERR_PTR(-EOPNOTSUPP);
1001 }
1002
1003 /* Some devices send ATT messages as soon as the physical link is
1004 * established. To be able to handle these ATT messages, the user-
1005 * space first establishes the connection and then starts the pairing
1006 * process.
1007 *
1008 * So if a hci_conn object already exists for the following connection
1009 * attempt, we simply update pending_sec_level and auth_type fields
1010 * and return the object found.
1011 */
Johan Hedberg9d4c1cc2015-10-21 18:03:01 +03001012 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001013 if (conn) {
1014 if (conn->pending_sec_level < sec_level)
1015 conn->pending_sec_level = sec_level;
1016 goto done;
1017 }
1018
1019 BT_DBG("requesting refresh of dst_addr");
1020
1021 conn = hci_conn_add(hdev, LE_LINK, dst, role);
1022 if (!conn)
1023 return ERR_PTR(-ENOMEM);
1024
Johan Hedberg84235d22015-11-11 08:11:20 +02001025 if (hci_explicit_conn_params_set(hdev, dst, dst_type) < 0)
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001026 return ERR_PTR(-EBUSY);
1027
1028 conn->state = BT_CONNECT;
1029 set_bit(HCI_CONN_SCANNING, &conn->flags);
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001030 conn->dst_type = dst_type;
1031 conn->sec_level = BT_SECURITY_LOW;
1032 conn->pending_sec_level = sec_level;
1033 conn->conn_timeout = conn_timeout;
1034
Johan Hedberg84235d22015-11-11 08:11:20 +02001035 hci_update_background_scan(hdev);
1036
Jakub Pawlowskif75113a2015-08-07 20:22:53 +02001037done:
1038 hci_conn_hold(conn);
1039 return conn;
1040}
1041
Andre Guedes04a6c582014-02-26 20:21:44 -03001042struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1043 u8 sec_level, u8 auth_type)
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001044{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 struct hci_conn *acl;
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001046
Marcel Holtmannd7a5a112015-03-13 02:11:00 -07001047 if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) {
Lukasz Rymanowskic4111102015-02-11 12:31:41 +01001048 if (lmp_bredr_capable(hdev))
1049 return ERR_PTR(-ECONNREFUSED);
1050
Johan Hedbergbeb19e42014-07-18 11:15:26 +03001051 return ERR_PTR(-EOPNOTSUPP);
Lukasz Rymanowskic4111102015-02-11 12:31:41 +01001052 }
Johan Hedberg56f87902013-10-02 13:43:13 +03001053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
1055 if (!acl) {
Johan Hedberga5c4e302014-07-16 11:56:07 +03001056 acl = hci_conn_add(hdev, ACL_LINK, dst, HCI_ROLE_MASTER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 if (!acl)
Johan Hedberg48c7aba2012-02-19 14:06:48 +02001058 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 }
1060
1061 hci_conn_hold(acl);
1062
1063 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
1064 acl->sec_level = BT_SECURITY_LOW;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001065 acl->pending_sec_level = sec_level;
1066 acl->auth_type = auth_type;
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -03001067 hci_acl_create_connection(acl);
Nick Pellyc3902162009-11-13 14:16:32 -08001068 }
1069
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -03001070 return acl;
1071}
1072
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +02001073struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1074 __u16 setting)
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -03001075{
1076 struct hci_conn *acl;
1077 struct hci_conn *sco;
1078
Frédéric Dalleaue660ed62013-08-19 14:23:54 +02001079 acl = hci_connect_acl(hdev, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -03001080 if (IS_ERR(acl))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001081 return acl;
1082
1083 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
1084 if (!sco) {
Johan Hedberga5c4e302014-07-16 11:56:07 +03001085 sco = hci_conn_add(hdev, type, dst, HCI_ROLE_MASTER);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001086 if (!sco) {
David Herrmann76a68ba2013-04-06 20:28:37 +02001087 hci_conn_drop(acl);
Johan Hedberg48c7aba2012-02-19 14:06:48 +02001088 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 }
1090 }
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001091
1092 acl->link = sco;
1093 sco->link = acl;
1094
1095 hci_conn_hold(sco);
1096
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +02001097 sco->setting = setting;
1098
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001099 if (acl->state == BT_CONNECTED &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001100 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Johan Hedberg58a681e2012-01-16 06:47:28 +02001101 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07001102 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001103
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001104 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +02001105 /* defer SCO setup until mode change completed */
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001106 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
Marcel Holtmann0684e5f2009-02-09 02:48:38 +01001107 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 }
1109
1110 hci_sco_setup(acl, 0x00);
Marcel Holtmann96a31832009-02-12 16:23:03 +01001111 }
Marcel Holtmann0684e5f2009-02-09 02:48:38 +01001112
Marcel Holtmann96a31832009-02-12 16:23:03 +01001113 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116/* Check link security requirement */
1117int hci_conn_check_link_mode(struct hci_conn *conn)
1118{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001119 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Marcel Holtmann40b552a2014-03-19 14:10:25 -07001121 /* In Secure Connections Only mode, it is required that Secure
1122 * Connections is used and the link is encrypted with AES-CCM
1123 * using a P-256 authenticated combination key.
1124 */
Marcel Holtmannd7a5a112015-03-13 02:11:00 -07001125 if (hci_dev_test_flag(conn->hdev, HCI_SC_ONLY)) {
Marcel Holtmann40b552a2014-03-19 14:10:25 -07001126 if (!hci_conn_sc_enabled(conn) ||
1127 !test_bit(HCI_CONN_AES_CCM, &conn->flags) ||
1128 conn->key_type != HCI_LK_AUTH_COMBINATION_P256)
1129 return 0;
1130 }
1131
Johan Hedberg4dae2792014-06-24 17:03:50 +03001132 if (hci_conn_ssp_enabled(conn) &&
1133 !test_bit(HCI_CONN_ENCRYPT, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 return 0;
1135
1136 return 1;
1137}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
1139/* Authenticate remote device */
1140static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
1141{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001142 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Johan Hedberg765c2a92011-01-19 12:06:52 +05301144 if (conn->pending_sec_level > sec_level)
1145 sec_level = conn->pending_sec_level;
1146
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 if (sec_level > conn->sec_level)
Johan Hedberg765c2a92011-01-19 12:06:52 +05301148 conn->pending_sec_level = sec_level;
Johan Hedberg4dae2792014-06-24 17:03:50 +03001149 else if (test_bit(HCI_CONN_AUTH, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 return 1;
1151
Johan Hedberg65cf6862011-01-19 12:06:49 +05301152 /* Make sure we preserve an existing MITM requirement*/
1153 auth_type |= (conn->auth_type & 0x01);
1154
Marcel Holtmann96a31832009-02-12 16:23:03 +01001155 conn->auth_type = auth_type;
1156
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001157 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 struct hci_cp_auth_requested cp;
Peter Hurleyb7d05ba2012-01-13 15:11:30 +01001159
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07001160 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +02001161 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001162 sizeof(cp), &cp);
Johan Hedberg09da1f32014-04-11 12:02:32 -07001163
1164 /* If we're already encrypted set the REAUTH_PEND flag,
1165 * otherwise set the ENCRYPT_PEND.
1166 */
Johan Hedberg4dae2792014-06-24 17:03:50 +03001167 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001168 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Johan Hedberg09da1f32014-04-11 12:02:32 -07001169 else
1170 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 return 0;
1174}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001176/* Encrypt the the link */
1177static void hci_conn_encrypt(struct hci_conn *conn)
1178{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001179 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001180
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001181 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001182 struct hci_cp_set_conn_encrypt cp;
1183 cp.handle = cpu_to_le16(conn->handle);
1184 cp.encrypt = 0x01;
1185 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001186 &cp);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001187 }
1188}
1189
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001190/* Enable security */
Johan Hedberge7cafc42014-07-17 15:35:38 +03001191int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1192 bool initiator)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001194 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
Vinicius Costa Gomesd8343f12012-08-23 21:32:44 -03001196 if (conn->type == LE_LINK)
1197 return smp_conn_security(conn, sec_level);
1198
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001199 /* For sdp we don't need the link key. */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001200 if (sec_level == BT_SECURITY_SDP)
1201 return 1;
1202
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001203 /* For non 2.1 devices and low security level we don't need the link
1204 key. */
Johan Hedbergaa64a8b2012-01-18 21:33:12 +02001205 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -07001206 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001207
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001208 /* For other security levels we need the link key. */
Johan Hedberg4dae2792014-06-24 17:03:50 +03001209 if (!test_bit(HCI_CONN_AUTH, &conn->flags))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001210 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211
Marcel Holtmann7b5a9242014-01-15 22:37:39 -08001212 /* An authenticated FIPS approved combination key has sufficient
1213 * security for security level 4. */
1214 if (conn->key_type == HCI_LK_AUTH_COMBINATION_P256 &&
1215 sec_level == BT_SECURITY_FIPS)
1216 goto encrypt;
1217
1218 /* An authenticated combination key has sufficient security for
1219 security level 3. */
1220 if ((conn->key_type == HCI_LK_AUTH_COMBINATION_P192 ||
1221 conn->key_type == HCI_LK_AUTH_COMBINATION_P256) &&
1222 sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001223 goto encrypt;
1224
1225 /* An unauthenticated combination key has sufficient security for
1226 security level 1 and 2. */
Marcel Holtmann66138ce2014-01-10 02:07:20 -08001227 if ((conn->key_type == HCI_LK_UNAUTH_COMBINATION_P192 ||
1228 conn->key_type == HCI_LK_UNAUTH_COMBINATION_P256) &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -03001229 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001230 goto encrypt;
1231
1232 /* A combination key has always sufficient security for the security
1233 levels 1 or 2. High security level requires the combination key
1234 is generated using maximum PIN code length (16).
1235 For pre 2.1 units. */
1236 if (conn->key_type == HCI_LK_COMBINATION &&
Marcel Holtmann7b5a9242014-01-15 22:37:39 -08001237 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW ||
1238 conn->pin_length == 16))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001239 goto encrypt;
1240
1241auth:
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001242 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 return 0;
1244
Johan Hedberg977f8fc2014-07-17 15:35:39 +03001245 if (initiator)
1246 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
1247
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +03001248 if (!hci_conn_auth(conn, sec_level, auth_type))
1249 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001250
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001251encrypt:
Johan Hedberg4dae2792014-06-24 17:03:50 +03001252 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02001253 return 1;
1254
1255 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 return 0;
1257}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001258EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001260/* Check secure link requirement */
1261int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
1262{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001263 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001264
Marcel Holtmann9cb2e032014-02-01 11:32:25 -08001265 /* Accept if non-secure or higher security level is required */
1266 if (sec_level != BT_SECURITY_HIGH && sec_level != BT_SECURITY_FIPS)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001267 return 1;
1268
Marcel Holtmann9cb2e032014-02-01 11:32:25 -08001269 /* Accept if secure or higher security level is already present */
1270 if (conn->sec_level == BT_SECURITY_HIGH ||
1271 conn->sec_level == BT_SECURITY_FIPS)
1272 return 1;
1273
1274 /* Reject not secure link */
1275 return 0;
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +02001276}
1277EXPORT_SYMBOL(hci_conn_check_secure);
1278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001280int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001282 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Johan Hedberg40bef302014-07-16 11:42:27 +03001284 if (role == conn->role)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 return 1;
1286
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001287 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 struct hci_cp_switch_role cp;
1289 bacpy(&cp.bdaddr, &conn->dst);
1290 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001291 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001293
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 return 0;
1295}
1296EXPORT_SYMBOL(hci_conn_switch_role);
1297
Marcel Holtmann04837f62006-07-03 10:02:33 +02001298/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07001299void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +02001300{
1301 struct hci_dev *hdev = conn->hdev;
1302
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001303 BT_DBG("hcon %p mode %d", conn, conn->mode);
Marcel Holtmann04837f62006-07-03 10:02:33 +02001304
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07001305 if (conn->mode != HCI_CM_SNIFF)
1306 goto timer;
1307
Johan Hedberg58a681e2012-01-16 06:47:28 +02001308 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +02001309 goto timer;
1310
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001311 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +02001312 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07001313 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001314 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +02001315 }
1316
1317timer:
1318 if (hdev->idle_timeout > 0)
Johan Hedberga74a84f2013-10-16 18:11:40 +03001319 queue_delayed_work(hdev->workqueue, &conn->idle_work,
1320 msecs_to_jiffies(hdev->idle_timeout));
Marcel Holtmann04837f62006-07-03 10:02:33 +02001321}
1322
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323/* Drop all connection on the device */
1324void hci_conn_hash_flush(struct hci_dev *hdev)
1325{
1326 struct hci_conn_hash *h = &hdev->conn_hash;
Andrei Emeltchenko3c4e0df02012-02-02 10:32:17 +02001327 struct hci_conn *c, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328
1329 BT_DBG("hdev %s", hdev->name);
1330
Andrei Emeltchenko3c4e0df02012-02-02 10:32:17 +02001331 list_for_each_entry_safe(c, n, &h->list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 c->state = BT_CLOSED;
1333
Johan Hedberg3a6d5762015-02-18 14:53:58 +02001334 hci_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 hci_conn_del(c);
1336 }
1337}
1338
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001339/* Check pending connect attempts */
1340void hci_conn_check_pending(struct hci_dev *hdev)
1341{
1342 struct hci_conn *conn;
1343
1344 BT_DBG("hdev %s", hdev->name);
1345
1346 hci_dev_lock(hdev);
1347
1348 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
1349 if (conn)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -03001350 hci_acl_create_connection(conn);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001351
1352 hci_dev_unlock(hdev);
1353}
1354
Johan Hedberg4dae2792014-06-24 17:03:50 +03001355static u32 get_link_mode(struct hci_conn *conn)
1356{
1357 u32 link_mode = 0;
1358
Johan Hedberg40bef302014-07-16 11:42:27 +03001359 if (conn->role == HCI_ROLE_MASTER)
Johan Hedberg4dae2792014-06-24 17:03:50 +03001360 link_mode |= HCI_LM_MASTER;
1361
1362 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1363 link_mode |= HCI_LM_ENCRYPT;
1364
1365 if (test_bit(HCI_CONN_AUTH, &conn->flags))
1366 link_mode |= HCI_LM_AUTH;
1367
1368 if (test_bit(HCI_CONN_SECURE, &conn->flags))
1369 link_mode |= HCI_LM_SECURE;
1370
1371 if (test_bit(HCI_CONN_FIPS, &conn->flags))
1372 link_mode |= HCI_LM_FIPS;
1373
1374 return link_mode;
1375}
1376
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377int hci_get_conn_list(void __user *arg)
1378{
Gustavo Padovanfc5fef62012-05-23 04:04:19 -03001379 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 struct hci_conn_list_req req, *cl;
1381 struct hci_conn_info *ci;
1382 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 int n = 0, size, err;
1384
1385 if (copy_from_user(&req, arg, sizeof(req)))
1386 return -EFAULT;
1387
1388 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
1389 return -EINVAL;
1390
1391 size = sizeof(req) + req.conn_num * sizeof(*ci);
1392
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001393 cl = kmalloc(size, GFP_KERNEL);
1394 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 return -ENOMEM;
1396
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001397 hdev = hci_dev_get(req.dev_id);
1398 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 kfree(cl);
1400 return -ENODEV;
1401 }
1402
1403 ci = cl->conn_info;
1404
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001405 hci_dev_lock(hdev);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001406 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 bacpy(&(ci + n)->bdaddr, &c->dst);
1408 (ci + n)->handle = c->handle;
1409 (ci + n)->type = c->type;
1410 (ci + n)->out = c->out;
1411 (ci + n)->state = c->state;
Johan Hedberg4dae2792014-06-24 17:03:50 +03001412 (ci + n)->link_mode = get_link_mode(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 if (++n >= req.conn_num)
1414 break;
1415 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001416 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
1418 cl->dev_id = hdev->id;
1419 cl->conn_num = n;
1420 size = sizeof(req) + n * sizeof(*ci);
1421
1422 hci_dev_put(hdev);
1423
1424 err = copy_to_user(arg, cl, size);
1425 kfree(cl);
1426
1427 return err ? -EFAULT : 0;
1428}
1429
1430int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
1431{
1432 struct hci_conn_info_req req;
1433 struct hci_conn_info ci;
1434 struct hci_conn *conn;
1435 char __user *ptr = arg + sizeof(req);
1436
1437 if (copy_from_user(&req, arg, sizeof(req)))
1438 return -EFAULT;
1439
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001440 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
1442 if (conn) {
1443 bacpy(&ci.bdaddr, &conn->dst);
1444 ci.handle = conn->handle;
1445 ci.type = conn->type;
1446 ci.out = conn->out;
1447 ci.state = conn->state;
Johan Hedberg4dae2792014-06-24 17:03:50 +03001448 ci.link_mode = get_link_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001450 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
1452 if (!conn)
1453 return -ENOENT;
1454
1455 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
1456}
Marcel Holtmann40be4922008-07-14 20:13:50 +02001457
1458int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
1459{
1460 struct hci_auth_info_req req;
1461 struct hci_conn *conn;
1462
1463 if (copy_from_user(&req, arg, sizeof(req)))
1464 return -EFAULT;
1465
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001466 hci_dev_lock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +02001467 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
1468 if (conn)
1469 req.type = conn->auth_type;
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001470 hci_dev_unlock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +02001471
1472 if (!conn)
1473 return -ENOENT;
1474
1475 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
1476}
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001477
1478struct hci_chan *hci_chan_create(struct hci_conn *conn)
1479{
1480 struct hci_dev *hdev = conn->hdev;
1481 struct hci_chan *chan;
1482
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001483 BT_DBG("%s hcon %p", hdev->name, conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001484
Johan Hedbergf94b6652014-08-18 00:41:44 +03001485 if (test_bit(HCI_CONN_DROP, &conn->flags)) {
1486 BT_DBG("Refusing to create new hci_chan");
1487 return NULL;
1488 }
1489
Johan Hedberg27f70f32014-07-21 10:50:06 +03001490 chan = kzalloc(sizeof(*chan), GFP_KERNEL);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001491 if (!chan)
1492 return NULL;
1493
Johan Hedberg6c388d32014-08-18 00:41:42 +03001494 chan->conn = hci_conn_get(conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001495 skb_queue_head_init(&chan->data_q);
Mat Martineau168df8e2012-10-23 15:24:13 -07001496 chan->state = BT_CONNECTED;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001497
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02001498 list_add_rcu(&chan->list, &conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001499
1500 return chan;
1501}
1502
Andrei Emeltchenko94720072012-09-06 15:05:43 +03001503void hci_chan_del(struct hci_chan *chan)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001504{
1505 struct hci_conn *conn = chan->conn;
1506 struct hci_dev *hdev = conn->hdev;
1507
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001508 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001509
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02001510 list_del_rcu(&chan->list);
1511
1512 synchronize_rcu();
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001513
Johan Hedbergbcbb6552014-08-18 20:33:27 +03001514 /* Prevent new hci_chan's to be created for this hci_conn */
Johan Hedbergf94b6652014-08-18 00:41:44 +03001515 set_bit(HCI_CONN_DROP, &conn->flags);
Johan Hedbergb3ff6702014-08-18 00:41:43 +03001516
Johan Hedberg6c388d32014-08-18 00:41:42 +03001517 hci_conn_put(conn);
Andrei Emeltchenkoe9b02742012-10-25 15:20:51 +03001518
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001519 skb_queue_purge(&chan->data_q);
1520 kfree(chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001521}
1522
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -02001523void hci_chan_list_flush(struct hci_conn *conn)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001524{
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +02001525 struct hci_chan *chan, *n;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001526
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001527 BT_DBG("hcon %p", conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001528
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +02001529 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001530 hci_chan_del(chan);
1531}
Andrei Emeltchenko42c4e532012-10-10 17:38:28 +03001532
1533static struct hci_chan *__hci_chan_lookup_handle(struct hci_conn *hcon,
1534 __u16 handle)
1535{
1536 struct hci_chan *hchan;
1537
1538 list_for_each_entry(hchan, &hcon->chan_list, list) {
1539 if (hchan->handle == handle)
1540 return hchan;
1541 }
1542
1543 return NULL;
1544}
1545
1546struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle)
1547{
1548 struct hci_conn_hash *h = &hdev->conn_hash;
1549 struct hci_conn *hcon;
1550 struct hci_chan *hchan = NULL;
1551
1552 rcu_read_lock();
1553
1554 list_for_each_entry_rcu(hcon, &h->list, list) {
1555 hchan = __hci_chan_lookup_handle(hcon, handle);
1556 if (hchan)
1557 break;
1558 }
1559
1560 rcu_read_unlock();
1561
1562 return hchan;
1563}