blob: 4925a02ae7e4db7df4d4cdfc972e68375743861c [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#include <net/bluetooth/bluetooth.h>
30#include <net/bluetooth/hci_core.h>
Andrei Emeltchenko9740e492012-05-29 13:59:02 +030031#include <net/bluetooth/a2mp.h>
Vinicius Costa Gomesd8343f12012-08-23 21:32:44 -030032#include <net/bluetooth/smp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -030034static void hci_le_create_connection(struct hci_conn *conn)
Ville Tervofcd89c02011-02-10 22:38:47 -030035{
36 struct hci_dev *hdev = conn->hdev;
37 struct hci_cp_le_create_conn cp;
38
39 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +020040 conn->out = true;
Vinicius Costa Gomesb92a6222011-02-10 22:38:52 -030041 conn->link_mode |= HCI_LM_MASTER;
Vinicius Costa Gomes7b5c0d52011-06-09 18:50:50 -030042 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -030043
44 memset(&cp, 0, sizeof(cp));
Andrei Emeltchenko82781e62012-05-25 11:38:27 +030045 cp.scan_interval = __constant_cpu_to_le16(0x0060);
46 cp.scan_window = __constant_cpu_to_le16(0x0030);
Ville Tervofcd89c02011-02-10 22:38:47 -030047 bacpy(&cp.peer_addr, &conn->dst);
Andre Guedes6d3ce0e72011-05-31 14:20:57 -030048 cp.peer_addr_type = conn->dst_type;
Andrei Emeltchenko82781e62012-05-25 11:38:27 +030049 cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
50 cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
51 cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
52 cp.min_ce_len = __constant_cpu_to_le16(0x0000);
53 cp.max_ce_len = __constant_cpu_to_le16(0x0000);
Ville Tervofcd89c02011-02-10 22:38:47 -030054
55 hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
56}
57
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -030058static void hci_le_create_connection_cancel(struct hci_conn *conn)
Ville Tervofcd89c02011-02-10 22:38:47 -030059{
60 hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
61}
62
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -030063static void hci_acl_create_connection(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -070064{
65 struct hci_dev *hdev = conn->hdev;
66 struct inquiry_entry *ie;
67 struct hci_cp_create_conn cp;
68
Andrei Emeltchenko42d2d872012-02-17 11:40:57 +020069 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +020072 conn->out = true;
Marcel Holtmanna8746412008-07-14 20:13:46 +020073
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 conn->link_mode = HCI_LM_MASTER;
75
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020076 conn->attempt++;
77
Marcel Holtmanne4e8e372008-07-14 20:13:47 +020078 conn->link_policy = hdev->link_policy;
79
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 memset(&cp, 0, sizeof(cp));
81 bacpy(&cp.bdaddr, &conn->dst);
82 cp.pscan_rep_mode = 0x02;
83
Andrei Emeltchenko70f230202010-12-01 16:58:25 +020084 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
85 if (ie) {
Marcel Holtmann41a96212008-07-14 20:13:48 +020086 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
87 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
88 cp.pscan_mode = ie->data.pscan_mode;
89 cp.clock_offset = ie->data.clock_offset |
Andrei Emeltchenko82781e62012-05-25 11:38:27 +030090 __constant_cpu_to_le16(0x8000);
Marcel Holtmann41a96212008-07-14 20:13:48 +020091 }
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 memcpy(conn->dev_class, ie->data.dev_class, 3);
Johan Hedberg58a681e2012-01-16 06:47:28 +020094 if (ie->data.ssp_mode > 0)
95 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 }
97
Marcel Holtmanna8746412008-07-14 20:13:46 +020098 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200100 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200102 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200103
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200104 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105}
106
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300107static void hci_acl_create_connection_cancel(struct hci_conn *conn)
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200108{
109 struct hci_cp_create_conn_cancel cp;
110
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300111 BT_DBG("hcon %p", conn);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200112
Andrei Emeltchenkod095c1e2011-12-01 14:33:27 +0200113 if (conn->hdev->hci_ver < BLUETOOTH_VER_1_2)
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200114 return;
115
116 bacpy(&cp.bdaddr, &conn->dst);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200117 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200118}
119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
121{
122 struct hci_cp_disconnect cp;
123
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300124 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126 conn->state = BT_DISCONN;
127
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700128 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 cp.reason = reason;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200130 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
132
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300133static void hci_amp_disconn(struct hci_conn *conn, __u8 reason)
134{
135 struct hci_cp_disconn_phy_link cp;
136
137 BT_DBG("hcon %p", conn);
138
139 conn->state = BT_DISCONN;
140
141 cp.phy_handle = HCI_PHY_HANDLE(conn->handle);
142 cp.reason = reason;
143 hci_send_cmd(conn->hdev, HCI_OP_DISCONN_PHY_LINK,
144 sizeof(cp), &cp);
145}
146
Vinicius Costa Gomes57f5d0d2012-07-27 19:32:54 -0300147static void hci_add_sco(struct hci_conn *conn, __u16 handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148{
149 struct hci_dev *hdev = conn->hdev;
150 struct hci_cp_add_sco cp;
151
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300152 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200155 conn->out = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Marcel Holtmannefc76882009-02-06 09:13:37 +0100157 conn->attempt++;
158
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700159 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200160 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200162 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200165void hci_setup_sync(struct hci_conn *conn, __u16 handle)
166{
167 struct hci_dev *hdev = conn->hdev;
168 struct hci_cp_setup_sync_conn cp;
169
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300170 BT_DBG("hcon %p", conn);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200171
172 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200173 conn->out = true;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200174
Marcel Holtmannefc76882009-02-06 09:13:37 +0100175 conn->attempt++;
176
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200177 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200178 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200179
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300180 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
181 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
182 cp.max_latency = __constant_cpu_to_le16(0xffff);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200183 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
184 cp.retrans_effort = 0xff;
185
186 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
187}
188
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200189void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300190 u16 latency, u16 to_multiplier)
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200191{
192 struct hci_cp_le_conn_update cp;
193 struct hci_dev *hdev = conn->hdev;
194
195 memset(&cp, 0, sizeof(cp));
196
197 cp.handle = cpu_to_le16(conn->handle);
198 cp.conn_interval_min = cpu_to_le16(min);
199 cp.conn_interval_max = cpu_to_le16(max);
200 cp.conn_latency = cpu_to_le16(latency);
201 cp.supervision_timeout = cpu_to_le16(to_multiplier);
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300202 cp.min_ce_len = __constant_cpu_to_le16(0x0001);
203 cp.max_ce_len = __constant_cpu_to_le16(0x0001);
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200204
205 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
206}
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200207
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300208void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300209 __u8 ltk[16])
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300210{
211 struct hci_dev *hdev = conn->hdev;
212 struct hci_cp_le_start_enc cp;
213
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300214 BT_DBG("hcon %p", conn);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300215
216 memset(&cp, 0, sizeof(cp));
217
218 cp.handle = cpu_to_le16(conn->handle);
219 memcpy(cp.ltk, ltk, sizeof(cp.ltk));
220 cp.ediv = ediv;
Anderson Briglia51beabd2011-09-19 14:41:09 -0400221 memcpy(cp.rand, rand, sizeof(cp.rand));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300222
223 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
224}
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300225
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400226/* Device _must_ be locked */
227void hci_sco_setup(struct hci_conn *conn, __u8 status)
228{
229 struct hci_conn *sco = conn->link;
230
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400231 if (!sco)
232 return;
233
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300234 BT_DBG("hcon %p", conn);
235
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400236 if (!status) {
237 if (lmp_esco_capable(conn->hdev))
238 hci_setup_sync(sco, conn->handle);
239 else
240 hci_add_sco(sco, conn->handle);
241 } else {
242 hci_proto_connect_cfm(sco, status);
243 hci_conn_del(sco);
244 }
245}
246
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300247static void hci_conn_disconnect(struct hci_conn *conn)
248{
249 __u8 reason = hci_proto_disconn_ind(conn);
250
251 switch (conn->type) {
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300252 case AMP_LINK:
253 hci_amp_disconn(conn, reason);
254 break;
Andre Guedes4c02e2d2013-01-30 11:50:55 -0300255 default:
256 hci_acl_disconn(conn, reason);
257 break;
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300258 }
259}
260
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300261static void hci_conn_timeout(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300263 struct hci_conn *conn = container_of(work, struct hci_conn,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300264 disc_work.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300266 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 if (atomic_read(&conn->refcnt))
269 return;
270
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200271 switch (conn->state) {
272 case BT_CONNECT:
Marcel Holtmann769be972008-07-14 20:13:49 +0200273 case BT_CONNECT2:
Ville Tervofcd89c02011-02-10 22:38:47 -0300274 if (conn->out) {
275 if (conn->type == ACL_LINK)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300276 hci_acl_create_connection_cancel(conn);
Ville Tervofcd89c02011-02-10 22:38:47 -0300277 else if (conn->type == LE_LINK)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300278 hci_le_create_connection_cancel(conn);
Ville Tervofcd89c02011-02-10 22:38:47 -0300279 }
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200280 break;
Marcel Holtmann769be972008-07-14 20:13:49 +0200281 case BT_CONFIG:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900282 case BT_CONNECTED:
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300283 hci_conn_disconnect(conn);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200284 break;
285 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200287 break;
288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289}
290
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200291/* Enter sniff mode */
292static void hci_conn_enter_sniff_mode(struct hci_conn *conn)
293{
294 struct hci_dev *hdev = conn->hdev;
295
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300296 BT_DBG("hcon %p mode %d", conn, conn->mode);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200297
298 if (test_bit(HCI_RAW, &hdev->flags))
299 return;
300
301 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
302 return;
303
304 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
305 return;
306
307 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
308 struct hci_cp_sniff_subrate cp;
309 cp.handle = cpu_to_le16(conn->handle);
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300310 cp.max_latency = __constant_cpu_to_le16(0);
311 cp.min_remote_timeout = __constant_cpu_to_le16(0);
312 cp.min_local_timeout = __constant_cpu_to_le16(0);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200313 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
314 }
315
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200316 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200317 struct hci_cp_sniff_mode cp;
318 cp.handle = cpu_to_le16(conn->handle);
319 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
320 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300321 cp.attempt = __constant_cpu_to_le16(4);
322 cp.timeout = __constant_cpu_to_le16(1);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200323 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
324 }
325}
326
Marcel Holtmann04837f62006-07-03 10:02:33 +0200327static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200329 struct hci_conn *conn = (void *) arg;
330
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300331 BT_DBG("hcon %p mode %d", conn, conn->mode);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200332
333 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
335
Johan Hedberg9f616562011-04-28 11:28:54 -0700336static void hci_conn_auto_accept(unsigned long arg)
337{
338 struct hci_conn *conn = (void *) arg;
339 struct hci_dev *hdev = conn->hdev;
340
Johan Hedberg9f616562011-04-28 11:28:54 -0700341 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300342 &conn->dst);
Johan Hedberg9f616562011-04-28 11:28:54 -0700343}
344
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
346{
347 struct hci_conn *conn;
348
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300349 BT_DBG("%s dst %pMR", hdev->name, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
Andre Guedescb601d72012-01-30 09:22:09 -0300351 conn = kzalloc(sizeof(struct hci_conn), GFP_KERNEL);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200352 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355 bacpy(&conn->dst, dst);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200356 conn->hdev = hdev;
357 conn->type = type;
358 conn->mode = HCI_CM_ACTIVE;
359 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300360 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200361 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300362 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200363 conn->key_type = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Johan Hedberg58a681e2012-01-16 06:47:28 +0200365 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200366 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200367
Marcel Holtmanna8746412008-07-14 20:13:46 +0200368 switch (type) {
369 case ACL_LINK:
370 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
371 break;
372 case SCO_LINK:
373 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100374 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
375 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200376 else
377 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
378 break;
379 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100380 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200381 break;
382 }
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200385
Marcel Holtmann70c1f202012-02-22 12:06:43 +0100386 INIT_LIST_HEAD(&conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200387
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300388 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800389 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
Johan Hedberg9f616562011-04-28 11:28:54 -0700390 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300391 (unsigned long) conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 atomic_set(&conn->refcnt, 0);
394
395 hci_dev_hold(hdev);
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 hci_conn_hash_add(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200398 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
400
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700401 atomic_set(&conn->devref, 0);
402
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700403 hci_conn_init_sysfs(conn);
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 return conn;
406}
407
408int hci_conn_del(struct hci_conn *conn)
409{
410 struct hci_dev *hdev = conn->hdev;
411
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300412 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Marcel Holtmann04837f62006-07-03 10:02:33 +0200414 del_timer(&conn->idle_timer);
415
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300416 cancel_delayed_work_sync(&conn->disc_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Johan Hedberg9f616562011-04-28 11:28:54 -0700418 del_timer(&conn->auto_accept_timer);
419
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200420 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 struct hci_conn *sco = conn->link;
422 if (sco)
423 sco->link = NULL;
424
425 /* Unacked frames */
426 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300427 } else if (conn->type == LE_LINK) {
428 if (hdev->le_pkts)
429 hdev->le_cnt += conn->sent;
430 else
431 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200432 } else {
433 struct hci_conn *acl = conn->link;
434 if (acl) {
435 acl->link = NULL;
436 hci_conn_put(acl);
437 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 }
439
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200440 hci_chan_list_flush(conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200441
Andrei Emeltchenko9740e492012-05-29 13:59:02 +0300442 if (conn->amp_mgr)
443 amp_mgr_put(conn->amp_mgr);
444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 hci_conn_hash_del(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200446 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200448
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700451 hci_conn_put_device(conn);
Dave Young2ae9a6b2009-02-21 16:13:34 +0800452
Marcel Holtmann384943e2009-05-08 18:20:43 -0700453 hci_dev_put(hdev);
454
Tomas Targownik163f4da2011-06-30 16:30:44 -0300455 if (conn->handle == 0)
456 kfree(conn);
457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 return 0;
459}
460
461struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
462{
463 int use_src = bacmp(src, BDADDR_ANY);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200464 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300466 BT_DBG("%pMR -> %pMR", src, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200468 read_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200470 list_for_each_entry(d, &hci_dev_list, list) {
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300471 if (!test_bit(HCI_UP, &d->flags) ||
Andrei Emeltchenkod300fa92012-06-19 15:21:21 +0300472 test_bit(HCI_RAW, &d->flags) ||
473 d->dev_type != HCI_BREDR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 continue;
475
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900476 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 * No source address - find interface with bdaddr != dst
478 * Source address - find interface with bdaddr == src
479 */
480
481 if (use_src) {
482 if (!bacmp(&d->bdaddr, src)) {
483 hdev = d; break;
484 }
485 } else {
486 if (bacmp(&d->bdaddr, dst)) {
487 hdev = d; break;
488 }
489 }
490 }
491
492 if (hdev)
493 hdev = hci_dev_hold(hdev);
494
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200495 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return hdev;
497}
498EXPORT_SYMBOL(hci_get_route);
499
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300500static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
501 u8 dst_type, u8 sec_level, u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Ville Tervofcd89c02011-02-10 22:38:47 -0300503 struct hci_conn *le;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
Johan Hedbergf1550472012-10-24 21:12:03 +0300505 if (test_bit(HCI_LE_PERIPHERAL, &hdev->flags))
506 return ERR_PTR(-ENOTSUPP);
507
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300508 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
509 if (!le) {
510 le = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
511 if (le)
512 return ERR_PTR(-EBUSY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300514 le = hci_conn_add(hdev, LE_LINK, dst);
515 if (!le)
516 return ERR_PTR(-ENOMEM);
Andrzej Kaczmarekdfc94db2012-05-30 15:39:21 +0200517
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300518 le->dst_type = bdaddr_to_le(dst_type);
519 hci_le_create_connection(le);
Ville Tervofcd89c02011-02-10 22:38:47 -0300520 }
521
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300522 le->pending_sec_level = sec_level;
523 le->auth_type = auth_type;
524
525 hci_conn_hold(le);
526
527 return le;
528}
529
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300530static struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
531 u8 sec_level, u8 auth_type)
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200532{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 struct hci_conn *acl;
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400534
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200535 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200536 if (!acl) {
537 acl = hci_conn_add(hdev, ACL_LINK, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if (!acl)
Johan Hedberg48c7aba2012-02-19 14:06:48 +0200539 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 }
541
542 hci_conn_hold(acl);
543
544 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700545 acl->sec_level = BT_SECURITY_LOW;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200546 acl->pending_sec_level = sec_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 acl->auth_type = auth_type;
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300548 hci_acl_create_connection(acl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
550
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300551 return acl;
552}
553
Vinicius Costa Gomesf91c8462012-08-17 21:37:59 -0300554static struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type,
555 bdaddr_t *dst, u8 sec_level, u8 auth_type)
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300556{
557 struct hci_conn *acl;
558 struct hci_conn *sco;
559
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300560 acl = hci_connect_acl(hdev, dst, sec_level, auth_type);
561 if (IS_ERR(acl))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 return acl;
563
564 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
565 if (!sco) {
566 sco = hci_conn_add(hdev, type, dst);
567 if (!sco) {
568 hci_conn_put(acl);
Johan Hedberg48c7aba2012-02-19 14:06:48 +0200569 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
571 }
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200572
573 acl->link = sco;
574 sco->link = acl;
575
576 hci_conn_hold(sco);
577
578 if (acl->state == BT_CONNECTED &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300579 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Johan Hedberg58a681e2012-01-16 06:47:28 +0200580 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700581 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200582
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200583 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200584 /* defer SCO setup until mode change completed */
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200585 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100586 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 }
588
589 hci_sco_setup(acl, 0x00);
Marcel Holtmann96a31832009-02-12 16:23:03 +0100590 }
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100591
Marcel Holtmann96a31832009-02-12 16:23:03 +0100592 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300595/* Create SCO, ACL or LE connection. */
596struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
597 __u8 dst_type, __u8 sec_level, __u8 auth_type)
598{
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300599 BT_DBG("%s dst %pMR type 0x%x", hdev->name, dst, type);
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300600
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300601 switch (type) {
602 case LE_LINK:
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300603 return hci_connect_le(hdev, dst, dst_type, sec_level, auth_type);
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300604 case ACL_LINK:
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300605 return hci_connect_acl(hdev, dst, sec_level, auth_type);
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300606 case SCO_LINK:
Vinicius Costa Gomesf91c8462012-08-17 21:37:59 -0300607 case ESCO_LINK:
608 return hci_connect_sco(hdev, type, dst, sec_level, auth_type);
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300609 }
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300610
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300611 return ERR_PTR(-EINVAL);
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300612}
613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614/* Check link security requirement */
615int hci_conn_check_link_mode(struct hci_conn *conn)
616{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300617 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200619 if (hci_conn_ssp_enabled(conn) && !(conn->link_mode & HCI_LM_ENCRYPT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 return 0;
621
622 return 1;
623}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625/* Authenticate remote device */
626static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
627{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300628 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
Johan Hedberg765c2a92011-01-19 12:06:52 +0530630 if (conn->pending_sec_level > sec_level)
631 sec_level = conn->pending_sec_level;
632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 if (sec_level > conn->sec_level)
Johan Hedberg765c2a92011-01-19 12:06:52 +0530634 conn->pending_sec_level = sec_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 else if (conn->link_mode & HCI_LM_AUTH)
636 return 1;
637
Johan Hedberg65cf6862011-01-19 12:06:49 +0530638 /* Make sure we preserve an existing MITM requirement*/
639 auth_type |= (conn->auth_type & 0x01);
640
Marcel Holtmann96a31832009-02-12 16:23:03 +0100641 conn->auth_type = auth_type;
642
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200643 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 struct hci_cp_auth_requested cp;
Peter Hurleyb7d05ba2012-01-13 15:11:30 +0100645
646 /* encrypt must be pending if auth is also pending */
647 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200650 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300651 sizeof(cp), &cp);
Waldemar Rymarkiewicz19f8def2011-05-31 15:49:25 +0200652 if (conn->key_type != 0xff)
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200653 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return 0;
657}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200659/* Encrypt the the link */
660static void hci_conn_encrypt(struct hci_conn *conn)
661{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300662 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200663
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200664 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200665 struct hci_cp_set_conn_encrypt cp;
666 cp.handle = cpu_to_le16(conn->handle);
667 cp.encrypt = 0x01;
668 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300669 &cp);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200670 }
671}
672
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100673/* Enable security */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100674int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300676 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Vinicius Costa Gomesd8343f12012-08-23 21:32:44 -0300678 if (conn->type == LE_LINK)
679 return smp_conn_security(conn, sec_level);
680
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200681 /* For sdp we don't need the link key. */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100682 if (sec_level == BT_SECURITY_SDP)
683 return 1;
684
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200685 /* For non 2.1 devices and low security level we don't need the link
686 key. */
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200687 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -0700688 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100689
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200690 /* For other security levels we need the link key. */
691 if (!(conn->link_mode & HCI_LM_AUTH))
692 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200694 /* An authenticated combination key has sufficient security for any
695 security level. */
696 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
697 goto encrypt;
698
699 /* An unauthenticated combination key has sufficient security for
700 security level 1 and 2. */
701 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300702 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200703 goto encrypt;
704
705 /* A combination key has always sufficient security for the security
706 levels 1 or 2. High security level requires the combination key
707 is generated using maximum PIN code length (16).
708 For pre 2.1 units. */
709 if (conn->key_type == HCI_LK_COMBINATION &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300710 (sec_level != BT_SECURITY_HIGH || conn->pin_length == 16))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200711 goto encrypt;
712
713auth:
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200714 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 return 0;
716
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +0300717 if (!hci_conn_auth(conn, sec_level, auth_type))
718 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100719
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200720encrypt:
721 if (conn->link_mode & HCI_LM_ENCRYPT)
722 return 1;
723
724 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 return 0;
726}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100727EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200729/* Check secure link requirement */
730int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
731{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300732 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200733
734 if (sec_level != BT_SECURITY_HIGH)
735 return 1; /* Accept if non-secure is required */
736
Waldemar Rymarkiewiczef4177e2011-06-02 14:24:52 +0200737 if (conn->sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200738 return 1;
739
740 return 0; /* Reject not secure link */
741}
742EXPORT_SYMBOL(hci_conn_check_secure);
743
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744/* Change link key */
745int hci_conn_change_link_key(struct hci_conn *conn)
746{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300747 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200749 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700751 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200752 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300753 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 return 0;
757}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100760int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300762 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
764 if (!role && conn->link_mode & HCI_LM_MASTER)
765 return 1;
766
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200767 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 struct hci_cp_switch_role cp;
769 bacpy(&cp.bdaddr, &conn->dst);
770 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200771 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 return 0;
775}
776EXPORT_SYMBOL(hci_conn_switch_role);
777
Marcel Holtmann04837f62006-07-03 10:02:33 +0200778/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700779void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200780{
781 struct hci_dev *hdev = conn->hdev;
782
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300783 BT_DBG("hcon %p mode %d", conn, conn->mode);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200784
785 if (test_bit(HCI_RAW, &hdev->flags))
786 return;
787
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700788 if (conn->mode != HCI_CM_SNIFF)
789 goto timer;
790
Johan Hedberg58a681e2012-01-16 06:47:28 +0200791 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200792 goto timer;
793
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200794 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +0200795 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700796 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200797 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200798 }
799
800timer:
801 if (hdev->idle_timeout > 0)
802 mod_timer(&conn->idle_timer,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300803 jiffies + msecs_to_jiffies(hdev->idle_timeout));
Marcel Holtmann04837f62006-07-03 10:02:33 +0200804}
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806/* Drop all connection on the device */
807void hci_conn_hash_flush(struct hci_dev *hdev)
808{
809 struct hci_conn_hash *h = &hdev->conn_hash;
Andrei Emeltchenko3c4e0df2012-02-02 10:32:17 +0200810 struct hci_conn *c, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812 BT_DBG("hdev %s", hdev->name);
813
Andrei Emeltchenko3c4e0df2012-02-02 10:32:17 +0200814 list_for_each_entry_safe(c, n, &h->list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 c->state = BT_CLOSED;
816
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +0200817 hci_proto_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 hci_conn_del(c);
819 }
820}
821
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200822/* Check pending connect attempts */
823void hci_conn_check_pending(struct hci_dev *hdev)
824{
825 struct hci_conn *conn;
826
827 BT_DBG("hdev %s", hdev->name);
828
829 hci_dev_lock(hdev);
830
831 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
832 if (conn)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300833 hci_acl_create_connection(conn);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200834
835 hci_dev_unlock(hdev);
836}
837
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700838void hci_conn_hold_device(struct hci_conn *conn)
839{
840 atomic_inc(&conn->devref);
841}
842EXPORT_SYMBOL(hci_conn_hold_device);
843
844void hci_conn_put_device(struct hci_conn *conn)
845{
846 if (atomic_dec_and_test(&conn->devref))
847 hci_conn_del_sysfs(conn);
848}
849EXPORT_SYMBOL(hci_conn_put_device);
850
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851int hci_get_conn_list(void __user *arg)
852{
Gustavo Padovanfc5fef62012-05-23 04:04:19 -0300853 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 struct hci_conn_list_req req, *cl;
855 struct hci_conn_info *ci;
856 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 int n = 0, size, err;
858
859 if (copy_from_user(&req, arg, sizeof(req)))
860 return -EFAULT;
861
862 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
863 return -EINVAL;
864
865 size = sizeof(req) + req.conn_num * sizeof(*ci);
866
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200867 cl = kmalloc(size, GFP_KERNEL);
868 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 return -ENOMEM;
870
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200871 hdev = hci_dev_get(req.dev_id);
872 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 kfree(cl);
874 return -ENODEV;
875 }
876
877 ci = cl->conn_info;
878
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300879 hci_dev_lock(hdev);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200880 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 bacpy(&(ci + n)->bdaddr, &c->dst);
882 (ci + n)->handle = c->handle;
883 (ci + n)->type = c->type;
884 (ci + n)->out = c->out;
885 (ci + n)->state = c->state;
886 (ci + n)->link_mode = c->link_mode;
887 if (++n >= req.conn_num)
888 break;
889 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300890 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
892 cl->dev_id = hdev->id;
893 cl->conn_num = n;
894 size = sizeof(req) + n * sizeof(*ci);
895
896 hci_dev_put(hdev);
897
898 err = copy_to_user(arg, cl, size);
899 kfree(cl);
900
901 return err ? -EFAULT : 0;
902}
903
904int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
905{
906 struct hci_conn_info_req req;
907 struct hci_conn_info ci;
908 struct hci_conn *conn;
909 char __user *ptr = arg + sizeof(req);
910
911 if (copy_from_user(&req, arg, sizeof(req)))
912 return -EFAULT;
913
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300914 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
916 if (conn) {
917 bacpy(&ci.bdaddr, &conn->dst);
918 ci.handle = conn->handle;
919 ci.type = conn->type;
920 ci.out = conn->out;
921 ci.state = conn->state;
922 ci.link_mode = conn->link_mode;
923 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300924 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926 if (!conn)
927 return -ENOENT;
928
929 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
930}
Marcel Holtmann40be4922008-07-14 20:13:50 +0200931
932int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
933{
934 struct hci_auth_info_req req;
935 struct hci_conn *conn;
936
937 if (copy_from_user(&req, arg, sizeof(req)))
938 return -EFAULT;
939
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300940 hci_dev_lock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200941 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
942 if (conn)
943 req.type = conn->auth_type;
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300944 hci_dev_unlock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200945
946 if (!conn)
947 return -ENOENT;
948
949 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
950}
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200951
952struct hci_chan *hci_chan_create(struct hci_conn *conn)
953{
954 struct hci_dev *hdev = conn->hdev;
955 struct hci_chan *chan;
956
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300957 BT_DBG("%s hcon %p", hdev->name, conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200958
Andre Guedes75d77352012-01-30 09:22:10 -0300959 chan = kzalloc(sizeof(struct hci_chan), GFP_KERNEL);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200960 if (!chan)
961 return NULL;
962
963 chan->conn = conn;
964 skb_queue_head_init(&chan->data_q);
Mat Martineau168df8e2012-10-23 15:24:13 -0700965 chan->state = BT_CONNECTED;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200966
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200967 list_add_rcu(&chan->list, &conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200968
969 return chan;
970}
971
Andrei Emeltchenko94720072012-09-06 15:05:43 +0300972void hci_chan_del(struct hci_chan *chan)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200973{
974 struct hci_conn *conn = chan->conn;
975 struct hci_dev *hdev = conn->hdev;
976
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300977 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200978
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200979 list_del_rcu(&chan->list);
980
981 synchronize_rcu();
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200982
Andrei Emeltchenkoe9b02742012-10-25 15:20:51 +0300983 hci_conn_put(conn);
984
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200985 skb_queue_purge(&chan->data_q);
986 kfree(chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200987}
988
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200989void hci_chan_list_flush(struct hci_conn *conn)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200990{
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +0200991 struct hci_chan *chan, *n;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200992
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300993 BT_DBG("hcon %p", conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200994
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +0200995 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200996 hci_chan_del(chan);
997}
Andrei Emeltchenko42c4e532012-10-10 17:38:28 +0300998
999static struct hci_chan *__hci_chan_lookup_handle(struct hci_conn *hcon,
1000 __u16 handle)
1001{
1002 struct hci_chan *hchan;
1003
1004 list_for_each_entry(hchan, &hcon->chan_list, list) {
1005 if (hchan->handle == handle)
1006 return hchan;
1007 }
1008
1009 return NULL;
1010}
1011
1012struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle)
1013{
1014 struct hci_conn_hash *h = &hdev->conn_hash;
1015 struct hci_conn *hcon;
1016 struct hci_chan *hchan = NULL;
1017
1018 rcu_read_lock();
1019
1020 list_for_each_entry_rcu(hcon, &h->list, list) {
1021 hchan = __hci_chan_lookup_handle(hcon, handle);
1022 if (hchan)
1023 break;
1024 }
1025
1026 rcu_read_unlock();
1027
1028 return hchan;
1029}