blob: 3db432473ad5214efc902f5bbaa36f631114defa [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;
54 conn->out = 1;
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;
Marcel Holtmanna8746412008-07-14 20:13:46 +020086 conn->out = 1;
87
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);
Marcel Holtmann41a96212008-07-14 20:13:48 +0200108 conn->ssp_mode = ie->data.ssp_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 }
110
Marcel Holtmanna8746412008-07-14 20:13:46 +0200111 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200113 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200115 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200116
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200117 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200120static void hci_acl_connect_cancel(struct hci_conn *conn)
121{
122 struct hci_cp_create_conn_cancel cp;
123
124 BT_DBG("%p", conn);
125
Andrei Emeltchenkod095c1e2011-12-01 14:33:27 +0200126 if (conn->hdev->hci_ver < BLUETOOTH_VER_1_2)
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200127 return;
128
129 bacpy(&cp.bdaddr, &conn->dst);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200130 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200131}
132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
134{
135 struct hci_cp_disconnect cp;
136
137 BT_DBG("%p", conn);
138
139 conn->state = BT_DISCONN;
140
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700141 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 cp.reason = reason;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200143 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144}
145
146void hci_add_sco(struct hci_conn *conn, __u16 handle)
147{
148 struct hci_dev *hdev = conn->hdev;
149 struct hci_cp_add_sco cp;
150
151 BT_DBG("%p", conn);
152
153 conn->state = BT_CONNECT;
154 conn->out = 1;
155
Marcel Holtmannefc76882009-02-06 09:13:37 +0100156 conn->attempt++;
157
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700158 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200159 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200161 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200164void hci_setup_sync(struct hci_conn *conn, __u16 handle)
165{
166 struct hci_dev *hdev = conn->hdev;
167 struct hci_cp_setup_sync_conn cp;
168
169 BT_DBG("%p", conn);
170
171 conn->state = BT_CONNECT;
172 conn->out = 1;
173
Marcel Holtmannefc76882009-02-06 09:13:37 +0100174 conn->attempt++;
175
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200176 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200177 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200178
179 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
180 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
181 cp.max_latency = cpu_to_le16(0xffff);
182 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
183 cp.retrans_effort = 0xff;
184
185 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
186}
187
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200188void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
189 u16 latency, u16 to_multiplier)
190{
191 struct hci_cp_le_conn_update cp;
192 struct hci_dev *hdev = conn->hdev;
193
194 memset(&cp, 0, sizeof(cp));
195
196 cp.handle = cpu_to_le16(conn->handle);
197 cp.conn_interval_min = cpu_to_le16(min);
198 cp.conn_interval_max = cpu_to_le16(max);
199 cp.conn_latency = cpu_to_le16(latency);
200 cp.supervision_timeout = cpu_to_le16(to_multiplier);
201 cp.min_ce_len = cpu_to_le16(0x0001);
202 cp.max_ce_len = cpu_to_le16(0x0001);
203
204 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
205}
206EXPORT_SYMBOL(hci_le_conn_update);
207
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300208void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
209 __u8 ltk[16])
210{
211 struct hci_dev *hdev = conn->hdev;
212 struct hci_cp_le_start_enc cp;
213
214 BT_DBG("%p", conn);
215
216 memset(&cp, 0, sizeof(cp));
217
218 cp.handle = cpu_to_le16(conn->handle);
219 memcpy(cp.ltk, ltk, sizeof(cp.ltk));
220 cp.ediv = ediv;
Anderson Briglia51beabd2011-09-19 14:41:09 -0400221 memcpy(cp.rand, rand, sizeof(cp.rand));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300222
223 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
224}
225EXPORT_SYMBOL(hci_le_start_enc);
226
227void hci_le_ltk_reply(struct hci_conn *conn, u8 ltk[16])
228{
229 struct hci_dev *hdev = conn->hdev;
230 struct hci_cp_le_ltk_reply cp;
231
232 BT_DBG("%p", conn);
233
234 memset(&cp, 0, sizeof(cp));
235
236 cp.handle = cpu_to_le16(conn->handle);
237 memcpy(cp.ltk, ltk, sizeof(ltk));
238
239 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
240}
241EXPORT_SYMBOL(hci_le_ltk_reply);
242
243void hci_le_ltk_neg_reply(struct hci_conn *conn)
244{
245 struct hci_dev *hdev = conn->hdev;
246 struct hci_cp_le_ltk_neg_reply cp;
247
248 BT_DBG("%p", conn);
249
250 memset(&cp, 0, sizeof(cp));
251
252 cp.handle = cpu_to_le16(conn->handle);
253
254 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(cp), &cp);
255}
256
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400257/* Device _must_ be locked */
258void hci_sco_setup(struct hci_conn *conn, __u8 status)
259{
260 struct hci_conn *sco = conn->link;
261
262 BT_DBG("%p", conn);
263
264 if (!sco)
265 return;
266
267 if (!status) {
268 if (lmp_esco_capable(conn->hdev))
269 hci_setup_sync(sco, conn->handle);
270 else
271 hci_add_sco(sco, conn->handle);
272 } else {
273 hci_proto_connect_cfm(sco, status);
274 hci_conn_del(sco);
275 }
276}
277
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300278static void hci_conn_timeout(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300280 struct hci_conn *conn = container_of(work, struct hci_conn,
281 disc_work.work);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200282 struct hci_dev *hdev = conn->hdev;
Marcel Holtmann2950f212009-02-12 14:02:50 +0100283 __u8 reason;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 BT_DBG("conn %p state %d", conn, conn->state);
286
287 if (atomic_read(&conn->refcnt))
288 return;
289
290 hci_dev_lock(hdev);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200291
292 switch (conn->state) {
293 case BT_CONNECT:
Marcel Holtmann769be972008-07-14 20:13:49 +0200294 case BT_CONNECT2:
Ville Tervofcd89c02011-02-10 22:38:47 -0300295 if (conn->out) {
296 if (conn->type == ACL_LINK)
297 hci_acl_connect_cancel(conn);
298 else if (conn->type == LE_LINK)
299 hci_le_connect_cancel(conn);
300 }
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200301 break;
Marcel Holtmann769be972008-07-14 20:13:49 +0200302 case BT_CONFIG:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900303 case BT_CONNECTED:
Marcel Holtmann2950f212009-02-12 14:02:50 +0100304 reason = hci_proto_disconn_ind(conn);
305 hci_acl_disconn(conn, reason);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200306 break;
307 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200309 break;
310 }
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Gustavo F. Padovan416dc942011-12-07 13:24:33 -0200315/* Enter sniff mode */
316static void hci_conn_enter_sniff_mode(struct hci_conn *conn)
317{
318 struct hci_dev *hdev = conn->hdev;
319
320 BT_DBG("conn %p mode %d", conn, conn->mode);
321
322 if (test_bit(HCI_RAW, &hdev->flags))
323 return;
324
325 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
326 return;
327
328 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
329 return;
330
331 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
332 struct hci_cp_sniff_subrate cp;
333 cp.handle = cpu_to_le16(conn->handle);
334 cp.max_latency = cpu_to_le16(0);
335 cp.min_remote_timeout = cpu_to_le16(0);
336 cp.min_local_timeout = cpu_to_le16(0);
337 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
338 }
339
340 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
341 struct hci_cp_sniff_mode cp;
342 cp.handle = cpu_to_le16(conn->handle);
343 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
344 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
345 cp.attempt = cpu_to_le16(4);
346 cp.timeout = cpu_to_le16(1);
347 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
348 }
349}
350
Marcel Holtmann04837f62006-07-03 10:02:33 +0200351static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200353 struct hci_conn *conn = (void *) arg;
354
355 BT_DBG("conn %p mode %d", conn, conn->mode);
356
357 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359
Johan Hedberg9f616562011-04-28 11:28:54 -0700360static void hci_conn_auto_accept(unsigned long arg)
361{
362 struct hci_conn *conn = (void *) arg;
363 struct hci_dev *hdev = conn->hdev;
364
Johan Hedberg9f616562011-04-28 11:28:54 -0700365 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
366 &conn->dst);
Johan Hedberg9f616562011-04-28 11:28:54 -0700367}
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
370{
371 struct hci_conn *conn;
372
373 BT_DBG("%s dst %s", hdev->name, batostr(dst));
374
Marcel Holtmann04837f62006-07-03 10:02:33 +0200375 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
376 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
379 bacpy(&conn->dst, dst);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200380 conn->hdev = hdev;
381 conn->type = type;
382 conn->mode = HCI_CM_ACTIVE;
383 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300384 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200385 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300386 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200387 conn->key_type = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Marcel Holtmann04837f62006-07-03 10:02:33 +0200389 conn->power_save = 1;
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200390 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200391
Marcel Holtmanna8746412008-07-14 20:13:46 +0200392 switch (type) {
393 case ACL_LINK:
394 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
395 break;
396 case SCO_LINK:
397 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100398 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
399 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200400 else
401 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
402 break;
403 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100404 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200405 break;
406 }
407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200409
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200410 INIT_LIST_HEAD(&conn->chan_list);;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200411
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300412 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800413 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
Johan Hedberg9f616562011-04-28 11:28:54 -0700414 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
415 (unsigned long) conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417 atomic_set(&conn->refcnt, 0);
418
419 hci_dev_hold(hdev);
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 hci_conn_hash_add(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200422 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
424
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700425 atomic_set(&conn->devref, 0);
426
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700427 hci_conn_init_sysfs(conn);
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 return conn;
430}
431
432int hci_conn_del(struct hci_conn *conn)
433{
434 struct hci_dev *hdev = conn->hdev;
435
436 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
437
Marcel Holtmann04837f62006-07-03 10:02:33 +0200438 del_timer(&conn->idle_timer);
439
Gustavo F. Padovan19c40e32011-06-17 13:03:21 -0300440 cancel_delayed_work_sync(&conn->disc_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Johan Hedberg9f616562011-04-28 11:28:54 -0700442 del_timer(&conn->auto_accept_timer);
443
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200444 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 struct hci_conn *sco = conn->link;
446 if (sco)
447 sco->link = NULL;
448
449 /* Unacked frames */
450 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300451 } else if (conn->type == LE_LINK) {
452 if (hdev->le_pkts)
453 hdev->le_cnt += conn->sent;
454 else
455 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200456 } else {
457 struct hci_conn *acl = conn->link;
458 if (acl) {
459 acl->link = NULL;
460 hci_conn_put(acl);
461 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 }
463
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200464
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200465 hci_chan_list_flush(conn);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 hci_conn_hash_del(hdev, conn);
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200468 if (hdev->notify)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200470
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700473 hci_conn_put_device(conn);
Dave Young2ae9a6b2009-02-21 16:13:34 +0800474
Marcel Holtmann384943e2009-05-08 18:20:43 -0700475 hci_dev_put(hdev);
476
Tomas Targownik163f4da2011-06-30 16:30:44 -0300477 if (conn->handle == 0)
478 kfree(conn);
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 return 0;
481}
482
483struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
484{
485 int use_src = bacmp(src, BDADDR_ANY);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200486 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
488 BT_DBG("%s -> %s", batostr(src), batostr(dst));
489
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200490 read_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200492 list_for_each_entry(d, &hci_dev_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
494 continue;
495
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900496 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 * No source address - find interface with bdaddr != dst
498 * Source address - find interface with bdaddr == src
499 */
500
501 if (use_src) {
502 if (!bacmp(&d->bdaddr, src)) {
503 hdev = d; break;
504 }
505 } else {
506 if (bacmp(&d->bdaddr, dst)) {
507 hdev = d; break;
508 }
509 }
510 }
511
512 if (hdev)
513 hdev = hci_dev_hold(hdev);
514
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -0200515 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return hdev;
517}
518EXPORT_SYMBOL(hci_get_route);
519
Ville Tervofcd89c02011-02-10 22:38:47 -0300520/* Create SCO, ACL or LE connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 * Device _must_ be locked */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100522struct 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 -0700523{
524 struct hci_conn *acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200525 struct hci_conn *sco;
Ville Tervofcd89c02011-02-10 22:38:47 -0300526 struct hci_conn *le;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528 BT_DBG("%s dst %s", hdev->name, batostr(dst));
529
Ville Tervofcd89c02011-02-10 22:38:47 -0300530 if (type == LE_LINK) {
Andre Guedeseda42b52011-05-31 14:20:56 -0300531 struct adv_entry *entry;
532
Ville Tervofcd89c02011-02-10 22:38:47 -0300533 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
Anderson Briglia15c47942011-02-21 15:09:23 -0300534 if (le)
Ville Tervo30e76272011-02-22 16:10:53 -0300535 return ERR_PTR(-EBUSY);
Andre Guedeseda42b52011-05-31 14:20:56 -0300536
537 entry = hci_find_adv_entry(hdev, dst);
538 if (!entry)
539 return ERR_PTR(-EHOSTUNREACH);
540
Anderson Briglia15c47942011-02-21 15:09:23 -0300541 le = hci_conn_add(hdev, LE_LINK, dst);
Ville Tervofcd89c02011-02-10 22:38:47 -0300542 if (!le)
Ville Tervo30e76272011-02-22 16:10:53 -0300543 return ERR_PTR(-ENOMEM);
Andre Guedes893d6752011-05-31 14:20:55 -0300544
Andre Guedeseda42b52011-05-31 14:20:56 -0300545 le->dst_type = entry->bdaddr_type;
546
Andre Guedes893d6752011-05-31 14:20:55 -0300547 hci_le_connect(le);
Ville Tervofcd89c02011-02-10 22:38:47 -0300548
549 hci_conn_hold(le);
550
551 return le;
552 }
553
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200554 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
555 if (!acl) {
556 acl = hci_conn_add(hdev, ACL_LINK, dst);
557 if (!acl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return NULL;
559 }
560
561 hci_conn_hold(acl);
562
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200563 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
Johan Hedberg765c2a92011-01-19 12:06:52 +0530564 acl->sec_level = BT_SECURITY_LOW;
565 acl->pending_sec_level = sec_level;
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200566 acl->auth_type = auth_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 hci_acl_connect(acl);
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200568 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200570 if (type == ACL_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 return acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200572
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200573 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
574 if (!sco) {
575 sco = hci_conn_add(hdev, type, dst);
576 if (!sco) {
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200577 hci_conn_put(acl);
578 return NULL;
579 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200581
582 acl->link = sco;
583 sco->link = acl;
584
585 hci_conn_hold(sco);
586
587 if (acl->state == BT_CONNECTED &&
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200588 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Nick Pellyc3902162009-11-13 14:16:32 -0800589 acl->power_save = 1;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700590 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Nick Pellyc3902162009-11-13 14:16:32 -0800591
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400592 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->pend)) {
593 /* defer SCO setup until mode change completed */
594 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->pend);
595 return sco;
596 }
597
598 hci_sco_setup(acl, 0x00);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200599 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200600
601 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602}
603EXPORT_SYMBOL(hci_connect);
604
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200605/* Check link security requirement */
606int hci_conn_check_link_mode(struct hci_conn *conn)
607{
608 BT_DBG("conn %p", conn);
609
610 if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
611 !(conn->link_mode & HCI_LM_ENCRYPT))
612 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
637 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)
642 set_bit(HCI_CONN_REAUTH_PEND, &conn->pend);
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
653 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
654 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. */
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -0700673 if (sec_level == BT_SECURITY_LOW &&
674 (!conn->ssp_mode || !conn->hdev->ssp_mode))
675 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100676
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200677 /* For other security levels we need the link key. */
678 if (!(conn->link_mode & HCI_LM_AUTH))
679 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200681 /* An authenticated combination key has sufficient security for any
682 security level. */
683 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
684 goto encrypt;
685
686 /* An unauthenticated combination key has sufficient security for
687 security level 1 and 2. */
688 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
689 (sec_level == BT_SECURITY_MEDIUM ||
690 sec_level == BT_SECURITY_LOW))
691 goto encrypt;
692
693 /* A combination key has always sufficient security for the security
694 levels 1 or 2. High security level requires the combination key
695 is generated using maximum PIN code length (16).
696 For pre 2.1 units. */
697 if (conn->key_type == HCI_LK_COMBINATION &&
698 (sec_level != BT_SECURITY_HIGH ||
699 conn->pin_length == 16))
700 goto encrypt;
701
702auth:
Gustavo F. Padovand7660912011-12-18 22:33:30 -0200703 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 return 0;
705
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +0300706 if (!hci_conn_auth(conn, sec_level, auth_type))
707 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100708
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200709encrypt:
710 if (conn->link_mode & HCI_LM_ENCRYPT)
711 return 1;
712
713 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 return 0;
715}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100716EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200718/* Check secure link requirement */
719int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
720{
721 BT_DBG("conn %p", conn);
722
723 if (sec_level != BT_SECURITY_HIGH)
724 return 1; /* Accept if non-secure is required */
725
Waldemar Rymarkiewiczef4177e2011-06-02 14:24:52 +0200726 if (conn->sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200727 return 1;
728
729 return 0; /* Reject not secure link */
730}
731EXPORT_SYMBOL(hci_conn_check_secure);
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733/* Change link key */
734int hci_conn_change_link_key(struct hci_conn *conn)
735{
736 BT_DBG("conn %p", conn);
737
738 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
739 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700740 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200741 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
742 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100744
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 return 0;
746}
747EXPORT_SYMBOL(hci_conn_change_link_key);
748
749/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100750int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
752 BT_DBG("conn %p", conn);
753
754 if (!role && conn->link_mode & HCI_LM_MASTER)
755 return 1;
756
757 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
758 struct hci_cp_switch_role cp;
759 bacpy(&cp.bdaddr, &conn->dst);
760 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200761 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 return 0;
765}
766EXPORT_SYMBOL(hci_conn_switch_role);
767
Marcel Holtmann04837f62006-07-03 10:02:33 +0200768/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700769void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200770{
771 struct hci_dev *hdev = conn->hdev;
772
773 BT_DBG("conn %p mode %d", conn, conn->mode);
774
775 if (test_bit(HCI_RAW, &hdev->flags))
776 return;
777
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700778 if (conn->mode != HCI_CM_SNIFF)
779 goto timer;
780
781 if (!conn->power_save && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200782 goto timer;
783
784 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
785 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700786 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200787 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200788 }
789
790timer:
791 if (hdev->idle_timeout > 0)
792 mod_timer(&conn->idle_timer,
793 jiffies + msecs_to_jiffies(hdev->idle_timeout));
794}
795
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796/* Drop all connection on the device */
797void hci_conn_hash_flush(struct hci_dev *hdev)
798{
799 struct hci_conn_hash *h = &hdev->conn_hash;
Gustavo F. Padovan3e9c40a2011-12-14 22:52:31 -0200800 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
802 BT_DBG("hdev %s", hdev->name);
803
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -0200804 list_for_each_entry_rcu(c, &h->list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 c->state = BT_CLOSED;
806
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +0200807 hci_proto_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 hci_conn_del(c);
809 }
810}
811
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200812/* Check pending connect attempts */
813void hci_conn_check_pending(struct hci_dev *hdev)
814{
815 struct hci_conn *conn;
816
817 BT_DBG("hdev %s", hdev->name);
818
819 hci_dev_lock(hdev);
820
821 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
822 if (conn)
823 hci_acl_connect(conn);
824
825 hci_dev_unlock(hdev);
826}
827
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700828void hci_conn_hold_device(struct hci_conn *conn)
829{
830 atomic_inc(&conn->devref);
831}
832EXPORT_SYMBOL(hci_conn_hold_device);
833
834void hci_conn_put_device(struct hci_conn *conn)
835{
836 if (atomic_dec_and_test(&conn->devref))
837 hci_conn_del_sysfs(conn);
838}
839EXPORT_SYMBOL(hci_conn_put_device);
840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841int hci_get_conn_list(void __user *arg)
842{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200843 register struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 struct hci_conn_list_req req, *cl;
845 struct hci_conn_info *ci;
846 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 int n = 0, size, err;
848
849 if (copy_from_user(&req, arg, sizeof(req)))
850 return -EFAULT;
851
852 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
853 return -EINVAL;
854
855 size = sizeof(req) + req.conn_num * sizeof(*ci);
856
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200857 cl = kmalloc(size, GFP_KERNEL);
858 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 return -ENOMEM;
860
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200861 hdev = hci_dev_get(req.dev_id);
862 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 kfree(cl);
864 return -ENODEV;
865 }
866
867 ci = cl->conn_info;
868
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300869 hci_dev_lock(hdev);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200870 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 bacpy(&(ci + n)->bdaddr, &c->dst);
872 (ci + n)->handle = c->handle;
873 (ci + n)->type = c->type;
874 (ci + n)->out = c->out;
875 (ci + n)->state = c->state;
876 (ci + n)->link_mode = c->link_mode;
877 if (++n >= req.conn_num)
878 break;
879 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300880 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 cl->dev_id = hdev->id;
883 cl->conn_num = n;
884 size = sizeof(req) + n * sizeof(*ci);
885
886 hci_dev_put(hdev);
887
888 err = copy_to_user(arg, cl, size);
889 kfree(cl);
890
891 return err ? -EFAULT : 0;
892}
893
894int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
895{
896 struct hci_conn_info_req req;
897 struct hci_conn_info ci;
898 struct hci_conn *conn;
899 char __user *ptr = arg + sizeof(req);
900
901 if (copy_from_user(&req, arg, sizeof(req)))
902 return -EFAULT;
903
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300904 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
906 if (conn) {
907 bacpy(&ci.bdaddr, &conn->dst);
908 ci.handle = conn->handle;
909 ci.type = conn->type;
910 ci.out = conn->out;
911 ci.state = conn->state;
912 ci.link_mode = conn->link_mode;
913 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300914 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
916 if (!conn)
917 return -ENOENT;
918
919 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
920}
Marcel Holtmann40be4922008-07-14 20:13:50 +0200921
922int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
923{
924 struct hci_auth_info_req req;
925 struct hci_conn *conn;
926
927 if (copy_from_user(&req, arg, sizeof(req)))
928 return -EFAULT;
929
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300930 hci_dev_lock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200931 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
932 if (conn)
933 req.type = conn->auth_type;
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300934 hci_dev_unlock(hdev);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200935
936 if (!conn)
937 return -ENOENT;
938
939 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
940}
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200941
942struct hci_chan *hci_chan_create(struct hci_conn *conn)
943{
944 struct hci_dev *hdev = conn->hdev;
945 struct hci_chan *chan;
946
947 BT_DBG("%s conn %p", hdev->name, conn);
948
949 chan = kzalloc(sizeof(struct hci_chan), GFP_ATOMIC);
950 if (!chan)
951 return NULL;
952
953 chan->conn = conn;
954 skb_queue_head_init(&chan->data_q);
955
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200956 list_add_rcu(&chan->list, &conn->chan_list);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200957
958 return chan;
959}
960
961int hci_chan_del(struct hci_chan *chan)
962{
963 struct hci_conn *conn = chan->conn;
964 struct hci_dev *hdev = conn->hdev;
965
966 BT_DBG("%s conn %p chan %p", hdev->name, conn, chan);
967
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200968 list_del_rcu(&chan->list);
969
970 synchronize_rcu();
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200971
972 skb_queue_purge(&chan->data_q);
973 kfree(chan);
974
975 return 0;
976}
977
Gustavo F. Padovan2c33c062011-12-14 13:02:51 -0200978void hci_chan_list_flush(struct hci_conn *conn)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200979{
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200980 struct hci_chan *chan;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200981
982 BT_DBG("conn %p", conn);
983
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -0200984 list_for_each_entry_rcu(chan, &conn->chan_list, list)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +0200985 hci_chan_del(chan);
986}