blob: 7ee6895c4b0c56c69650bfb560dd2d489219cf90 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/slab.h>
33#include <linux/poll.h>
34#include <linux/fcntl.h>
35#include <linux/init.h>
36#include <linux/skbuff.h>
37#include <linux/interrupt.h>
38#include <linux/notifier.h>
39#include <net/sock.h>
40
41#include <asm/system.h>
Andrei Emeltchenko70f230202010-12-01 16:58:25 +020042#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <asm/unaligned.h>
44
45#include <net/bluetooth/bluetooth.h>
46#include <net/bluetooth/hci_core.h>
47
Ville Tervofcd89c02011-02-10 22:38:47 -030048static void hci_le_connect(struct hci_conn *conn)
49{
50 struct hci_dev *hdev = conn->hdev;
51 struct hci_cp_le_create_conn cp;
52
53 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +020054 conn->out = true;
Vinicius Costa Gomesb92a6222011-02-10 22:38:52 -030055 conn->link_mode |= HCI_LM_MASTER;
Vinicius Costa Gomes7b5c0d52011-06-09 18:50:50 -030056 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -030057
58 memset(&cp, 0, sizeof(cp));
Anderson Lizardo0e833912011-07-27 18:40:09 -030059 cp.scan_interval = cpu_to_le16(0x0060);
60 cp.scan_window = cpu_to_le16(0x0030);
Ville Tervofcd89c02011-02-10 22:38:47 -030061 bacpy(&cp.peer_addr, &conn->dst);
Andre Guedes6d3ce0e72011-05-31 14:20:57 -030062 cp.peer_addr_type = conn->dst_type;
Anderson Lizardo0e833912011-07-27 18:40:09 -030063 cp.conn_interval_min = cpu_to_le16(0x0028);
64 cp.conn_interval_max = cpu_to_le16(0x0038);
65 cp.supervision_timeout = cpu_to_le16(0x002a);
66 cp.min_ce_len = cpu_to_le16(0x0000);
67 cp.max_ce_len = cpu_to_le16(0x0000);
Ville Tervofcd89c02011-02-10 22:38:47 -030068
69 hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
70}
71
72static void hci_le_connect_cancel(struct hci_conn *conn)
73{
74 hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
75}
76
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020077void hci_acl_connect(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -070078{
79 struct hci_dev *hdev = conn->hdev;
80 struct inquiry_entry *ie;
81 struct hci_cp_create_conn cp;
82
Andrei Emeltchenko42d2d872012-02-17 11:40:57 +020083 BT_DBG("hcon %p", conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
85 conn->state = BT_CONNECT;
Johan Hedberga0c808b2012-01-16 09:49:58 +020086 conn->out = true;
Marcel Holtmanna8746412008-07-14 20:13:46 +020087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 conn->link_mode = HCI_LM_MASTER;
89
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020090 conn->attempt++;
91
Marcel Holtmanne4e8e372008-07-14 20:13:47 +020092 conn->link_policy = hdev->link_policy;
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 memset(&cp, 0, sizeof(cp));
95 bacpy(&cp.bdaddr, &conn->dst);
96 cp.pscan_rep_mode = 0x02;
97
Andrei Emeltchenko70f230202010-12-01 16:58:25 +020098 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
99 if (ie) {
Marcel Holtmann41a96212008-07-14 20:13:48 +0200100 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
101 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
102 cp.pscan_mode = ie->data.pscan_mode;
103 cp.clock_offset = ie->data.clock_offset |
104 cpu_to_le16(0x8000);
105 }
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 memcpy(conn->dev_class, ie->data.dev_class, 3);
Johan Hedberg58a681e2012-01-16 06:47:28 +0200108 if (ie->data.ssp_mode > 0)
109 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 }
111
Marcel Holtmanna8746412008-07-14 20:13:46 +0200112 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200114 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200116 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200117
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200118 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119}
120
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200121static void hci_acl_connect_cancel(struct hci_conn *conn)
122{
123 struct hci_cp_create_conn_cancel cp;
124
125 BT_DBG("%p", conn);
126
Andrei Emeltchenkod095c1e2011-12-01 14:33:27 +0200127 if (conn->hdev->hci_ver < BLUETOOTH_VER_1_2)
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200128 return;
129
130 bacpy(&cp.bdaddr, &conn->dst);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200131 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200132}
133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
135{
136 struct hci_cp_disconnect cp;
137
138 BT_DBG("%p", conn);
139
140 conn->state = BT_DISCONN;
141
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700142 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 cp.reason = reason;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200144 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
147void hci_add_sco(struct hci_conn *conn, __u16 handle)
148{
149 struct hci_dev *hdev = conn->hdev;
150 struct hci_cp_add_sco cp;
151
152 BT_DBG("%p", conn);
153
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
170 BT_DBG("%p", conn);
171
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
180 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
181 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
182 cp.max_latency = cpu_to_le16(0xffff);
183 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,
190 u16 latency, u16 to_multiplier)
191{
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);
202 cp.min_ce_len = cpu_to_le16(0x0001);
203 cp.max_ce_len = cpu_to_le16(0x0001);
204
205 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
206}
207EXPORT_SYMBOL(hci_le_conn_update);
208
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300209void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
210 __u8 ltk[16])
211{
212 struct hci_dev *hdev = conn->hdev;
213 struct hci_cp_le_start_enc cp;
214
215 BT_DBG("%p", conn);
216
217 memset(&cp, 0, sizeof(cp));
218
219 cp.handle = cpu_to_le16(conn->handle);
220 memcpy(cp.ltk, ltk, sizeof(cp.ltk));
221 cp.ediv = ediv;
Anderson Briglia51beabd2011-09-19 14:41:09 -0400222 memcpy(cp.rand, rand, sizeof(cp.rand));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300223
224 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
225}
226EXPORT_SYMBOL(hci_le_start_enc);
227
228void hci_le_ltk_reply(struct hci_conn *conn, u8 ltk[16])
229{
230 struct hci_dev *hdev = conn->hdev;
231 struct hci_cp_le_ltk_reply cp;
232
233 BT_DBG("%p", conn);
234
235 memset(&cp, 0, sizeof(cp));
236
237 cp.handle = cpu_to_le16(conn->handle);
238 memcpy(cp.ltk, ltk, sizeof(ltk));
239
240 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
241}
242EXPORT_SYMBOL(hci_le_ltk_reply);
243
244void hci_le_ltk_neg_reply(struct hci_conn *conn)
245{
246 struct hci_dev *hdev = conn->hdev;
247 struct hci_cp_le_ltk_neg_reply cp;
248
249 BT_DBG("%p", conn);
250
251 memset(&cp, 0, sizeof(cp));
252
253 cp.handle = cpu_to_le16(conn->handle);
254
255 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(cp), &cp);
256}
257
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400258/* Device _must_ be locked */
259void hci_sco_setup(struct hci_conn *conn, __u8 status)
260{
261 struct hci_conn *sco = conn->link;
262
263 BT_DBG("%p", conn);
264
265 if (!sco)
266 return;
267
268 if (!status) {
269 if (lmp_esco_capable(conn->hdev))
270 hci_setup_sync(sco, conn->handle);
271 else
272 hci_add_sco(sco, conn->handle);
273 } else {
274 hci_proto_connect_cfm(sco, status);
275 hci_conn_del(sco);
276 }
277}
278
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300279static void hci_conn_timeout(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280{
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300281 struct hci_conn *conn = container_of(work, struct hci_conn,
282 disc_work.work);
Marcel Holtmann2950f212009-02-12 14:02:50 +0100283 __u8 reason;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Andrei Emeltchenkoe05dcc32012-02-17 11:40:56 +0200285 BT_DBG("conn %p state %s", conn, state_to_string(conn->state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 if (atomic_read(&conn->refcnt))
288 return;
289
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200290 switch (conn->state) {
291 case BT_CONNECT:
Marcel Holtmann769be972008-07-14 20:13:49 +0200292 case BT_CONNECT2:
Ville Tervofcd89c02011-02-10 22:38:47 -0300293 if (conn->out) {
294 if (conn->type == ACL_LINK)
295 hci_acl_connect_cancel(conn);
296 else if (conn->type == LE_LINK)
297 hci_le_connect_cancel(conn);
298 }
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200299 break;
Marcel Holtmann769be972008-07-14 20:13:49 +0200300 case BT_CONFIG:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900301 case BT_CONNECTED:
Marcel Holtmann2950f212009-02-12 14:02:50 +0100302 reason = hci_proto_disconn_ind(conn);
303 hci_acl_disconn(conn, reason);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200304 break;
305 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200307 break;
308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309}
310
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200311/* Enter sniff mode */
312static void hci_conn_enter_sniff_mode(struct hci_conn *conn)
313{
314 struct hci_dev *hdev = conn->hdev;
315
316 BT_DBG("conn %p mode %d", conn, conn->mode);
317
318 if (test_bit(HCI_RAW, &hdev->flags))
319 return;
320
321 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
322 return;
323
324 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
325 return;
326
327 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
328 struct hci_cp_sniff_subrate cp;
329 cp.handle = cpu_to_le16(conn->handle);
330 cp.max_latency = cpu_to_le16(0);
331 cp.min_remote_timeout = cpu_to_le16(0);
332 cp.min_local_timeout = cpu_to_le16(0);
333 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
334 }
335
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200336 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200337 struct hci_cp_sniff_mode cp;
338 cp.handle = cpu_to_le16(conn->handle);
339 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
340 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
341 cp.attempt = cpu_to_le16(4);
342 cp.timeout = cpu_to_le16(1);
343 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
344 }
345}
346
Marcel Holtmann04837f62006-07-03 10:02:33 +0200347static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200349 struct hci_conn *conn = (void *) arg;
350
351 BT_DBG("conn %p mode %d", conn, conn->mode);
352
353 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
355
Johan Hedberg9f616562011-04-28 11:28:54 -0700356static void hci_conn_auto_accept(unsigned long arg)
357{
358 struct hci_conn *conn = (void *) arg;
359 struct hci_dev *hdev = conn->hdev;
360
Johan Hedberg9f616562011-04-28 11:28:54 -0700361 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
362 &conn->dst);
Johan Hedberg9f616562011-04-28 11:28:54 -0700363}
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
366{
367 struct hci_conn *conn;
368
369 BT_DBG("%s dst %s", hdev->name, batostr(dst));
370
Andre Guedescb601d72012-01-30 09:22:09 -0300371 conn = kzalloc(sizeof(struct hci_conn), GFP_KERNEL);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200372 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 bacpy(&conn->dst, dst);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200376 conn->hdev = hdev;
377 conn->type = type;
378 conn->mode = HCI_CM_ACTIVE;
379 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300380 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200381 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300382 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200383 conn->key_type = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Johan Hedberg58a681e2012-01-16 06:47:28 +0200385 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200386 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200387
Marcel Holtmanna8746412008-07-14 20:13:46 +0200388 switch (type) {
389 case ACL_LINK:
390 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
391 break;
392 case SCO_LINK:
393 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100394 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
395 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200396 else
397 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
398 break;
399 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100400 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200401 break;
402 }
403
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200405
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200406 INIT_LIST_HEAD(&conn->chan_list);;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200407
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300408 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800409 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
Johan Hedberg9f616562011-04-28 11:28:54 -0700410 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
411 (unsigned long) conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 atomic_set(&conn->refcnt, 0);
414
415 hci_dev_hold(hdev);
416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 hci_conn_hash_add(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200418 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
420
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700421 atomic_set(&conn->devref, 0);
422
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700423 hci_conn_init_sysfs(conn);
424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 return conn;
426}
427
428int hci_conn_del(struct hci_conn *conn)
429{
430 struct hci_dev *hdev = conn->hdev;
431
432 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
433
Marcel Holtmann04837f62006-07-03 10:02:33 +0200434 del_timer(&conn->idle_timer);
435
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300436 cancel_delayed_work_sync(&conn->disc_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Johan Hedberg9f616562011-04-28 11:28:54 -0700438 del_timer(&conn->auto_accept_timer);
439
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200440 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 struct hci_conn *sco = conn->link;
442 if (sco)
443 sco->link = NULL;
444
445 /* Unacked frames */
446 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300447 } else if (conn->type == LE_LINK) {
448 if (hdev->le_pkts)
449 hdev->le_cnt += conn->sent;
450 else
451 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200452 } else {
453 struct hci_conn *acl = conn->link;
454 if (acl) {
455 acl->link = NULL;
456 hci_conn_put(acl);
457 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 }
459
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200460
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200461 hci_chan_list_flush(conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 hci_conn_hash_del(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200464 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700469 hci_conn_put_device(conn);
Dave Young2ae9a6b2009-02-21 16:13:34 +0800470
Marcel Holtmann384943e2009-05-08 18:20:43 -0700471 hci_dev_put(hdev);
472
Tomas Targownik163f4da2011-06-30 16:30:44 -0300473 if (conn->handle == 0)
474 kfree(conn);
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return 0;
477}
478
479struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
480{
481 int use_src = bacmp(src, BDADDR_ANY);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200482 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 BT_DBG("%s -> %s", batostr(src), batostr(dst));
485
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200486 read_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200488 list_for_each_entry(d, &hci_dev_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
490 continue;
491
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900492 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 * No source address - find interface with bdaddr != dst
494 * Source address - find interface with bdaddr == src
495 */
496
497 if (use_src) {
498 if (!bacmp(&d->bdaddr, src)) {
499 hdev = d; break;
500 }
501 } else {
502 if (bacmp(&d->bdaddr, dst)) {
503 hdev = d; break;
504 }
505 }
506 }
507
508 if (hdev)
509 hdev = hci_dev_hold(hdev);
510
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200511 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 return hdev;
513}
514EXPORT_SYMBOL(hci_get_route);
515
Ville Tervofcd89c02011-02-10 22:38:47 -0300516/* Create SCO, ACL or LE connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 * Device _must_ be locked */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100518struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
520 struct hci_conn *acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200521 struct hci_conn *sco;
Ville Tervofcd89c02011-02-10 22:38:47 -0300522 struct hci_conn *le;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
524 BT_DBG("%s dst %s", hdev->name, batostr(dst));
525
Ville Tervofcd89c02011-02-10 22:38:47 -0300526 if (type == LE_LINK) {
Andre Guedeseda42b52011-05-31 14:20:56 -0300527 struct adv_entry *entry;
528
Ville Tervofcd89c02011-02-10 22:38:47 -0300529 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
Anderson Briglia15c47942011-02-21 15:09:23 -0300530 if (le)
Ville Tervo30e76272011-02-22 16:10:53 -0300531 return ERR_PTR(-EBUSY);
Andre Guedeseda42b52011-05-31 14:20:56 -0300532
533 entry = hci_find_adv_entry(hdev, dst);
534 if (!entry)
535 return ERR_PTR(-EHOSTUNREACH);
536
Anderson Briglia15c47942011-02-21 15:09:23 -0300537 le = hci_conn_add(hdev, LE_LINK, dst);
Ville Tervofcd89c02011-02-10 22:38:47 -0300538 if (!le)
Ville Tervo30e76272011-02-22 16:10:53 -0300539 return ERR_PTR(-ENOMEM);
Andre Guedes893d6752011-05-31 14:20:55 -0300540
Andre Guedeseda42b52011-05-31 14:20:56 -0300541 le->dst_type = entry->bdaddr_type;
542
Andre Guedes893d6752011-05-31 14:20:55 -0300543 hci_le_connect(le);
Ville Tervofcd89c02011-02-10 22:38:47 -0300544
545 hci_conn_hold(le);
546
547 return le;
548 }
549
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200550 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
551 if (!acl) {
552 acl = hci_conn_add(hdev, ACL_LINK, dst);
553 if (!acl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 return NULL;
555 }
556
557 hci_conn_hold(acl);
558
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200559 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
Johan Hedberg765c2a92011-01-19 12:06:52 +0530560 acl->sec_level = BT_SECURITY_LOW;
561 acl->pending_sec_level = sec_level;
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200562 acl->auth_type = auth_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 hci_acl_connect(acl);
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200564 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200566 if (type == ACL_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 return acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200568
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200569 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
570 if (!sco) {
571 sco = hci_conn_add(hdev, type, dst);
572 if (!sco) {
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200573 hci_conn_put(acl);
574 return NULL;
575 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200577
578 acl->link = sco;
579 sco->link = acl;
580
581 hci_conn_hold(sco);
582
583 if (acl->state == BT_CONNECTED &&
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200584 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Johan Hedberg58a681e2012-01-16 06:47:28 +0200585 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700586 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Nick Pellyc3902162009-11-13 14:16:32 -0800587
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200588 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400589 /* defer SCO setup until mode change completed */
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200590 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400591 return sco;
592 }
593
594 hci_sco_setup(acl, 0x00);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200595 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200596
597 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598}
599EXPORT_SYMBOL(hci_connect);
600
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200601/* Check link security requirement */
602int hci_conn_check_link_mode(struct hci_conn *conn)
603{
604 BT_DBG("conn %p", conn);
605
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200606 if (hci_conn_ssp_enabled(conn) && !(conn->link_mode & HCI_LM_ENCRYPT))
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200607 return 0;
608
609 return 1;
610}
611EXPORT_SYMBOL(hci_conn_check_link_mode);
612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613/* Authenticate remote device */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100614static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615{
616 BT_DBG("conn %p", conn);
617
Johan Hedberg765c2a92011-01-19 12:06:52 +0530618 if (conn->pending_sec_level > sec_level)
619 sec_level = conn->pending_sec_level;
620
Marcel Holtmann96a31832009-02-12 16:23:03 +0100621 if (sec_level > conn->sec_level)
Johan Hedberg765c2a92011-01-19 12:06:52 +0530622 conn->pending_sec_level = sec_level;
Marcel Holtmann96a31832009-02-12 16:23:03 +0100623 else if (conn->link_mode & HCI_LM_AUTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 return 1;
625
Johan Hedberg65cf6862011-01-19 12:06:49 +0530626 /* Make sure we preserve an existing MITM requirement*/
627 auth_type |= (conn->auth_type & 0x01);
628
Marcel Holtmann96a31832009-02-12 16:23:03 +0100629 conn->auth_type = auth_type;
630
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200631 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 struct hci_cp_auth_requested cp;
Peter Hurleyb7d05ba2012-01-13 15:11:30 +0100633
634 /* encrypt must be pending if auth is also pending */
635 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
636
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700637 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200638 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
639 sizeof(cp), &cp);
Waldemar Rymarkiewicz19f8def2011-05-31 15:49:25 +0200640 if (conn->key_type != 0xff)
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200641 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 return 0;
645}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200647/* Encrypt the the link */
648static void hci_conn_encrypt(struct hci_conn *conn)
649{
650 BT_DBG("conn %p", conn);
651
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200652 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200653 struct hci_cp_set_conn_encrypt cp;
654 cp.handle = cpu_to_le16(conn->handle);
655 cp.encrypt = 0x01;
656 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
657 &cp);
658 }
659}
660
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100661/* Enable security */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100662int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663{
664 BT_DBG("conn %p", conn);
665
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200666 /* For sdp we don't need the link key. */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100667 if (sec_level == BT_SECURITY_SDP)
668 return 1;
669
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200670 /* For non 2.1 devices and low security level we don't need the link
671 key. */
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200672 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -0700673 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100674
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200675 /* For other security levels we need the link key. */
676 if (!(conn->link_mode & HCI_LM_AUTH))
677 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200679 /* An authenticated combination key has sufficient security for any
680 security level. */
681 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
682 goto encrypt;
683
684 /* An unauthenticated combination key has sufficient security for
685 security level 1 and 2. */
686 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
687 (sec_level == BT_SECURITY_MEDIUM ||
688 sec_level == BT_SECURITY_LOW))
689 goto encrypt;
690
691 /* A combination key has always sufficient security for the security
692 levels 1 or 2. High security level requires the combination key
693 is generated using maximum PIN code length (16).
694 For pre 2.1 units. */
695 if (conn->key_type == HCI_LK_COMBINATION &&
696 (sec_level != BT_SECURITY_HIGH ||
697 conn->pin_length == 16))
698 goto encrypt;
699
700auth:
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200701 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 return 0;
703
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +0300704 if (!hci_conn_auth(conn, sec_level, auth_type))
705 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100706
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200707encrypt:
708 if (conn->link_mode & HCI_LM_ENCRYPT)
709 return 1;
710
711 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 return 0;
713}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100714EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200716/* Check secure link requirement */
717int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
718{
719 BT_DBG("conn %p", conn);
720
721 if (sec_level != BT_SECURITY_HIGH)
722 return 1; /* Accept if non-secure is required */
723
Waldemar Rymarkiewiczef4177e2011-06-02 14:24:52 +0200724 if (conn->sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200725 return 1;
726
727 return 0; /* Reject not secure link */
728}
729EXPORT_SYMBOL(hci_conn_check_secure);
730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731/* Change link key */
732int hci_conn_change_link_key(struct hci_conn *conn)
733{
734 BT_DBG("conn %p", conn);
735
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200736 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700738 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200739 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
740 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 return 0;
744}
745EXPORT_SYMBOL(hci_conn_change_link_key);
746
747/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100748int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749{
750 BT_DBG("conn %p", conn);
751
752 if (!role && conn->link_mode & HCI_LM_MASTER)
753 return 1;
754
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200755 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 struct hci_cp_switch_role cp;
757 bacpy(&cp.bdaddr, &conn->dst);
758 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200759 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 return 0;
763}
764EXPORT_SYMBOL(hci_conn_switch_role);
765
Marcel Holtmann04837f62006-07-03 10:02:33 +0200766/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700767void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200768{
769 struct hci_dev *hdev = conn->hdev;
770
771 BT_DBG("conn %p mode %d", conn, conn->mode);
772
773 if (test_bit(HCI_RAW, &hdev->flags))
774 return;
775
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700776 if (conn->mode != HCI_CM_SNIFF)
777 goto timer;
778
Johan Hedberg58a681e2012-01-16 06:47:28 +0200779 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200780 goto timer;
781
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200782 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +0200783 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700784 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200785 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200786 }
787
788timer:
789 if (hdev->idle_timeout > 0)
790 mod_timer(&conn->idle_timer,
791 jiffies + msecs_to_jiffies(hdev->idle_timeout));
792}
793
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794/* Drop all connection on the device */
795void hci_conn_hash_flush(struct hci_dev *hdev)
796{
797 struct hci_conn_hash *h = &hdev->conn_hash;
Andrei Emeltchenko3c4e0df2012-02-02 10:32:17 +0200798 struct hci_conn *c, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
800 BT_DBG("hdev %s", hdev->name);
801
Andrei Emeltchenko3c4e0df2012-02-02 10:32:17 +0200802 list_for_each_entry_safe(c, n, &h->list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 c->state = BT_CLOSED;
804
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +0200805 hci_proto_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 hci_conn_del(c);
807 }
808}
809
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200810/* Check pending connect attempts */
811void hci_conn_check_pending(struct hci_dev *hdev)
812{
813 struct hci_conn *conn;
814
815 BT_DBG("hdev %s", hdev->name);
816
817 hci_dev_lock(hdev);
818
819 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
820 if (conn)
821 hci_acl_connect(conn);
822
823 hci_dev_unlock(hdev);
824}
825
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700826void hci_conn_hold_device(struct hci_conn *conn)
827{
828 atomic_inc(&conn->devref);
829}
830EXPORT_SYMBOL(hci_conn_hold_device);
831
832void hci_conn_put_device(struct hci_conn *conn)
833{
834 if (atomic_dec_and_test(&conn->devref))
835 hci_conn_del_sysfs(conn);
836}
837EXPORT_SYMBOL(hci_conn_put_device);
838
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839int hci_get_conn_list(void __user *arg)
840{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200841 register struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 struct hci_conn_list_req req, *cl;
843 struct hci_conn_info *ci;
844 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 int n = 0, size, err;
846
847 if (copy_from_user(&req, arg, sizeof(req)))
848 return -EFAULT;
849
850 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
851 return -EINVAL;
852
853 size = sizeof(req) + req.conn_num * sizeof(*ci);
854
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200855 cl = kmalloc(size, GFP_KERNEL);
856 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 return -ENOMEM;
858
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200859 hdev = hci_dev_get(req.dev_id);
860 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 kfree(cl);
862 return -ENODEV;
863 }
864
865 ci = cl->conn_info;
866
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300867 hci_dev_lock(hdev);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200868 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 bacpy(&(ci + n)->bdaddr, &c->dst);
870 (ci + n)->handle = c->handle;
871 (ci + n)->type = c->type;
872 (ci + n)->out = c->out;
873 (ci + n)->state = c->state;
874 (ci + n)->link_mode = c->link_mode;
875 if (++n >= req.conn_num)
876 break;
877 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300878 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
880 cl->dev_id = hdev->id;
881 cl->conn_num = n;
882 size = sizeof(req) + n * sizeof(*ci);
883
884 hci_dev_put(hdev);
885
886 err = copy_to_user(arg, cl, size);
887 kfree(cl);
888
889 return err ? -EFAULT : 0;
890}
891
892int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
893{
894 struct hci_conn_info_req req;
895 struct hci_conn_info ci;
896 struct hci_conn *conn;
897 char __user *ptr = arg + sizeof(req);
898
899 if (copy_from_user(&req, arg, sizeof(req)))
900 return -EFAULT;
901
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300902 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
904 if (conn) {
905 bacpy(&ci.bdaddr, &conn->dst);
906 ci.handle = conn->handle;
907 ci.type = conn->type;
908 ci.out = conn->out;
909 ci.state = conn->state;
910 ci.link_mode = conn->link_mode;
911 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300912 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
914 if (!conn)
915 return -ENOENT;
916
917 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
918}
Marcel Holtmann40be4922008-07-14 20:13:50 +0200919
920int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
921{
922 struct hci_auth_info_req req;
923 struct hci_conn *conn;
924
925 if (copy_from_user(&req, arg, sizeof(req)))
926 return -EFAULT;
927
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300928 hci_dev_lock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200929 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
930 if (conn)
931 req.type = conn->auth_type;
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300932 hci_dev_unlock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200933
934 if (!conn)
935 return -ENOENT;
936
937 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
938}
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200939
940struct hci_chan *hci_chan_create(struct hci_conn *conn)
941{
942 struct hci_dev *hdev = conn->hdev;
943 struct hci_chan *chan;
944
945 BT_DBG("%s conn %p", hdev->name, conn);
946
Andre Guedes75d77352012-01-30 09:22:10 -0300947 chan = kzalloc(sizeof(struct hci_chan), GFP_KERNEL);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200948 if (!chan)
949 return NULL;
950
951 chan->conn = conn;
952 skb_queue_head_init(&chan->data_q);
953
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200954 list_add_rcu(&chan->list, &conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200955
956 return chan;
957}
958
959int hci_chan_del(struct hci_chan *chan)
960{
961 struct hci_conn *conn = chan->conn;
962 struct hci_dev *hdev = conn->hdev;
963
964 BT_DBG("%s conn %p chan %p", hdev->name, conn, chan);
965
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200966 list_del_rcu(&chan->list);
967
968 synchronize_rcu();
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200969
970 skb_queue_purge(&chan->data_q);
971 kfree(chan);
972
973 return 0;
974}
975
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200976void hci_chan_list_flush(struct hci_conn *conn)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200977{
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +0200978 struct hci_chan *chan, *n;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200979
980 BT_DBG("conn %p", conn);
981
Andrei Emeltchenko2a5a5ec2012-02-02 10:32:18 +0200982 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200983 hci_chan_del(chan);
984}