blob: 7b38a0ba8765351cef6ead90d6b13e76365cf78c [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
83 BT_DBG("%p", conn);
84
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 Holtmann04837f62006-07-03 10:02:33 +0200283 struct hci_dev *hdev = conn->hdev;
Marcel Holtmann2950f212009-02-12 14:02:50 +0100284 __u8 reason;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 BT_DBG("conn %p state %d", conn, conn->state);
287
288 if (atomic_read(&conn->refcnt))
289 return;
290
291 hci_dev_lock(hdev);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200292
293 switch (conn->state) {
294 case BT_CONNECT:
Marcel Holtmann769be972008-07-14 20:13:49 +0200295 case BT_CONNECT2:
Ville Tervofcd89c02011-02-10 22:38:47 -0300296 if (conn->out) {
297 if (conn->type == ACL_LINK)
298 hci_acl_connect_cancel(conn);
299 else if (conn->type == LE_LINK)
300 hci_le_connect_cancel(conn);
301 }
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200302 break;
Marcel Holtmann769be972008-07-14 20:13:49 +0200303 case BT_CONFIG:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900304 case BT_CONNECTED:
Marcel Holtmann2950f212009-02-12 14:02:50 +0100305 reason = hci_proto_disconn_ind(conn);
306 hci_acl_disconn(conn, reason);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200307 break;
308 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200310 break;
311 }
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314}
315
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200316/* Enter sniff mode */
317static void hci_conn_enter_sniff_mode(struct hci_conn *conn)
318{
319 struct hci_dev *hdev = conn->hdev;
320
321 BT_DBG("conn %p mode %d", conn, conn->mode);
322
323 if (test_bit(HCI_RAW, &hdev->flags))
324 return;
325
326 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
327 return;
328
329 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
330 return;
331
332 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
333 struct hci_cp_sniff_subrate cp;
334 cp.handle = cpu_to_le16(conn->handle);
335 cp.max_latency = cpu_to_le16(0);
336 cp.min_remote_timeout = cpu_to_le16(0);
337 cp.min_local_timeout = cpu_to_le16(0);
338 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
339 }
340
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200341 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200342 struct hci_cp_sniff_mode cp;
343 cp.handle = cpu_to_le16(conn->handle);
344 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
345 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
346 cp.attempt = cpu_to_le16(4);
347 cp.timeout = cpu_to_le16(1);
348 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
349 }
350}
351
Marcel Holtmann04837f62006-07-03 10:02:33 +0200352static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200354 struct hci_conn *conn = (void *) arg;
355
356 BT_DBG("conn %p mode %d", conn, conn->mode);
357
358 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
Johan Hedberg9f616562011-04-28 11:28:54 -0700361static void hci_conn_auto_accept(unsigned long arg)
362{
363 struct hci_conn *conn = (void *) arg;
364 struct hci_dev *hdev = conn->hdev;
365
Johan Hedberg9f616562011-04-28 11:28:54 -0700366 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
367 &conn->dst);
Johan Hedberg9f616562011-04-28 11:28:54 -0700368}
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
371{
372 struct hci_conn *conn;
373
374 BT_DBG("%s dst %s", hdev->name, batostr(dst));
375
Andre Guedescb601d72012-01-30 09:22:09 -0300376 conn = kzalloc(sizeof(struct hci_conn), GFP_KERNEL);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200377 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 bacpy(&conn->dst, dst);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200381 conn->hdev = hdev;
382 conn->type = type;
383 conn->mode = HCI_CM_ACTIVE;
384 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300385 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200386 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300387 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200388 conn->key_type = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Johan Hedberg58a681e2012-01-16 06:47:28 +0200390 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200391 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200392
Marcel Holtmanna8746412008-07-14 20:13:46 +0200393 switch (type) {
394 case ACL_LINK:
395 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
396 break;
397 case SCO_LINK:
398 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100399 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
400 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200401 else
402 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
403 break;
404 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100405 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200406 break;
407 }
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200410
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200411 INIT_LIST_HEAD(&conn->chan_list);;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200412
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300413 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800414 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
Johan Hedberg9f616562011-04-28 11:28:54 -0700415 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
416 (unsigned long) conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
418 atomic_set(&conn->refcnt, 0);
419
420 hci_dev_hold(hdev);
421
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 hci_conn_hash_add(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200423 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
425
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700426 atomic_set(&conn->devref, 0);
427
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700428 hci_conn_init_sysfs(conn);
429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 return conn;
431}
432
433int hci_conn_del(struct hci_conn *conn)
434{
435 struct hci_dev *hdev = conn->hdev;
436
437 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
438
Marcel Holtmann04837f62006-07-03 10:02:33 +0200439 del_timer(&conn->idle_timer);
440
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300441 cancel_delayed_work_sync(&conn->disc_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Johan Hedberg9f616562011-04-28 11:28:54 -0700443 del_timer(&conn->auto_accept_timer);
444
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200445 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 struct hci_conn *sco = conn->link;
447 if (sco)
448 sco->link = NULL;
449
450 /* Unacked frames */
451 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300452 } else if (conn->type == LE_LINK) {
453 if (hdev->le_pkts)
454 hdev->le_cnt += conn->sent;
455 else
456 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200457 } else {
458 struct hci_conn *acl = conn->link;
459 if (acl) {
460 acl->link = NULL;
461 hci_conn_put(acl);
462 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 }
464
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200465
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200466 hci_chan_list_flush(conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 hci_conn_hash_del(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200469 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700474 hci_conn_put_device(conn);
Dave Young2ae9a6b2009-02-21 16:13:34 +0800475
Marcel Holtmann384943e2009-05-08 18:20:43 -0700476 hci_dev_put(hdev);
477
Tomas Targownik163f4da2011-06-30 16:30:44 -0300478 if (conn->handle == 0)
479 kfree(conn);
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 return 0;
482}
483
484struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
485{
486 int use_src = bacmp(src, BDADDR_ANY);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200487 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
489 BT_DBG("%s -> %s", batostr(src), batostr(dst));
490
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200491 read_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200493 list_for_each_entry(d, &hci_dev_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
495 continue;
496
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900497 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 * No source address - find interface with bdaddr != dst
499 * Source address - find interface with bdaddr == src
500 */
501
502 if (use_src) {
503 if (!bacmp(&d->bdaddr, src)) {
504 hdev = d; break;
505 }
506 } else {
507 if (bacmp(&d->bdaddr, dst)) {
508 hdev = d; break;
509 }
510 }
511 }
512
513 if (hdev)
514 hdev = hci_dev_hold(hdev);
515
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200516 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 return hdev;
518}
519EXPORT_SYMBOL(hci_get_route);
520
Ville Tervofcd89c02011-02-10 22:38:47 -0300521/* Create SCO, ACL or LE connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 * Device _must_ be locked */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100523struct 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 -0700524{
525 struct hci_conn *acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200526 struct hci_conn *sco;
Ville Tervofcd89c02011-02-10 22:38:47 -0300527 struct hci_conn *le;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529 BT_DBG("%s dst %s", hdev->name, batostr(dst));
530
Ville Tervofcd89c02011-02-10 22:38:47 -0300531 if (type == LE_LINK) {
Andre Guedeseda42b52011-05-31 14:20:56 -0300532 struct adv_entry *entry;
533
Ville Tervofcd89c02011-02-10 22:38:47 -0300534 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
Anderson Briglia15c47942011-02-21 15:09:23 -0300535 if (le)
Ville Tervo30e76272011-02-22 16:10:53 -0300536 return ERR_PTR(-EBUSY);
Andre Guedeseda42b52011-05-31 14:20:56 -0300537
538 entry = hci_find_adv_entry(hdev, dst);
539 if (!entry)
540 return ERR_PTR(-EHOSTUNREACH);
541
Anderson Briglia15c47942011-02-21 15:09:23 -0300542 le = hci_conn_add(hdev, LE_LINK, dst);
Ville Tervofcd89c02011-02-10 22:38:47 -0300543 if (!le)
Ville Tervo30e76272011-02-22 16:10:53 -0300544 return ERR_PTR(-ENOMEM);
Andre Guedes893d6752011-05-31 14:20:55 -0300545
Andre Guedeseda42b52011-05-31 14:20:56 -0300546 le->dst_type = entry->bdaddr_type;
547
Andre Guedes893d6752011-05-31 14:20:55 -0300548 hci_le_connect(le);
Ville Tervofcd89c02011-02-10 22:38:47 -0300549
550 hci_conn_hold(le);
551
552 return le;
553 }
554
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200555 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
556 if (!acl) {
557 acl = hci_conn_add(hdev, ACL_LINK, dst);
558 if (!acl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 return NULL;
560 }
561
562 hci_conn_hold(acl);
563
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200564 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
Johan Hedberg765c2a92011-01-19 12:06:52 +0530565 acl->sec_level = BT_SECURITY_LOW;
566 acl->pending_sec_level = sec_level;
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200567 acl->auth_type = auth_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 hci_acl_connect(acl);
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200569 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200571 if (type == ACL_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 return acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200573
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200574 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
575 if (!sco) {
576 sco = hci_conn_add(hdev, type, dst);
577 if (!sco) {
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200578 hci_conn_put(acl);
579 return NULL;
580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200582
583 acl->link = sco;
584 sco->link = acl;
585
586 hci_conn_hold(sco);
587
588 if (acl->state == BT_CONNECTED &&
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200589 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Johan Hedberg58a681e2012-01-16 06:47:28 +0200590 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700591 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Nick Pellyc3902162009-11-13 14:16:32 -0800592
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200593 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400594 /* defer SCO setup until mode change completed */
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200595 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400596 return sco;
597 }
598
599 hci_sco_setup(acl, 0x00);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200600 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200601
602 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603}
604EXPORT_SYMBOL(hci_connect);
605
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200606/* Check link security requirement */
607int hci_conn_check_link_mode(struct hci_conn *conn)
608{
609 BT_DBG("conn %p", conn);
610
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200611 if (hci_conn_ssp_enabled(conn) && !(conn->link_mode & HCI_LM_ENCRYPT))
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200612 return 0;
613
614 return 1;
615}
616EXPORT_SYMBOL(hci_conn_check_link_mode);
617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618/* Authenticate remote device */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100619static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
621 BT_DBG("conn %p", conn);
622
Johan Hedberg765c2a92011-01-19 12:06:52 +0530623 if (conn->pending_sec_level > sec_level)
624 sec_level = conn->pending_sec_level;
625
Marcel Holtmann96a31832009-02-12 16:23:03 +0100626 if (sec_level > conn->sec_level)
Johan Hedberg765c2a92011-01-19 12:06:52 +0530627 conn->pending_sec_level = sec_level;
Marcel Holtmann96a31832009-02-12 16:23:03 +0100628 else if (conn->link_mode & HCI_LM_AUTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 return 1;
630
Johan Hedberg65cf6862011-01-19 12:06:49 +0530631 /* Make sure we preserve an existing MITM requirement*/
632 auth_type |= (conn->auth_type & 0x01);
633
Marcel Holtmann96a31832009-02-12 16:23:03 +0100634 conn->auth_type = auth_type;
635
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200636 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 struct hci_cp_auth_requested cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700638 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200639 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
640 sizeof(cp), &cp);
Waldemar Rymarkiewicz19f8def2011-05-31 15:49:25 +0200641 if (conn->key_type != 0xff)
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200642 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 return 0;
646}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200648/* Encrypt the the link */
649static void hci_conn_encrypt(struct hci_conn *conn)
650{
651 BT_DBG("conn %p", conn);
652
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200653 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200654 struct hci_cp_set_conn_encrypt cp;
655 cp.handle = cpu_to_le16(conn->handle);
656 cp.encrypt = 0x01;
657 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
658 &cp);
659 }
660}
661
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100662/* Enable security */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100663int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664{
665 BT_DBG("conn %p", conn);
666
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200667 /* For sdp we don't need the link key. */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100668 if (sec_level == BT_SECURITY_SDP)
669 return 1;
670
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200671 /* For non 2.1 devices and low security level we don't need the link
672 key. */
Johan Hedbergaa64a8b2012-01-18 21:33:12 +0200673 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -0700674 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100675
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200676 /* For other security levels we need the link key. */
677 if (!(conn->link_mode & HCI_LM_AUTH))
678 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200680 /* An authenticated combination key has sufficient security for any
681 security level. */
682 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
683 goto encrypt;
684
685 /* An unauthenticated combination key has sufficient security for
686 security level 1 and 2. */
687 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
688 (sec_level == BT_SECURITY_MEDIUM ||
689 sec_level == BT_SECURITY_LOW))
690 goto encrypt;
691
692 /* A combination key has always sufficient security for the security
693 levels 1 or 2. High security level requires the combination key
694 is generated using maximum PIN code length (16).
695 For pre 2.1 units. */
696 if (conn->key_type == HCI_LK_COMBINATION &&
697 (sec_level != BT_SECURITY_HIGH ||
698 conn->pin_length == 16))
699 goto encrypt;
700
701auth:
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200702 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 return 0;
704
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +0300705 if (!hci_conn_auth(conn, sec_level, auth_type))
706 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100707
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200708encrypt:
709 if (conn->link_mode & HCI_LM_ENCRYPT)
710 return 1;
711
712 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 return 0;
714}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100715EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200717/* Check secure link requirement */
718int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
719{
720 BT_DBG("conn %p", conn);
721
722 if (sec_level != BT_SECURITY_HIGH)
723 return 1; /* Accept if non-secure is required */
724
Waldemar Rymarkiewiczef4177e2011-06-02 14:24:52 +0200725 if (conn->sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200726 return 1;
727
728 return 0; /* Reject not secure link */
729}
730EXPORT_SYMBOL(hci_conn_check_secure);
731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732/* Change link key */
733int hci_conn_change_link_key(struct hci_conn *conn)
734{
735 BT_DBG("conn %p", conn);
736
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200737 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700739 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200740 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
741 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100743
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 return 0;
745}
746EXPORT_SYMBOL(hci_conn_change_link_key);
747
748/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100749int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
751 BT_DBG("conn %p", conn);
752
753 if (!role && conn->link_mode & HCI_LM_MASTER)
754 return 1;
755
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200756 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 struct hci_cp_switch_role cp;
758 bacpy(&cp.bdaddr, &conn->dst);
759 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200760 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 return 0;
764}
765EXPORT_SYMBOL(hci_conn_switch_role);
766
Marcel Holtmann04837f62006-07-03 10:02:33 +0200767/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700768void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200769{
770 struct hci_dev *hdev = conn->hdev;
771
772 BT_DBG("conn %p mode %d", conn, conn->mode);
773
774 if (test_bit(HCI_RAW, &hdev->flags))
775 return;
776
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700777 if (conn->mode != HCI_CM_SNIFF)
778 goto timer;
779
Johan Hedberg58a681e2012-01-16 06:47:28 +0200780 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200781 goto timer;
782
Johan Hedberg51a8efd2012-01-16 06:10:31 +0200783 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +0200784 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700785 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200786 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200787 }
788
789timer:
790 if (hdev->idle_timeout > 0)
791 mod_timer(&conn->idle_timer,
792 jiffies + msecs_to_jiffies(hdev->idle_timeout));
793}
794
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795/* Drop all connection on the device */
796void hci_conn_hash_flush(struct hci_dev *hdev)
797{
798 struct hci_conn_hash *h = &hdev->conn_hash;
Gustavo F. Padovan3e9c40a2011-12-14 22:52:31 -0200799 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
801 BT_DBG("hdev %s", hdev->name);
802
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -0200803 list_for_each_entry_rcu(c, &h->list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 c->state = BT_CLOSED;
805
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +0200806 hci_proto_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 hci_conn_del(c);
808 }
809}
810
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200811/* Check pending connect attempts */
812void hci_conn_check_pending(struct hci_dev *hdev)
813{
814 struct hci_conn *conn;
815
816 BT_DBG("hdev %s", hdev->name);
817
818 hci_dev_lock(hdev);
819
820 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
821 if (conn)
822 hci_acl_connect(conn);
823
824 hci_dev_unlock(hdev);
825}
826
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700827void hci_conn_hold_device(struct hci_conn *conn)
828{
829 atomic_inc(&conn->devref);
830}
831EXPORT_SYMBOL(hci_conn_hold_device);
832
833void hci_conn_put_device(struct hci_conn *conn)
834{
835 if (atomic_dec_and_test(&conn->devref))
836 hci_conn_del_sysfs(conn);
837}
838EXPORT_SYMBOL(hci_conn_put_device);
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840int hci_get_conn_list(void __user *arg)
841{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200842 register struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 struct hci_conn_list_req req, *cl;
844 struct hci_conn_info *ci;
845 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 int n = 0, size, err;
847
848 if (copy_from_user(&req, arg, sizeof(req)))
849 return -EFAULT;
850
851 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
852 return -EINVAL;
853
854 size = sizeof(req) + req.conn_num * sizeof(*ci);
855
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200856 cl = kmalloc(size, GFP_KERNEL);
857 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 return -ENOMEM;
859
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200860 hdev = hci_dev_get(req.dev_id);
861 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 kfree(cl);
863 return -ENODEV;
864 }
865
866 ci = cl->conn_info;
867
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300868 hci_dev_lock(hdev);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200869 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 bacpy(&(ci + n)->bdaddr, &c->dst);
871 (ci + n)->handle = c->handle;
872 (ci + n)->type = c->type;
873 (ci + n)->out = c->out;
874 (ci + n)->state = c->state;
875 (ci + n)->link_mode = c->link_mode;
876 if (++n >= req.conn_num)
877 break;
878 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300879 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
881 cl->dev_id = hdev->id;
882 cl->conn_num = n;
883 size = sizeof(req) + n * sizeof(*ci);
884
885 hci_dev_put(hdev);
886
887 err = copy_to_user(arg, cl, size);
888 kfree(cl);
889
890 return err ? -EFAULT : 0;
891}
892
893int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
894{
895 struct hci_conn_info_req req;
896 struct hci_conn_info ci;
897 struct hci_conn *conn;
898 char __user *ptr = arg + sizeof(req);
899
900 if (copy_from_user(&req, arg, sizeof(req)))
901 return -EFAULT;
902
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300903 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
905 if (conn) {
906 bacpy(&ci.bdaddr, &conn->dst);
907 ci.handle = conn->handle;
908 ci.type = conn->type;
909 ci.out = conn->out;
910 ci.state = conn->state;
911 ci.link_mode = conn->link_mode;
912 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300913 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914
915 if (!conn)
916 return -ENOENT;
917
918 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
919}
Marcel Holtmann40be4922008-07-14 20:13:50 +0200920
921int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
922{
923 struct hci_auth_info_req req;
924 struct hci_conn *conn;
925
926 if (copy_from_user(&req, arg, sizeof(req)))
927 return -EFAULT;
928
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300929 hci_dev_lock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200930 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
931 if (conn)
932 req.type = conn->auth_type;
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300933 hci_dev_unlock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200934
935 if (!conn)
936 return -ENOENT;
937
938 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
939}
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200940
941struct hci_chan *hci_chan_create(struct hci_conn *conn)
942{
943 struct hci_dev *hdev = conn->hdev;
944 struct hci_chan *chan;
945
946 BT_DBG("%s conn %p", hdev->name, conn);
947
Andre Guedes75d77352012-01-30 09:22:10 -0300948 chan = kzalloc(sizeof(struct hci_chan), GFP_KERNEL);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200949 if (!chan)
950 return NULL;
951
952 chan->conn = conn;
953 skb_queue_head_init(&chan->data_q);
954
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200955 list_add_rcu(&chan->list, &conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200956
957 return chan;
958}
959
960int hci_chan_del(struct hci_chan *chan)
961{
962 struct hci_conn *conn = chan->conn;
963 struct hci_dev *hdev = conn->hdev;
964
965 BT_DBG("%s conn %p chan %p", hdev->name, conn, chan);
966
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200967 list_del_rcu(&chan->list);
968
969 synchronize_rcu();
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200970
971 skb_queue_purge(&chan->data_q);
972 kfree(chan);
973
974 return 0;
975}
976
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200977void hci_chan_list_flush(struct hci_conn *conn)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200978{
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200979 struct hci_chan *chan;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200980
981 BT_DBG("conn %p", conn);
982
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200983 list_for_each_entry_rcu(chan, &conn->chan_list, list)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200984 hci_chan_del(chan);
985}