blob: d2380e0c7df0ae9052e9f8555c3505602e624ee1 [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
Frédéric Dalleau2dea6322013-08-19 14:24:03 +020034struct sco_param {
35 u16 pkt_type;
36 u16 max_latency;
37};
38
39static const struct sco_param sco_param_cvsd[] = {
40 { EDR_ESCO_MASK & ~ESCO_2EV3, 0x000a }, /* S3 */
41 { EDR_ESCO_MASK & ~ESCO_2EV3, 0x0007 }, /* S2 */
42 { EDR_ESCO_MASK | ESCO_EV3, 0x0007 }, /* S1 */
43 { EDR_ESCO_MASK | ESCO_HV3, 0xffff }, /* D1 */
44 { EDR_ESCO_MASK | ESCO_HV1, 0xffff }, /* D0 */
45};
46
47static const struct sco_param sco_param_wideband[] = {
48 { EDR_ESCO_MASK & ~ESCO_2EV3, 0x000d }, /* T2 */
49 { EDR_ESCO_MASK | ESCO_EV3, 0x0008 }, /* T1 */
50};
51
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -030052static void hci_le_create_connection(struct hci_conn *conn)
Ville Tervofcd89c02011-02-10 22:38:47 -030053{
54 struct hci_dev *hdev = conn->hdev;
55 struct hci_cp_le_create_conn cp;
56
57 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +020058 conn->out = true;
Vinicius Costa Gomesb92a6222011-02-10 22:38:52 -030059 conn->link_mode |= HCI_LM_MASTER;
Vinicius Costa Gomes7b5c0d52011-06-09 18:50:50 -030060 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -030061
62 memset(&cp, 0, sizeof(cp));
Andrei Emeltchenko82781e62012-05-25 11:38:27 +030063 cp.scan_interval = __constant_cpu_to_le16(0x0060);
64 cp.scan_window = __constant_cpu_to_le16(0x0030);
Ville Tervofcd89c02011-02-10 22:38:47 -030065 bacpy(&cp.peer_addr, &conn->dst);
Andre Guedes6d3ce0e72011-05-31 14:20:57 -030066 cp.peer_addr_type = conn->dst_type;
Andrei Emeltchenko82781e62012-05-25 11:38:27 +030067 cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
68 cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
69 cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
70 cp.min_ce_len = __constant_cpu_to_le16(0x0000);
71 cp.max_ce_len = __constant_cpu_to_le16(0x0000);
Ville Tervofcd89c02011-02-10 22:38:47 -030072
73 hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
74}
75
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -030076static void hci_le_create_connection_cancel(struct hci_conn *conn)
Ville Tervofcd89c02011-02-10 22:38:47 -030077{
78 hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
79}
80
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -030081static void hci_acl_create_connection(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
83 struct hci_dev *hdev = conn->hdev;
84 struct inquiry_entry *ie;
85 struct hci_cp_create_conn cp;
86
Andrei Emeltchenko42d2d872012-02-17 11:40:57 +020087 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +020090 conn->out = true;
Marcel Holtmanna8746412008-07-14 20:13:46 +020091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 conn->link_mode = HCI_LM_MASTER;
93
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020094 conn->attempt++;
95
Marcel Holtmanne4e8e372008-07-14 20:13:47 +020096 conn->link_policy = hdev->link_policy;
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 memset(&cp, 0, sizeof(cp));
99 bacpy(&cp.bdaddr, &conn->dst);
100 cp.pscan_rep_mode = 0x02;
101
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200102 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
103 if (ie) {
Marcel Holtmann41a96212008-07-14 20:13:48 +0200104 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
105 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
106 cp.pscan_mode = ie->data.pscan_mode;
107 cp.clock_offset = ie->data.clock_offset |
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300108 __constant_cpu_to_le16(0x8000);
Marcel Holtmann41a96212008-07-14 20:13:48 +0200109 }
110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 memcpy(conn->dev_class, ie->data.dev_class, 3);
Johan Hedberg58a681e2012-01-16 06:47:28 +0200112 if (ie->data.ssp_mode > 0)
113 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 }
115
Marcel Holtmanna8746412008-07-14 20:13:46 +0200116 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200118 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200120 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200121
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200122 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300125static void hci_acl_create_connection_cancel(struct hci_conn *conn)
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200126{
127 struct hci_cp_create_conn_cancel cp;
128
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300129 BT_DBG("hcon %p", conn);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200130
Andrei Emeltchenkod095c1e2011-12-01 14:33:27 +0200131 if (conn->hdev->hci_ver < BLUETOOTH_VER_1_2)
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200132 return;
133
134 bacpy(&cp.bdaddr, &conn->dst);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200135 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200136}
137
Claudio Takahasi93796fa2013-04-11 13:54:56 -0300138static void hci_reject_sco(struct hci_conn *conn)
139{
140 struct hci_cp_reject_sync_conn_req cp;
141
142 cp.reason = HCI_ERROR_REMOTE_USER_TERM;
143 bacpy(&cp.bdaddr, &conn->dst);
144
145 hci_send_cmd(conn->hdev, HCI_OP_REJECT_SYNC_CONN_REQ, sizeof(cp), &cp);
146}
147
Andre Guedesbed71742013-01-30 11:50:56 -0300148void hci_disconnect(struct hci_conn *conn, __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149{
150 struct hci_cp_disconnect 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_DISCONN;
155
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700156 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 cp.reason = reason;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200158 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159}
160
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300161static void hci_amp_disconn(struct hci_conn *conn, __u8 reason)
162{
163 struct hci_cp_disconn_phy_link cp;
164
165 BT_DBG("hcon %p", conn);
166
167 conn->state = BT_DISCONN;
168
169 cp.phy_handle = HCI_PHY_HANDLE(conn->handle);
170 cp.reason = reason;
171 hci_send_cmd(conn->hdev, HCI_OP_DISCONN_PHY_LINK,
172 sizeof(cp), &cp);
173}
174
Vinicius Costa Gomes57f5d0d2012-07-27 19:32:54 -0300175static void hci_add_sco(struct hci_conn *conn, __u16 handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176{
177 struct hci_dev *hdev = conn->hdev;
178 struct hci_cp_add_sco cp;
179
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300180 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200183 conn->out = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Marcel Holtmannefc76882009-02-06 09:13:37 +0100185 conn->attempt++;
186
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700187 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200188 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200190 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191}
192
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200193bool hci_setup_sync(struct hci_conn *conn, __u16 handle)
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200194{
195 struct hci_dev *hdev = conn->hdev;
196 struct hci_cp_setup_sync_conn cp;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200197 const struct sco_param *param;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200198
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300199 BT_DBG("hcon %p", conn);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200200
201 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +0200202 conn->out = true;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200203
Marcel Holtmannefc76882009-02-06 09:13:37 +0100204 conn->attempt++;
205
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200206 cp.handle = cpu_to_le16(handle);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200207
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300208 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
209 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200210 cp.voice_setting = cpu_to_le16(conn->setting);
211
212 switch (conn->setting & SCO_AIRMODE_MASK) {
213 case SCO_AIRMODE_TRANSP:
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200214 if (conn->attempt > ARRAY_SIZE(sco_param_wideband))
215 return false;
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200216 cp.retrans_effort = 0x02;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200217 param = &sco_param_wideband[conn->attempt - 1];
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200218 break;
219 case SCO_AIRMODE_CVSD:
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200220 if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
221 return false;
222 cp.retrans_effort = 0x01;
223 param = &sco_param_cvsd[conn->attempt - 1];
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200224 break;
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200225 default:
226 return false;
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200227 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200228
Frédéric Dalleau2dea6322013-08-19 14:24:03 +0200229 cp.pkt_type = __cpu_to_le16(param->pkt_type);
230 cp.max_latency = __cpu_to_le16(param->max_latency);
231
232 if (hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp) < 0)
233 return false;
234
235 return true;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200236}
237
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200238void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300239 u16 latency, u16 to_multiplier)
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200240{
241 struct hci_cp_le_conn_update cp;
242 struct hci_dev *hdev = conn->hdev;
243
244 memset(&cp, 0, sizeof(cp));
245
246 cp.handle = cpu_to_le16(conn->handle);
247 cp.conn_interval_min = cpu_to_le16(min);
248 cp.conn_interval_max = cpu_to_le16(max);
249 cp.conn_latency = cpu_to_le16(latency);
250 cp.supervision_timeout = cpu_to_le16(to_multiplier);
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300251 cp.min_ce_len = __constant_cpu_to_le16(0x0001);
252 cp.max_ce_len = __constant_cpu_to_le16(0x0001);
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200253
254 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
255}
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200256
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300257void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300258 __u8 ltk[16])
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300259{
260 struct hci_dev *hdev = conn->hdev;
261 struct hci_cp_le_start_enc cp;
262
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300263 BT_DBG("hcon %p", conn);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300264
265 memset(&cp, 0, sizeof(cp));
266
267 cp.handle = cpu_to_le16(conn->handle);
268 memcpy(cp.ltk, ltk, sizeof(cp.ltk));
269 cp.ediv = ediv;
Anderson Briglia51beabd2011-09-19 14:41:09 -0400270 memcpy(cp.rand, rand, sizeof(cp.rand));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300271
272 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
273}
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300274
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400275/* Device _must_ be locked */
276void hci_sco_setup(struct hci_conn *conn, __u8 status)
277{
278 struct hci_conn *sco = conn->link;
279
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400280 if (!sco)
281 return;
282
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300283 BT_DBG("hcon %p", conn);
284
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400285 if (!status) {
286 if (lmp_esco_capable(conn->hdev))
287 hci_setup_sync(sco, conn->handle);
288 else
289 hci_add_sco(sco, conn->handle);
290 } else {
291 hci_proto_connect_cfm(sco, status);
292 hci_conn_del(sco);
293 }
294}
295
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300296static void hci_conn_disconnect(struct hci_conn *conn)
297{
298 __u8 reason = hci_proto_disconn_ind(conn);
299
300 switch (conn->type) {
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300301 case AMP_LINK:
302 hci_amp_disconn(conn, reason);
303 break;
Andre Guedes4c02e2d2013-01-30 11:50:55 -0300304 default:
Andre Guedesbed71742013-01-30 11:50:56 -0300305 hci_disconnect(conn, reason);
Andre Guedes4c02e2d2013-01-30 11:50:55 -0300306 break;
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300307 }
308}
309
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300310static void hci_conn_timeout(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300312 struct hci_conn *conn = container_of(work, struct hci_conn,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300313 disc_work.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300315 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 if (atomic_read(&conn->refcnt))
318 return;
319
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200320 switch (conn->state) {
321 case BT_CONNECT:
Marcel Holtmann769be972008-07-14 20:13:49 +0200322 case BT_CONNECT2:
Ville Tervofcd89c02011-02-10 22:38:47 -0300323 if (conn->out) {
324 if (conn->type == ACL_LINK)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300325 hci_acl_create_connection_cancel(conn);
Ville Tervofcd89c02011-02-10 22:38:47 -0300326 else if (conn->type == LE_LINK)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300327 hci_le_create_connection_cancel(conn);
Claudio Takahasi93796fa2013-04-11 13:54:56 -0300328 } else if (conn->type == SCO_LINK || conn->type == ESCO_LINK) {
329 hci_reject_sco(conn);
Ville Tervofcd89c02011-02-10 22:38:47 -0300330 }
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200331 break;
Marcel Holtmann769be972008-07-14 20:13:49 +0200332 case BT_CONFIG:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900333 case BT_CONNECTED:
Andrei Emeltchenko53502d62012-10-10 17:38:27 +0300334 hci_conn_disconnect(conn);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200335 break;
336 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200338 break;
339 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340}
341
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200342/* Enter sniff mode */
343static void hci_conn_enter_sniff_mode(struct hci_conn *conn)
344{
345 struct hci_dev *hdev = conn->hdev;
346
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300347 BT_DBG("hcon %p mode %d", conn, conn->mode);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200348
349 if (test_bit(HCI_RAW, &hdev->flags))
350 return;
351
352 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
353 return;
354
355 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
356 return;
357
358 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
359 struct hci_cp_sniff_subrate cp;
360 cp.handle = cpu_to_le16(conn->handle);
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300361 cp.max_latency = __constant_cpu_to_le16(0);
362 cp.min_remote_timeout = __constant_cpu_to_le16(0);
363 cp.min_local_timeout = __constant_cpu_to_le16(0);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200364 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
365 }
366
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200367 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200368 struct hci_cp_sniff_mode cp;
369 cp.handle = cpu_to_le16(conn->handle);
370 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
371 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
Andrei Emeltchenko82781e62012-05-25 11:38:27 +0300372 cp.attempt = __constant_cpu_to_le16(4);
373 cp.timeout = __constant_cpu_to_le16(1);
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200374 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
375 }
376}
377
Marcel Holtmann04837f62006-07-03 10:02:33 +0200378static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200380 struct hci_conn *conn = (void *) arg;
381
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300382 BT_DBG("hcon %p mode %d", conn, conn->mode);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200383
384 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385}
386
Johan Hedberg9f616562011-04-28 11:28:54 -0700387static void hci_conn_auto_accept(unsigned long arg)
388{
389 struct hci_conn *conn = (void *) arg;
390 struct hci_dev *hdev = conn->hdev;
391
Johan Hedberg9f616562011-04-28 11:28:54 -0700392 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300393 &conn->dst);
Johan Hedberg9f616562011-04-28 11:28:54 -0700394}
395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
397{
398 struct hci_conn *conn;
399
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300400 BT_DBG("%s dst %pMR", hdev->name, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Andre Guedescb601d72012-01-30 09:22:09 -0300402 conn = kzalloc(sizeof(struct hci_conn), GFP_KERNEL);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200403 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 bacpy(&conn->dst, dst);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200407 conn->hdev = hdev;
408 conn->type = type;
409 conn->mode = HCI_CM_ACTIVE;
410 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300411 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200412 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300413 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200414 conn->key_type = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Johan Hedberg58a681e2012-01-16 06:47:28 +0200416 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200417 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200418
Marcel Holtmanna8746412008-07-14 20:13:46 +0200419 switch (type) {
420 case ACL_LINK:
421 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
422 break;
423 case SCO_LINK:
424 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100425 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
426 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200427 else
428 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
429 break;
430 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100431 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200432 break;
433 }
434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200436
Marcel Holtmann70c1f202012-02-22 12:06:43 +0100437 INIT_LIST_HEAD(&conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200438
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300439 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800440 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
Johan Hedberg9f616562011-04-28 11:28:54 -0700441 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300442 (unsigned long) conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 atomic_set(&conn->refcnt, 0);
445
446 hci_dev_hold(hdev);
447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 hci_conn_hash_add(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200449 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
451
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700452 hci_conn_init_sysfs(conn);
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 return conn;
455}
456
457int hci_conn_del(struct hci_conn *conn)
458{
459 struct hci_dev *hdev = conn->hdev;
460
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300461 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Marcel Holtmann04837f62006-07-03 10:02:33 +0200463 del_timer(&conn->idle_timer);
464
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300465 cancel_delayed_work_sync(&conn->disc_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Johan Hedberg9f616562011-04-28 11:28:54 -0700467 del_timer(&conn->auto_accept_timer);
468
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200469 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 struct hci_conn *sco = conn->link;
471 if (sco)
472 sco->link = NULL;
473
474 /* Unacked frames */
475 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300476 } else if (conn->type == LE_LINK) {
477 if (hdev->le_pkts)
478 hdev->le_cnt += conn->sent;
479 else
480 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200481 } else {
482 struct hci_conn *acl = conn->link;
483 if (acl) {
484 acl->link = NULL;
David Herrmann76a68ba2013-04-06 20:28:37 +0200485 hci_conn_drop(acl);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200486 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 }
488
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200489 hci_chan_list_flush(conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200490
Andrei Emeltchenko9740e492012-05-29 13:59:02 +0300491 if (conn->amp_mgr)
492 amp_mgr_put(conn->amp_mgr);
493
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 hci_conn_hash_del(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200495 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
David Herrmannfc225c32013-04-06 20:28:38 +0200500 hci_conn_del_sysfs(conn);
Dave Young2ae9a6b2009-02-21 16:13:34 +0800501
Marcel Holtmann384943e2009-05-08 18:20:43 -0700502 hci_dev_put(hdev);
503
David Herrmann8d123562013-04-06 20:28:39 +0200504 hci_conn_put(conn);
Tomas Targownik163f4da2011-06-30 16:30:44 -0300505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return 0;
507}
508
509struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
510{
511 int use_src = bacmp(src, BDADDR_ANY);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200512 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300514 BT_DBG("%pMR -> %pMR", src, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200516 read_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200518 list_for_each_entry(d, &hci_dev_list, list) {
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300519 if (!test_bit(HCI_UP, &d->flags) ||
Andrei Emeltchenkod300fa92012-06-19 15:21:21 +0300520 test_bit(HCI_RAW, &d->flags) ||
Marcel Holtmannaf750e92013-09-03 18:08:37 -0700521 test_bit(HCI_USER_CHANNEL, &d->dev_flags) ||
Andrei Emeltchenkod300fa92012-06-19 15:21:21 +0300522 d->dev_type != HCI_BREDR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 continue;
524
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900525 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 * No source address - find interface with bdaddr != dst
527 * Source address - find interface with bdaddr == src
528 */
529
530 if (use_src) {
531 if (!bacmp(&d->bdaddr, src)) {
532 hdev = d; break;
533 }
534 } else {
535 if (bacmp(&d->bdaddr, dst)) {
536 hdev = d; break;
537 }
538 }
539 }
540
541 if (hdev)
542 hdev = hci_dev_hold(hdev);
543
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200544 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 return hdev;
546}
547EXPORT_SYMBOL(hci_get_route);
548
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300549static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
550 u8 dst_type, u8 sec_level, u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551{
Ville Tervofcd89c02011-02-10 22:38:47 -0300552 struct hci_conn *le;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Johan Hedbergf15504782012-10-24 21:12:03 +0300554 if (test_bit(HCI_LE_PERIPHERAL, &hdev->flags))
555 return ERR_PTR(-ENOTSUPP);
556
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300557 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
558 if (!le) {
559 le = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
560 if (le)
561 return ERR_PTR(-EBUSY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300563 le = hci_conn_add(hdev, LE_LINK, dst);
564 if (!le)
565 return ERR_PTR(-ENOMEM);
Andrzej Kaczmarekdfc94db2012-05-30 15:39:21 +0200566
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300567 le->dst_type = bdaddr_to_le(dst_type);
568 hci_le_create_connection(le);
Ville Tervofcd89c02011-02-10 22:38:47 -0300569 }
570
Vinicius Costa Gomesd04aef42012-07-27 19:32:56 -0300571 le->pending_sec_level = sec_level;
572 le->auth_type = auth_type;
573
574 hci_conn_hold(le);
575
576 return le;
577}
578
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300579static struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
580 u8 sec_level, u8 auth_type)
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200581{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 struct hci_conn *acl;
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400583
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200584 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200585 if (!acl) {
586 acl = hci_conn_add(hdev, ACL_LINK, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 if (!acl)
Johan Hedberg48c7aba2012-02-19 14:06:48 +0200588 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 }
590
591 hci_conn_hold(acl);
592
593 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700594 acl->sec_level = BT_SECURITY_LOW;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200595 acl->pending_sec_level = sec_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 acl->auth_type = auth_type;
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300597 hci_acl_create_connection(acl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 }
599
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300600 return acl;
601}
602
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200603struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
604 __u16 setting)
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300605{
606 struct hci_conn *acl;
607 struct hci_conn *sco;
608
Frédéric Dalleaue660ed62013-08-19 14:23:54 +0200609 acl = hci_connect_acl(hdev, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
Vinicius Costa Gomesdb474272012-07-28 22:35:59 -0300610 if (IS_ERR(acl))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 return acl;
612
613 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
614 if (!sco) {
615 sco = hci_conn_add(hdev, type, dst);
616 if (!sco) {
David Herrmann76a68ba2013-04-06 20:28:37 +0200617 hci_conn_drop(acl);
Johan Hedberg48c7aba2012-02-19 14:06:48 +0200618 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 }
620 }
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200621
622 acl->link = sco;
623 sco->link = acl;
624
625 hci_conn_hold(sco);
626
Frédéric Dalleau10c62dd2013-08-19 14:23:59 +0200627 sco->setting = setting;
628
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200629 if (acl->state == BT_CONNECTED &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300630 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Johan Hedberg58a681e2012-01-16 06:47:28 +0200631 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700632 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200633
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200634 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200635 /* defer SCO setup until mode change completed */
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200636 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100637 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 }
639
640 hci_sco_setup(acl, 0x00);
Marcel Holtmann96a31832009-02-12 16:23:03 +0100641 }
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100642
Marcel Holtmann96a31832009-02-12 16:23:03 +0100643 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300646/* Create SCO, ACL or LE connection. */
647struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
648 __u8 dst_type, __u8 sec_level, __u8 auth_type)
649{
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300650 BT_DBG("%s dst %pMR type 0x%x", hdev->name, dst, type);
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300651
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300652 switch (type) {
653 case LE_LINK:
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300654 return hci_connect_le(hdev, dst, dst_type, sec_level, auth_type);
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300655 case ACL_LINK:
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300656 return hci_connect_acl(hdev, dst, sec_level, auth_type);
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300657 }
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300658
Vinicius Costa Gomes4cd2d982012-07-27 19:32:59 -0300659 return ERR_PTR(-EINVAL);
Vinicius Costa Gomesb7d839b2012-07-27 19:32:58 -0300660}
661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662/* Check link security requirement */
663int hci_conn_check_link_mode(struct hci_conn *conn)
664{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300665 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200667 if (hci_conn_ssp_enabled(conn) && !(conn->link_mode & HCI_LM_ENCRYPT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 return 0;
669
670 return 1;
671}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
673/* Authenticate remote device */
674static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
675{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300676 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Johan Hedberg765c2a92011-01-19 12:06:52 +0530678 if (conn->pending_sec_level > sec_level)
679 sec_level = conn->pending_sec_level;
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 if (sec_level > conn->sec_level)
Johan Hedberg765c2a92011-01-19 12:06:52 +0530682 conn->pending_sec_level = sec_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 else if (conn->link_mode & HCI_LM_AUTH)
684 return 1;
685
Johan Hedberg65cf6862011-01-19 12:06:49 +0530686 /* Make sure we preserve an existing MITM requirement*/
687 auth_type |= (conn->auth_type & 0x01);
688
Marcel Holtmann96a31832009-02-12 16:23:03 +0100689 conn->auth_type = auth_type;
690
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200691 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 struct hci_cp_auth_requested cp;
Peter Hurleyb7d05ba2012-01-13 15:11:30 +0100693
694 /* encrypt must be pending if auth is also pending */
695 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200698 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300699 sizeof(cp), &cp);
Waldemar Rymarkiewicz19f8def2011-05-31 15:49:25 +0200700 if (conn->key_type != 0xff)
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200701 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100703
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 return 0;
705}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200707/* Encrypt the the link */
708static void hci_conn_encrypt(struct hci_conn *conn)
709{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300710 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200711
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200712 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200713 struct hci_cp_set_conn_encrypt cp;
714 cp.handle = cpu_to_le16(conn->handle);
715 cp.encrypt = 0x01;
716 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300717 &cp);
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200718 }
719}
720
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100721/* Enable security */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100722int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300724 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Vinicius Costa Gomesd8343f12012-08-23 21:32:44 -0300726 if (conn->type == LE_LINK)
727 return smp_conn_security(conn, sec_level);
728
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200729 /* For sdp we don't need the link key. */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100730 if (sec_level == BT_SECURITY_SDP)
731 return 1;
732
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200733 /* For non 2.1 devices and low security level we don't need the link
734 key. */
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200735 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -0700736 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100737
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200738 /* For other security levels we need the link key. */
739 if (!(conn->link_mode & HCI_LM_AUTH))
740 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200742 /* An authenticated combination key has sufficient security for any
743 security level. */
744 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
745 goto encrypt;
746
747 /* An unauthenticated combination key has sufficient security for
748 security level 1 and 2. */
749 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300750 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200751 goto encrypt;
752
753 /* A combination key has always sufficient security for the security
754 levels 1 or 2. High security level requires the combination key
755 is generated using maximum PIN code length (16).
756 For pre 2.1 units. */
757 if (conn->key_type == HCI_LK_COMBINATION &&
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300758 (sec_level != BT_SECURITY_HIGH || conn->pin_length == 16))
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200759 goto encrypt;
760
761auth:
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200762 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 return 0;
764
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +0300765 if (!hci_conn_auth(conn, sec_level, auth_type))
766 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100767
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200768encrypt:
769 if (conn->link_mode & HCI_LM_ENCRYPT)
770 return 1;
771
772 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 return 0;
774}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100775EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200777/* Check secure link requirement */
778int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
779{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300780 BT_DBG("hcon %p", conn);
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200781
782 if (sec_level != BT_SECURITY_HIGH)
783 return 1; /* Accept if non-secure is required */
784
Waldemar Rymarkiewiczef4177e2011-06-02 14:24:52 +0200785 if (conn->sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200786 return 1;
787
788 return 0; /* Reject not secure link */
789}
790EXPORT_SYMBOL(hci_conn_check_secure);
791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792/* Change link key */
793int hci_conn_change_link_key(struct hci_conn *conn)
794{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300795 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200797 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700799 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200800 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300801 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 return 0;
805}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100808int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300810 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812 if (!role && conn->link_mode & HCI_LM_MASTER)
813 return 1;
814
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200815 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 struct hci_cp_switch_role cp;
817 bacpy(&cp.bdaddr, &conn->dst);
818 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200819 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 return 0;
823}
824EXPORT_SYMBOL(hci_conn_switch_role);
825
Marcel Holtmann04837f62006-07-03 10:02:33 +0200826/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700827void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200828{
829 struct hci_dev *hdev = conn->hdev;
830
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300831 BT_DBG("hcon %p mode %d", conn, conn->mode);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200832
833 if (test_bit(HCI_RAW, &hdev->flags))
834 return;
835
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700836 if (conn->mode != HCI_CM_SNIFF)
837 goto timer;
838
Johan Hedberg58a681e2012-01-16 06:47:28 +0200839 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200840 goto timer;
841
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200842 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +0200843 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700844 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200845 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200846 }
847
848timer:
849 if (hdev->idle_timeout > 0)
850 mod_timer(&conn->idle_timer,
Gustavo Padovan5974e4c2012-05-17 00:36:25 -0300851 jiffies + msecs_to_jiffies(hdev->idle_timeout));
Marcel Holtmann04837f62006-07-03 10:02:33 +0200852}
853
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854/* Drop all connection on the device */
855void hci_conn_hash_flush(struct hci_dev *hdev)
856{
857 struct hci_conn_hash *h = &hdev->conn_hash;
Andrei Emeltchenko3c4e0df2012-02-02 10:32:17 +0200858 struct hci_conn *c, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860 BT_DBG("hdev %s", hdev->name);
861
Andrei Emeltchenko3c4e0df2012-02-02 10:32:17 +0200862 list_for_each_entry_safe(c, n, &h->list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 c->state = BT_CLOSED;
864
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +0200865 hci_proto_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 hci_conn_del(c);
867 }
868}
869
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200870/* Check pending connect attempts */
871void hci_conn_check_pending(struct hci_dev *hdev)
872{
873 struct hci_conn *conn;
874
875 BT_DBG("hdev %s", hdev->name);
876
877 hci_dev_lock(hdev);
878
879 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
880 if (conn)
Vinicius Costa Gomes1aef8662012-07-27 19:32:55 -0300881 hci_acl_create_connection(conn);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200882
883 hci_dev_unlock(hdev);
884}
885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886int hci_get_conn_list(void __user *arg)
887{
Gustavo Padovanfc5fef62012-05-23 04:04:19 -0300888 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 struct hci_conn_list_req req, *cl;
890 struct hci_conn_info *ci;
891 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 int n = 0, size, err;
893
894 if (copy_from_user(&req, arg, sizeof(req)))
895 return -EFAULT;
896
897 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
898 return -EINVAL;
899
900 size = sizeof(req) + req.conn_num * sizeof(*ci);
901
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200902 cl = kmalloc(size, GFP_KERNEL);
903 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 return -ENOMEM;
905
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200906 hdev = hci_dev_get(req.dev_id);
907 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 kfree(cl);
909 return -ENODEV;
910 }
911
912 ci = cl->conn_info;
913
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300914 hci_dev_lock(hdev);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200915 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 bacpy(&(ci + n)->bdaddr, &c->dst);
917 (ci + n)->handle = c->handle;
918 (ci + n)->type = c->type;
919 (ci + n)->out = c->out;
920 (ci + n)->state = c->state;
921 (ci + n)->link_mode = c->link_mode;
922 if (++n >= req.conn_num)
923 break;
924 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300925 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
927 cl->dev_id = hdev->id;
928 cl->conn_num = n;
929 size = sizeof(req) + n * sizeof(*ci);
930
931 hci_dev_put(hdev);
932
933 err = copy_to_user(arg, cl, size);
934 kfree(cl);
935
936 return err ? -EFAULT : 0;
937}
938
939int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
940{
941 struct hci_conn_info_req req;
942 struct hci_conn_info ci;
943 struct hci_conn *conn;
944 char __user *ptr = arg + sizeof(req);
945
946 if (copy_from_user(&req, arg, sizeof(req)))
947 return -EFAULT;
948
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300949 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
951 if (conn) {
952 bacpy(&ci.bdaddr, &conn->dst);
953 ci.handle = conn->handle;
954 ci.type = conn->type;
955 ci.out = conn->out;
956 ci.state = conn->state;
957 ci.link_mode = conn->link_mode;
958 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300959 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960
961 if (!conn)
962 return -ENOENT;
963
964 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
965}
Marcel Holtmann40be4922008-07-14 20:13:50 +0200966
967int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
968{
969 struct hci_auth_info_req req;
970 struct hci_conn *conn;
971
972 if (copy_from_user(&req, arg, sizeof(req)))
973 return -EFAULT;
974
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300975 hci_dev_lock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200976 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
977 if (conn)
978 req.type = conn->auth_type;
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300979 hci_dev_unlock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200980
981 if (!conn)
982 return -ENOENT;
983
984 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
985}
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200986
987struct hci_chan *hci_chan_create(struct hci_conn *conn)
988{
989 struct hci_dev *hdev = conn->hdev;
990 struct hci_chan *chan;
991
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +0300992 BT_DBG("%s hcon %p", hdev->name, conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200993
Andre Guedes75d77352012-01-30 09:22:10 -0300994 chan = kzalloc(sizeof(struct hci_chan), GFP_KERNEL);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200995 if (!chan)
996 return NULL;
997
998 chan->conn = conn;
999 skb_queue_head_init(&chan->data_q);
Mat Martineau168df8e2012-10-23 15:24:13 -07001000 chan->state = BT_CONNECTED;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001001
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02001002 list_add_rcu(&chan->list, &conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001003
1004 return chan;
1005}
1006
Andrei Emeltchenko94720072012-09-06 15:05:43 +03001007void hci_chan_del(struct hci_chan *chan)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001008{
1009 struct hci_conn *conn = chan->conn;
1010 struct hci_dev *hdev = conn->hdev;
1011
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001012 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001013
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02001014 list_del_rcu(&chan->list);
1015
1016 synchronize_rcu();
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001017
David Herrmann76a68ba2013-04-06 20:28:37 +02001018 hci_conn_drop(conn);
Andrei Emeltchenkoe9b02742012-10-25 15:20:51 +03001019
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001020 skb_queue_purge(&chan->data_q);
1021 kfree(chan);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001022}
1023
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -02001024void hci_chan_list_flush(struct hci_conn *conn)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001025{
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +02001026 struct hci_chan *chan, *n;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001027
Andrei Emeltchenko38b3fef2012-06-15 11:50:28 +03001028 BT_DBG("hcon %p", conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001029
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +02001030 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02001031 hci_chan_del(chan);
1032}
Andrei Emeltchenko42c4e532012-10-10 17:38:28 +03001033
1034static struct hci_chan *__hci_chan_lookup_handle(struct hci_conn *hcon,
1035 __u16 handle)
1036{
1037 struct hci_chan *hchan;
1038
1039 list_for_each_entry(hchan, &hcon->chan_list, list) {
1040 if (hchan->handle == handle)
1041 return hchan;
1042 }
1043
1044 return NULL;
1045}
1046
1047struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle)
1048{
1049 struct hci_conn_hash *h = &hdev->conn_hash;
1050 struct hci_conn *hcon;
1051 struct hci_chan *hchan = NULL;
1052
1053 rcu_read_lock();
1054
1055 list_for_each_entry_rcu(hcon, &h->list, list) {
1056 hchan = __hci_chan_lookup_handle(hcon, handle);
1057 if (hchan)
1058 break;
1059 }
1060
1061 rcu_read_unlock();
1062
1063 return hchan;
1064}