blob: 198773c1cc7cd743e3e8af5834c4092babf47741 [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
Bhakthavatsala Raghavendrab03b5702013-02-12 19:44:47 +05303 Copyright (c) 2000-2001, 2010-2013 The Linux Foundation. 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 event 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070048/* Handle HCI Event packets */
49
Marcel Holtmanna9de9242007-10-20 13:33:56 +020050static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020052 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Marcel Holtmanna9de9242007-10-20 13:33:56 +020054 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Marcel Holtmanna9de9242007-10-20 13:33:56 +020056 if (status)
57 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070059 clear_bit(HCI_INQUIRY, &hdev->flags);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010060
Johan Hedberg23bb5762010-12-21 23:01:27 +020061 hci_req_complete(hdev, HCI_OP_INQUIRY_CANCEL, status);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010062
Marcel Holtmanna9de9242007-10-20 13:33:56 +020063 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064}
65
Marcel Holtmanna9de9242007-10-20 13:33:56 +020066static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020068 __u8 status = *((__u8 *) skb->data);
69
70 BT_DBG("%s status 0x%x", hdev->name, status);
71
72 if (status)
73 return;
74
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070075 clear_bit(HCI_INQUIRY, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +020076
77 hci_conn_check_pending(hdev);
78}
79
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -070080static void hci_cc_link_key_reply(struct hci_dev *hdev, struct sk_buff *skb)
81{
82 struct hci_rp_link_key_reply *rp = (void *) skb->data;
83 struct hci_conn *conn;
84 struct hci_cp_link_key_reply *cp;
85
86 BT_DBG("%s status 0x%x", hdev->name, rp->status);
87 if (rp->status)
88 return;
89
90 cp = hci_sent_cmd_data(hdev, HCI_OP_LINK_KEY_REPLY);
91 if (!cp)
92 return;
93
94 hci_dev_lock(hdev);
95 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
96 if (conn) {
97 hci_conn_hold(conn);
98 memcpy(conn->link_key, cp->link_key, sizeof(conn->link_key));
99 conn->key_type = 5;
100 hci_conn_put(conn);
101 }
102 hci_dev_unlock(hdev);
103}
104
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200105static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
106{
107 BT_DBG("%s", hdev->name);
108}
109
110static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
111{
112 struct hci_rp_role_discovery *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200115 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200117 if (rp->status)
118 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200120 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200122 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
123 if (conn) {
124 if (rp->role)
125 conn->link_mode &= ~HCI_LM_MASTER;
126 else
127 conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200129
130 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
132
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200133static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
134{
135 struct hci_rp_read_link_policy *rp = (void *) skb->data;
136 struct hci_conn *conn;
137
138 BT_DBG("%s status 0x%x", hdev->name, rp->status);
139
140 if (rp->status)
141 return;
142
143 hci_dev_lock(hdev);
144
145 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
146 if (conn)
147 conn->link_policy = __le16_to_cpu(rp->policy);
148
149 hci_dev_unlock(hdev);
150}
151
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200152static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200154 struct hci_rp_write_link_policy *rp = (void *) skb->data;
155 struct hci_conn *conn;
156 void *sent;
157
158 BT_DBG("%s status 0x%x", hdev->name, rp->status);
159
160 if (rp->status)
161 return;
162
163 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
164 if (!sent)
165 return;
166
167 hci_dev_lock(hdev);
168
169 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200170 if (conn)
Harvey Harrison83985312008-05-02 16:25:46 -0700171 conn->link_policy = get_unaligned_le16(sent + 2);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200172
173 hci_dev_unlock(hdev);
174}
175
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200176static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
177{
178 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
179
180 BT_DBG("%s status 0x%x", hdev->name, rp->status);
181
182 if (rp->status)
183 return;
184
185 hdev->link_policy = __le16_to_cpu(rp->policy);
186}
187
188static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
189{
190 __u8 status = *((__u8 *) skb->data);
191 void *sent;
192
193 BT_DBG("%s status 0x%x", hdev->name, status);
194
195 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
196 if (!sent)
197 return;
198
199 if (!status)
200 hdev->link_policy = get_unaligned_le16(sent);
201
Johan Hedberg23bb5762010-12-21 23:01:27 +0200202 hci_req_complete(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200203}
204
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200205static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
206{
207 __u8 status = *((__u8 *) skb->data);
208
209 BT_DBG("%s status 0x%x", hdev->name, status);
210
Gustavo F. Padovan10572132011-03-16 15:36:29 -0300211 clear_bit(HCI_RESET, &hdev->flags);
212
Johan Hedberg23bb5762010-12-21 23:01:27 +0200213 hci_req_complete(hdev, HCI_OP_RESET, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200214}
215
216static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
217{
218 __u8 status = *((__u8 *) skb->data);
219 void *sent;
220
221 BT_DBG("%s status 0x%x", hdev->name, status);
222
223 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
224 if (!sent)
225 return;
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800226 hci_dev_lock(hdev);
Royston Rodriguesc58c0c22011-10-24 12:54:13 +0530227 if (!status)
228 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
229
Johan Hedbergb312b1612011-03-16 14:29:37 +0200230 if (test_bit(HCI_MGMT, &hdev->flags))
231 mgmt_set_local_name_complete(hdev->id, sent, status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800232 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200233}
234
235static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
236{
237 struct hci_rp_read_local_name *rp = (void *) skb->data;
238
239 BT_DBG("%s status 0x%x", hdev->name, rp->status);
240
241 if (rp->status)
242 return;
243
Johan Hedberg1f6c6372011-03-16 14:29:35 +0200244 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200245}
246
247static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
248{
249 __u8 status = *((__u8 *) skb->data);
250 void *sent;
251
252 BT_DBG("%s status 0x%x", hdev->name, status);
253
254 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
255 if (!sent)
256 return;
257
258 if (!status) {
259 __u8 param = *((__u8 *) sent);
260
261 if (param == AUTH_ENABLED)
262 set_bit(HCI_AUTH, &hdev->flags);
263 else
264 clear_bit(HCI_AUTH, &hdev->flags);
265 }
266
Johan Hedberg23bb5762010-12-21 23:01:27 +0200267 hci_req_complete(hdev, HCI_OP_WRITE_AUTH_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200268}
269
270static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
271{
272 __u8 status = *((__u8 *) skb->data);
273 void *sent;
274
275 BT_DBG("%s status 0x%x", hdev->name, status);
276
277 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
278 if (!sent)
279 return;
280
281 if (!status) {
282 __u8 param = *((__u8 *) sent);
283
284 if (param)
285 set_bit(HCI_ENCRYPT, &hdev->flags);
286 else
287 clear_bit(HCI_ENCRYPT, &hdev->flags);
288 }
289
Johan Hedberg23bb5762010-12-21 23:01:27 +0200290 hci_req_complete(hdev, HCI_OP_WRITE_ENCRYPT_MODE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200291}
292
293static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
294{
295 __u8 status = *((__u8 *) skb->data);
296 void *sent;
297
298 BT_DBG("%s status 0x%x", hdev->name, status);
299
300 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
301 if (!sent)
302 return;
303
304 if (!status) {
305 __u8 param = *((__u8 *) sent);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200306 int old_pscan, old_iscan;
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800307 hci_dev_lock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200308
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200309 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
310 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200311
Johan Hedberg73f22f62010-12-29 16:00:25 +0200312 if (param & SCAN_INQUIRY) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200313 set_bit(HCI_ISCAN, &hdev->flags);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200314 if (!old_iscan)
315 mgmt_discoverable(hdev->id, 1);
316 } else if (old_iscan)
Johan Hedberg73f22f62010-12-29 16:00:25 +0200317 mgmt_discoverable(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200318
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200319 if (param & SCAN_PAGE) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200320 set_bit(HCI_PSCAN, &hdev->flags);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200321 if (!old_pscan)
322 mgmt_connectable(hdev->id, 1);
323 } else if (old_pscan)
324 mgmt_connectable(hdev->id, 0);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800325 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200326 }
327
Johan Hedberg23bb5762010-12-21 23:01:27 +0200328 hci_req_complete(hdev, HCI_OP_WRITE_SCAN_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200329}
330
331static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
332{
333 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
334
335 BT_DBG("%s status 0x%x", hdev->name, rp->status);
336
337 if (rp->status)
338 return;
339
340 memcpy(hdev->dev_class, rp->dev_class, 3);
341
342 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
343 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
344}
345
346static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
347{
348 __u8 status = *((__u8 *) skb->data);
349 void *sent;
350
351 BT_DBG("%s status 0x%x", hdev->name, status);
352
Marcel Holtmannf383f272008-07-14 20:13:47 +0200353 if (status)
354 return;
355
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200356 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
357 if (!sent)
358 return;
359
Marcel Holtmannf383f272008-07-14 20:13:47 +0200360 memcpy(hdev->dev_class, sent, 3);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200361}
362
363static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
364{
365 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 __u16 setting;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200367
368 BT_DBG("%s status 0x%x", hdev->name, rp->status);
369
370 if (rp->status)
371 return;
372
373 setting = __le16_to_cpu(rp->voice_setting);
374
Marcel Holtmannf383f272008-07-14 20:13:47 +0200375 if (hdev->voice_setting == setting)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200376 return;
377
378 hdev->voice_setting = setting;
379
380 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
381
382 if (hdev->notify) {
383 tasklet_disable(&hdev->tx_task);
384 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
385 tasklet_enable(&hdev->tx_task);
386 }
387}
388
389static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
390{
391 __u8 status = *((__u8 *) skb->data);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200392 __u16 setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 void *sent;
394
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200395 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Marcel Holtmannf383f272008-07-14 20:13:47 +0200397 if (status)
398 return;
399
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200400 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
401 if (!sent)
402 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Marcel Holtmannf383f272008-07-14 20:13:47 +0200404 setting = get_unaligned_le16(sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Marcel Holtmannf383f272008-07-14 20:13:47 +0200406 if (hdev->voice_setting == setting)
407 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Marcel Holtmannf383f272008-07-14 20:13:47 +0200409 hdev->voice_setting = setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Marcel Holtmannf383f272008-07-14 20:13:47 +0200411 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
412
413 if (hdev->notify) {
414 tasklet_disable(&hdev->tx_task);
415 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
416 tasklet_enable(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 }
418}
419
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200420static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200422 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200424 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Johan Hedberg23bb5762010-12-21 23:01:27 +0200426 hci_req_complete(hdev, HCI_OP_HOST_BUFFER_SIZE, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427}
428
Sunny Kapdi93bef892012-07-30 14:52:56 -0700429static void hci_cc_le_clear_white_list(struct hci_dev *hdev,
430 struct sk_buff *skb)
431{
432 __u8 status = *((__u8 *) skb->data);
433
434 BT_DBG("%s status 0x%x", hdev->name, status);
435
436 hci_req_complete(hdev, HCI_OP_LE_CLEAR_WHITE_LIST, status);
437}
438
Marcel Holtmann333140b2008-07-14 20:13:48 +0200439static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
440{
441 struct hci_rp_read_ssp_mode *rp = (void *) skb->data;
442
443 BT_DBG("%s status 0x%x", hdev->name, rp->status);
444
445 if (rp->status)
446 return;
447
448 hdev->ssp_mode = rp->mode;
449}
450
451static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
452{
453 __u8 status = *((__u8 *) skb->data);
454 void *sent;
455
456 BT_DBG("%s status 0x%x", hdev->name, status);
457
458 if (status)
459 return;
460
461 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
462 if (!sent)
463 return;
464
465 hdev->ssp_mode = *((__u8 *) sent);
466}
467
Johan Hedbergd5859e22011-01-25 01:19:58 +0200468static u8 hci_get_inquiry_mode(struct hci_dev *hdev)
469{
470 if (hdev->features[6] & LMP_EXT_INQ)
471 return 2;
472
473 if (hdev->features[3] & LMP_RSSI_INQ)
474 return 1;
475
476 if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 &&
477 hdev->lmp_subver == 0x0757)
478 return 1;
479
480 if (hdev->manufacturer == 15) {
481 if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963)
482 return 1;
483 if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963)
484 return 1;
485 if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965)
486 return 1;
487 }
488
489 if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 &&
490 hdev->lmp_subver == 0x1805)
491 return 1;
492
493 return 0;
494}
495
496static void hci_setup_inquiry_mode(struct hci_dev *hdev)
497{
498 u8 mode;
499
500 mode = hci_get_inquiry_mode(hdev);
501
502 hci_send_cmd(hdev, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode);
503}
504
505static void hci_setup_event_mask(struct hci_dev *hdev)
506{
507 /* The second byte is 0xff instead of 0x9f (two reserved bits
508 * disabled) since a Broadcom 1.2 dongle doesn't respond to the
509 * command otherwise */
510 u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 };
511
Brian Gixa68668b2011-08-11 15:49:36 -0700512 BT_DBG("");
513
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700514 /* Events for 1.2 and newer controllers */
515 if (hdev->lmp_ver > 1) {
516 events[4] |= 0x01; /* Flow Specification Complete */
517 events[4] |= 0x02; /* Inquiry Result with RSSI */
518 events[4] |= 0x04; /* Read Remote Extended Features Complete */
519 events[5] |= 0x08; /* Synchronous Connection Complete */
520 events[5] |= 0x10; /* Synchronous Connection Changed */
521 }
Johan Hedbergd5859e22011-01-25 01:19:58 +0200522
523 if (hdev->features[3] & LMP_RSSI_INQ)
524 events[4] |= 0x04; /* Inquiry Result with RSSI */
525
526 if (hdev->features[5] & LMP_SNIFF_SUBR)
527 events[5] |= 0x20; /* Sniff Subrating */
528
529 if (hdev->features[5] & LMP_PAUSE_ENC)
530 events[5] |= 0x80; /* Encryption Key Refresh Complete */
531
532 if (hdev->features[6] & LMP_EXT_INQ)
533 events[5] |= 0x40; /* Extended Inquiry Result */
534
535 if (hdev->features[6] & LMP_NO_FLUSH)
536 events[7] |= 0x01; /* Enhanced Flush Complete */
537
538 if (hdev->features[7] & LMP_LSTO)
539 events[6] |= 0x80; /* Link Supervision Timeout Changed */
540
541 if (hdev->features[6] & LMP_SIMPLE_PAIR) {
542 events[6] |= 0x01; /* IO Capability Request */
543 events[6] |= 0x02; /* IO Capability Response */
544 events[6] |= 0x04; /* User Confirmation Request */
545 events[6] |= 0x08; /* User Passkey Request */
546 events[6] |= 0x10; /* Remote OOB Data Request */
547 events[6] |= 0x20; /* Simple Pairing Complete */
548 events[7] |= 0x04; /* User Passkey Notification */
549 events[7] |= 0x08; /* Keypress Notification */
550 events[7] |= 0x10; /* Remote Host Supported
551 * Features Notification */
552 }
553
554 if (hdev->features[4] & LMP_LE)
555 events[7] |= 0x20; /* LE Meta-Event */
556
557 hci_send_cmd(hdev, HCI_OP_SET_EVENT_MASK, sizeof(events), events);
558}
559
560static void hci_setup(struct hci_dev *hdev)
561{
Johan Hedbergd5859e22011-01-25 01:19:58 +0200562 if (hdev->lmp_ver > 1)
563 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL);
564
565 if (hdev->features[6] & LMP_SIMPLE_PAIR) {
566 u8 mode = 0x01;
567 hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, sizeof(mode), &mode);
568 }
569
570 if (hdev->features[3] & LMP_RSSI_INQ)
571 hci_setup_inquiry_mode(hdev);
572
573 if (hdev->features[7] & LMP_INQ_TX_PWR)
574 hci_send_cmd(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL);
575}
576
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200577static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
578{
579 struct hci_rp_read_local_version *rp = (void *) skb->data;
580
581 BT_DBG("%s status 0x%x", hdev->name, rp->status);
582
583 if (rp->status)
584 return;
585
586 hdev->hci_ver = rp->hci_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200587 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200588 hdev->lmp_ver = rp->lmp_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200589 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200590 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200591
592 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
593 hdev->manufacturer,
594 hdev->hci_ver, hdev->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200595
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700596 if (hdev->dev_type == HCI_BREDR && test_bit(HCI_INIT, &hdev->flags))
Johan Hedbergd5859e22011-01-25 01:19:58 +0200597 hci_setup(hdev);
598}
599
600static void hci_setup_link_policy(struct hci_dev *hdev)
601{
602 u16 link_policy = 0;
603
604 if (hdev->features[0] & LMP_RSWITCH)
605 link_policy |= HCI_LP_RSWITCH;
606 if (hdev->features[0] & LMP_HOLD)
607 link_policy |= HCI_LP_HOLD;
608 if (hdev->features[0] & LMP_SNIFF)
609 link_policy |= HCI_LP_SNIFF;
610 if (hdev->features[1] & LMP_PARK)
611 link_policy |= HCI_LP_PARK;
612
613 link_policy = cpu_to_le16(link_policy);
614 hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY,
615 sizeof(link_policy), &link_policy);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200616}
617
618static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
619{
620 struct hci_rp_read_local_commands *rp = (void *) skb->data;
621
622 BT_DBG("%s status 0x%x", hdev->name, rp->status);
623
624 if (rp->status)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200625 goto done;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200626
627 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
Johan Hedbergd5859e22011-01-25 01:19:58 +0200628
629 if (test_bit(HCI_INIT, &hdev->flags) && (hdev->commands[5] & 0x10))
630 hci_setup_link_policy(hdev);
631
632done:
633 hci_req_complete(hdev, HCI_OP_READ_LOCAL_COMMANDS, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200634}
635
636static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
637{
638 struct hci_rp_read_local_features *rp = (void *) skb->data;
639
640 BT_DBG("%s status 0x%x", hdev->name, rp->status);
641
642 if (rp->status)
643 return;
644
645 memcpy(hdev->features, rp->features, 8);
646
Brian Gixa68668b2011-08-11 15:49:36 -0700647 if (hdev->dev_type == HCI_BREDR && test_bit(HCI_INIT, &hdev->flags)) {
648 if (hdev->features[6] & LMP_SIMPLE_PAIR) {
649 u8 mode = 0x01;
650 hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE,
651 sizeof(mode), &mode);
652 }
653
654 if (hdev->features[3] & LMP_RSSI_INQ)
655 hci_setup_inquiry_mode(hdev);
656
657 if (hdev->features[7] & LMP_INQ_TX_PWR)
658 hci_send_cmd(hdev, HCI_OP_READ_INQ_RSP_TX_POWER,
659 0, NULL);
660
661 hci_setup_event_mask(hdev);
662 }
663
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200664 /* Adjust default settings according to features
665 * supported by device. */
666
667 if (hdev->features[0] & LMP_3SLOT)
668 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
669
670 if (hdev->features[0] & LMP_5SLOT)
671 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
672
673 if (hdev->features[1] & LMP_HV2) {
674 hdev->pkt_type |= (HCI_HV2);
675 hdev->esco_type |= (ESCO_HV2);
676 }
677
678 if (hdev->features[1] & LMP_HV3) {
679 hdev->pkt_type |= (HCI_HV3);
680 hdev->esco_type |= (ESCO_HV3);
681 }
682
683 if (hdev->features[3] & LMP_ESCO)
684 hdev->esco_type |= (ESCO_EV3);
685
686 if (hdev->features[4] & LMP_EV4)
687 hdev->esco_type |= (ESCO_EV4);
688
689 if (hdev->features[4] & LMP_EV5)
690 hdev->esco_type |= (ESCO_EV5);
691
Marcel Holtmannefc76882009-02-06 09:13:37 +0100692 if (hdev->features[5] & LMP_EDR_ESCO_2M)
693 hdev->esco_type |= (ESCO_2EV3);
694
695 if (hdev->features[5] & LMP_EDR_ESCO_3M)
696 hdev->esco_type |= (ESCO_3EV3);
697
698 if (hdev->features[5] & LMP_EDR_3S_ESCO)
699 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
700
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200701 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
702 hdev->features[0], hdev->features[1],
703 hdev->features[2], hdev->features[3],
704 hdev->features[4], hdev->features[5],
705 hdev->features[6], hdev->features[7]);
706}
707
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700708static void hci_cc_read_flow_control_mode(struct hci_dev *hdev,
709 struct sk_buff *skb)
Andre Guedesd5fa5132011-06-30 19:20:52 -0300710{
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700711 struct hci_rp_read_flow_control_mode *rp = (void *) skb->data;
Andre Guedesd5fa5132011-06-30 19:20:52 -0300712
713 BT_DBG("%s status 0x%x", hdev->name, rp->status);
714
715 if (rp->status)
716 return;
717
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700718 hdev->flow_ctl_mode = rp->mode;
Andre Guedesd5fa5132011-06-30 19:20:52 -0300719}
720
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200721static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
722{
723 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
724
725 BT_DBG("%s status 0x%x", hdev->name, rp->status);
726
727 if (rp->status)
728 return;
729
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700730 if (hdev->flow_ctl_mode == HCI_PACKET_BASED_FLOW_CTL_MODE) {
731 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
732 hdev->sco_mtu = rp->sco_mtu;
733 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
734 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
735 hdev->acl_cnt = hdev->acl_pkts;
736 hdev->sco_cnt = hdev->sco_pkts;
737 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200738
739 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
740 hdev->sco_mtu = 64;
741 hdev->sco_pkts = 8;
742 }
743
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200744
745 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
746 hdev->acl_mtu, hdev->acl_pkts,
747 hdev->sco_mtu, hdev->sco_pkts);
748}
749
750static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
751{
752 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
753
754 BT_DBG("%s status 0x%x", hdev->name, rp->status);
755
756 if (!rp->status)
757 bacpy(&hdev->bdaddr, &rp->bdaddr);
758
Johan Hedberg23bb5762010-12-21 23:01:27 +0200759 hci_req_complete(hdev, HCI_OP_READ_BD_ADDR, rp->status);
760}
761
762static void hci_cc_write_ca_timeout(struct hci_dev *hdev, struct sk_buff *skb)
763{
764 __u8 status = *((__u8 *) skb->data);
765
766 BT_DBG("%s status 0x%x", hdev->name, status);
767
768 hci_req_complete(hdev, HCI_OP_WRITE_CA_TIMEOUT, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200769}
770
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -0700771static void hci_cc_read_data_block_size(struct hci_dev *hdev,
772 struct sk_buff *skb)
773{
774 struct hci_rp_read_data_block_size *rp = (void *) skb->data;
775
776 BT_DBG("%s status 0x%x", hdev->name, rp->status);
777
778 if (rp->status)
779 return;
780
781 if (hdev->flow_ctl_mode == HCI_BLOCK_BASED_FLOW_CTL_MODE) {
782 hdev->acl_mtu = __le16_to_cpu(rp->max_acl_len);
783 hdev->sco_mtu = 0;
784 hdev->data_block_len = __le16_to_cpu(rp->data_block_len);
785 /* acl_pkts indicates the number of blocks */
786 hdev->acl_pkts = __le16_to_cpu(rp->num_blocks);
787 hdev->sco_pkts = 0;
788 hdev->acl_cnt = hdev->acl_pkts;
789 hdev->sco_cnt = 0;
790 }
791
792 BT_DBG("%s acl mtu %d:%d, data block len %d", hdev->name,
793 hdev->acl_mtu, hdev->acl_cnt, hdev->data_block_len);
794}
795
796static void hci_cc_read_local_amp_info(struct hci_dev *hdev,
797 struct sk_buff *skb)
798{
799 struct hci_rp_read_local_amp_info *rp = (void *) skb->data;
800
801 BT_DBG("%s status 0x%x", hdev->name, rp->status);
802
803 if (rp->status)
804 return;
805
806 hdev->amp_status = rp->amp_status;
807 hdev->amp_total_bw = __le32_to_cpu(rp->total_bw);
808 hdev->amp_max_bw = __le32_to_cpu(rp->max_bw);
809 hdev->amp_min_latency = __le32_to_cpu(rp->min_latency);
810 hdev->amp_max_pdu = __le32_to_cpu(rp->max_pdu);
811 hdev->amp_type = rp->amp_type;
812 hdev->amp_pal_cap = __le16_to_cpu(rp->pal_cap);
813 hdev->amp_assoc_size = __le16_to_cpu(rp->max_assoc_size);
814 hdev->amp_be_flush_to = __le32_to_cpu(rp->be_flush_to);
815 hdev->amp_max_flush_to = __le32_to_cpu(rp->max_flush_to);
816
817 hci_req_complete(hdev, HCI_OP_READ_LOCAL_AMP_INFO, rp->status);
818}
819
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200820static void hci_cc_delete_stored_link_key(struct hci_dev *hdev,
821 struct sk_buff *skb)
822{
823 __u8 status = *((__u8 *) skb->data);
824
825 BT_DBG("%s status 0x%x", hdev->name, status);
826
827 hci_req_complete(hdev, HCI_OP_DELETE_STORED_LINK_KEY, status);
828}
829
Johan Hedbergd5859e22011-01-25 01:19:58 +0200830static void hci_cc_set_event_mask(struct hci_dev *hdev, struct sk_buff *skb)
831{
832 __u8 status = *((__u8 *) skb->data);
833
834 BT_DBG("%s status 0x%x", hdev->name, status);
835
836 hci_req_complete(hdev, HCI_OP_SET_EVENT_MASK, status);
837}
838
839static void hci_cc_write_inquiry_mode(struct hci_dev *hdev,
840 struct sk_buff *skb)
841{
842 __u8 status = *((__u8 *) skb->data);
843
844 BT_DBG("%s status 0x%x", hdev->name, status);
845
846 hci_req_complete(hdev, HCI_OP_WRITE_INQUIRY_MODE, status);
847}
848
849static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
850 struct sk_buff *skb)
851{
852 __u8 status = *((__u8 *) skb->data);
853
854 BT_DBG("%s status 0x%x", hdev->name, status);
855
856 hci_req_complete(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, status);
857}
858
859static void hci_cc_set_event_flt(struct hci_dev *hdev, struct sk_buff *skb)
860{
861 __u8 status = *((__u8 *) skb->data);
862
863 BT_DBG("%s status 0x%x", hdev->name, status);
864
865 hci_req_complete(hdev, HCI_OP_SET_EVENT_FLT, status);
866}
867
Johan Hedberg980e1a52011-01-22 06:10:07 +0200868static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
869{
870 struct hci_rp_pin_code_reply *rp = (void *) skb->data;
871 struct hci_cp_pin_code_reply *cp;
872 struct hci_conn *conn;
873
874 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800875 hci_dev_lock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200876
877 if (test_bit(HCI_MGMT, &hdev->flags))
878 mgmt_pin_code_reply_complete(hdev->id, &rp->bdaddr, rp->status);
879
880 if (rp->status != 0)
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800881 goto unlock;
Johan Hedberg980e1a52011-01-22 06:10:07 +0200882
883 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
884 if (!cp)
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800885 goto unlock;
Johan Hedberg980e1a52011-01-22 06:10:07 +0200886
887 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
888 if (conn)
889 conn->pin_length = cp->pin_len;
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800890unlock:
891 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200892}
893
894static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
895{
896 struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;
897
898 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800899 hci_dev_lock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200900
901 if (test_bit(HCI_MGMT, &hdev->flags))
902 mgmt_pin_code_neg_reply_complete(hdev->id, &rp->bdaddr,
903 rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800904 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200905}
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300906static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
907 struct sk_buff *skb)
908{
909 struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;
910
911 BT_DBG("%s status 0x%x", hdev->name, rp->status);
912
913 if (rp->status)
914 return;
915
916 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
917 hdev->le_pkts = rp->le_max_pkt;
918
919 hdev->le_cnt = hdev->le_pkts;
920
921 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
922
923 hci_req_complete(hdev, HCI_OP_LE_READ_BUFFER_SIZE, rp->status);
924}
Johan Hedberg980e1a52011-01-22 06:10:07 +0200925
Sunny Kapdi93bef892012-07-30 14:52:56 -0700926static void hci_cc_le_read_white_list_size(struct hci_dev *hdev,
927 struct sk_buff *skb)
928{
929 struct hci_rp_le_read_white_list_size *rp = (void *) skb->data;
930
931 BT_DBG("%s status 0x%x", hdev->name, rp->status);
932
933 if (rp->status)
934 return;
935
936 hdev->le_white_list_size = rp->size;
937
938 BT_DBG("%s le white list %d", hdev->name, hdev->le_white_list_size);
939
940 hci_req_complete(hdev, HCI_OP_LE_READ_WHITE_LIST_SIZE, rp->status);
941}
942
Johan Hedberga5c29682011-02-19 12:05:57 -0300943static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
944{
945 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
946
947 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800948 hci_dev_lock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -0300949
950 if (test_bit(HCI_MGMT, &hdev->flags))
951 mgmt_user_confirm_reply_complete(hdev->id, &rp->bdaddr,
952 rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800953 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -0300954}
955
956static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
957 struct sk_buff *skb)
958{
959 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
960
961 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800962 hci_dev_lock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -0300963
964 if (test_bit(HCI_MGMT, &hdev->flags))
965 mgmt_user_confirm_neg_reply_complete(hdev->id, &rp->bdaddr,
966 rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800967 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -0300968}
969
Archana Ramachandran26a752b2011-12-20 11:27:40 -0800970static void hci_cc_read_rssi(struct hci_dev *hdev, struct sk_buff *skb)
971{
972 struct hci_conn *conn;
973 struct hci_rp_read_rssi *rp = (void *) skb->data;
974
975 BT_DBG("%s status 0x%x", hdev->name, rp->status);
976
977 BT_DBG("%s rssi : %d handle : %d", hdev->name, rp->rssi, rp->handle);
978
979 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
980 if (conn)
981 mgmt_read_rssi_complete(hdev->id, rp->rssi, &conn->dst,
982 __le16_to_cpu(rp->handle), rp->status);
983}
984
Szymon Jancc35938b2011-03-22 13:12:21 +0100985static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
986 struct sk_buff *skb)
987{
988 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
989
990 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800991 hci_dev_lock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +0100992
993 mgmt_read_local_oob_data_reply_complete(hdev->id, rp->hash,
994 rp->randomizer, rp->status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -0800995 hci_dev_unlock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +0100996}
997
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -0300998static void hci_cc_le_ltk_reply(struct hci_dev *hdev, struct sk_buff *skb)
999{
1000 struct hci_rp_le_ltk_reply *rp = (void *) skb->data;
1001
1002 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1003
1004 if (rp->status)
1005 return;
1006
1007 hci_req_complete(hdev, HCI_OP_LE_LTK_REPLY, rp->status);
1008}
1009
1010static void hci_cc_le_ltk_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
1011{
1012 struct hci_rp_le_ltk_neg_reply *rp = (void *) skb->data;
1013
1014 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1015
1016 if (rp->status)
1017 return;
1018
1019 hci_req_complete(hdev, HCI_OP_LE_LTK_NEG_REPLY, rp->status);
1020}
1021
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001022static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
1023 struct sk_buff *skb)
Andre Guedese326af42011-06-30 19:20:53 -03001024{
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001025 void *sent;
1026 __u8 param_scan_enable;
Andre Guedese326af42011-06-30 19:20:53 -03001027 __u8 status = *((__u8 *) skb->data);
1028
Andre Guedese326af42011-06-30 19:20:53 -03001029 if (status)
1030 return;
1031
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001032 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
1033 if (!sent)
1034 return;
1035
1036 param_scan_enable = *((__u8 *) sent);
1037 if (param_scan_enable == 0x01) {
1038 del_timer(&hdev->adv_timer);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001039 } else if (param_scan_enable == 0x00) {
1040 mod_timer(&hdev->adv_timer, jiffies + ADV_CLEAR_TIMEOUT);
1041 }
Andre Guedese326af42011-06-30 19:20:53 -03001042}
1043
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001044static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
1045{
1046 BT_DBG("%s status 0x%x", hdev->name, status);
1047
1048 if (status) {
Johan Hedberg23bb5762010-12-21 23:01:27 +02001049 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Johan Hedberg314b2382011-04-27 10:29:57 -04001050
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001051 hci_conn_check_pending(hdev);
Brian Gixa68668b2011-08-11 15:49:36 -07001052 } else {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001053 set_bit(HCI_INQUIRY, &hdev->flags);
Subramanian Srinivasana727a492011-11-30 13:06:07 -08001054 hci_dev_lock(hdev);
Brian Gixa68668b2011-08-11 15:49:36 -07001055 if (test_bit(HCI_MGMT, &hdev->flags))
1056 mgmt_inquiry_started(hdev->id);
Subramanian Srinivasana727a492011-11-30 13:06:07 -08001057 hci_dev_unlock(hdev);
Brian Gixa68668b2011-08-11 15:49:36 -07001058 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001059}
1060
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
1062{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001063 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001066 BT_DBG("%s status 0x%x", hdev->name, status);
1067
1068 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 if (!cp)
1070 return;
1071
1072 hci_dev_lock(hdev);
1073
1074 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1075
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001076 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
1078 if (status) {
1079 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +02001080 if (status != 0x0c || conn->attempt > 2) {
1081 conn->state = BT_CLOSED;
1082 hci_proto_connect_cfm(conn, status);
1083 hci_conn_del(conn);
1084 } else
1085 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 }
1087 } else {
1088 if (!conn) {
Nick Pellybbcda3b2010-02-11 11:54:28 -08001089 conn = hci_conn_add(hdev, ACL_LINK, 0, &cp->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 if (conn) {
1091 conn->out = 1;
1092 conn->link_mode |= HCI_LM_MASTER;
1093 } else
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001094 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 }
1096 }
1097
1098 hci_dev_unlock(hdev);
1099}
1100
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001101static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001103 struct hci_cp_add_sco *cp;
1104 struct hci_conn *acl, *sco;
1105 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001107 BT_DBG("%s status 0x%x", hdev->name, status);
1108
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001109 if (!status)
1110 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001112 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
1113 if (!cp)
1114 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001116 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001118 BT_DBG("%s handle %d", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001119
1120 hci_dev_lock(hdev);
1121
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001122 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001123 if (acl) {
1124 sco = acl->link;
1125 if (sco) {
1126 sco->state = BT_CLOSED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001127
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001128 hci_proto_connect_cfm(sco, status);
1129 hci_conn_del(sco);
1130 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001131 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001132
1133 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134}
1135
Marcel Holtmannf8558552008-07-14 20:13:49 +02001136static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
1137{
1138 struct hci_cp_auth_requested *cp;
1139 struct hci_conn *conn;
1140
1141 BT_DBG("%s status 0x%x", hdev->name, status);
1142
Marcel Holtmannf8558552008-07-14 20:13:49 +02001143 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
1144 if (!cp)
1145 return;
1146
1147 hci_dev_lock(hdev);
1148
1149 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1150 if (conn) {
Prabhakaran Mc7953ca72012-03-06 20:43:46 +05301151 if (status) {
1152 mgmt_auth_failed(hdev->id, &conn->dst, status);
1153 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1154
1155 if (conn->state == BT_CONFIG) {
1156 conn->state = BT_CONNECTED;
1157 hci_proto_connect_cfm(conn, status);
1158 hci_conn_put(conn);
1159 } else {
1160 hci_auth_cfm(conn, status);
1161 hci_conn_hold(conn);
1162 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
1163 hci_conn_put(conn);
1164 }
1165
1166 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1167 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1168 hci_encrypt_cfm(conn, status, 0x00);
1169 }
Marcel Holtmannf8558552008-07-14 20:13:49 +02001170 }
Srinivas Krovvidi9ff51452011-09-27 19:25:02 +05301171 conn->auth_initiator = 1;
Marcel Holtmannf8558552008-07-14 20:13:49 +02001172 }
1173
1174 hci_dev_unlock(hdev);
1175}
1176
1177static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
1178{
1179 struct hci_cp_set_conn_encrypt *cp;
1180 struct hci_conn *conn;
1181
1182 BT_DBG("%s status 0x%x", hdev->name, status);
1183
1184 if (!status)
1185 return;
1186
1187 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
1188 if (!cp)
1189 return;
1190
1191 hci_dev_lock(hdev);
1192
1193 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1194 if (conn) {
1195 if (conn->state == BT_CONFIG) {
1196 hci_proto_connect_cfm(conn, status);
1197 hci_conn_put(conn);
1198 }
1199 }
1200
1201 hci_dev_unlock(hdev);
1202}
1203
Johan Hedberg127178d2010-11-18 22:22:29 +02001204static int hci_outgoing_auth_needed(struct hci_dev *hdev,
Szymon Janc138d22e2011-02-17 16:44:23 +01001205 struct hci_conn *conn)
Johan Hedberg392599b2010-11-18 22:22:28 +02001206{
Johan Hedberg392599b2010-11-18 22:22:28 +02001207 if (conn->state != BT_CONFIG || !conn->out)
1208 return 0;
1209
Johan Hedberg765c2a92011-01-19 12:06:52 +05301210 if (conn->pending_sec_level == BT_SECURITY_SDP)
Johan Hedberg392599b2010-11-18 22:22:28 +02001211 return 0;
1212
1213 /* Only request authentication for SSP connections or non-SSP
Prabhakaran Mc6001a712011-09-06 11:56:25 +05301214 * devices with sec_level >= BT_SECURITY_MEDIUM*/
1215 BT_DBG("Pending sec level is %d", conn->pending_sec_level);
Johan Hedberg392599b2010-11-18 22:22:28 +02001216 if (!(hdev->ssp_mode > 0 && conn->ssp_mode > 0) &&
Prabhakaran Mc6001a712011-09-06 11:56:25 +05301217 conn->pending_sec_level < BT_SECURITY_MEDIUM)
Johan Hedberg392599b2010-11-18 22:22:28 +02001218 return 0;
1219
Johan Hedberg392599b2010-11-18 22:22:28 +02001220 return 1;
1221}
1222
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001223static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
1224{
Johan Hedberg127178d2010-11-18 22:22:29 +02001225 struct hci_cp_remote_name_req *cp;
1226 struct hci_conn *conn;
1227
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001228 BT_DBG("%s status 0x%x", hdev->name, status);
Johan Hedberg127178d2010-11-18 22:22:29 +02001229
1230 /* If successful wait for the name req complete event before
1231 * checking for the need to do authentication */
1232 if (!status)
1233 return;
1234
1235 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
1236 if (!cp)
1237 return;
1238
1239 hci_dev_lock(hdev);
1240
1241 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001242 if (conn && hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001243 struct hci_cp_auth_requested cp;
1244 cp.handle = __cpu_to_le16(conn->handle);
1245 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1246 }
1247
1248 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001249}
1250
Marcel Holtmann769be972008-07-14 20:13:49 +02001251static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
1252{
1253 struct hci_cp_read_remote_features *cp;
1254 struct hci_conn *conn;
1255
1256 BT_DBG("%s status 0x%x", hdev->name, status);
1257
1258 if (!status)
1259 return;
1260
1261 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
1262 if (!cp)
1263 return;
1264
1265 hci_dev_lock(hdev);
1266
1267 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1268 if (conn) {
1269 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001270 hci_proto_connect_cfm(conn, status);
1271 hci_conn_put(conn);
1272 }
1273 }
1274
1275 hci_dev_unlock(hdev);
1276}
1277
1278static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
1279{
1280 struct hci_cp_read_remote_ext_features *cp;
1281 struct hci_conn *conn;
1282
1283 BT_DBG("%s status 0x%x", hdev->name, status);
1284
1285 if (!status)
1286 return;
1287
1288 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
1289 if (!cp)
1290 return;
1291
1292 hci_dev_lock(hdev);
1293
1294 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1295 if (conn) {
1296 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001297 hci_proto_connect_cfm(conn, status);
1298 hci_conn_put(conn);
1299 }
1300 }
1301
1302 hci_dev_unlock(hdev);
1303}
1304
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001305static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
1306{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001307 struct hci_cp_setup_sync_conn *cp;
1308 struct hci_conn *acl, *sco;
1309 __u16 handle;
1310
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001311 BT_DBG("%s status 0x%x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001312
1313 if (!status)
1314 return;
1315
1316 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
1317 if (!cp)
1318 return;
1319
1320 handle = __le16_to_cpu(cp->handle);
1321
1322 BT_DBG("%s handle %d", hdev->name, handle);
1323
1324 hci_dev_lock(hdev);
1325
1326 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001327 if (acl) {
1328 sco = acl->link;
1329 if (sco) {
1330 sco->state = BT_CLOSED;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001331
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001332 hci_proto_connect_cfm(sco, status);
1333 hci_conn_del(sco);
1334 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001335 }
1336
1337 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001338}
1339
1340static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1341{
1342 struct hci_cp_sniff_mode *cp;
1343 struct hci_conn *conn;
1344
1345 BT_DBG("%s status 0x%x", hdev->name, status);
1346
1347 if (!status)
1348 return;
1349
1350 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
1351 if (!cp)
1352 return;
1353
1354 hci_dev_lock(hdev);
1355
1356 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001357 if (conn) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001358 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1359
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001360 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
1361 hci_sco_setup(conn, status);
1362 }
1363
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001364 hci_dev_unlock(hdev);
1365}
1366
1367static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
1368{
1369 struct hci_cp_exit_sniff_mode *cp;
1370 struct hci_conn *conn;
1371
1372 BT_DBG("%s status 0x%x", hdev->name, status);
1373
1374 if (!status)
1375 return;
1376
1377 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
1378 if (!cp)
1379 return;
1380
1381 hci_dev_lock(hdev);
1382
1383 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001384 if (conn) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001385 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1386
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001387 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
1388 hci_sco_setup(conn, status);
1389 }
1390
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001391 hci_dev_unlock(hdev);
1392}
1393
Ville Tervofcd89c02011-02-10 22:38:47 -03001394static void hci_cs_le_create_conn(struct hci_dev *hdev, __u8 status)
1395{
1396 struct hci_cp_le_create_conn *cp;
1397 struct hci_conn *conn;
Brian Gixa94b6122012-02-23 16:07:10 -08001398 unsigned long exp = msecs_to_jiffies(5000);
Ville Tervofcd89c02011-02-10 22:38:47 -03001399
1400 BT_DBG("%s status 0x%x", hdev->name, status);
1401
1402 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_CREATE_CONN);
1403 if (!cp)
1404 return;
1405
1406 hci_dev_lock(hdev);
1407
1408 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->peer_addr);
1409
1410 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->peer_addr),
1411 conn);
1412
1413 if (status) {
1414 if (conn && conn->state == BT_CONNECT) {
1415 conn->state = BT_CLOSED;
1416 hci_proto_connect_cfm(conn, status);
1417 hci_conn_del(conn);
1418 }
1419 } else {
1420 if (!conn) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001421 conn = hci_le_conn_add(hdev, &cp->peer_addr,
1422 cp->peer_addr_type);
1423 if (conn)
Ville Tervofcd89c02011-02-10 22:38:47 -03001424 conn->out = 1;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001425 else
Ville Tervofcd89c02011-02-10 22:38:47 -03001426 BT_ERR("No memory for new connection");
Brian Gixa94b6122012-02-23 16:07:10 -08001427 } else
1428 exp = msecs_to_jiffies(conn->conn_timeout * 1000);
Brian Gix114f3a62011-09-27 14:02:20 -07001429
Brian Gixa94b6122012-02-23 16:07:10 -08001430 if (conn && exp)
1431 mod_timer(&conn->disc_timer, jiffies + exp);
Ville Tervofcd89c02011-02-10 22:38:47 -03001432 }
1433
1434 hci_dev_unlock(hdev);
1435}
1436
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001437static void hci_cs_accept_logical_link(struct hci_dev *hdev, __u8 status)
1438{
1439 struct hci_cp_create_logical_link *ap;
1440 struct hci_chan *chan;
1441
1442 BT_DBG("%s status 0x%x", hdev->name, status);
1443
1444 ap = hci_sent_cmd_data(hdev, HCI_OP_ACCEPT_LOGICAL_LINK);
1445 if (!ap)
1446 return;
1447
1448 hci_dev_lock(hdev);
1449
1450 chan = hci_chan_list_lookup_id(hdev, ap->phy_handle);
1451
1452 BT_DBG("%s chan %p", hdev->name, chan);
1453
1454 if (status) {
1455 if (chan && chan->state == BT_CONNECT) {
1456 chan->state = BT_CLOSED;
1457 hci_proto_create_cfm(chan, status);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001458 }
Mat Martineau9f8d4672011-12-14 12:10:46 -08001459 } else if (chan) {
1460 chan->state = BT_CONNECT2;
1461 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001462
1463 hci_dev_unlock(hdev);
1464}
1465
1466static void hci_cs_create_logical_link(struct hci_dev *hdev, __u8 status)
1467{
1468 struct hci_cp_create_logical_link *cp;
1469 struct hci_chan *chan;
1470
1471 BT_DBG("%s status 0x%x", hdev->name, status);
1472
1473 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_LOGICAL_LINK);
1474 if (!cp)
1475 return;
1476
1477 hci_dev_lock(hdev);
1478
1479 chan = hci_chan_list_lookup_id(hdev, cp->phy_handle);
1480
1481 BT_DBG("%s chan %p", hdev->name, chan);
1482
1483 if (status) {
1484 if (chan && chan->state == BT_CONNECT) {
1485 chan->state = BT_CLOSED;
1486 hci_proto_create_cfm(chan, status);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001487 }
1488 } else if (chan)
1489 chan->state = BT_CONNECT2;
1490
1491 hci_dev_unlock(hdev);
1492}
1493
1494static void hci_cs_flow_spec_modify(struct hci_dev *hdev, __u8 status)
1495{
1496 struct hci_cp_flow_spec_modify *cp;
1497 struct hci_chan *chan;
1498
1499 BT_DBG("%s status 0x%x", hdev->name, status);
1500
1501 cp = hci_sent_cmd_data(hdev, HCI_OP_FLOW_SPEC_MODIFY);
1502 if (!cp)
1503 return;
1504
1505 hci_dev_lock(hdev);
1506
1507 chan = hci_chan_list_lookup_handle(hdev, cp->log_handle);
1508 if (chan) {
1509 if (status)
1510 hci_proto_modify_cfm(chan, status);
1511 else {
1512 chan->tx_fs = cp->tx_fs;
1513 chan->rx_fs = cp->rx_fs;
1514 }
1515 }
1516
1517 hci_dev_unlock(hdev);
1518}
1519
1520static void hci_cs_disconn_logical_link(struct hci_dev *hdev, __u8 status)
1521{
1522 struct hci_cp_disconn_logical_link *cp;
1523 struct hci_chan *chan;
1524
1525 if (!status)
1526 return;
1527
1528 BT_DBG("%s status 0x%x", hdev->name, status);
1529
1530 cp = hci_sent_cmd_data(hdev, HCI_OP_DISCONN_LOGICAL_LINK);
1531 if (!cp)
1532 return;
1533
1534 hci_dev_lock(hdev);
1535
1536 chan = hci_chan_list_lookup_handle(hdev, cp->log_handle);
1537 if (chan)
1538 hci_chan_del(chan);
1539
1540 hci_dev_unlock(hdev);
1541}
1542
1543static void hci_cs_disconn_physical_link(struct hci_dev *hdev, __u8 status)
1544{
1545 struct hci_cp_disconn_phys_link *cp;
1546 struct hci_conn *conn;
1547
1548 if (!status)
1549 return;
1550
1551 BT_DBG("%s status 0x%x", hdev->name, status);
1552
1553 cp = hci_sent_cmd_data(hdev, HCI_OP_DISCONN_PHYS_LINK);
1554 if (!cp)
1555 return;
1556
1557 hci_dev_lock(hdev);
1558
1559 conn = hci_conn_hash_lookup_handle(hdev, cp->phy_handle);
1560 if (conn) {
1561 conn->state = BT_CLOSED;
1562 hci_conn_del(conn);
1563 }
1564
1565 hci_dev_unlock(hdev);
1566}
1567
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03001568static void hci_cs_le_start_enc(struct hci_dev *hdev, u8 status)
1569{
1570 BT_DBG("%s status 0x%x", hdev->name, status);
1571}
1572
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001573static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1574{
1575 __u8 status = *((__u8 *) skb->data);
1576
1577 BT_DBG("%s status %d", hdev->name, status);
1578
Royston Rodrigues1670f382012-02-28 21:39:10 +05301579 if (!hdev->disco_state)
Brian Gixa68668b2011-08-11 15:49:36 -07001580 clear_bit(HCI_INQUIRY, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001581
Johan Hedberg23bb5762010-12-21 23:01:27 +02001582 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -08001583 hci_dev_lock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001584
Brian Gixa68668b2011-08-11 15:49:36 -07001585 if (test_bit(HCI_MGMT, &hdev->flags))
1586 mgmt_inquiry_complete_evt(hdev->id, status);
Subramanian Srinivasana727a492011-11-30 13:06:07 -08001587 hci_dev_unlock(hdev);
Brian Gixa68668b2011-08-11 15:49:36 -07001588
1589 if (!lmp_le_capable(hdev))
1590 hci_conn_check_pending(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001591}
1592
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1594{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001595 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001596 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 int num_rsp = *((__u8 *) skb->data);
1598
1599 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1600
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001601 if (!num_rsp)
1602 return;
1603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001605
Johan Hedberge17acd42011-03-30 23:57:16 +03001606 for (; num_rsp; num_rsp--, info++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 bacpy(&data.bdaddr, &info->bdaddr);
1608 data.pscan_rep_mode = info->pscan_rep_mode;
1609 data.pscan_period_mode = info->pscan_period_mode;
1610 data.pscan_mode = info->pscan_mode;
1611 memcpy(data.dev_class, info->dev_class, 3);
1612 data.clock_offset = info->clock_offset;
1613 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001614 data.ssp_mode = 0x00;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 hci_inquiry_cache_update(hdev, &data);
Brian Gixa68668b2011-08-11 15:49:36 -07001616 mgmt_device_found(hdev->id, &info->bdaddr, 0, 0,
1617 info->dev_class, 0, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001619
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 hci_dev_unlock(hdev);
1621}
1622
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001623static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001625 struct hci_ev_conn_complete *ev = (void *) skb->data;
1626 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001628 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001629
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001631
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001632 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann94992372009-04-19 19:30:03 +02001633 if (!conn) {
1634 if (ev->link_type != SCO_LINK)
1635 goto unlock;
1636
1637 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1638 if (!conn)
1639 goto unlock;
1640
1641 conn->type = SCO_LINK;
1642 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001643
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001644 if (!ev->status) {
1645 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +02001646
1647 if (conn->type == ACL_LINK) {
1648 conn->state = BT_CONFIG;
1649 hci_conn_hold(conn);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001650 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Brian Gix2e2f50d2011-09-13 12:36:04 -07001651 mgmt_connected(hdev->id, &ev->bdaddr, 0);
Brian Gixa68668b2011-08-11 15:49:36 -07001652 } else if (conn->type == LE_LINK) {
1653 conn->state = BT_CONNECTED;
1654 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Brian Gix2e2f50d2011-09-13 12:36:04 -07001655 mgmt_connected(hdev->id, &ev->bdaddr, 1);
Marcel Holtmann769be972008-07-14 20:13:49 +02001656 } else
1657 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001658
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07001659 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001660 hci_conn_add_sysfs(conn);
1661
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001662 if (test_bit(HCI_AUTH, &hdev->flags))
1663 conn->link_mode |= HCI_LM_AUTH;
1664
1665 if (test_bit(HCI_ENCRYPT, &hdev->flags))
1666 conn->link_mode |= HCI_LM_ENCRYPT;
1667
Srinivas Krovvidid352b262012-01-12 19:46:26 +05301668 /* Get remote version */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001669 if (conn->type == ACL_LINK) {
Srinivas Krovvidid352b262012-01-12 19:46:26 +05301670 struct hci_cp_read_remote_version cp;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001671 cp.handle = ev->handle;
Mallikarjuna GBadc3a9a2012-11-21 17:01:05 +05301672 hci_send_cmd(hdev, HCI_OP_READ_CLOCK_OFFSET,
1673 sizeof(cp), &cp);
Srinivas Krovvidid352b262012-01-12 19:46:26 +05301674 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_VERSION,
1675 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001676 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001677
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001678 /* Set packet type for incoming connection */
Marcel Holtmanna8746412008-07-14 20:13:46 +02001679 if (!conn->out && hdev->hci_ver < 3) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001680 struct hci_cp_change_conn_ptype cp;
1681 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +02001682 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1683 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
1684 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001685 }
Johan Hedberg17d5c042011-01-22 06:09:08 +02001686 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001687 conn->state = BT_CLOSED;
Brian Gixa68668b2011-08-11 15:49:36 -07001688 if (conn->type == ACL_LINK || conn->type == LE_LINK)
Johan Hedberg17d5c042011-01-22 06:09:08 +02001689 mgmt_connect_failed(hdev->id, &ev->bdaddr, ev->status);
1690 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001691
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001692 if (conn->type == ACL_LINK)
1693 hci_sco_setup(conn, ev->status);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001694
Marcel Holtmann769be972008-07-14 20:13:49 +02001695 if (ev->status) {
1696 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001697 hci_conn_del(conn);
Marcel Holtmannc89b6e62009-01-15 21:57:03 +01001698 } else if (ev->link_type != ACL_LINK)
1699 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001700
1701unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001703
1704 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705}
1706
hyungseoung.yoodbb18fb2011-11-18 13:57:01 +09001707static inline bool is_sco_active(struct hci_dev *hdev)
1708{
1709 if (hci_conn_hash_lookup_state(hdev, SCO_LINK, BT_CONNECTED) ||
1710 (hci_conn_hash_lookup_state(hdev, ESCO_LINK,
1711 BT_CONNECTED)))
1712 return true;
1713 return false;
1714}
1715
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1717{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001718 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 int mask = hdev->link_mode;
1720
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001721 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
1722 batostr(&ev->bdaddr), ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723
1724 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
1725
Szymon Janc138d22e2011-02-17 16:44:23 +01001726 if ((mask & HCI_LM_ACCEPT) &&
1727 !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001729 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
1732 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001733
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001734 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1735 if (ie)
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001736 memcpy(ie->data.dev_class, ev->dev_class, 3);
1737
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1739 if (!conn) {
Nick Pellybbcda3b2010-02-11 11:54:28 -08001740 /* pkt_type not yet used for incoming connections */
1741 conn = hci_conn_add(hdev, ev->link_type, 0, &ev->bdaddr);
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001742 if (!conn) {
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001743 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 hci_dev_unlock(hdev);
1745 return;
1746 }
1747 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001748
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 memcpy(conn->dev_class, ev->dev_class, 3);
Srinivas Krovvidi0916aed2011-12-20 12:06:34 +05301750 /* For incoming connection update remote class to userspace */
1751 mgmt_remote_class(hdev->id, &ev->bdaddr, ev->dev_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001753
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 hci_dev_unlock(hdev);
1755
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001756 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
1757 struct hci_cp_accept_conn_req cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001759 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
hyungseoung.yoodbb18fb2011-11-18 13:57:01 +09001761 if (lmp_rswitch_capable(hdev) && ((mask & HCI_LM_MASTER)
1762 || is_sco_active(hdev)))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001763 cp.role = 0x00; /* Become master */
1764 else
1765 cp.role = 0x01; /* Remain slave */
1766
1767 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
1768 sizeof(cp), &cp);
1769 } else {
1770 struct hci_cp_accept_sync_conn_req cp;
1771
1772 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +02001773 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001774
1775 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
1776 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001777 cp.max_latency = cpu_to_le16(0x000A);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001778 cp.content_format = cpu_to_le16(hdev->voice_setting);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001779 cp.retrans_effort = 0x01;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001780
1781 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
1782 sizeof(cp), &cp);
1783 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 } else {
1785 /* Connection rejected */
1786 struct hci_cp_reject_conn_req cp;
1787
1788 bacpy(&cp.bdaddr, &ev->bdaddr);
1789 cp.reason = 0x0f;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001790 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 }
1792}
1793
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1795{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001796 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001797 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
Archana Ramachandranda09d262012-08-14 12:03:01 -07001799 BT_DBG("%s status %d reason %d", hdev->name, ev->status, ev->reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800
Johan Hedberg8962ee72011-01-20 12:40:27 +02001801 if (ev->status) {
Subramanian Srinivasana727a492011-11-30 13:06:07 -08001802 hci_dev_lock(hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02001803 mgmt_disconnect_failed(hdev->id);
Subramanian Srinivasana727a492011-11-30 13:06:07 -08001804 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 return;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001806 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807
1808 hci_dev_lock(hdev);
1809
Marcel Holtmann04837f62006-07-03 10:02:33 +02001810 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergf7520542011-01-20 12:34:39 +02001811 if (!conn)
1812 goto unlock;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001813
Johan Hedbergf7520542011-01-20 12:34:39 +02001814 conn->state = BT_CLOSED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815
Brian Gixa68668b2011-08-11 15:49:36 -07001816 if (conn->type == ACL_LINK || conn->type == LE_LINK)
Archana Ramachandranda09d262012-08-14 12:03:01 -07001817 mgmt_disconnected(hdev->id, &conn->dst, ev->reason);
Johan Hedbergf7520542011-01-20 12:34:39 +02001818
Brian Gixe9ceb522011-09-22 10:46:35 -07001819 if (conn->type == LE_LINK)
1820 del_timer(&conn->smp_timer);
1821
Mat Martineau3b9239a2012-02-16 11:54:30 -08001822 hci_proto_disconn_cfm(conn, ev->reason, 0);
Johan Hedbergf7520542011-01-20 12:34:39 +02001823 hci_conn_del(conn);
1824
1825unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 hci_dev_unlock(hdev);
1827}
1828
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001829static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1830{
1831 struct hci_ev_auth_complete *ev = (void *) skb->data;
1832 struct hci_conn *conn;
1833
1834 BT_DBG("%s status %d", hdev->name, ev->status);
1835
1836 hci_dev_lock(hdev);
1837
1838 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001839 if (conn) {
1840 if (ev->status == 0x06 && hdev->ssp_mode > 0 &&
1841 conn->ssp_mode > 0) {
1842 struct hci_cp_auth_requested cp;
Prabhakaran Mcb04401d2011-09-20 17:37:55 +05301843 hci_remove_link_key(hdev, &conn->dst);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001844 cp.handle = cpu_to_le16(conn->handle);
1845 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
1846 sizeof(cp), &cp);
1847 hci_dev_unlock(hdev);
1848 BT_INFO("Pin or key missing");
1849 return;
1850 }
Waldemar Rymarkiewicz54444292011-05-31 15:49:26 +02001851
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001852 if (!ev->status) {
Waldemar Rymarkiewicz54444292011-05-31 15:49:26 +02001853 conn->link_mode |= HCI_LM_AUTH;
1854 conn->sec_level = conn->pending_sec_level;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001855 } else {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001856 mgmt_auth_failed(hdev->id, &conn->dst, ev->status);
1857 conn->sec_level = BT_SECURITY_LOW;
1858 }
1859
1860 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1861
1862 if (conn->state == BT_CONFIG) {
1863 if (!ev->status && hdev->ssp_mode > 0 &&
1864 conn->ssp_mode > 0) {
1865 struct hci_cp_set_conn_encrypt cp;
1866 cp.handle = ev->handle;
1867 cp.encrypt = 0x01;
1868 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1869 sizeof(cp), &cp);
1870 } else {
1871 conn->state = BT_CONNECTED;
1872 hci_proto_connect_cfm(conn, ev->status);
1873 hci_conn_put(conn);
1874 }
1875 } else {
1876 hci_auth_cfm(conn, ev->status);
1877
1878 hci_conn_hold(conn);
1879 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001880 hci_conn_put(conn);
1881 }
1882
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001883 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1884 if (!ev->status) {
Prabhakaran Mc48584712012-04-20 15:47:58 +05301885 if (conn->link_mode & HCI_LM_ENCRYPT) {
1886 /* Encryption implies authentication */
1887 conn->link_mode |= HCI_LM_AUTH;
1888 conn->link_mode |= HCI_LM_ENCRYPT;
1889 conn->sec_level =
1890 conn->pending_sec_level;
1891 clear_bit(HCI_CONN_ENCRYPT_PEND,
1892 &conn->pend);
1893 hci_encrypt_cfm(conn, ev->status, 1);
1894
1895 if (test_bit(HCI_MGMT, &hdev->flags))
1896 mgmt_encrypt_change(hdev->id,
1897 &conn->dst,
1898 ev->status);
1899
1900 } else {
1901 struct hci_cp_set_conn_encrypt cp;
1902 cp.handle = ev->handle;
1903 cp.encrypt = 0x01;
1904 hci_send_cmd(hdev,
1905 HCI_OP_SET_CONN_ENCRYPT,
1906 sizeof(cp), &cp);
1907 }
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001908 } else {
1909 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1910 hci_encrypt_cfm(conn, ev->status, 0x00);
1911 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001912 }
1913 }
1914
1915 hci_dev_unlock(hdev);
1916}
1917
1918static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1919{
Johan Hedberg127178d2010-11-18 22:22:29 +02001920 struct hci_ev_remote_name *ev = (void *) skb->data;
1921 struct hci_conn *conn;
1922
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001923 BT_DBG("%s", hdev->name);
1924
1925 hci_conn_check_pending(hdev);
Johan Hedberg127178d2010-11-18 22:22:29 +02001926
1927 hci_dev_lock(hdev);
1928
Brian Gixa68668b2011-08-11 15:49:36 -07001929 if (test_bit(HCI_MGMT, &hdev->flags))
1930 mgmt_remote_name(hdev->id, &ev->bdaddr, ev->status, ev->name);
Johan Hedberga88a9652011-03-30 13:18:12 +03001931
Johan Hedberg127178d2010-11-18 22:22:29 +02001932 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07001933 if (conn && hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001934 struct hci_cp_auth_requested cp;
1935 cp.handle = __cpu_to_le16(conn->handle);
1936 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1937 }
1938
1939 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001940}
1941
1942static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1943{
1944 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1945 struct hci_conn *conn;
1946
1947 BT_DBG("%s status %d", hdev->name, ev->status);
1948
1949 hci_dev_lock(hdev);
1950
1951 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1952 if (conn) {
1953 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02001954 if (ev->encrypt) {
1955 /* Encryption implies authentication */
1956 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001957 conn->link_mode |= HCI_LM_ENCRYPT;
Vinicius Costa Gomes64532ec2011-06-09 18:50:53 -03001958 conn->sec_level = conn->pending_sec_level;
Marcel Holtmannae293192008-07-14 20:13:45 +02001959 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001960 conn->link_mode &= ~HCI_LM_ENCRYPT;
1961 }
1962
1963 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1964
Marcel Holtmannf8558552008-07-14 20:13:49 +02001965 if (conn->state == BT_CONFIG) {
1966 if (!ev->status)
1967 conn->state = BT_CONNECTED;
1968
1969 hci_proto_connect_cfm(conn, ev->status);
1970 hci_conn_put(conn);
Prabhakaran Mcafface82012-04-10 11:38:35 +05301971 } else {
1972 /*
1973 * If the remote device does not support
1974 * Pause Encryption, usually during the
1975 * roleSwitch we see Encryption disable
1976 * for short duration. Allow remote device
1977 * to disable encryption
1978 * for short duration in this case.
1979 */
1980 if ((ev->encrypt == 0) && (ev->status == 0) &&
1981 ((conn->features[5] & LMP_PAUSE_ENC) == 0)) {
1982 mod_timer(&conn->encrypt_pause_timer,
1983 jiffies + msecs_to_jiffies(500));
1984 BT_INFO("enc pause timer, enc_pend_flag set");
1985 } else {
1986 del_timer(&conn->encrypt_pause_timer);
1987 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
1988 }
1989 }
Prabhakaran Mc46230fa2011-11-30 18:11:21 +05301990
1991 if (test_bit(HCI_MGMT, &hdev->flags))
1992 mgmt_encrypt_change(hdev->id, &conn->dst, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001993 }
1994
1995 hci_dev_unlock(hdev);
1996}
1997
1998static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1999{
2000 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
2001 struct hci_conn *conn;
2002
2003 BT_DBG("%s status %d", hdev->name, ev->status);
2004
2005 hci_dev_lock(hdev);
2006
2007 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2008 if (conn) {
2009 if (!ev->status)
2010 conn->link_mode |= HCI_LM_SECURE;
2011
2012 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
2013
2014 hci_key_change_cfm(conn, ev->status);
2015 }
2016
2017 hci_dev_unlock(hdev);
2018}
2019
2020static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
2021{
2022 struct hci_ev_remote_features *ev = (void *) skb->data;
2023 struct hci_conn *conn;
2024
2025 BT_DBG("%s status %d", hdev->name, ev->status);
2026
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002027 hci_dev_lock(hdev);
2028
2029 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02002030 if (!conn)
2031 goto unlock;
Marcel Holtmann769be972008-07-14 20:13:49 +02002032
Sunny Kapdif3caf882012-02-25 19:27:09 -08002033 if (!ev->status) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002034 memcpy(conn->features, ev->features, 8);
Sunny Kapdif3caf882012-02-25 19:27:09 -08002035 mgmt_remote_features(hdev->id, &conn->dst, ev->features);
2036 }
Johan Hedbergccd556f2010-11-10 17:11:51 +02002037
2038 if (conn->state != BT_CONFIG)
2039 goto unlock;
2040
2041 if (!ev->status && lmp_ssp_capable(hdev) && lmp_ssp_capable(conn)) {
2042 struct hci_cp_read_remote_ext_features cp;
2043 cp.handle = ev->handle;
2044 cp.page = 0x01;
2045 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
Marcel Holtmann769be972008-07-14 20:13:49 +02002046 sizeof(cp), &cp);
Johan Hedberg392599b2010-11-18 22:22:28 +02002047 goto unlock;
Prabhakaran Mc9f08bfd2012-03-26 18:18:17 +05302048 } else if (!(lmp_ssp_capable(conn)) && conn->auth_initiator &&
Bhakthavatsala Raghavendrab03b5702013-02-12 19:44:47 +05302049 (conn->pending_sec_level == BT_SECURITY_VERY_HIGH)) {
Prabhakaran Mc9f08bfd2012-03-26 18:18:17 +05302050 conn->pending_sec_level = BT_SECURITY_MEDIUM;
Johan Hedberg392599b2010-11-18 22:22:28 +02002051 }
2052
Johan Hedberg127178d2010-11-18 22:22:29 +02002053 if (!ev->status) {
2054 struct hci_cp_remote_name_req cp;
2055 memset(&cp, 0, sizeof(cp));
2056 bacpy(&cp.bdaddr, &conn->dst);
2057 cp.pscan_rep_mode = 0x02;
2058 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
2059 }
Johan Hedberg392599b2010-11-18 22:22:28 +02002060
Johan Hedberg127178d2010-11-18 22:22:29 +02002061 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002062 conn->state = BT_CONNECTED;
2063 hci_proto_connect_cfm(conn, ev->status);
2064 hci_conn_put(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +02002065 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002066
Johan Hedbergccd556f2010-11-10 17:11:51 +02002067unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002068 hci_dev_unlock(hdev);
2069}
2070
2071static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
2072{
Srinivas Krovvidid352b262012-01-12 19:46:26 +05302073 struct hci_ev_remote_version *ev = (void *) skb->data;
2074 struct hci_cp_read_remote_features cp;
2075 struct hci_conn *conn;
2076 BT_DBG("%s status %d", hdev->name, ev->status);
2077
2078 hci_dev_lock(hdev);
2079 cp.handle = ev->handle;
2080 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
2081 sizeof(cp), &cp);
2082
2083 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2084 if (!conn)
2085 goto unlock;
2086 if (!ev->status)
2087 mgmt_remote_version(hdev->id, &conn->dst, ev->lmp_ver,
2088 ev->manufacturer, ev->lmp_subver);
2089unlock:
2090 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002091}
2092
2093static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2094{
2095 BT_DBG("%s", hdev->name);
2096}
2097
2098static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2099{
2100 struct hci_ev_cmd_complete *ev = (void *) skb->data;
2101 __u16 opcode;
2102
2103 skb_pull(skb, sizeof(*ev));
2104
2105 opcode = __le16_to_cpu(ev->opcode);
2106
Bhasker Neti6f4ceb12012-06-26 16:48:18 +05302107 if (test_bit(HCI_RESET, &hdev->flags) && (opcode != HCI_OP_RESET))
2108 return;
2109
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002110 switch (opcode) {
2111 case HCI_OP_INQUIRY_CANCEL:
2112 hci_cc_inquiry_cancel(hdev, skb);
2113 break;
2114
2115 case HCI_OP_EXIT_PERIODIC_INQ:
2116 hci_cc_exit_periodic_inq(hdev, skb);
2117 break;
2118
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002119 case HCI_OP_LINK_KEY_REPLY:
2120 hci_cc_link_key_reply(hdev, skb);
2121 break;
2122
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002123 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
2124 hci_cc_remote_name_req_cancel(hdev, skb);
2125 break;
2126
2127 case HCI_OP_ROLE_DISCOVERY:
2128 hci_cc_role_discovery(hdev, skb);
2129 break;
2130
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02002131 case HCI_OP_READ_LINK_POLICY:
2132 hci_cc_read_link_policy(hdev, skb);
2133 break;
2134
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002135 case HCI_OP_WRITE_LINK_POLICY:
2136 hci_cc_write_link_policy(hdev, skb);
2137 break;
2138
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02002139 case HCI_OP_READ_DEF_LINK_POLICY:
2140 hci_cc_read_def_link_policy(hdev, skb);
2141 break;
2142
2143 case HCI_OP_WRITE_DEF_LINK_POLICY:
2144 hci_cc_write_def_link_policy(hdev, skb);
2145 break;
2146
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002147 case HCI_OP_RESET:
2148 hci_cc_reset(hdev, skb);
2149 break;
2150
2151 case HCI_OP_WRITE_LOCAL_NAME:
2152 hci_cc_write_local_name(hdev, skb);
2153 break;
2154
2155 case HCI_OP_READ_LOCAL_NAME:
2156 hci_cc_read_local_name(hdev, skb);
2157 break;
2158
2159 case HCI_OP_WRITE_AUTH_ENABLE:
2160 hci_cc_write_auth_enable(hdev, skb);
2161 break;
2162
2163 case HCI_OP_WRITE_ENCRYPT_MODE:
2164 hci_cc_write_encrypt_mode(hdev, skb);
2165 break;
2166
2167 case HCI_OP_WRITE_SCAN_ENABLE:
2168 hci_cc_write_scan_enable(hdev, skb);
2169 break;
2170
2171 case HCI_OP_READ_CLASS_OF_DEV:
2172 hci_cc_read_class_of_dev(hdev, skb);
2173 break;
2174
2175 case HCI_OP_WRITE_CLASS_OF_DEV:
2176 hci_cc_write_class_of_dev(hdev, skb);
2177 break;
2178
2179 case HCI_OP_READ_VOICE_SETTING:
2180 hci_cc_read_voice_setting(hdev, skb);
2181 break;
2182
2183 case HCI_OP_WRITE_VOICE_SETTING:
2184 hci_cc_write_voice_setting(hdev, skb);
2185 break;
2186
2187 case HCI_OP_HOST_BUFFER_SIZE:
2188 hci_cc_host_buffer_size(hdev, skb);
2189 break;
2190
Marcel Holtmann333140b2008-07-14 20:13:48 +02002191 case HCI_OP_READ_SSP_MODE:
2192 hci_cc_read_ssp_mode(hdev, skb);
2193 break;
2194
2195 case HCI_OP_WRITE_SSP_MODE:
2196 hci_cc_write_ssp_mode(hdev, skb);
2197 break;
2198
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002199 case HCI_OP_READ_LOCAL_VERSION:
2200 hci_cc_read_local_version(hdev, skb);
2201 break;
2202
2203 case HCI_OP_READ_LOCAL_COMMANDS:
2204 hci_cc_read_local_commands(hdev, skb);
2205 break;
2206
2207 case HCI_OP_READ_LOCAL_FEATURES:
2208 hci_cc_read_local_features(hdev, skb);
2209 break;
2210
2211 case HCI_OP_READ_BUFFER_SIZE:
2212 hci_cc_read_buffer_size(hdev, skb);
2213 break;
2214
2215 case HCI_OP_READ_BD_ADDR:
2216 hci_cc_read_bd_addr(hdev, skb);
2217 break;
2218
Johan Hedberg23bb5762010-12-21 23:01:27 +02002219 case HCI_OP_WRITE_CA_TIMEOUT:
2220 hci_cc_write_ca_timeout(hdev, skb);
2221 break;
2222
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002223 case HCI_OP_READ_FLOW_CONTROL_MODE:
2224 hci_cc_read_flow_control_mode(hdev, skb);
2225 break;
2226
2227 case HCI_OP_READ_DATA_BLOCK_SIZE:
2228 hci_cc_read_data_block_size(hdev, skb);
2229 break;
2230
2231 case HCI_OP_READ_LOCAL_AMP_INFO:
2232 hci_cc_read_local_amp_info(hdev, skb);
2233 break;
2234
2235 case HCI_OP_READ_LOCAL_AMP_ASSOC:
2236 case HCI_OP_WRITE_REMOTE_AMP_ASSOC:
2237 hci_amp_cmd_complete(hdev, opcode, skb);
2238 break;
2239
Johan Hedbergb0916ea2011-01-10 13:44:55 +02002240 case HCI_OP_DELETE_STORED_LINK_KEY:
2241 hci_cc_delete_stored_link_key(hdev, skb);
2242 break;
2243
Johan Hedbergd5859e22011-01-25 01:19:58 +02002244 case HCI_OP_SET_EVENT_MASK:
2245 hci_cc_set_event_mask(hdev, skb);
2246 break;
2247
2248 case HCI_OP_WRITE_INQUIRY_MODE:
2249 hci_cc_write_inquiry_mode(hdev, skb);
2250 break;
2251
2252 case HCI_OP_READ_INQ_RSP_TX_POWER:
2253 hci_cc_read_inq_rsp_tx_power(hdev, skb);
2254 break;
2255
2256 case HCI_OP_SET_EVENT_FLT:
2257 hci_cc_set_event_flt(hdev, skb);
2258 break;
2259
Johan Hedberg980e1a52011-01-22 06:10:07 +02002260 case HCI_OP_PIN_CODE_REPLY:
2261 hci_cc_pin_code_reply(hdev, skb);
2262 break;
2263
2264 case HCI_OP_PIN_CODE_NEG_REPLY:
2265 hci_cc_pin_code_neg_reply(hdev, skb);
2266 break;
2267
Szymon Jancc35938b2011-03-22 13:12:21 +01002268 case HCI_OP_READ_LOCAL_OOB_DATA:
2269 hci_cc_read_local_oob_data_reply(hdev, skb);
2270 break;
2271
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002272 case HCI_OP_LE_READ_BUFFER_SIZE:
2273 hci_cc_le_read_buffer_size(hdev, skb);
2274 break;
2275
Sunny Kapdi93bef892012-07-30 14:52:56 -07002276 case HCI_OP_LE_READ_WHITE_LIST_SIZE:
2277 hci_cc_le_read_white_list_size(hdev, skb);
2278 break;
2279
2280 case HCI_OP_LE_CLEAR_WHITE_LIST:
2281 hci_cc_le_clear_white_list(hdev, skb);
2282 break;
2283
Archana Ramachandran26a752b2011-12-20 11:27:40 -08002284 case HCI_OP_READ_RSSI:
2285 hci_cc_read_rssi(hdev, skb);
2286 break;
2287
Johan Hedberga5c29682011-02-19 12:05:57 -03002288 case HCI_OP_USER_CONFIRM_REPLY:
2289 hci_cc_user_confirm_reply(hdev, skb);
2290 break;
2291
2292 case HCI_OP_USER_CONFIRM_NEG_REPLY:
2293 hci_cc_user_confirm_neg_reply(hdev, skb);
2294 break;
2295
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03002296 case HCI_OP_LE_LTK_REPLY:
2297 hci_cc_le_ltk_reply(hdev, skb);
2298 break;
2299
2300 case HCI_OP_LE_LTK_NEG_REPLY:
2301 hci_cc_le_ltk_neg_reply(hdev, skb);
2302 break;
2303
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002304 case HCI_OP_LE_SET_SCAN_ENABLE:
2305 hci_cc_le_set_scan_enable(hdev, skb);
Andre Guedese326af42011-06-30 19:20:53 -03002306 break;
2307
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002308 default:
2309 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
2310 break;
2311 }
2312
Ville Tervo6bd32322011-02-16 16:32:41 +02002313 if (ev->opcode != HCI_OP_NOP)
2314 del_timer(&hdev->cmd_timer);
2315
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002316 if (ev->ncmd) {
2317 atomic_set(&hdev->cmd_cnt, 1);
2318 if (!skb_queue_empty(&hdev->cmd_q))
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002319 tasklet_schedule(&hdev->cmd_task);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002320 }
2321}
2322
2323static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
2324{
2325 struct hci_ev_cmd_status *ev = (void *) skb->data;
2326 __u16 opcode;
2327
2328 skb_pull(skb, sizeof(*ev));
2329
2330 opcode = __le16_to_cpu(ev->opcode);
2331
2332 switch (opcode) {
2333 case HCI_OP_INQUIRY:
2334 hci_cs_inquiry(hdev, ev->status);
2335 break;
2336
2337 case HCI_OP_CREATE_CONN:
2338 hci_cs_create_conn(hdev, ev->status);
2339 break;
2340
2341 case HCI_OP_ADD_SCO:
2342 hci_cs_add_sco(hdev, ev->status);
2343 break;
2344
Marcel Holtmannf8558552008-07-14 20:13:49 +02002345 case HCI_OP_AUTH_REQUESTED:
2346 hci_cs_auth_requested(hdev, ev->status);
2347 break;
2348
2349 case HCI_OP_SET_CONN_ENCRYPT:
2350 hci_cs_set_conn_encrypt(hdev, ev->status);
2351 break;
2352
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002353 case HCI_OP_REMOTE_NAME_REQ:
2354 hci_cs_remote_name_req(hdev, ev->status);
2355 break;
2356
Marcel Holtmann769be972008-07-14 20:13:49 +02002357 case HCI_OP_READ_REMOTE_FEATURES:
2358 hci_cs_read_remote_features(hdev, ev->status);
2359 break;
2360
2361 case HCI_OP_READ_REMOTE_EXT_FEATURES:
2362 hci_cs_read_remote_ext_features(hdev, ev->status);
2363 break;
2364
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002365 case HCI_OP_SETUP_SYNC_CONN:
2366 hci_cs_setup_sync_conn(hdev, ev->status);
2367 break;
2368
2369 case HCI_OP_SNIFF_MODE:
2370 hci_cs_sniff_mode(hdev, ev->status);
2371 break;
2372
2373 case HCI_OP_EXIT_SNIFF_MODE:
2374 hci_cs_exit_sniff_mode(hdev, ev->status);
2375 break;
2376
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002377 case HCI_OP_CREATE_LOGICAL_LINK:
2378 hci_cs_create_logical_link(hdev, ev->status);
2379 break;
2380
2381 case HCI_OP_ACCEPT_LOGICAL_LINK:
2382 hci_cs_accept_logical_link(hdev, ev->status);
2383 break;
2384
2385 case HCI_OP_DISCONN_LOGICAL_LINK:
2386 hci_cs_disconn_logical_link(hdev, ev->status);
2387 break;
2388
2389 case HCI_OP_FLOW_SPEC_MODIFY:
2390 hci_cs_flow_spec_modify(hdev, ev->status);
2391 break;
2392
2393 case HCI_OP_CREATE_PHYS_LINK:
2394 case HCI_OP_ACCEPT_PHYS_LINK:
2395 hci_amp_cmd_status(hdev, opcode, ev->status);
2396 break;
2397
2398 case HCI_OP_DISCONN_PHYS_LINK:
2399 hci_cs_disconn_physical_link(hdev, ev->status);
2400
Johan Hedberg8962ee72011-01-20 12:40:27 +02002401 case HCI_OP_DISCONNECT:
2402 if (ev->status != 0)
2403 mgmt_disconnect_failed(hdev->id);
2404 break;
2405
Ville Tervofcd89c02011-02-10 22:38:47 -03002406 case HCI_OP_LE_CREATE_CONN:
2407 hci_cs_le_create_conn(hdev, ev->status);
2408 break;
2409
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03002410 case HCI_OP_LE_START_ENC:
2411 hci_cs_le_start_enc(hdev, ev->status);
2412 break;
2413
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002414 default:
2415 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
2416 break;
2417 }
2418
Ville Tervo6bd32322011-02-16 16:32:41 +02002419 if (ev->opcode != HCI_OP_NOP)
2420 del_timer(&hdev->cmd_timer);
2421
Gustavo F. Padovan10572132011-03-16 15:36:29 -03002422 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002423 atomic_set(&hdev->cmd_cnt, 1);
2424 if (!skb_queue_empty(&hdev->cmd_q))
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002425 tasklet_schedule(&hdev->cmd_task);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002426 }
2427}
2428
2429static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
2430{
2431 struct hci_ev_role_change *ev = (void *) skb->data;
2432 struct hci_conn *conn;
2433
2434 BT_DBG("%s status %d", hdev->name, ev->status);
2435
2436 hci_dev_lock(hdev);
2437
2438 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2439 if (conn) {
2440 if (!ev->status) {
2441 if (ev->role)
2442 conn->link_mode &= ~HCI_LM_MASTER;
2443 else
2444 conn->link_mode |= HCI_LM_MASTER;
2445 }
2446
2447 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
2448
2449 hci_role_switch_cfm(conn, ev->status, ev->role);
2450 }
2451
2452 hci_dev_unlock(hdev);
2453}
2454
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
2456{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002457 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08002458 __le16 *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 int i;
2460
2461 skb_pull(skb, sizeof(*ev));
2462
2463 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
2464
2465 if (skb->len < ev->num_hndl * 4) {
2466 BT_DBG("%s bad parameters", hdev->name);
2467 return;
2468 }
2469
2470 tasklet_disable(&hdev->tx_task);
2471
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08002472 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002473 struct hci_conn *conn = NULL;
2474 struct hci_chan *chan;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 __u16 handle, count;
2476
Harvey Harrison83985312008-05-02 16:25:46 -07002477 handle = get_unaligned_le16(ptr++);
2478 count = get_unaligned_le16(ptr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002480 if (hdev->dev_type == HCI_BREDR)
2481 conn = hci_conn_hash_lookup_handle(hdev, handle);
2482 else {
2483 chan = hci_chan_list_lookup_handle(hdev, handle);
2484 if (chan)
2485 conn = chan->conn;
2486 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 if (conn) {
2488 conn->sent -= count;
2489
Marcel Holtmann5b7f99092007-07-11 09:51:55 +02002490 if (conn->type == ACL_LINK) {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002491 hdev->acl_cnt += count;
2492 if (hdev->acl_cnt > hdev->acl_pkts)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 hdev->acl_cnt = hdev->acl_pkts;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002494 } else if (conn->type == LE_LINK) {
2495 if (hdev->le_pkts) {
2496 hdev->le_cnt += count;
2497 if (hdev->le_cnt > hdev->le_pkts)
2498 hdev->le_cnt = hdev->le_pkts;
2499 } else {
2500 hdev->acl_cnt += count;
2501 if (hdev->acl_cnt > hdev->acl_pkts)
2502 hdev->acl_cnt = hdev->acl_pkts;
2503 }
Marcel Holtmann5b7f99092007-07-11 09:51:55 +02002504 } else {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002505 hdev->sco_cnt += count;
2506 if (hdev->sco_cnt > hdev->sco_pkts)
Marcel Holtmann5b7f99092007-07-11 09:51:55 +02002507 hdev->sco_cnt = hdev->sco_pkts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508 }
2509 }
2510 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002511
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002512 tasklet_schedule(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513
2514 tasklet_enable(&hdev->tx_task);
2515}
2516
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002517static inline void hci_num_comp_blocks_evt(struct hci_dev *hdev,
2518 struct sk_buff *skb)
2519{
2520 struct hci_ev_num_comp_blocks *ev = (void *) skb->data;
2521 __le16 *ptr;
2522 int i;
2523
2524 skb_pull(skb, sizeof(*ev));
2525
2526 BT_DBG("%s total_num_blocks %d num_hndl %d",
2527 hdev->name, ev->total_num_blocks, ev->num_hndl);
2528
2529 if (skb->len < ev->num_hndl * 6) {
2530 BT_DBG("%s bad parameters", hdev->name);
2531 return;
2532 }
2533
2534 tasklet_disable(&hdev->tx_task);
2535
2536 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
2537 struct hci_conn *conn = NULL;
2538 struct hci_chan *chan;
2539 __u16 handle, block_count;
2540
2541 handle = get_unaligned_le16(ptr++);
2542
2543 /* Skip packet count */
2544 ptr++;
2545 block_count = get_unaligned_le16(ptr++);
2546
2547 BT_DBG("%s handle %d count %d", hdev->name, handle,
2548 block_count);
2549
2550 if (hdev->dev_type == HCI_BREDR)
2551 conn = hci_conn_hash_lookup_handle(hdev, handle);
2552 else {
2553 chan = hci_chan_list_lookup_handle(hdev, handle);
2554 if (chan)
2555 conn = chan->conn;
2556 }
2557 if (conn) {
2558 BT_DBG("%s conn %p sent %d", hdev->name,
2559 conn, conn->sent);
2560
2561 conn->sent -= block_count;
2562
2563 if (conn->type == ACL_LINK) {
2564 hdev->acl_cnt += block_count;
2565 if (hdev->acl_cnt > hdev->acl_pkts)
2566 hdev->acl_cnt = hdev->acl_pkts;
2567 } else {
2568 /* We should not find ourselves here */
2569 BT_DBG("Unexpected event for SCO connection");
2570 }
2571 }
2572 }
2573
2574 tasklet_schedule(&hdev->tx_task);
2575
2576 tasklet_enable(&hdev->tx_task);
2577}
2578
Marcel Holtmann04837f62006-07-03 10:02:33 +02002579static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002581 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002582 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583
2584 BT_DBG("%s status %d", hdev->name, ev->status);
2585
2586 hci_dev_lock(hdev);
2587
Marcel Holtmann04837f62006-07-03 10:02:33 +02002588 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2589 if (conn) {
2590 conn->mode = ev->mode;
2591 conn->interval = __le16_to_cpu(ev->interval);
2592
2593 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
2594 if (conn->mode == HCI_CM_ACTIVE)
2595 conn->power_save = 1;
2596 else
2597 conn->power_save = 0;
2598 }
Rahul Kashyapb44f9e22012-05-03 16:45:17 +05302599 if (conn->mode == HCI_CM_SNIFF)
2600 if (wake_lock_active(&conn->idle_lock))
2601 wake_unlock(&conn->idle_lock);
Marcel Holtmanne73439d2010-07-26 10:06:00 -04002602
2603 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
2604 hci_sco_setup(conn, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002605 }
2606
2607 hci_dev_unlock(hdev);
2608}
2609
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2611{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002612 struct hci_ev_pin_code_req *ev = (void *) skb->data;
2613 struct hci_conn *conn;
2614
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002615 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002616
2617 hci_dev_lock(hdev);
2618
2619 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Marcel Holtmann3d7a9d12009-05-09 12:09:21 -07002620 if (conn && conn->state == BT_CONNECTED) {
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002621 hci_conn_hold(conn);
2622 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
2623 hci_conn_put(conn);
Srinivas Krovvidi32ba9352012-01-26 10:48:08 +05302624 hci_conn_enter_active_mode(conn, 0);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002625 }
2626
Johan Hedberg03b555e2011-01-04 15:40:05 +02002627 if (!test_bit(HCI_PAIRABLE, &hdev->flags))
2628 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
2629 sizeof(ev->bdaddr), &ev->bdaddr);
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02002630
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002631 if (test_bit(HCI_MGMT, &hdev->flags))
2632 mgmt_pin_code_request(hdev->id, &ev->bdaddr);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002633
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002634 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635}
2636
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2638{
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002639 struct hci_ev_link_key_req *ev = (void *) skb->data;
2640 struct hci_cp_link_key_reply cp;
2641 struct hci_conn *conn;
2642 struct link_key *key;
2643
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002644 BT_DBG("%s", hdev->name);
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002645
2646 if (!test_bit(HCI_LINK_KEYS, &hdev->flags))
2647 return;
2648
2649 hci_dev_lock(hdev);
2650
2651 key = hci_find_link_key(hdev, &ev->bdaddr);
2652 if (!key) {
2653 BT_DBG("%s link key not found for %s", hdev->name,
2654 batostr(&ev->bdaddr));
2655 goto not_found;
2656 }
2657
Brian Gixcf956772011-10-20 15:18:51 -07002658 BT_DBG("%s found key type %u for %s", hdev->name, key->key_type,
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002659 batostr(&ev->bdaddr));
2660
Brian Gixcf956772011-10-20 15:18:51 -07002661 if (!test_bit(HCI_DEBUG_KEYS, &hdev->flags) && key->key_type == 0x03) {
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002662 BT_DBG("%s ignoring debug key", hdev->name);
2663 goto not_found;
2664 }
2665
2666 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2667
Prabhakaran Mc6001a712011-09-06 11:56:25 +05302668 if (conn) {
2669 BT_DBG("Conn pending sec level is %d, ssp is %d, key len is %d",
2670 conn->pending_sec_level, conn->ssp_mode, key->pin_len);
2671 }
Bhakthavatsala Raghavendraf1fb43c2013-02-13 13:27:45 +05302672 if (conn && (conn->ssp_mode == 0) &&
2673 (conn->pending_sec_level == BT_SECURITY_VERY_HIGH) &&
2674 (key->pin_len != 16)) {
2675 BT_DBG("Security is high ignoring this key");
2676 goto not_found;
2677 }
Prabhakaran Mc6001a712011-09-06 11:56:25 +05302678
Brian Gixcf956772011-10-20 15:18:51 -07002679 if (key->key_type == 0x04 && conn && conn->auth_type != 0xff &&
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002680 (conn->auth_type & 0x01)) {
2681 BT_DBG("%s ignoring unauthenticated key", hdev->name);
2682 goto not_found;
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002683 }
2684
2685 bacpy(&cp.bdaddr, &ev->bdaddr);
2686 memcpy(cp.link_key, key->val, 16);
2687
2688 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
2689
2690 hci_dev_unlock(hdev);
2691
2692 return;
2693
2694not_found:
2695 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
2696 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697}
2698
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
2700{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002701 struct hci_ev_link_key_notify *ev = (void *) skb->data;
2702 struct hci_conn *conn;
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002703 u8 pin_len = 0;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002704
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002705 BT_DBG("%s type %d", hdev->name, ev->key_type);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002706
2707 hci_dev_lock(hdev);
2708
2709 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2710 if (conn) {
2711 hci_conn_hold(conn);
2712 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002713
2714 memcpy(conn->link_key, ev->link_key, 16);
2715 conn->key_type = ev->key_type;
2716 hci_disconnect_amp(conn, 0x06);
2717
Prabhakaran Mc48584712012-04-20 15:47:58 +05302718 conn->link_mode &= ~HCI_LM_ENCRYPT;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002719 pin_len = conn->pin_length;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002720 hci_conn_put(conn);
Srinivas Krovvidi32ba9352012-01-26 10:48:08 +05302721 hci_conn_enter_active_mode(conn, 0);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002722 }
2723
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002724 if (test_bit(HCI_LINK_KEYS, &hdev->flags))
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07002725 hci_add_link_key(hdev, 1, &ev->bdaddr, ev->link_key,
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002726 ev->key_type, pin_len);
2727
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002728 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729}
2730
Marcel Holtmann04837f62006-07-03 10:02:33 +02002731static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
2732{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002733 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002734 struct hci_conn *conn;
2735
2736 BT_DBG("%s status %d", hdev->name, ev->status);
2737
2738 hci_dev_lock(hdev);
2739
2740 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741 if (conn && !ev->status) {
2742 struct inquiry_entry *ie;
2743
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002744 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2745 if (ie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746 ie->data.clock_offset = ev->clock_offset;
2747 ie->timestamp = jiffies;
2748 }
2749 }
2750
2751 hci_dev_unlock(hdev);
2752}
2753
Marcel Holtmanna8746412008-07-14 20:13:46 +02002754static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
2755{
2756 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
2757 struct hci_conn *conn;
2758
2759 BT_DBG("%s status %d", hdev->name, ev->status);
2760
2761 hci_dev_lock(hdev);
2762
2763 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2764 if (conn && !ev->status)
2765 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
2766
2767 hci_dev_unlock(hdev);
2768}
2769
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002770static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
2771{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002772 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002773 struct inquiry_entry *ie;
2774
2775 BT_DBG("%s", hdev->name);
2776
2777 hci_dev_lock(hdev);
2778
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002779 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2780 if (ie) {
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002781 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
2782 ie->timestamp = jiffies;
2783 }
2784
2785 hci_dev_unlock(hdev);
2786}
2787
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002788static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
2789{
2790 struct inquiry_data data;
2791 int num_rsp = *((__u8 *) skb->data);
2792
2793 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2794
2795 if (!num_rsp)
2796 return;
2797
2798 hci_dev_lock(hdev);
2799
2800 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
Szymon Janc138d22e2011-02-17 16:44:23 +01002801 struct inquiry_info_with_rssi_and_pscan_mode *info;
2802 info = (void *) (skb->data + 1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002803
Johan Hedberge17acd42011-03-30 23:57:16 +03002804 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002805 bacpy(&data.bdaddr, &info->bdaddr);
2806 data.pscan_rep_mode = info->pscan_rep_mode;
2807 data.pscan_period_mode = info->pscan_period_mode;
2808 data.pscan_mode = info->pscan_mode;
2809 memcpy(data.dev_class, info->dev_class, 3);
2810 data.clock_offset = info->clock_offset;
2811 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002812 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002813 hci_inquiry_cache_update(hdev, &data);
Brian Gixa68668b2011-08-11 15:49:36 -07002814 mgmt_device_found(hdev->id, &info->bdaddr, 0, 0,
Johan Hedberge17acd42011-03-30 23:57:16 +03002815 info->dev_class, info->rssi,
Brian Gixa68668b2011-08-11 15:49:36 -07002816 0, NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002817 }
2818 } else {
2819 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
2820
Johan Hedberge17acd42011-03-30 23:57:16 +03002821 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002822 bacpy(&data.bdaddr, &info->bdaddr);
2823 data.pscan_rep_mode = info->pscan_rep_mode;
2824 data.pscan_period_mode = info->pscan_period_mode;
2825 data.pscan_mode = 0x00;
2826 memcpy(data.dev_class, info->dev_class, 3);
2827 data.clock_offset = info->clock_offset;
2828 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002829 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002830 hci_inquiry_cache_update(hdev, &data);
Brian Gixa68668b2011-08-11 15:49:36 -07002831 mgmt_device_found(hdev->id, &info->bdaddr, 0, 0,
Johan Hedberge17acd42011-03-30 23:57:16 +03002832 info->dev_class, info->rssi,
Brian Gixa68668b2011-08-11 15:49:36 -07002833 0, NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002834 }
2835 }
2836
2837 hci_dev_unlock(hdev);
2838}
2839
2840static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
2841{
Marcel Holtmann41a96212008-07-14 20:13:48 +02002842 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
2843 struct hci_conn *conn;
2844
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002845 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02002846
Marcel Holtmann41a96212008-07-14 20:13:48 +02002847 hci_dev_lock(hdev);
2848
2849 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02002850 if (!conn)
2851 goto unlock;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002852
Johan Hedbergccd556f2010-11-10 17:11:51 +02002853 if (!ev->status && ev->page == 0x01) {
2854 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002855
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002856 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2857 if (ie)
Johan Hedbergccd556f2010-11-10 17:11:51 +02002858 ie->data.ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann769be972008-07-14 20:13:49 +02002859
Johan Hedbergccd556f2010-11-10 17:11:51 +02002860 conn->ssp_mode = (ev->features[0] & 0x01);
Bhakthavatsala Raghavendra6edb4f12011-11-04 16:07:41 +05302861 /*In case if remote device ssp supported/2.0 device
Bhakthavatsala Raghavendrab03b5702013-02-12 19:44:47 +05302862 reduce the security level to MEDIUM if it is VERY HIGH*/
Prabhakaran Mc453651c2012-03-02 11:55:59 +05302863 if (!conn->ssp_mode && conn->auth_initiator &&
Bhakthavatsala Raghavendrab03b5702013-02-12 19:44:47 +05302864 (conn->pending_sec_level == BT_SECURITY_VERY_HIGH))
Bhakthavatsala Raghavendra6edb4f12011-11-04 16:07:41 +05302865 conn->pending_sec_level = BT_SECURITY_MEDIUM;
Prabhakaran Mc76a83552012-04-09 14:43:18 +05302866
2867 if (conn->ssp_mode && conn->auth_initiator &&
2868 conn->io_capability != 0x03) {
Bhakthavatsala Raghavendrab03b5702013-02-12 19:44:47 +05302869 conn->pending_sec_level = BT_SECURITY_VERY_HIGH;
Prabhakaran Mc76a83552012-04-09 14:43:18 +05302870 conn->auth_type = HCI_AT_DEDICATED_BONDING_MITM;
2871 }
Marcel Holtmann41a96212008-07-14 20:13:48 +02002872 }
2873
Johan Hedbergccd556f2010-11-10 17:11:51 +02002874 if (conn->state != BT_CONFIG)
2875 goto unlock;
2876
Johan Hedberg127178d2010-11-18 22:22:29 +02002877 if (!ev->status) {
2878 struct hci_cp_remote_name_req cp;
2879 memset(&cp, 0, sizeof(cp));
2880 bacpy(&cp.bdaddr, &conn->dst);
2881 cp.pscan_rep_mode = 0x02;
2882 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
2883 }
Johan Hedberg392599b2010-11-18 22:22:28 +02002884
Johan Hedberg127178d2010-11-18 22:22:29 +02002885 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002886 conn->state = BT_CONNECTED;
2887 hci_proto_connect_cfm(conn, ev->status);
2888 hci_conn_put(conn);
2889 }
2890
2891unlock:
Marcel Holtmann41a96212008-07-14 20:13:48 +02002892 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002893}
2894
2895static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2896{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002897 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
2898 struct hci_conn *conn;
2899
2900 BT_DBG("%s status %d", hdev->name, ev->status);
2901
2902 hci_dev_lock(hdev);
2903
2904 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02002905 if (!conn) {
2906 if (ev->link_type == ESCO_LINK)
2907 goto unlock;
2908
2909 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
2910 if (!conn)
2911 goto unlock;
2912
2913 conn->type = SCO_LINK;
2914 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002915
Marcel Holtmann732547f2009-04-19 19:14:14 +02002916 switch (ev->status) {
2917 case 0x00:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002918 conn->handle = __le16_to_cpu(ev->handle);
2919 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002920
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07002921 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002922 hci_conn_add_sysfs(conn);
Marcel Holtmann732547f2009-04-19 19:14:14 +02002923 break;
2924
Stephen Coe705e5712010-02-16 11:29:44 -05002925 case 0x11: /* Unsupported Feature or Parameter Value */
Marcel Holtmann732547f2009-04-19 19:14:14 +02002926 case 0x1c: /* SCO interval rejected */
Nick Pelly1038a002010-02-03 11:42:26 -08002927 case 0x1a: /* Unsupported Remote Feature */
Marcel Holtmann732547f2009-04-19 19:14:14 +02002928 case 0x1f: /* Unspecified error */
2929 if (conn->out && conn->attempt < 2) {
Kun Han Kim15b911f2011-07-08 09:30:28 -07002930 if (!conn->hdev->is_wbs)
2931 conn->pkt_type =
2932 (hdev->esco_type & SCO_ESCO_MASK) |
Marcel Holtmann732547f2009-04-19 19:14:14 +02002933 (hdev->esco_type & EDR_ESCO_MASK);
2934 hci_setup_sync(conn, conn->link->handle);
2935 goto unlock;
2936 }
2937 /* fall through */
2938
2939 default:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002940 conn->state = BT_CLOSED;
Marcel Holtmann732547f2009-04-19 19:14:14 +02002941 break;
2942 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002943
2944 hci_proto_connect_cfm(conn, ev->status);
2945 if (ev->status)
2946 hci_conn_del(conn);
2947
2948unlock:
2949 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002950}
2951
2952static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
2953{
2954 BT_DBG("%s", hdev->name);
2955}
2956
Marcel Holtmann04837f62006-07-03 10:02:33 +02002957static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
2958{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002959 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
Srinivas Krovvidia7c3d7e2012-08-06 15:31:55 +05302960 struct hci_conn *conn =
2961 hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Marcel Holtmann04837f62006-07-03 10:02:33 +02002962
2963 BT_DBG("%s status %d", hdev->name, ev->status);
Srinivas Krovvidia7c3d7e2012-08-06 15:31:55 +05302964 if (conn && (ev->max_rx_latency > hdev->sniff_max_interval)) {
2965 BT_ERR("value of rx_latency:%d", ev->max_rx_latency);
2966 hci_dev_lock(hdev);
2967 hci_conn_enter_active_mode(conn, 1);
2968 hci_dev_unlock(hdev);
2969 }
Marcel Holtmann04837f62006-07-03 10:02:33 +02002970}
2971
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002972static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
2973{
2974 struct inquiry_data data;
2975 struct extended_inquiry_info *info = (void *) (skb->data + 1);
2976 int num_rsp = *((__u8 *) skb->data);
2977
2978 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2979
2980 if (!num_rsp)
2981 return;
2982
2983 hci_dev_lock(hdev);
2984
Johan Hedberge17acd42011-03-30 23:57:16 +03002985 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002986 bacpy(&data.bdaddr, &info->bdaddr);
Szymon Janc138d22e2011-02-17 16:44:23 +01002987 data.pscan_rep_mode = info->pscan_rep_mode;
2988 data.pscan_period_mode = info->pscan_period_mode;
2989 data.pscan_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002990 memcpy(data.dev_class, info->dev_class, 3);
Szymon Janc138d22e2011-02-17 16:44:23 +01002991 data.clock_offset = info->clock_offset;
2992 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002993 data.ssp_mode = 0x01;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002994 hci_inquiry_cache_update(hdev, &data);
Brian Gixa68668b2011-08-11 15:49:36 -07002995 mgmt_device_found(hdev->id, &info->bdaddr, 0, 0,
2996 info->dev_class, info->rssi,
2997 HCI_MAX_EIR_LENGTH, info->data);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002998 }
2999
3000 hci_dev_unlock(hdev);
3001}
3002
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003003static inline u8 hci_get_auth_req(struct hci_conn *conn)
3004{
Brian Gixa68668b2011-08-11 15:49:36 -07003005 BT_DBG("%p", conn);
3006
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003007 /* If remote requests dedicated bonding follow that lead */
3008 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) {
3009 /* If both remote and local IO capabilities allow MITM
3010 * protection then require it, otherwise don't */
Brian Gixa68668b2011-08-11 15:49:36 -07003011 if (conn->remote_cap == 0x03 || conn->io_capability == 0x03) {
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003012 return 0x02;
Brian Gixa68668b2011-08-11 15:49:36 -07003013 } else {
3014 conn->auth_type |= 0x01;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003015 return 0x03;
Brian Gixa68668b2011-08-11 15:49:36 -07003016 }
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003017 }
3018
3019 /* If remote requests no-bonding follow that lead */
Brian Gixa68668b2011-08-11 15:49:36 -07003020 if (conn->remote_auth <= 0x01)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003021 return 0x00;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003022
3023 return conn->auth_type;
3024}
3025
Marcel Holtmann04936842008-07-14 20:13:48 +02003026static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
3027{
3028 struct hci_ev_io_capa_request *ev = (void *) skb->data;
3029 struct hci_conn *conn;
3030
3031 BT_DBG("%s", hdev->name);
3032
3033 hci_dev_lock(hdev);
3034
3035 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003036 if (!conn)
3037 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02003038
Johan Hedberg03b555e2011-01-04 15:40:05 +02003039 hci_conn_hold(conn);
3040
3041 if (!test_bit(HCI_MGMT, &hdev->flags))
3042 goto unlock;
3043
3044 if (test_bit(HCI_PAIRABLE, &hdev->flags) ||
3045 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003046 struct hci_cp_io_capability_reply cp;
Brian Gixa68668b2011-08-11 15:49:36 -07003047 u8 io_cap = conn->io_capability;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003048
Brian Gixa68668b2011-08-11 15:49:36 -07003049 /* ACL-SSP does not support IO CAP 0x04 */
3050 cp.capability = (io_cap == 0x04) ? 0x01 : io_cap;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003051 bacpy(&cp.bdaddr, &ev->bdaddr);
Brian Gixa68668b2011-08-11 15:49:36 -07003052 if (conn->auth_initiator)
3053 cp.authentication = conn->auth_type;
3054 else
3055 cp.authentication = hci_get_auth_req(conn);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003056
Szymon Jancce85ee12011-03-22 13:12:23 +01003057 if ((conn->out == 0x01 || conn->remote_oob == 0x01) &&
3058 hci_find_remote_oob_data(hdev, &conn->dst))
3059 cp.oob_data = 0x01;
3060 else
3061 cp.oob_data = 0x00;
3062
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003063 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
3064 sizeof(cp), &cp);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003065 } else {
3066 struct hci_cp_io_capability_neg_reply cp;
3067
3068 bacpy(&cp.bdaddr, &ev->bdaddr);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003069 cp.reason = 0x16; /* Pairing not allowed */
Johan Hedberg03b555e2011-01-04 15:40:05 +02003070
3071 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
3072 sizeof(cp), &cp);
3073 }
3074
3075unlock:
3076 hci_dev_unlock(hdev);
3077}
3078
3079static inline void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
3080{
3081 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
3082 struct hci_conn *conn;
3083
3084 BT_DBG("%s", hdev->name);
3085
3086 hci_dev_lock(hdev);
3087
3088 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3089 if (!conn)
3090 goto unlock;
3091
Johan Hedberg03b555e2011-01-04 15:40:05 +02003092 conn->remote_cap = ev->capability;
3093 conn->remote_oob = ev->oob_data;
3094 conn->remote_auth = ev->authentication;
3095
3096unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02003097 hci_dev_unlock(hdev);
3098}
3099
Brian Gixa68668b2011-08-11 15:49:36 -07003100static inline void hci_user_ssp_confirmation_evt(struct hci_dev *hdev,
3101 u8 event, struct sk_buff *skb)
Johan Hedberga5c29682011-02-19 12:05:57 -03003102{
3103 struct hci_ev_user_confirm_req *ev = (void *) skb->data;
3104
3105 BT_DBG("%s", hdev->name);
3106
3107 hci_dev_lock(hdev);
3108
Brian Gixa68668b2011-08-11 15:49:36 -07003109 if (test_bit(HCI_MGMT, &hdev->flags)) {
3110 if (event == HCI_EV_USER_PASSKEY_REQUEST)
3111 mgmt_user_confirm_request(hdev->id, event,
3112 &ev->bdaddr, 0);
3113 else
3114 mgmt_user_confirm_request(hdev->id, event,
3115 &ev->bdaddr, ev->passkey);
3116 }
Johan Hedberga5c29682011-02-19 12:05:57 -03003117
3118 hci_dev_unlock(hdev);
3119}
3120
Marcel Holtmann04936842008-07-14 20:13:48 +02003121static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
3122{
3123 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
3124 struct hci_conn *conn;
3125
3126 BT_DBG("%s", hdev->name);
3127
3128 hci_dev_lock(hdev);
3129
3130 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg2a611692011-02-19 12:06:00 -03003131 if (!conn)
3132 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02003133
Johan Hedberg2a611692011-02-19 12:06:00 -03003134 /* To avoid duplicate auth_failed events to user space we check
3135 * the HCI_CONN_AUTH_PEND flag which will be set if we
3136 * initiated the authentication. A traditional auth_complete
3137 * event gets always produced as initiator and is also mapped to
3138 * the mgmt_auth_failed event */
3139 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->pend) && ev->status != 0)
3140 mgmt_auth_failed(hdev->id, &conn->dst, ev->status);
3141
3142 hci_conn_put(conn);
3143
3144unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02003145 hci_dev_unlock(hdev);
3146}
3147
Marcel Holtmann41a96212008-07-14 20:13:48 +02003148static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
3149{
3150 struct hci_ev_remote_host_features *ev = (void *) skb->data;
3151 struct inquiry_entry *ie;
3152
3153 BT_DBG("%s", hdev->name);
3154
3155 hci_dev_lock(hdev);
3156
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02003157 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
3158 if (ie)
Marcel Holtmann41a96212008-07-14 20:13:48 +02003159 ie->data.ssp_mode = (ev->features[0] & 0x01);
3160
3161 hci_dev_unlock(hdev);
3162}
3163
Szymon Janc2763eda2011-03-22 13:12:22 +01003164static inline void hci_remote_oob_data_request_evt(struct hci_dev *hdev,
3165 struct sk_buff *skb)
3166{
3167 struct hci_ev_remote_oob_data_request *ev = (void *) skb->data;
3168 struct oob_data *data;
3169
3170 BT_DBG("%s", hdev->name);
3171
3172 hci_dev_lock(hdev);
3173
Szymon Jance1ba1f12011-04-06 13:01:59 +02003174 if (!test_bit(HCI_MGMT, &hdev->flags))
3175 goto unlock;
3176
Szymon Janc2763eda2011-03-22 13:12:22 +01003177 data = hci_find_remote_oob_data(hdev, &ev->bdaddr);
3178 if (data) {
3179 struct hci_cp_remote_oob_data_reply cp;
3180
3181 bacpy(&cp.bdaddr, &ev->bdaddr);
3182 memcpy(cp.hash, data->hash, sizeof(cp.hash));
3183 memcpy(cp.randomizer, data->randomizer, sizeof(cp.randomizer));
3184
3185 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY, sizeof(cp),
3186 &cp);
3187 } else {
3188 struct hci_cp_remote_oob_data_neg_reply cp;
3189
3190 bacpy(&cp.bdaddr, &ev->bdaddr);
3191 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY, sizeof(cp),
3192 &cp);
3193 }
3194
Szymon Jance1ba1f12011-04-06 13:01:59 +02003195unlock:
Szymon Janc2763eda2011-03-22 13:12:22 +01003196 hci_dev_unlock(hdev);
3197}
3198
Ville Tervofcd89c02011-02-10 22:38:47 -03003199static inline void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
3200{
3201 struct hci_ev_le_conn_complete *ev = (void *) skb->data;
3202 struct hci_conn *conn;
Sunny Kapdi93bef892012-07-30 14:52:56 -07003203 u8 white_list;
Ville Tervofcd89c02011-02-10 22:38:47 -03003204
3205 BT_DBG("%s status %d", hdev->name, ev->status);
3206
3207 hci_dev_lock(hdev);
3208
Sunny Kapdi93bef892012-07-30 14:52:56 -07003209 /* Ignore event for LE cancel create conn whitelist */
3210 if (ev->status && !bacmp(&ev->bdaddr, BDADDR_ANY))
3211 goto unlock;
3212
3213 if (hci_conn_hash_lookup_ba(hdev, LE_LINK, BDADDR_ANY))
3214 white_list = 1;
3215 else
3216 white_list = 0;
3217
3218 BT_DBG("w_list %d", white_list);
3219
Ville Tervofcd89c02011-02-10 22:38:47 -03003220 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &ev->bdaddr);
Ville Tervob62f3282011-02-10 22:38:50 -03003221 if (!conn) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003222 conn = hci_le_conn_add(hdev, &ev->bdaddr, ev->bdaddr_type);
Ville Tervob62f3282011-02-10 22:38:50 -03003223 if (!conn) {
3224 BT_ERR("No memory for new connection");
3225 hci_dev_unlock(hdev);
3226 return;
3227 }
3228 }
Ville Tervofcd89c02011-02-10 22:38:47 -03003229
3230 if (ev->status) {
3231 hci_proto_connect_cfm(conn, ev->status);
3232 conn->state = BT_CLOSED;
3233 hci_conn_del(conn);
3234 goto unlock;
3235 }
3236
Vinicius Costa Gomes403d2c82011-06-09 18:50:50 -03003237 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -03003238 conn->handle = __le16_to_cpu(ev->handle);
3239 conn->state = BT_CONNECTED;
Brian Gixa68668b2011-08-11 15:49:36 -07003240 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Brian Gix2e2f50d2011-09-13 12:36:04 -07003241 mgmt_connected(hdev->id, &ev->bdaddr, 1);
Sunny Kapdia42b5022012-07-05 22:48:31 -07003242 mgmt_le_conn_params(hdev->id, &ev->bdaddr,
3243 __le16_to_cpu(ev->interval),
3244 __le16_to_cpu(ev->latency),
3245 __le16_to_cpu(ev->supervision_timeout));
Ville Tervofcd89c02011-02-10 22:38:47 -03003246
Brian Gix6d5fb8a2011-09-09 14:53:04 -07003247 hci_conn_hold(conn);
Ville Tervofcd89c02011-02-10 22:38:47 -03003248 hci_conn_hold_device(conn);
3249 hci_conn_add_sysfs(conn);
3250
Sunny Kapdi93bef892012-07-30 14:52:56 -07003251 if (!white_list)
3252 hci_proto_connect_cfm(conn, ev->status);
Ville Tervofcd89c02011-02-10 22:38:47 -03003253
3254unlock:
3255 hci_dev_unlock(hdev);
3256}
3257
Sunny Kapdia42b5022012-07-05 22:48:31 -07003258static inline void hci_le_conn_update_complete_evt(struct hci_dev *hdev,
3259 struct sk_buff *skb)
3260{
3261 struct hci_ev_le_conn_update_complete *ev = (void *) skb->data;
3262 struct hci_conn *conn;
3263
3264 BT_DBG("%s status %d", hdev->name, ev->status);
3265
3266 hci_dev_lock(hdev);
3267
3268 conn = hci_conn_hash_lookup_handle(hdev,
3269 __le16_to_cpu(ev->handle));
3270 if (conn == NULL) {
3271 BT_ERR("Unknown connection update");
3272 goto unlock;
3273 }
3274
3275 if (ev->status) {
3276 BT_ERR("Connection update unsuccessful");
3277 goto unlock;
3278 }
3279
3280 mgmt_le_conn_params(hdev->id, &conn->dst,
3281 __le16_to_cpu(ev->interval),
3282 __le16_to_cpu(ev->latency),
3283 __le16_to_cpu(ev->supervision_timeout));
3284
3285unlock:
3286 hci_dev_unlock(hdev);
3287}
3288
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003289static inline void hci_le_ltk_request_evt(struct hci_dev *hdev,
3290 struct sk_buff *skb)
3291{
3292 struct hci_ev_le_ltk_req *ev = (void *) skb->data;
3293 struct hci_cp_le_ltk_reply cp;
Vinicius Costa Gomes60e56472011-07-07 18:59:37 -03003294 struct hci_cp_le_ltk_neg_reply neg;
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003295 struct hci_conn *conn;
Vinicius Costa Gomes60e56472011-07-07 18:59:37 -03003296 struct link_key *ltk;
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003297
3298 BT_DBG("%s handle %d", hdev->name, cpu_to_le16(ev->handle));
3299
3300 hci_dev_lock(hdev);
3301
3302 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Vinicius Costa Gomes60e56472011-07-07 18:59:37 -03003303 if (conn == NULL)
3304 goto not_found;
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003305
Vinicius Costa Gomes60e56472011-07-07 18:59:37 -03003306 ltk = hci_find_ltk(hdev, ev->ediv, ev->random);
3307 if (ltk == NULL)
3308 goto not_found;
3309
3310 memcpy(cp.ltk, ltk->val, sizeof(ltk->val));
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003311 cp.handle = cpu_to_le16(conn->handle);
Vinicius Costa Gomes1fa2de32011-07-08 18:31:45 -03003312 conn->pin_length = ltk->pin_len;
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003313
3314 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
3315
3316 hci_dev_unlock(hdev);
Vinicius Costa Gomes60e56472011-07-07 18:59:37 -03003317
3318 return;
3319
3320not_found:
3321 neg.handle = ev->handle;
3322 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(neg), &neg);
3323 hci_dev_unlock(hdev);
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003324}
3325
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003326static inline void hci_le_adv_report_evt(struct hci_dev *hdev,
3327 struct sk_buff *skb)
3328{
3329 struct hci_ev_le_advertising_info *ev;
3330 u8 num_reports;
3331
3332 num_reports = skb->data[0];
3333 ev = (void *) &skb->data[1];
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003334
Brian Gix3dd70172011-09-16 21:38:54 -07003335 hci_dev_lock(hdev);
3336
Brian Gixa68668b2011-08-11 15:49:36 -07003337 while (num_reports--) {
3338 mgmt_device_found(hdev->id, &ev->bdaddr, ev->bdaddr_type,
3339 1, NULL, 0, ev->length, ev->data);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003340 hci_add_adv_entry(hdev, ev);
Brian Gixa68668b2011-08-11 15:49:36 -07003341 ev = (void *) (ev->data + ev->length + 1);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003342 }
Brian Gix3dd70172011-09-16 21:38:54 -07003343
3344 hci_dev_unlock(hdev);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003345}
3346
Ville Tervofcd89c02011-02-10 22:38:47 -03003347static inline void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
3348{
3349 struct hci_ev_le_meta *le_ev = (void *) skb->data;
3350
3351 skb_pull(skb, sizeof(*le_ev));
3352
3353 switch (le_ev->subevent) {
3354 case HCI_EV_LE_CONN_COMPLETE:
3355 hci_le_conn_complete_evt(hdev, skb);
3356 break;
3357
Sunny Kapdia42b5022012-07-05 22:48:31 -07003358 case HCI_EV_LE_CONN_UPDATE_COMPLETE:
3359 hci_le_conn_update_complete_evt(hdev, skb);
3360 break;
3361
Vinicius Costa Gomes735038c2011-06-09 18:50:47 -03003362 case HCI_EV_LE_LTK_REQ:
3363 hci_le_ltk_request_evt(hdev, skb);
3364 break;
3365
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003366 case HCI_EV_LE_ADVERTISING_REPORT:
3367 hci_le_adv_report_evt(hdev, skb);
3368 break;
3369
Ville Tervofcd89c02011-02-10 22:38:47 -03003370 default:
3371 break;
3372 }
3373}
3374
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003375static inline void hci_phy_link_complete(struct hci_dev *hdev,
3376 struct sk_buff *skb)
3377{
3378 struct hci_ev_phys_link_complete *ev = (void *) skb->data;
3379 struct hci_conn *conn;
3380
3381 BT_DBG("%s handle %d status %d", hdev->name, ev->phy_handle,
3382 ev->status);
3383
3384 hci_dev_lock(hdev);
3385
3386 if (ev->status == 0) {
3387 conn = hci_conn_add(hdev, ACL_LINK, 0, BDADDR_ANY);
3388 if (conn) {
3389 conn->handle = ev->phy_handle;
3390 conn->state = BT_CONNECTED;
3391
3392 hci_conn_hold(conn);
3393 conn->disc_timeout = HCI_DISCONN_TIMEOUT/2;
3394 hci_conn_put(conn);
3395
3396 hci_conn_hold_device(conn);
3397 hci_conn_add_sysfs(conn);
3398 } else
3399 BT_ERR("No memory for new connection");
3400 }
3401
3402 hci_dev_unlock(hdev);
3403}
3404
3405static inline void hci_log_link_complete(struct hci_dev *hdev,
3406 struct sk_buff *skb)
3407{
3408 struct hci_ev_log_link_complete *ev = (void *) skb->data;
3409 struct hci_chan *chan;
3410
3411 BT_DBG("%s handle %d status %d", hdev->name,
3412 __le16_to_cpu(ev->log_handle), ev->status);
3413
3414 hci_dev_lock(hdev);
3415
3416 chan = hci_chan_list_lookup_id(hdev, ev->phy_handle);
3417
Mat Martineau9f8d4672011-12-14 12:10:46 -08003418 if (chan) {
3419 if (ev->status == 0) {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003420 chan->ll_handle = __le16_to_cpu(ev->log_handle);
3421 chan->state = BT_CONNECTED;
Mat Martineau9f8d4672011-12-14 12:10:46 -08003422 } else {
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003423 chan->state = BT_CLOSED;
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003424 }
Mat Martineau9f8d4672011-12-14 12:10:46 -08003425
3426 hci_proto_create_cfm(chan, ev->status);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003427 }
3428
3429 hci_dev_unlock(hdev);
3430}
3431
3432static inline void hci_flow_spec_modify_complete(struct hci_dev *hdev,
3433 struct sk_buff *skb)
3434{
3435 struct hci_ev_flow_spec_modify_complete *ev = (void *) skb->data;
3436 struct hci_chan *chan;
3437
3438 BT_DBG("%s handle %d status %d", hdev->name,
3439 __le16_to_cpu(ev->log_handle), ev->status);
3440
3441 hci_dev_lock(hdev);
3442
3443 chan = hci_chan_list_lookup_handle(hdev, ev->log_handle);
3444 if (chan)
3445 hci_proto_modify_cfm(chan, ev->status);
3446
3447 hci_dev_unlock(hdev);
3448}
3449
3450static inline void hci_disconn_log_link_complete_evt(struct hci_dev *hdev,
3451 struct sk_buff *skb)
3452{
3453 struct hci_ev_disconn_log_link_complete *ev = (void *) skb->data;
3454 struct hci_chan *chan;
3455
3456 BT_DBG("%s handle %d status %d", hdev->name,
3457 __le16_to_cpu(ev->log_handle), ev->status);
3458
3459 if (ev->status)
3460 return;
3461
3462 hci_dev_lock(hdev);
3463
3464 chan = hci_chan_list_lookup_handle(hdev, __le16_to_cpu(ev->log_handle));
Mat Martineau9f8d4672011-12-14 12:10:46 -08003465 if (chan)
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003466 hci_proto_destroy_cfm(chan, ev->reason);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003467
3468 hci_dev_unlock(hdev);
3469}
3470
3471static inline void hci_disconn_phy_link_complete_evt(struct hci_dev *hdev,
3472 struct sk_buff *skb)
3473{
3474 struct hci_ev_disconn_phys_link_complete *ev = (void *) skb->data;
3475 struct hci_conn *conn;
3476
3477 BT_DBG("%s status %d", hdev->name, ev->status);
3478
3479 if (ev->status)
3480 return;
3481
3482 hci_dev_lock(hdev);
3483
3484 conn = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3485 if (conn) {
3486 conn->state = BT_CLOSED;
3487
Mat Martineau3b9239a2012-02-16 11:54:30 -08003488 hci_proto_disconn_cfm(conn, ev->reason, 0);
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003489 hci_conn_del(conn);
3490 }
3491
3492 hci_dev_unlock(hdev);
3493}
3494
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
3496{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003497 struct hci_event_hdr *hdr = (void *) skb->data;
3498 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499
Brian Gixdfdd9362011-08-18 09:58:02 -07003500 BT_DBG("");
3501
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502 skb_pull(skb, HCI_EVENT_HDR_SIZE);
3503
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003504 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 case HCI_EV_INQUIRY_COMPLETE:
3506 hci_inquiry_complete_evt(hdev, skb);
3507 break;
3508
3509 case HCI_EV_INQUIRY_RESULT:
3510 hci_inquiry_result_evt(hdev, skb);
3511 break;
3512
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003513 case HCI_EV_CONN_COMPLETE:
3514 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02003515 break;
3516
Linus Torvalds1da177e2005-04-16 15:20:36 -07003517 case HCI_EV_CONN_REQUEST:
3518 hci_conn_request_evt(hdev, skb);
3519 break;
3520
Linus Torvalds1da177e2005-04-16 15:20:36 -07003521 case HCI_EV_DISCONN_COMPLETE:
3522 hci_disconn_complete_evt(hdev, skb);
3523 break;
3524
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525 case HCI_EV_AUTH_COMPLETE:
3526 hci_auth_complete_evt(hdev, skb);
3527 break;
3528
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003529 case HCI_EV_REMOTE_NAME:
3530 hci_remote_name_evt(hdev, skb);
3531 break;
3532
Linus Torvalds1da177e2005-04-16 15:20:36 -07003533 case HCI_EV_ENCRYPT_CHANGE:
3534 hci_encrypt_change_evt(hdev, skb);
3535 break;
3536
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003537 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
3538 hci_change_link_key_complete_evt(hdev, skb);
3539 break;
3540
3541 case HCI_EV_REMOTE_FEATURES:
3542 hci_remote_features_evt(hdev, skb);
3543 break;
3544
3545 case HCI_EV_REMOTE_VERSION:
3546 hci_remote_version_evt(hdev, skb);
3547 break;
3548
3549 case HCI_EV_QOS_SETUP_COMPLETE:
3550 hci_qos_setup_complete_evt(hdev, skb);
3551 break;
3552
3553 case HCI_EV_CMD_COMPLETE:
3554 hci_cmd_complete_evt(hdev, skb);
3555 break;
3556
3557 case HCI_EV_CMD_STATUS:
3558 hci_cmd_status_evt(hdev, skb);
3559 break;
3560
3561 case HCI_EV_ROLE_CHANGE:
3562 hci_role_change_evt(hdev, skb);
3563 break;
3564
3565 case HCI_EV_NUM_COMP_PKTS:
3566 hci_num_comp_pkts_evt(hdev, skb);
3567 break;
3568
3569 case HCI_EV_MODE_CHANGE:
3570 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571 break;
3572
3573 case HCI_EV_PIN_CODE_REQ:
3574 hci_pin_code_request_evt(hdev, skb);
3575 break;
3576
3577 case HCI_EV_LINK_KEY_REQ:
3578 hci_link_key_request_evt(hdev, skb);
3579 break;
3580
3581 case HCI_EV_LINK_KEY_NOTIFY:
3582 hci_link_key_notify_evt(hdev, skb);
3583 break;
3584
3585 case HCI_EV_CLOCK_OFFSET:
3586 hci_clock_offset_evt(hdev, skb);
3587 break;
3588
Marcel Holtmanna8746412008-07-14 20:13:46 +02003589 case HCI_EV_PKT_TYPE_CHANGE:
3590 hci_pkt_type_change_evt(hdev, skb);
3591 break;
3592
Marcel Holtmann85a1e932005-08-09 20:28:02 -07003593 case HCI_EV_PSCAN_REP_MODE:
3594 hci_pscan_rep_mode_evt(hdev, skb);
3595 break;
3596
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003597 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
3598 hci_inquiry_result_with_rssi_evt(hdev, skb);
3599 break;
3600
3601 case HCI_EV_REMOTE_EXT_FEATURES:
3602 hci_remote_ext_features_evt(hdev, skb);
3603 break;
3604
3605 case HCI_EV_SYNC_CONN_COMPLETE:
3606 hci_sync_conn_complete_evt(hdev, skb);
3607 break;
3608
3609 case HCI_EV_SYNC_CONN_CHANGED:
3610 hci_sync_conn_changed_evt(hdev, skb);
3611 break;
3612
Marcel Holtmann04837f62006-07-03 10:02:33 +02003613 case HCI_EV_SNIFF_SUBRATE:
3614 hci_sniff_subrate_evt(hdev, skb);
3615 break;
3616
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003617 case HCI_EV_EXTENDED_INQUIRY_RESULT:
3618 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619 break;
3620
Marcel Holtmann04936842008-07-14 20:13:48 +02003621 case HCI_EV_IO_CAPA_REQUEST:
3622 hci_io_capa_request_evt(hdev, skb);
3623 break;
3624
Johan Hedberg03b555e2011-01-04 15:40:05 +02003625 case HCI_EV_IO_CAPA_REPLY:
3626 hci_io_capa_reply_evt(hdev, skb);
3627 break;
3628
Brian Gixa68668b2011-08-11 15:49:36 -07003629 case HCI_EV_USER_PASSKEY_REQUEST:
3630 case HCI_EV_USER_PASSKEY_NOTIFICATION:
Johan Hedberga5c29682011-02-19 12:05:57 -03003631 case HCI_EV_USER_CONFIRM_REQUEST:
Brian Gixa68668b2011-08-11 15:49:36 -07003632 hci_user_ssp_confirmation_evt(hdev, event, skb);
Johan Hedberga5c29682011-02-19 12:05:57 -03003633 break;
3634
Marcel Holtmann04936842008-07-14 20:13:48 +02003635 case HCI_EV_SIMPLE_PAIR_COMPLETE:
3636 hci_simple_pair_complete_evt(hdev, skb);
3637 break;
3638
Marcel Holtmann41a96212008-07-14 20:13:48 +02003639 case HCI_EV_REMOTE_HOST_FEATURES:
3640 hci_remote_host_features_evt(hdev, skb);
3641 break;
3642
Ville Tervofcd89c02011-02-10 22:38:47 -03003643 case HCI_EV_LE_META:
3644 hci_le_meta_evt(hdev, skb);
3645 break;
3646
Szymon Janc2763eda2011-03-22 13:12:22 +01003647 case HCI_EV_REMOTE_OOB_DATA_REQUEST:
3648 hci_remote_oob_data_request_evt(hdev, skb);
3649 break;
3650
Bryan Huntsman3f2bc4d2011-08-16 17:27:22 -07003651 case HCI_EV_PHYS_LINK_COMPLETE:
3652 hci_phy_link_complete(hdev, skb);
3653 hci_amp_event_packet(hdev, event, skb);
3654 break;
3655
3656 case HCI_EV_LOG_LINK_COMPLETE:
3657 hci_log_link_complete(hdev, skb);
3658 break;
3659
3660 case HCI_EV_FLOW_SPEC_MODIFY_COMPLETE:
3661 hci_flow_spec_modify_complete(hdev, skb);
3662 break;
3663
3664 case HCI_EV_DISCONN_LOG_LINK_COMPLETE:
3665 hci_disconn_log_link_complete_evt(hdev, skb);
3666 break;
3667
3668 case HCI_EV_DISCONN_PHYS_LINK_COMPLETE:
3669 hci_disconn_phy_link_complete_evt(hdev, skb);
3670 hci_amp_event_packet(hdev, event, skb);
3671 break;
3672
3673 case HCI_EV_NUM_COMP_BLOCKS:
3674 hci_num_comp_blocks_evt(hdev, skb);
3675 break;
3676
3677 case HCI_EV_CHANNEL_SELECTED:
3678 hci_amp_event_packet(hdev, event, skb);
3679 break;
3680
3681 case HCI_EV_AMP_STATUS_CHANGE:
3682 hci_amp_event_packet(hdev, event, skb);
3683 break;
3684
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003685 default:
3686 BT_DBG("%s event 0x%x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003687 break;
3688 }
3689
3690 kfree_skb(skb);
3691 hdev->stat.evt_rx++;
3692}
3693
3694/* Generate internal stack event */
3695void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
3696{
3697 struct hci_event_hdr *hdr;
3698 struct hci_ev_stack_internal *ev;
3699 struct sk_buff *skb;
3700
3701 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
3702 if (!skb)
3703 return;
3704
3705 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
3706 hdr->evt = HCI_EV_STACK_INTERNAL;
3707 hdr->plen = sizeof(*ev) + dlen;
3708
3709 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
3710 ev->type = type;
3711 memcpy(ev->data, data, dlen);
3712
Marcel Holtmann576c7d82005-08-06 12:36:54 +02003713 bt_cb(skb)->incoming = 1;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07003714 __net_timestamp(skb);
Marcel Holtmann576c7d82005-08-06 12:36:54 +02003715
Marcel Holtmann0d48d932005-08-09 20:30:28 -07003716 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003717 skb->dev = (void *) hdev;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003718 hci_send_to_sock(hdev, skb, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003719 kfree_skb(skb);
3720}