blob: b4e7cde353658af7dacead300635b0fb44618b75 [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
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
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 core. */
26
S.Çağlar Onur824530212008-02-17 23:25:57 -080027#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/module.h>
29#include <linux/kmod.h>
30
31#include <linux/types.h>
32#include <linux/errno.h>
33#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/sched.h>
35#include <linux/slab.h>
36#include <linux/poll.h>
37#include <linux/fcntl.h>
38#include <linux/init.h>
39#include <linux/skbuff.h>
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +010040#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/interrupt.h>
42#include <linux/notifier.h>
Marcel Holtmann611b30f2009-06-08 14:41:38 +020043#include <linux/rfkill.h>
Ville Tervo6bd32322011-02-16 16:32:41 +020044#include <linux/timer.h>
Vinicius Costa Gomes3a0259b2011-06-09 18:50:43 -030045#include <linux/crypto.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <net/sock.h>
47
48#include <asm/system.h>
Andrei Emeltchenko70f230202010-12-01 16:58:25 +020049#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <asm/unaligned.h>
51
52#include <net/bluetooth/bluetooth.h>
53#include <net/bluetooth/hci_core.h>
54
Johan Hedbergab81cbf2010-12-15 13:53:18 +020055#define AUTO_OFF_TIMEOUT 2000
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static void hci_cmd_task(unsigned long arg);
58static void hci_rx_task(unsigned long arg);
59static void hci_tx_task(unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61static DEFINE_RWLOCK(hci_task_lock);
62
63/* HCI device list */
64LIST_HEAD(hci_dev_list);
65DEFINE_RWLOCK(hci_dev_list_lock);
66
67/* HCI callback list */
68LIST_HEAD(hci_cb_list);
69DEFINE_RWLOCK(hci_cb_list_lock);
70
71/* HCI protocols */
72#define HCI_MAX_PROTO 2
73struct hci_proto *hci_proto[HCI_MAX_PROTO];
74
75/* HCI notifiers list */
Alan Sterne041c682006-03-27 01:16:30 -080076static ATOMIC_NOTIFIER_HEAD(hci_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78/* ---- HCI notifications ---- */
79
80int hci_register_notifier(struct notifier_block *nb)
81{
Alan Sterne041c682006-03-27 01:16:30 -080082 return atomic_notifier_chain_register(&hci_notifier, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083}
84
85int hci_unregister_notifier(struct notifier_block *nb)
86{
Alan Sterne041c682006-03-27 01:16:30 -080087 return atomic_notifier_chain_unregister(&hci_notifier, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088}
89
Marcel Holtmann65164552005-10-28 19:20:48 +020090static void hci_notify(struct hci_dev *hdev, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Alan Sterne041c682006-03-27 01:16:30 -080092 atomic_notifier_call_chain(&hci_notifier, event, hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94
95/* ---- HCI requests ---- */
96
Johan Hedberg23bb5762010-12-21 23:01:27 +020097void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Johan Hedberg23bb5762010-12-21 23:01:27 +020099 BT_DBG("%s command 0x%04x result 0x%2.2x", hdev->name, cmd, result);
100
Johan Hedberga5040ef2011-01-10 13:28:59 +0200101 /* If this is the init phase check if the completed command matches
102 * the last init command, and if not just return.
103 */
104 if (test_bit(HCI_INIT, &hdev->flags) && hdev->init_last_cmd != cmd)
Johan Hedberg23bb5762010-12-21 23:01:27 +0200105 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107 if (hdev->req_status == HCI_REQ_PEND) {
108 hdev->req_result = result;
109 hdev->req_status = HCI_REQ_DONE;
110 wake_up_interruptible(&hdev->req_wait_q);
111 }
112}
113
114static void hci_req_cancel(struct hci_dev *hdev, int err)
115{
116 BT_DBG("%s err 0x%2.2x", hdev->name, err);
117
118 if (hdev->req_status == HCI_REQ_PEND) {
119 hdev->req_result = err;
120 hdev->req_status = HCI_REQ_CANCELED;
121 wake_up_interruptible(&hdev->req_wait_q);
122 }
123}
124
125/* Execute request and wait for completion. */
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900126static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt),
Szymon Janc01df8c32011-02-17 16:46:47 +0100127 unsigned long opt, __u32 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
129 DECLARE_WAITQUEUE(wait, current);
130 int err = 0;
131
132 BT_DBG("%s start", hdev->name);
133
134 hdev->req_status = HCI_REQ_PEND;
135
136 add_wait_queue(&hdev->req_wait_q, &wait);
137 set_current_state(TASK_INTERRUPTIBLE);
138
139 req(hdev, opt);
140 schedule_timeout(timeout);
141
142 remove_wait_queue(&hdev->req_wait_q, &wait);
143
144 if (signal_pending(current))
145 return -EINTR;
146
147 switch (hdev->req_status) {
148 case HCI_REQ_DONE:
Joe Perchese1750722011-06-29 18:18:29 -0700149 err = -bt_to_errno(hdev->req_result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 break;
151
152 case HCI_REQ_CANCELED:
153 err = -hdev->req_result;
154 break;
155
156 default:
157 err = -ETIMEDOUT;
158 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700159 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Johan Hedberga5040ef2011-01-10 13:28:59 +0200161 hdev->req_status = hdev->req_result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163 BT_DBG("%s end: err %d", hdev->name, err);
164
165 return err;
166}
167
168static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt),
Szymon Janc01df8c32011-02-17 16:46:47 +0100169 unsigned long opt, __u32 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
171 int ret;
172
Marcel Holtmann7c6a3292008-09-12 03:11:54 +0200173 if (!test_bit(HCI_UP, &hdev->flags))
174 return -ENETDOWN;
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 /* Serialize all requests */
177 hci_req_lock(hdev);
178 ret = __hci_request(hdev, req, opt, timeout);
179 hci_req_unlock(hdev);
180
181 return ret;
182}
183
184static void hci_reset_req(struct hci_dev *hdev, unsigned long opt)
185{
186 BT_DBG("%s %ld", hdev->name, opt);
187
188 /* Reset device */
Gustavo F. Padovanf630cf02011-03-16 15:36:29 -0300189 set_bit(HCI_RESET, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200190 hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191}
192
193static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
194{
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200195 struct hci_cp_delete_stored_link_key cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 struct sk_buff *skb;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -0800197 __le16 param;
Marcel Holtmann89f27832007-09-09 08:39:49 +0200198 __u8 flt_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
200 BT_DBG("%s %ld", hdev->name, opt);
201
202 /* Driver initialization */
203
204 /* Special commands */
205 while ((skb = skb_dequeue(&hdev->driver_init))) {
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700206 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 skb->dev = (void *) hdev;
Marcel Holtmannc78ae282009-11-18 01:02:54 +0100208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 skb_queue_tail(&hdev->cmd_q, skb);
Marcel Holtmannc78ae282009-11-18 01:02:54 +0100210 tasklet_schedule(&hdev->cmd_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 }
212 skb_queue_purge(&hdev->driver_init);
213
214 /* Mandatory initialization */
215
216 /* Reset */
Gustavo F. Padovanf630cf02011-03-16 15:36:29 -0300217 if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) {
218 set_bit(HCI_RESET, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200219 hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
Gustavo F. Padovanf630cf02011-03-16 15:36:29 -0300220 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 /* Read Local Supported Features */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200223 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Marcel Holtmann1143e5a2006-09-23 09:57:20 +0200225 /* Read Local Version */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200226 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL);
Marcel Holtmann1143e5a2006-09-23 09:57:20 +0200227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 /* Read Buffer Size (ACL mtu, max pkt, etc.) */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200229 hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231#if 0
232 /* Host buffer size */
233 {
234 struct hci_cp_host_buffer_size cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700235 cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 cp.sco_mtu = HCI_MAX_SCO_SIZE;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700237 cp.acl_max_pkt = cpu_to_le16(0xffff);
238 cp.sco_max_pkt = cpu_to_le16(0xffff);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200239 hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 }
241#endif
242
243 /* Read BD Address */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200244 hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL);
245
246 /* Read Class of Device */
247 hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL);
248
249 /* Read Local Name */
250 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
252 /* Read Voice Setting */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200253 hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255 /* Optional initialization */
256
257 /* Clear Event Filters */
Marcel Holtmann89f27832007-09-09 08:39:49 +0200258 flt_type = HCI_FLT_CLEAR_ALL;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200259 hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 /* Connection accept timeout ~20 secs */
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700262 param = cpu_to_le16(0x7d00);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200263 hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, &param);
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200264
265 bacpy(&cp.bdaddr, BDADDR_ANY);
266 cp.delete_all = 1;
267 hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300270static void hci_le_init_req(struct hci_dev *hdev, unsigned long opt)
271{
272 BT_DBG("%s", hdev->name);
273
274 /* Read LE buffer size */
275 hci_send_cmd(hdev, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL);
276}
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278static void hci_scan_req(struct hci_dev *hdev, unsigned long opt)
279{
280 __u8 scan = opt;
281
282 BT_DBG("%s %x", hdev->name, scan);
283
284 /* Inquiry and Page scans */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200285 hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286}
287
288static void hci_auth_req(struct hci_dev *hdev, unsigned long opt)
289{
290 __u8 auth = opt;
291
292 BT_DBG("%s %x", hdev->name, auth);
293
294 /* Authentication */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200295 hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
298static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt)
299{
300 __u8 encrypt = opt;
301
302 BT_DBG("%s %x", hdev->name, encrypt);
303
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200304 /* Encryption */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200305 hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306}
307
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200308static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt)
309{
310 __le16 policy = cpu_to_le16(opt);
311
Marcel Holtmanna418b892008-11-30 12:17:28 +0100312 BT_DBG("%s %x", hdev->name, policy);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200313
314 /* Default link policy */
315 hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy);
316}
317
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900318/* Get HCI device by index.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 * Device is held on return. */
320struct hci_dev *hci_dev_get(int index)
321{
322 struct hci_dev *hdev = NULL;
323 struct list_head *p;
324
325 BT_DBG("%d", index);
326
327 if (index < 0)
328 return NULL;
329
330 read_lock(&hci_dev_list_lock);
331 list_for_each(p, &hci_dev_list) {
332 struct hci_dev *d = list_entry(p, struct hci_dev, list);
333 if (d->id == index) {
334 hdev = hci_dev_hold(d);
335 break;
336 }
337 }
338 read_unlock(&hci_dev_list_lock);
339 return hdev;
340}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342/* ---- Inquiry support ---- */
343static void inquiry_cache_flush(struct hci_dev *hdev)
344{
345 struct inquiry_cache *cache = &hdev->inq_cache;
346 struct inquiry_entry *next = cache->list, *e;
347
348 BT_DBG("cache %p", cache);
349
350 cache->list = NULL;
351 while ((e = next)) {
352 next = e->next;
353 kfree(e);
354 }
355}
356
357struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr)
358{
359 struct inquiry_cache *cache = &hdev->inq_cache;
360 struct inquiry_entry *e;
361
362 BT_DBG("cache %p, %s", cache, batostr(bdaddr));
363
364 for (e = cache->list; e; e = e->next)
365 if (!bacmp(&e->data.bdaddr, bdaddr))
366 break;
367 return e;
368}
369
370void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data)
371{
372 struct inquiry_cache *cache = &hdev->inq_cache;
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200373 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr));
376
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200377 ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr);
378 if (!ie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 /* Entry not in the cache. Add new one. */
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200380 ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC);
381 if (!ie)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 return;
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200383
384 ie->next = cache->list;
385 cache->list = ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 }
387
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200388 memcpy(&ie->data, data, sizeof(*data));
389 ie->timestamp = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 cache->timestamp = jiffies;
391}
392
393static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf)
394{
395 struct inquiry_cache *cache = &hdev->inq_cache;
396 struct inquiry_info *info = (struct inquiry_info *) buf;
397 struct inquiry_entry *e;
398 int copied = 0;
399
400 for (e = cache->list; e && copied < num; e = e->next, copied++) {
401 struct inquiry_data *data = &e->data;
402 bacpy(&info->bdaddr, &data->bdaddr);
403 info->pscan_rep_mode = data->pscan_rep_mode;
404 info->pscan_period_mode = data->pscan_period_mode;
405 info->pscan_mode = data->pscan_mode;
406 memcpy(info->dev_class, data->dev_class, 3);
407 info->clock_offset = data->clock_offset;
408 info++;
409 }
410
411 BT_DBG("cache %p, copied %d", cache, copied);
412 return copied;
413}
414
415static void hci_inq_req(struct hci_dev *hdev, unsigned long opt)
416{
417 struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt;
418 struct hci_cp_inquiry cp;
419
420 BT_DBG("%s", hdev->name);
421
422 if (test_bit(HCI_INQUIRY, &hdev->flags))
423 return;
424
425 /* Start Inquiry */
426 memcpy(&cp.lap, &ir->lap, 3);
427 cp.length = ir->length;
428 cp.num_rsp = ir->num_rsp;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200429 hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430}
431
432int hci_inquiry(void __user *arg)
433{
434 __u8 __user *ptr = arg;
435 struct hci_inquiry_req ir;
436 struct hci_dev *hdev;
437 int err = 0, do_inquiry = 0, max_rsp;
438 long timeo;
439 __u8 *buf;
440
441 if (copy_from_user(&ir, ptr, sizeof(ir)))
442 return -EFAULT;
443
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200444 hdev = hci_dev_get(ir.dev_id);
445 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 return -ENODEV;
447
448 hci_dev_lock_bh(hdev);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900449 if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX ||
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200450 inquiry_cache_empty(hdev) ||
451 ir.flags & IREQ_CACHE_FLUSH) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 inquiry_cache_flush(hdev);
453 do_inquiry = 1;
454 }
455 hci_dev_unlock_bh(hdev);
456
Marcel Holtmann04837f62006-07-03 10:02:33 +0200457 timeo = ir.length * msecs_to_jiffies(2000);
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200458
459 if (do_inquiry) {
460 err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo);
461 if (err < 0)
462 goto done;
463 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465 /* for unlimited number of responses we will use buffer with 255 entries */
466 max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp;
467
468 /* cache_dump can't sleep. Therefore we allocate temp buffer and then
469 * copy it to the user space.
470 */
Szymon Janc01df8c32011-02-17 16:46:47 +0100471 buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL);
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200472 if (!buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 err = -ENOMEM;
474 goto done;
475 }
476
477 hci_dev_lock_bh(hdev);
478 ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf);
479 hci_dev_unlock_bh(hdev);
480
481 BT_DBG("num_rsp %d", ir.num_rsp);
482
483 if (!copy_to_user(ptr, &ir, sizeof(ir))) {
484 ptr += sizeof(ir);
485 if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) *
486 ir.num_rsp))
487 err = -EFAULT;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900488 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 err = -EFAULT;
490
491 kfree(buf);
492
493done:
494 hci_dev_put(hdev);
495 return err;
496}
497
498/* ---- HCI ioctl helpers ---- */
499
500int hci_dev_open(__u16 dev)
501{
502 struct hci_dev *hdev;
503 int ret = 0;
504
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200505 hdev = hci_dev_get(dev);
506 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 return -ENODEV;
508
509 BT_DBG("%s %p", hdev->name, hdev);
510
511 hci_req_lock(hdev);
512
Marcel Holtmann611b30f2009-06-08 14:41:38 +0200513 if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) {
514 ret = -ERFKILL;
515 goto done;
516 }
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (test_bit(HCI_UP, &hdev->flags)) {
519 ret = -EALREADY;
520 goto done;
521 }
522
523 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
524 set_bit(HCI_RAW, &hdev->flags);
525
Marcel Holtmann943da252010-02-13 02:28:41 +0100526 /* Treat all non BR/EDR controllers as raw devices for now */
527 if (hdev->dev_type != HCI_BREDR)
528 set_bit(HCI_RAW, &hdev->flags);
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 if (hdev->open(hdev)) {
531 ret = -EIO;
532 goto done;
533 }
534
535 if (!test_bit(HCI_RAW, &hdev->flags)) {
536 atomic_set(&hdev->cmd_cnt, 1);
537 set_bit(HCI_INIT, &hdev->flags);
Johan Hedberga5040ef2011-01-10 13:28:59 +0200538 hdev->init_last_cmd = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Marcel Holtmann04837f62006-07-03 10:02:33 +0200540 ret = __hci_request(hdev, hci_init_req, 0,
541 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
Andre Guedeseead27d2011-06-30 19:20:55 -0300543 if (lmp_host_le_capable(hdev))
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300544 ret = __hci_request(hdev, hci_le_init_req, 0,
545 msecs_to_jiffies(HCI_INIT_TIMEOUT));
546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 clear_bit(HCI_INIT, &hdev->flags);
548 }
549
550 if (!ret) {
551 hci_dev_hold(hdev);
552 set_bit(HCI_UP, &hdev->flags);
553 hci_notify(hdev, HCI_DEV_UP);
Johan Hedberg5add6af2010-12-16 10:00:37 +0200554 if (!test_bit(HCI_SETUP, &hdev->flags))
555 mgmt_powered(hdev->id, 1);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900556 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 /* Init failed, cleanup */
558 tasklet_kill(&hdev->rx_task);
559 tasklet_kill(&hdev->tx_task);
560 tasklet_kill(&hdev->cmd_task);
561
562 skb_queue_purge(&hdev->cmd_q);
563 skb_queue_purge(&hdev->rx_q);
564
565 if (hdev->flush)
566 hdev->flush(hdev);
567
568 if (hdev->sent_cmd) {
569 kfree_skb(hdev->sent_cmd);
570 hdev->sent_cmd = NULL;
571 }
572
573 hdev->close(hdev);
574 hdev->flags = 0;
575 }
576
577done:
578 hci_req_unlock(hdev);
579 hci_dev_put(hdev);
580 return ret;
581}
582
583static int hci_dev_do_close(struct hci_dev *hdev)
584{
585 BT_DBG("%s %p", hdev->name, hdev);
586
587 hci_req_cancel(hdev, ENODEV);
588 hci_req_lock(hdev);
589
590 if (!test_and_clear_bit(HCI_UP, &hdev->flags)) {
Vinicius Costa Gomesb79f44c2011-04-11 18:46:55 -0300591 del_timer_sync(&hdev->cmd_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 hci_req_unlock(hdev);
593 return 0;
594 }
595
596 /* Kill RX and TX tasks */
597 tasklet_kill(&hdev->rx_task);
598 tasklet_kill(&hdev->tx_task);
599
600 hci_dev_lock_bh(hdev);
601 inquiry_cache_flush(hdev);
602 hci_conn_hash_flush(hdev);
603 hci_dev_unlock_bh(hdev);
604
605 hci_notify(hdev, HCI_DEV_DOWN);
606
607 if (hdev->flush)
608 hdev->flush(hdev);
609
610 /* Reset device */
611 skb_queue_purge(&hdev->cmd_q);
612 atomic_set(&hdev->cmd_cnt, 1);
613 if (!test_bit(HCI_RAW, &hdev->flags)) {
614 set_bit(HCI_INIT, &hdev->flags);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200615 __hci_request(hdev, hci_reset_req, 0,
616 msecs_to_jiffies(250));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 clear_bit(HCI_INIT, &hdev->flags);
618 }
619
620 /* Kill cmd task */
621 tasklet_kill(&hdev->cmd_task);
622
623 /* Drop queues */
624 skb_queue_purge(&hdev->rx_q);
625 skb_queue_purge(&hdev->cmd_q);
626 skb_queue_purge(&hdev->raw_q);
627
628 /* Drop last sent command */
629 if (hdev->sent_cmd) {
Vinicius Costa Gomesb79f44c2011-04-11 18:46:55 -0300630 del_timer_sync(&hdev->cmd_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 kfree_skb(hdev->sent_cmd);
632 hdev->sent_cmd = NULL;
633 }
634
635 /* After this point our queues are empty
636 * and no tasks are scheduled. */
637 hdev->close(hdev);
638
Johan Hedberg5add6af2010-12-16 10:00:37 +0200639 mgmt_powered(hdev->id, 0);
640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 /* Clear flags */
642 hdev->flags = 0;
643
644 hci_req_unlock(hdev);
645
646 hci_dev_put(hdev);
647 return 0;
648}
649
650int hci_dev_close(__u16 dev)
651{
652 struct hci_dev *hdev;
653 int err;
654
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200655 hdev = hci_dev_get(dev);
656 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 return -ENODEV;
658 err = hci_dev_do_close(hdev);
659 hci_dev_put(hdev);
660 return err;
661}
662
663int hci_dev_reset(__u16 dev)
664{
665 struct hci_dev *hdev;
666 int ret = 0;
667
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200668 hdev = hci_dev_get(dev);
669 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return -ENODEV;
671
672 hci_req_lock(hdev);
673 tasklet_disable(&hdev->tx_task);
674
675 if (!test_bit(HCI_UP, &hdev->flags))
676 goto done;
677
678 /* Drop queues */
679 skb_queue_purge(&hdev->rx_q);
680 skb_queue_purge(&hdev->cmd_q);
681
682 hci_dev_lock_bh(hdev);
683 inquiry_cache_flush(hdev);
684 hci_conn_hash_flush(hdev);
685 hci_dev_unlock_bh(hdev);
686
687 if (hdev->flush)
688 hdev->flush(hdev);
689
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900690 atomic_set(&hdev->cmd_cnt, 1);
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300691 hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693 if (!test_bit(HCI_RAW, &hdev->flags))
Marcel Holtmann04837f62006-07-03 10:02:33 +0200694 ret = __hci_request(hdev, hci_reset_req, 0,
695 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697done:
698 tasklet_enable(&hdev->tx_task);
699 hci_req_unlock(hdev);
700 hci_dev_put(hdev);
701 return ret;
702}
703
704int hci_dev_reset_stat(__u16 dev)
705{
706 struct hci_dev *hdev;
707 int ret = 0;
708
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200709 hdev = hci_dev_get(dev);
710 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 return -ENODEV;
712
713 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
714
715 hci_dev_put(hdev);
716
717 return ret;
718}
719
720int hci_dev_cmd(unsigned int cmd, void __user *arg)
721{
722 struct hci_dev *hdev;
723 struct hci_dev_req dr;
724 int err = 0;
725
726 if (copy_from_user(&dr, arg, sizeof(dr)))
727 return -EFAULT;
728
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200729 hdev = hci_dev_get(dr.dev_id);
730 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 return -ENODEV;
732
733 switch (cmd) {
734 case HCISETAUTH:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200735 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
736 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 break;
738
739 case HCISETENCRYPT:
740 if (!lmp_encrypt_capable(hdev)) {
741 err = -EOPNOTSUPP;
742 break;
743 }
744
745 if (!test_bit(HCI_AUTH, &hdev->flags)) {
746 /* Auth must be enabled first */
Marcel Holtmann04837f62006-07-03 10:02:33 +0200747 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
748 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 if (err)
750 break;
751 }
752
Marcel Holtmann04837f62006-07-03 10:02:33 +0200753 err = hci_request(hdev, hci_encrypt_req, dr.dev_opt,
754 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 break;
756
757 case HCISETSCAN:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200758 err = hci_request(hdev, hci_scan_req, dr.dev_opt,
759 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 break;
761
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200762 case HCISETLINKPOL:
763 err = hci_request(hdev, hci_linkpol_req, dr.dev_opt,
764 msecs_to_jiffies(HCI_INIT_TIMEOUT));
765 break;
766
767 case HCISETLINKMODE:
768 hdev->link_mode = ((__u16) dr.dev_opt) &
769 (HCI_LM_MASTER | HCI_LM_ACCEPT);
770 break;
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 case HCISETPTYPE:
773 hdev->pkt_type = (__u16) dr.dev_opt;
774 break;
775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 case HCISETACLMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200777 hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1);
778 hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 break;
780
781 case HCISETSCOMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200782 hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1);
783 hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 break;
785
786 default:
787 err = -EINVAL;
788 break;
789 }
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200790
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 hci_dev_put(hdev);
792 return err;
793}
794
795int hci_get_dev_list(void __user *arg)
796{
797 struct hci_dev_list_req *dl;
798 struct hci_dev_req *dr;
799 struct list_head *p;
800 int n = 0, size, err;
801 __u16 dev_num;
802
803 if (get_user(dev_num, (__u16 __user *) arg))
804 return -EFAULT;
805
806 if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr))
807 return -EINVAL;
808
809 size = sizeof(*dl) + dev_num * sizeof(*dr);
810
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200811 dl = kzalloc(size, GFP_KERNEL);
812 if (!dl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 return -ENOMEM;
814
815 dr = dl->dev_req;
816
817 read_lock_bh(&hci_dev_list_lock);
818 list_for_each(p, &hci_dev_list) {
819 struct hci_dev *hdev;
Johan Hedbergc542a062011-01-26 13:11:03 +0200820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 hdev = list_entry(p, struct hci_dev, list);
Johan Hedbergc542a062011-01-26 13:11:03 +0200822
Johan Hedbergab81cbf2010-12-15 13:53:18 +0200823 hci_del_off_timer(hdev);
Johan Hedbergc542a062011-01-26 13:11:03 +0200824
825 if (!test_bit(HCI_MGMT, &hdev->flags))
826 set_bit(HCI_PAIRABLE, &hdev->flags);
827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 (dr + n)->dev_id = hdev->id;
829 (dr + n)->dev_opt = hdev->flags;
Johan Hedbergc542a062011-01-26 13:11:03 +0200830
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 if (++n >= dev_num)
832 break;
833 }
834 read_unlock_bh(&hci_dev_list_lock);
835
836 dl->dev_num = n;
837 size = sizeof(*dl) + n * sizeof(*dr);
838
839 err = copy_to_user(arg, dl, size);
840 kfree(dl);
841
842 return err ? -EFAULT : 0;
843}
844
845int hci_get_dev_info(void __user *arg)
846{
847 struct hci_dev *hdev;
848 struct hci_dev_info di;
849 int err = 0;
850
851 if (copy_from_user(&di, arg, sizeof(di)))
852 return -EFAULT;
853
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200854 hdev = hci_dev_get(di.dev_id);
855 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 return -ENODEV;
857
Johan Hedbergab81cbf2010-12-15 13:53:18 +0200858 hci_del_off_timer(hdev);
859
Johan Hedbergc542a062011-01-26 13:11:03 +0200860 if (!test_bit(HCI_MGMT, &hdev->flags))
861 set_bit(HCI_PAIRABLE, &hdev->flags);
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 strcpy(di.name, hdev->name);
864 di.bdaddr = hdev->bdaddr;
Marcel Holtmann943da252010-02-13 02:28:41 +0100865 di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 di.flags = hdev->flags;
867 di.pkt_type = hdev->pkt_type;
868 di.acl_mtu = hdev->acl_mtu;
869 di.acl_pkts = hdev->acl_pkts;
870 di.sco_mtu = hdev->sco_mtu;
871 di.sco_pkts = hdev->sco_pkts;
872 di.link_policy = hdev->link_policy;
873 di.link_mode = hdev->link_mode;
874
875 memcpy(&di.stat, &hdev->stat, sizeof(di.stat));
876 memcpy(&di.features, &hdev->features, sizeof(di.features));
877
878 if (copy_to_user(arg, &di, sizeof(di)))
879 err = -EFAULT;
880
881 hci_dev_put(hdev);
882
883 return err;
884}
885
886/* ---- Interface to HCI drivers ---- */
887
Marcel Holtmann611b30f2009-06-08 14:41:38 +0200888static int hci_rfkill_set_block(void *data, bool blocked)
889{
890 struct hci_dev *hdev = data;
891
892 BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked);
893
894 if (!blocked)
895 return 0;
896
897 hci_dev_do_close(hdev);
898
899 return 0;
900}
901
902static const struct rfkill_ops hci_rfkill_ops = {
903 .set_block = hci_rfkill_set_block,
904};
905
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906/* Alloc HCI device */
907struct hci_dev *hci_alloc_dev(void)
908{
909 struct hci_dev *hdev;
910
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200911 hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 if (!hdev)
913 return NULL;
914
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 skb_queue_head_init(&hdev->driver_init);
916
917 return hdev;
918}
919EXPORT_SYMBOL(hci_alloc_dev);
920
921/* Free HCI device */
922void hci_free_dev(struct hci_dev *hdev)
923{
924 skb_queue_purge(&hdev->driver_init);
925
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200926 /* will free via device release */
927 put_device(&hdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928}
929EXPORT_SYMBOL(hci_free_dev);
930
Johan Hedbergab81cbf2010-12-15 13:53:18 +0200931static void hci_power_on(struct work_struct *work)
932{
933 struct hci_dev *hdev = container_of(work, struct hci_dev, power_on);
934
935 BT_DBG("%s", hdev->name);
936
937 if (hci_dev_open(hdev->id) < 0)
938 return;
939
940 if (test_bit(HCI_AUTO_OFF, &hdev->flags))
941 mod_timer(&hdev->off_timer,
942 jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT));
943
944 if (test_and_clear_bit(HCI_SETUP, &hdev->flags))
945 mgmt_index_added(hdev->id);
946}
947
948static void hci_power_off(struct work_struct *work)
949{
950 struct hci_dev *hdev = container_of(work, struct hci_dev, power_off);
951
952 BT_DBG("%s", hdev->name);
953
954 hci_dev_close(hdev->id);
955}
956
957static void hci_auto_off(unsigned long data)
958{
959 struct hci_dev *hdev = (struct hci_dev *) data;
960
961 BT_DBG("%s", hdev->name);
962
963 clear_bit(HCI_AUTO_OFF, &hdev->flags);
964
965 queue_work(hdev->workqueue, &hdev->power_off);
966}
967
968void hci_del_off_timer(struct hci_dev *hdev)
969{
970 BT_DBG("%s", hdev->name);
971
972 clear_bit(HCI_AUTO_OFF, &hdev->flags);
973 del_timer(&hdev->off_timer);
974}
975
Johan Hedberg2aeb9a12011-01-04 12:08:51 +0200976int hci_uuids_clear(struct hci_dev *hdev)
977{
978 struct list_head *p, *n;
979
980 list_for_each_safe(p, n, &hdev->uuids) {
981 struct bt_uuid *uuid;
982
983 uuid = list_entry(p, struct bt_uuid, list);
984
985 list_del(p);
986 kfree(uuid);
987 }
988
989 return 0;
990}
991
Johan Hedberg55ed8ca12011-01-17 14:41:05 +0200992int hci_link_keys_clear(struct hci_dev *hdev)
993{
994 struct list_head *p, *n;
995
996 list_for_each_safe(p, n, &hdev->link_keys) {
997 struct link_key *key;
998
999 key = list_entry(p, struct link_key, list);
1000
1001 list_del(p);
1002 kfree(key);
1003 }
1004
1005 return 0;
1006}
1007
1008struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
1009{
1010 struct list_head *p;
1011
1012 list_for_each(p, &hdev->link_keys) {
1013 struct link_key *k;
1014
1015 k = list_entry(p, struct link_key, list);
1016
1017 if (bacmp(bdaddr, &k->bdaddr) == 0)
1018 return k;
1019 }
1020
1021 return NULL;
1022}
1023
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001024static int hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn,
1025 u8 key_type, u8 old_key_type)
1026{
1027 /* Legacy key */
1028 if (key_type < 0x03)
1029 return 1;
1030
1031 /* Debug keys are insecure so don't store them persistently */
1032 if (key_type == HCI_LK_DEBUG_COMBINATION)
1033 return 0;
1034
1035 /* Changed combination key and there's no previous one */
1036 if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff)
1037 return 0;
1038
1039 /* Security mode 3 case */
1040 if (!conn)
1041 return 1;
1042
1043 /* Neither local nor remote side had no-bonding as requirement */
1044 if (conn->auth_type > 0x01 && conn->remote_auth > 0x01)
1045 return 1;
1046
1047 /* Local side had dedicated bonding as requirement */
1048 if (conn->auth_type == 0x02 || conn->auth_type == 0x03)
1049 return 1;
1050
1051 /* Remote side had dedicated bonding as requirement */
1052 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03)
1053 return 1;
1054
1055 /* If none of the above criteria match, then don't store the key
1056 * persistently */
1057 return 0;
1058}
1059
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001060struct link_key *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8])
1061{
1062 struct link_key *k;
1063
1064 list_for_each_entry(k, &hdev->link_keys, list) {
1065 struct key_master_id *id;
1066
1067 if (k->type != HCI_LK_SMP_LTK)
1068 continue;
1069
1070 if (k->dlen != sizeof(*id))
1071 continue;
1072
1073 id = (void *) &k->data;
1074 if (id->ediv == ediv &&
1075 (memcmp(rand, id->rand, sizeof(id->rand)) == 0))
1076 return k;
1077 }
1078
1079 return NULL;
1080}
1081EXPORT_SYMBOL(hci_find_ltk);
1082
1083struct link_key *hci_find_link_key_type(struct hci_dev *hdev,
1084 bdaddr_t *bdaddr, u8 type)
1085{
1086 struct link_key *k;
1087
1088 list_for_each_entry(k, &hdev->link_keys, list)
1089 if (k->type == type && bacmp(bdaddr, &k->bdaddr) == 0)
1090 return k;
1091
1092 return NULL;
1093}
1094EXPORT_SYMBOL(hci_find_link_key_type);
1095
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001096int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
1097 bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001098{
1099 struct link_key *key, *old_key;
Johan Hedberg4df378a2011-04-28 11:29:03 -07001100 u8 old_key_type, persistent;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001101
1102 old_key = hci_find_link_key(hdev, bdaddr);
1103 if (old_key) {
1104 old_key_type = old_key->type;
1105 key = old_key;
1106 } else {
Johan Hedberg12adcf32011-04-28 11:29:00 -07001107 old_key_type = conn ? conn->key_type : 0xff;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001108 key = kzalloc(sizeof(*key), GFP_ATOMIC);
1109 if (!key)
1110 return -ENOMEM;
1111 list_add(&key->list, &hdev->link_keys);
1112 }
1113
1114 BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type);
1115
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001116 /* Some buggy controller combinations generate a changed
1117 * combination key for legacy pairing even when there's no
1118 * previous key */
1119 if (type == HCI_LK_CHANGED_COMBINATION &&
1120 (!conn || conn->remote_auth == 0xff) &&
Johan Hedberg655fe6e2011-04-28 11:29:01 -07001121 old_key_type == 0xff) {
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001122 type = HCI_LK_COMBINATION;
Johan Hedberg655fe6e2011-04-28 11:29:01 -07001123 if (conn)
1124 conn->key_type = type;
1125 }
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001126
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001127 bacpy(&key->bdaddr, bdaddr);
1128 memcpy(key->val, val, 16);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001129 key->pin_len = pin_len;
1130
Waldemar Rymarkiewiczb6020ba2011-04-28 12:07:53 +02001131 if (type == HCI_LK_CHANGED_COMBINATION)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001132 key->type = old_key_type;
Johan Hedberg4748fed2011-04-28 11:29:02 -07001133 else
1134 key->type = type;
1135
Johan Hedberg4df378a2011-04-28 11:29:03 -07001136 if (!new_key)
1137 return 0;
1138
1139 persistent = hci_persistent_key(hdev, conn, type, old_key_type);
1140
1141 mgmt_new_key(hdev->id, key, persistent);
1142
1143 if (!persistent) {
1144 list_del(&key->list);
1145 kfree(key);
1146 }
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001147
1148 return 0;
1149}
1150
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001151int hci_add_ltk(struct hci_dev *hdev, int new_key, bdaddr_t *bdaddr,
Vinicius Costa Gomes726b4ff2011-07-08 18:31:45 -03001152 u8 key_size, __le16 ediv, u8 rand[8], u8 ltk[16])
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001153{
1154 struct link_key *key, *old_key;
1155 struct key_master_id *id;
1156 u8 old_key_type;
1157
1158 BT_DBG("%s addr %s", hdev->name, batostr(bdaddr));
1159
1160 old_key = hci_find_link_key_type(hdev, bdaddr, HCI_LK_SMP_LTK);
1161 if (old_key) {
1162 key = old_key;
1163 old_key_type = old_key->type;
1164 } else {
1165 key = kzalloc(sizeof(*key) + sizeof(*id), GFP_ATOMIC);
1166 if (!key)
1167 return -ENOMEM;
1168 list_add(&key->list, &hdev->link_keys);
1169 old_key_type = 0xff;
1170 }
1171
1172 key->dlen = sizeof(*id);
1173
1174 bacpy(&key->bdaddr, bdaddr);
1175 memcpy(key->val, ltk, sizeof(key->val));
1176 key->type = HCI_LK_SMP_LTK;
Vinicius Costa Gomes726b4ff2011-07-08 18:31:45 -03001177 key->pin_len = key_size;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001178
1179 id = (void *) &key->data;
1180 id->ediv = ediv;
1181 memcpy(id->rand, rand, sizeof(id->rand));
1182
1183 if (new_key)
1184 mgmt_new_key(hdev->id, key, old_key_type);
1185
1186 return 0;
1187}
1188
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001189int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
1190{
1191 struct link_key *key;
1192
1193 key = hci_find_link_key(hdev, bdaddr);
1194 if (!key)
1195 return -ENOENT;
1196
1197 BT_DBG("%s removing %s", hdev->name, batostr(bdaddr));
1198
1199 list_del(&key->list);
1200 kfree(key);
1201
1202 return 0;
1203}
1204
Ville Tervo6bd32322011-02-16 16:32:41 +02001205/* HCI command timer function */
1206static void hci_cmd_timer(unsigned long arg)
1207{
1208 struct hci_dev *hdev = (void *) arg;
1209
1210 BT_ERR("%s command tx timeout", hdev->name);
1211 atomic_set(&hdev->cmd_cnt, 1);
1212 tasklet_schedule(&hdev->cmd_task);
1213}
1214
Szymon Janc2763eda2011-03-22 13:12:22 +01001215struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1216 bdaddr_t *bdaddr)
1217{
1218 struct oob_data *data;
1219
1220 list_for_each_entry(data, &hdev->remote_oob_data, list)
1221 if (bacmp(bdaddr, &data->bdaddr) == 0)
1222 return data;
1223
1224 return NULL;
1225}
1226
1227int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr)
1228{
1229 struct oob_data *data;
1230
1231 data = hci_find_remote_oob_data(hdev, bdaddr);
1232 if (!data)
1233 return -ENOENT;
1234
1235 BT_DBG("%s removing %s", hdev->name, batostr(bdaddr));
1236
1237 list_del(&data->list);
1238 kfree(data);
1239
1240 return 0;
1241}
1242
1243int hci_remote_oob_data_clear(struct hci_dev *hdev)
1244{
1245 struct oob_data *data, *n;
1246
1247 list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) {
1248 list_del(&data->list);
1249 kfree(data);
1250 }
1251
1252 return 0;
1253}
1254
1255int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
1256 u8 *randomizer)
1257{
1258 struct oob_data *data;
1259
1260 data = hci_find_remote_oob_data(hdev, bdaddr);
1261
1262 if (!data) {
1263 data = kmalloc(sizeof(*data), GFP_ATOMIC);
1264 if (!data)
1265 return -ENOMEM;
1266
1267 bacpy(&data->bdaddr, bdaddr);
1268 list_add(&data->list, &hdev->remote_oob_data);
1269 }
1270
1271 memcpy(data->hash, hash, sizeof(data->hash));
1272 memcpy(data->randomizer, randomizer, sizeof(data->randomizer));
1273
1274 BT_DBG("%s for %s", hdev->name, batostr(bdaddr));
1275
1276 return 0;
1277}
1278
Antti Julkub2a66aa2011-06-15 12:01:14 +03001279struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev,
1280 bdaddr_t *bdaddr)
1281{
1282 struct list_head *p;
1283
1284 list_for_each(p, &hdev->blacklist) {
1285 struct bdaddr_list *b;
1286
1287 b = list_entry(p, struct bdaddr_list, list);
1288
1289 if (bacmp(bdaddr, &b->bdaddr) == 0)
1290 return b;
1291 }
1292
1293 return NULL;
1294}
1295
1296int hci_blacklist_clear(struct hci_dev *hdev)
1297{
1298 struct list_head *p, *n;
1299
1300 list_for_each_safe(p, n, &hdev->blacklist) {
1301 struct bdaddr_list *b;
1302
1303 b = list_entry(p, struct bdaddr_list, list);
1304
1305 list_del(p);
1306 kfree(b);
1307 }
1308
1309 return 0;
1310}
1311
1312int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr)
1313{
1314 struct bdaddr_list *entry;
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001315 int err;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001316
1317 if (bacmp(bdaddr, BDADDR_ANY) == 0)
1318 return -EBADF;
1319
Andre Guedes8aded712011-07-07 10:30:35 -03001320 hci_dev_lock_bh(hdev);
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001321
1322 if (hci_blacklist_lookup(hdev, bdaddr)) {
1323 err = -EEXIST;
1324 goto err;
1325 }
Antti Julkub2a66aa2011-06-15 12:01:14 +03001326
1327 entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL);
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001328 if (!entry) {
Dan Carpenter8475e232011-08-03 17:22:45 +03001329 err = -ENOMEM;
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001330 goto err;
1331 }
Antti Julkub2a66aa2011-06-15 12:01:14 +03001332
1333 bacpy(&entry->bdaddr, bdaddr);
1334
1335 list_add(&entry->list, &hdev->blacklist);
1336
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001337 err = 0;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001338
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001339err:
Andre Guedes8aded712011-07-07 10:30:35 -03001340 hci_dev_unlock_bh(hdev);
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001341 return err;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001342}
1343
1344int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr)
1345{
1346 struct bdaddr_list *entry;
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001347 int err = 0;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001348
Andre Guedes8aded712011-07-07 10:30:35 -03001349 hci_dev_lock_bh(hdev);
Antti Julkub2a66aa2011-06-15 12:01:14 +03001350
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001351 if (bacmp(bdaddr, BDADDR_ANY) == 0) {
1352 hci_blacklist_clear(hdev);
1353 goto done;
1354 }
Antti Julkub2a66aa2011-06-15 12:01:14 +03001355
1356 entry = hci_blacklist_lookup(hdev, bdaddr);
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001357 if (!entry) {
1358 err = -ENOENT;
1359 goto done;
1360 }
Antti Julkub2a66aa2011-06-15 12:01:14 +03001361
1362 list_del(&entry->list);
1363 kfree(entry);
1364
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001365done:
Andre Guedes8aded712011-07-07 10:30:35 -03001366 hci_dev_unlock_bh(hdev);
Gustavo F. Padovana7925bd2011-06-17 16:15:10 -03001367 return err;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001368}
1369
Andre Guedes35815082011-05-26 16:23:53 -03001370static void hci_clear_adv_cache(unsigned long arg)
1371{
1372 struct hci_dev *hdev = (void *) arg;
1373
1374 hci_dev_lock(hdev);
1375
1376 hci_adv_entries_clear(hdev);
1377
1378 hci_dev_unlock(hdev);
1379}
1380
Andre Guedes76c86862011-05-26 16:23:50 -03001381int hci_adv_entries_clear(struct hci_dev *hdev)
1382{
1383 struct adv_entry *entry, *tmp;
1384
1385 list_for_each_entry_safe(entry, tmp, &hdev->adv_entries, list) {
1386 list_del(&entry->list);
1387 kfree(entry);
1388 }
1389
1390 BT_DBG("%s adv cache cleared", hdev->name);
1391
1392 return 0;
1393}
1394
1395struct adv_entry *hci_find_adv_entry(struct hci_dev *hdev, bdaddr_t *bdaddr)
1396{
1397 struct adv_entry *entry;
1398
1399 list_for_each_entry(entry, &hdev->adv_entries, list)
1400 if (bacmp(bdaddr, &entry->bdaddr) == 0)
1401 return entry;
1402
1403 return NULL;
1404}
1405
1406static inline int is_connectable_adv(u8 evt_type)
1407{
1408 if (evt_type == ADV_IND || evt_type == ADV_DIRECT_IND)
1409 return 1;
1410
1411 return 0;
1412}
1413
1414int hci_add_adv_entry(struct hci_dev *hdev,
1415 struct hci_ev_le_advertising_info *ev)
1416{
1417 struct adv_entry *entry;
1418
1419 if (!is_connectable_adv(ev->evt_type))
1420 return -EINVAL;
1421
1422 /* Only new entries should be added to adv_entries. So, if
1423 * bdaddr was found, don't add it. */
1424 if (hci_find_adv_entry(hdev, &ev->bdaddr))
1425 return 0;
1426
1427 entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
1428 if (!entry)
1429 return -ENOMEM;
1430
1431 bacpy(&entry->bdaddr, &ev->bdaddr);
1432 entry->bdaddr_type = ev->bdaddr_type;
1433
1434 list_add(&entry->list, &hdev->adv_entries);
1435
1436 BT_DBG("%s adv entry added: address %s type %u", hdev->name,
1437 batostr(&entry->bdaddr), entry->bdaddr_type);
1438
1439 return 0;
1440}
1441
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442/* Register HCI device */
1443int hci_register_dev(struct hci_dev *hdev)
1444{
1445 struct list_head *head = &hci_dev_list, *p;
Marcel Holtmannef222012007-07-11 06:42:04 +02001446 int i, id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Marcel Holtmannc13854c2010-02-08 15:27:07 +01001448 BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name,
1449 hdev->bus, hdev->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450
1451 if (!hdev->open || !hdev->close || !hdev->destruct)
1452 return -EINVAL;
1453
1454 write_lock_bh(&hci_dev_list_lock);
1455
1456 /* Find first available device id */
1457 list_for_each(p, &hci_dev_list) {
1458 if (list_entry(p, struct hci_dev, list)->id != id)
1459 break;
1460 head = p; id++;
1461 }
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001462
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 sprintf(hdev->name, "hci%d", id);
1464 hdev->id = id;
1465 list_add(&hdev->list, head);
1466
1467 atomic_set(&hdev->refcnt, 1);
1468 spin_lock_init(&hdev->lock);
1469
1470 hdev->flags = 0;
1471 hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001472 hdev->esco_type = (ESCO_HV1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 hdev->link_mode = (HCI_LM_ACCEPT);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02001474 hdev->io_capability = 0x03; /* No Input No Output */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
Marcel Holtmann04837f62006-07-03 10:02:33 +02001476 hdev->idle_timeout = 0;
1477 hdev->sniff_max_interval = 800;
1478 hdev->sniff_min_interval = 80;
1479
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001480 tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev);
1482 tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev);
1483
1484 skb_queue_head_init(&hdev->rx_q);
1485 skb_queue_head_init(&hdev->cmd_q);
1486 skb_queue_head_init(&hdev->raw_q);
1487
Ville Tervo6bd32322011-02-16 16:32:41 +02001488 setup_timer(&hdev->cmd_timer, hci_cmd_timer, (unsigned long) hdev);
1489
Suraj Sumangalacd4c5392010-07-14 13:02:16 +05301490 for (i = 0; i < NUM_REASSEMBLY; i++)
Marcel Holtmannef222012007-07-11 06:42:04 +02001491 hdev->reassembly[i] = NULL;
1492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 init_waitqueue_head(&hdev->req_wait_q);
Thomas Gleixnera6a67ef2009-07-26 08:18:19 +00001494 mutex_init(&hdev->req_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
1496 inquiry_cache_init(hdev);
1497
1498 hci_conn_hash_init(hdev);
1499
David Millerea4bd8b2010-07-30 21:54:49 -07001500 INIT_LIST_HEAD(&hdev->blacklist);
Johan Hedbergf0358562010-05-18 13:20:32 +02001501
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001502 INIT_LIST_HEAD(&hdev->uuids);
1503
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001504 INIT_LIST_HEAD(&hdev->link_keys);
1505
Szymon Janc2763eda2011-03-22 13:12:22 +01001506 INIT_LIST_HEAD(&hdev->remote_oob_data);
1507
Andre Guedes76c86862011-05-26 16:23:50 -03001508 INIT_LIST_HEAD(&hdev->adv_entries);
Andre Guedes35815082011-05-26 16:23:53 -03001509 setup_timer(&hdev->adv_timer, hci_clear_adv_cache,
1510 (unsigned long) hdev);
Andre Guedes76c86862011-05-26 16:23:50 -03001511
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001512 INIT_WORK(&hdev->power_on, hci_power_on);
1513 INIT_WORK(&hdev->power_off, hci_power_off);
1514 setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev);
1515
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
1517
1518 atomic_set(&hdev->promisc, 0);
1519
1520 write_unlock_bh(&hci_dev_list_lock);
1521
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001522 hdev->workqueue = create_singlethread_workqueue(hdev->name);
1523 if (!hdev->workqueue)
1524 goto nomem;
1525
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 hci_register_sysfs(hdev);
1527
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001528 hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev,
1529 RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev);
1530 if (hdev->rfkill) {
1531 if (rfkill_register(hdev->rfkill) < 0) {
1532 rfkill_destroy(hdev->rfkill);
1533 hdev->rfkill = NULL;
1534 }
1535 }
1536
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001537 set_bit(HCI_AUTO_OFF, &hdev->flags);
1538 set_bit(HCI_SETUP, &hdev->flags);
1539 queue_work(hdev->workqueue, &hdev->power_on);
1540
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 hci_notify(hdev, HCI_DEV_REG);
1542
1543 return id;
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001544
1545nomem:
1546 write_lock_bh(&hci_dev_list_lock);
1547 list_del(&hdev->list);
1548 write_unlock_bh(&hci_dev_list_lock);
1549
1550 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551}
1552EXPORT_SYMBOL(hci_register_dev);
1553
1554/* Unregister HCI device */
1555int hci_unregister_dev(struct hci_dev *hdev)
1556{
Marcel Holtmannef222012007-07-11 06:42:04 +02001557 int i;
1558
Marcel Holtmannc13854c2010-02-08 15:27:07 +01001559 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 write_lock_bh(&hci_dev_list_lock);
1562 list_del(&hdev->list);
1563 write_unlock_bh(&hci_dev_list_lock);
1564
1565 hci_dev_do_close(hdev);
1566
Suraj Sumangalacd4c5392010-07-14 13:02:16 +05301567 for (i = 0; i < NUM_REASSEMBLY; i++)
Marcel Holtmannef222012007-07-11 06:42:04 +02001568 kfree_skb(hdev->reassembly[i]);
1569
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001570 if (!test_bit(HCI_INIT, &hdev->flags) &&
1571 !test_bit(HCI_SETUP, &hdev->flags))
1572 mgmt_index_removed(hdev->id);
1573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 hci_notify(hdev, HCI_DEV_UNREG);
1575
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001576 if (hdev->rfkill) {
1577 rfkill_unregister(hdev->rfkill);
1578 rfkill_destroy(hdev->rfkill);
1579 }
1580
Dave Young147e2d52008-03-05 18:45:59 -08001581 hci_unregister_sysfs(hdev);
1582
Gustavo F. Padovanc6f3c5f2011-02-15 20:22:03 -03001583 hci_del_off_timer(hdev);
Andre Guedes35815082011-05-26 16:23:53 -03001584 del_timer(&hdev->adv_timer);
Gustavo F. Padovanc6f3c5f2011-02-15 20:22:03 -03001585
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001586 destroy_workqueue(hdev->workqueue);
1587
Johan Hedberge2e0cac2011-01-04 12:08:50 +02001588 hci_dev_lock_bh(hdev);
1589 hci_blacklist_clear(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001590 hci_uuids_clear(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001591 hci_link_keys_clear(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01001592 hci_remote_oob_data_clear(hdev);
Andre Guedes76c86862011-05-26 16:23:50 -03001593 hci_adv_entries_clear(hdev);
Johan Hedberge2e0cac2011-01-04 12:08:50 +02001594 hci_dev_unlock_bh(hdev);
1595
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 __hci_dev_put(hdev);
Marcel Holtmannef222012007-07-11 06:42:04 +02001597
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 return 0;
1599}
1600EXPORT_SYMBOL(hci_unregister_dev);
1601
1602/* Suspend HCI device */
1603int hci_suspend_dev(struct hci_dev *hdev)
1604{
1605 hci_notify(hdev, HCI_DEV_SUSPEND);
1606 return 0;
1607}
1608EXPORT_SYMBOL(hci_suspend_dev);
1609
1610/* Resume HCI device */
1611int hci_resume_dev(struct hci_dev *hdev)
1612{
1613 hci_notify(hdev, HCI_DEV_RESUME);
1614 return 0;
1615}
1616EXPORT_SYMBOL(hci_resume_dev);
1617
Marcel Holtmann76bca882009-11-18 00:40:39 +01001618/* Receive frame from HCI drivers */
1619int hci_recv_frame(struct sk_buff *skb)
1620{
1621 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
1622 if (!hdev || (!test_bit(HCI_UP, &hdev->flags)
1623 && !test_bit(HCI_INIT, &hdev->flags))) {
1624 kfree_skb(skb);
1625 return -ENXIO;
1626 }
1627
1628 /* Incomming skb */
1629 bt_cb(skb)->incoming = 1;
1630
1631 /* Time stamp */
1632 __net_timestamp(skb);
1633
1634 /* Queue frame for rx task */
1635 skb_queue_tail(&hdev->rx_q, skb);
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001636 tasklet_schedule(&hdev->rx_task);
1637
Marcel Holtmann76bca882009-11-18 00:40:39 +01001638 return 0;
1639}
1640EXPORT_SYMBOL(hci_recv_frame);
1641
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301642static int hci_reassembly(struct hci_dev *hdev, int type, void *data,
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03001643 int count, __u8 index)
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301644{
1645 int len = 0;
1646 int hlen = 0;
1647 int remain = count;
1648 struct sk_buff *skb;
1649 struct bt_skb_cb *scb;
1650
1651 if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) ||
1652 index >= NUM_REASSEMBLY)
1653 return -EILSEQ;
1654
1655 skb = hdev->reassembly[index];
1656
1657 if (!skb) {
1658 switch (type) {
1659 case HCI_ACLDATA_PKT:
1660 len = HCI_MAX_FRAME_SIZE;
1661 hlen = HCI_ACL_HDR_SIZE;
1662 break;
1663 case HCI_EVENT_PKT:
1664 len = HCI_MAX_EVENT_SIZE;
1665 hlen = HCI_EVENT_HDR_SIZE;
1666 break;
1667 case HCI_SCODATA_PKT:
1668 len = HCI_MAX_SCO_SIZE;
1669 hlen = HCI_SCO_HDR_SIZE;
1670 break;
1671 }
1672
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03001673 skb = bt_skb_alloc(len, GFP_ATOMIC);
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301674 if (!skb)
1675 return -ENOMEM;
1676
1677 scb = (void *) skb->cb;
1678 scb->expect = hlen;
1679 scb->pkt_type = type;
1680
1681 skb->dev = (void *) hdev;
1682 hdev->reassembly[index] = skb;
1683 }
1684
1685 while (count) {
1686 scb = (void *) skb->cb;
1687 len = min(scb->expect, (__u16)count);
1688
1689 memcpy(skb_put(skb, len), data, len);
1690
1691 count -= len;
1692 data += len;
1693 scb->expect -= len;
1694 remain = count;
1695
1696 switch (type) {
1697 case HCI_EVENT_PKT:
1698 if (skb->len == HCI_EVENT_HDR_SIZE) {
1699 struct hci_event_hdr *h = hci_event_hdr(skb);
1700 scb->expect = h->plen;
1701
1702 if (skb_tailroom(skb) < scb->expect) {
1703 kfree_skb(skb);
1704 hdev->reassembly[index] = NULL;
1705 return -ENOMEM;
1706 }
1707 }
1708 break;
1709
1710 case HCI_ACLDATA_PKT:
1711 if (skb->len == HCI_ACL_HDR_SIZE) {
1712 struct hci_acl_hdr *h = hci_acl_hdr(skb);
1713 scb->expect = __le16_to_cpu(h->dlen);
1714
1715 if (skb_tailroom(skb) < scb->expect) {
1716 kfree_skb(skb);
1717 hdev->reassembly[index] = NULL;
1718 return -ENOMEM;
1719 }
1720 }
1721 break;
1722
1723 case HCI_SCODATA_PKT:
1724 if (skb->len == HCI_SCO_HDR_SIZE) {
1725 struct hci_sco_hdr *h = hci_sco_hdr(skb);
1726 scb->expect = h->dlen;
1727
1728 if (skb_tailroom(skb) < scb->expect) {
1729 kfree_skb(skb);
1730 hdev->reassembly[index] = NULL;
1731 return -ENOMEM;
1732 }
1733 }
1734 break;
1735 }
1736
1737 if (scb->expect == 0) {
1738 /* Complete frame */
1739
1740 bt_cb(skb)->pkt_type = type;
1741 hci_recv_frame(skb);
1742
1743 hdev->reassembly[index] = NULL;
1744 return remain;
1745 }
1746 }
1747
1748 return remain;
1749}
1750
Marcel Holtmannef222012007-07-11 06:42:04 +02001751int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
1752{
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05301753 int rem = 0;
1754
Marcel Holtmannef222012007-07-11 06:42:04 +02001755 if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
1756 return -EILSEQ;
1757
Gustavo F. Padovanda5f6c32010-07-24 01:34:54 -03001758 while (count) {
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03001759 rem = hci_reassembly(hdev, type, data, count, type - 1);
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05301760 if (rem < 0)
1761 return rem;
Marcel Holtmannef222012007-07-11 06:42:04 +02001762
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05301763 data += (count - rem);
1764 count = rem;
Joe Perchesf81c6222011-06-03 11:51:19 +00001765 }
Marcel Holtmannef222012007-07-11 06:42:04 +02001766
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05301767 return rem;
Marcel Holtmannef222012007-07-11 06:42:04 +02001768}
1769EXPORT_SYMBOL(hci_recv_fragment);
1770
Suraj Sumangala99811512010-07-14 13:02:19 +05301771#define STREAM_REASSEMBLY 0
1772
1773int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count)
1774{
1775 int type;
1776 int rem = 0;
1777
Gustavo F. Padovanda5f6c32010-07-24 01:34:54 -03001778 while (count) {
Suraj Sumangala99811512010-07-14 13:02:19 +05301779 struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY];
1780
1781 if (!skb) {
1782 struct { char type; } *pkt;
1783
1784 /* Start of the frame */
1785 pkt = data;
1786 type = pkt->type;
1787
1788 data++;
1789 count--;
1790 } else
1791 type = bt_cb(skb)->pkt_type;
1792
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03001793 rem = hci_reassembly(hdev, type, data, count,
1794 STREAM_REASSEMBLY);
Suraj Sumangala99811512010-07-14 13:02:19 +05301795 if (rem < 0)
1796 return rem;
1797
1798 data += (count - rem);
1799 count = rem;
Joe Perchesf81c6222011-06-03 11:51:19 +00001800 }
Suraj Sumangala99811512010-07-14 13:02:19 +05301801
1802 return rem;
1803}
1804EXPORT_SYMBOL(hci_recv_stream_fragment);
1805
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806/* ---- Interface to upper protocols ---- */
1807
1808/* Register/Unregister protocols.
1809 * hci_task_lock is used to ensure that no tasks are running. */
1810int hci_register_proto(struct hci_proto *hp)
1811{
1812 int err = 0;
1813
1814 BT_DBG("%p name %s id %d", hp, hp->name, hp->id);
1815
1816 if (hp->id >= HCI_MAX_PROTO)
1817 return -EINVAL;
1818
1819 write_lock_bh(&hci_task_lock);
1820
1821 if (!hci_proto[hp->id])
1822 hci_proto[hp->id] = hp;
1823 else
1824 err = -EEXIST;
1825
1826 write_unlock_bh(&hci_task_lock);
1827
1828 return err;
1829}
1830EXPORT_SYMBOL(hci_register_proto);
1831
1832int hci_unregister_proto(struct hci_proto *hp)
1833{
1834 int err = 0;
1835
1836 BT_DBG("%p name %s id %d", hp, hp->name, hp->id);
1837
1838 if (hp->id >= HCI_MAX_PROTO)
1839 return -EINVAL;
1840
1841 write_lock_bh(&hci_task_lock);
1842
1843 if (hci_proto[hp->id])
1844 hci_proto[hp->id] = NULL;
1845 else
1846 err = -ENOENT;
1847
1848 write_unlock_bh(&hci_task_lock);
1849
1850 return err;
1851}
1852EXPORT_SYMBOL(hci_unregister_proto);
1853
1854int hci_register_cb(struct hci_cb *cb)
1855{
1856 BT_DBG("%p name %s", cb, cb->name);
1857
1858 write_lock_bh(&hci_cb_list_lock);
1859 list_add(&cb->list, &hci_cb_list);
1860 write_unlock_bh(&hci_cb_list_lock);
1861
1862 return 0;
1863}
1864EXPORT_SYMBOL(hci_register_cb);
1865
1866int hci_unregister_cb(struct hci_cb *cb)
1867{
1868 BT_DBG("%p name %s", cb, cb->name);
1869
1870 write_lock_bh(&hci_cb_list_lock);
1871 list_del(&cb->list);
1872 write_unlock_bh(&hci_cb_list_lock);
1873
1874 return 0;
1875}
1876EXPORT_SYMBOL(hci_unregister_cb);
1877
1878static int hci_send_frame(struct sk_buff *skb)
1879{
1880 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
1881
1882 if (!hdev) {
1883 kfree_skb(skb);
1884 return -ENODEV;
1885 }
1886
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001887 BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888
1889 if (atomic_read(&hdev->promisc)) {
1890 /* Time stamp */
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001891 __net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001893 hci_send_to_sock(hdev, skb, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 }
1895
1896 /* Get rid of skb owner, prior to sending to the driver. */
1897 skb_orphan(skb);
1898
1899 return hdev->send(skb);
1900}
1901
1902/* Send HCI command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001903int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904{
1905 int len = HCI_COMMAND_HDR_SIZE + plen;
1906 struct hci_command_hdr *hdr;
1907 struct sk_buff *skb;
1908
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001909 BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
1911 skb = bt_skb_alloc(len, GFP_ATOMIC);
1912 if (!skb) {
Marcel Holtmannef222012007-07-11 06:42:04 +02001913 BT_ERR("%s no memory for command", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 return -ENOMEM;
1915 }
1916
1917 hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001918 hdr->opcode = cpu_to_le16(opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 hdr->plen = plen;
1920
1921 if (plen)
1922 memcpy(skb_put(skb, plen), param, plen);
1923
1924 BT_DBG("skb len %d", skb->len);
1925
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001926 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 skb->dev = (void *) hdev;
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001928
Johan Hedberga5040ef2011-01-10 13:28:59 +02001929 if (test_bit(HCI_INIT, &hdev->flags))
1930 hdev->init_last_cmd = opcode;
1931
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 skb_queue_tail(&hdev->cmd_q, skb);
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001933 tasklet_schedule(&hdev->cmd_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934
1935 return 0;
1936}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
1938/* Get data from the previously sent command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001939void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940{
1941 struct hci_command_hdr *hdr;
1942
1943 if (!hdev->sent_cmd)
1944 return NULL;
1945
1946 hdr = (void *) hdev->sent_cmd->data;
1947
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001948 if (hdr->opcode != cpu_to_le16(opcode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 return NULL;
1950
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001951 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952
1953 return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE;
1954}
1955
1956/* Send ACL data */
1957static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags)
1958{
1959 struct hci_acl_hdr *hdr;
1960 int len = skb->len;
1961
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001962 skb_push(skb, HCI_ACL_HDR_SIZE);
1963 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001964 hdr = (struct hci_acl_hdr *)skb_transport_header(skb);
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07001965 hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags));
1966 hdr->dlen = cpu_to_le16(len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967}
1968
Gustavo F. Padovan9a9c6a32010-05-01 16:15:43 -03001969void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970{
1971 struct hci_dev *hdev = conn->hdev;
1972 struct sk_buff *list;
1973
1974 BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags);
1975
1976 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001977 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Andrei Emeltchenkoe7021122011-01-03 11:14:36 +02001978 hci_add_acl_hdr(skb, conn->handle, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001980 list = skb_shinfo(skb)->frag_list;
1981 if (!list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 /* Non fragmented */
1983 BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len);
1984
1985 skb_queue_tail(&conn->data_q, skb);
1986 } else {
1987 /* Fragmented */
1988 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
1989
1990 skb_shinfo(skb)->frag_list = NULL;
1991
1992 /* Queue all fragments atomically */
1993 spin_lock_bh(&conn->data_q.lock);
1994
1995 __skb_queue_tail(&conn->data_q, skb);
Andrei Emeltchenkoe7021122011-01-03 11:14:36 +02001996
1997 flags &= ~ACL_START;
1998 flags |= ACL_CONT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 do {
2000 skb = list; list = list->next;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002001
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002003 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Andrei Emeltchenkoe7021122011-01-03 11:14:36 +02002004 hci_add_acl_hdr(skb, conn->handle, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005
2006 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
2007
2008 __skb_queue_tail(&conn->data_q, skb);
2009 } while (list);
2010
2011 spin_unlock_bh(&conn->data_q.lock);
2012 }
2013
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002014 tasklet_schedule(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015}
2016EXPORT_SYMBOL(hci_send_acl);
2017
2018/* Send SCO data */
Gustavo F. Padovan0d861d82010-05-01 16:15:35 -03002019void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020{
2021 struct hci_dev *hdev = conn->hdev;
2022 struct hci_sco_hdr hdr;
2023
2024 BT_DBG("%s len %d", hdev->name, skb->len);
2025
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07002026 hdr.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 hdr.dlen = skb->len;
2028
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03002029 skb_push(skb, HCI_SCO_HDR_SIZE);
2030 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07002031 memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032
2033 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002034 bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002035
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 skb_queue_tail(&conn->data_q, skb);
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002037 tasklet_schedule(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038}
2039EXPORT_SYMBOL(hci_send_sco);
2040
2041/* ---- HCI TX task (outgoing data) ---- */
2042
2043/* HCI Connection scheduler */
2044static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote)
2045{
2046 struct hci_conn_hash *h = &hdev->conn_hash;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02002047 struct hci_conn *conn = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 int num = 0, min = ~0;
2049 struct list_head *p;
2050
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002051 /* We don't have to lock device here. Connections are always
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 * added and removed with TX task disabled. */
2053 list_for_each(p, &h->list) {
2054 struct hci_conn *c;
2055 c = list_entry(p, struct hci_conn, list);
2056
Marcel Holtmann769be972008-07-14 20:13:49 +02002057 if (c->type != type || skb_queue_empty(&c->data_q))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 continue;
Marcel Holtmann769be972008-07-14 20:13:49 +02002059
2060 if (c->state != BT_CONNECTED && c->state != BT_CONFIG)
2061 continue;
2062
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 num++;
2064
2065 if (c->sent < min) {
2066 min = c->sent;
2067 conn = c;
2068 }
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002069
2070 if (hci_conn_num(hdev, type) == num)
2071 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 }
2073
2074 if (conn) {
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002075 int cnt, q;
2076
2077 switch (conn->type) {
2078 case ACL_LINK:
2079 cnt = hdev->acl_cnt;
2080 break;
2081 case SCO_LINK:
2082 case ESCO_LINK:
2083 cnt = hdev->sco_cnt;
2084 break;
2085 case LE_LINK:
2086 cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
2087 break;
2088 default:
2089 cnt = 0;
2090 BT_ERR("Unknown link type");
2091 }
2092
2093 q = cnt / num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 *quote = q ? q : 1;
2095 } else
2096 *quote = 0;
2097
2098 BT_DBG("conn %p quote %d", conn, *quote);
2099 return conn;
2100}
2101
Ville Tervobae1f5d92011-02-10 22:38:53 -03002102static inline void hci_link_tx_to(struct hci_dev *hdev, __u8 type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103{
2104 struct hci_conn_hash *h = &hdev->conn_hash;
2105 struct list_head *p;
2106 struct hci_conn *c;
2107
Ville Tervobae1f5d92011-02-10 22:38:53 -03002108 BT_ERR("%s link tx timeout", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
2110 /* Kill stalled connections */
2111 list_for_each(p, &h->list) {
2112 c = list_entry(p, struct hci_conn, list);
Ville Tervobae1f5d92011-02-10 22:38:53 -03002113 if (c->type == type && c->sent) {
2114 BT_ERR("%s killing stalled connection %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 hdev->name, batostr(&c->dst));
2116 hci_acl_disconn(c, 0x13);
2117 }
2118 }
2119}
2120
2121static inline void hci_sched_acl(struct hci_dev *hdev)
2122{
2123 struct hci_conn *conn;
2124 struct sk_buff *skb;
2125 int quote;
2126
2127 BT_DBG("%s", hdev->name);
2128
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002129 if (!hci_conn_num(hdev, ACL_LINK))
2130 return;
2131
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 if (!test_bit(HCI_RAW, &hdev->flags)) {
2133 /* ACL tx timeout must be longer than maximum
2134 * link supervision timeout (40.9 seconds) */
S.Çağlar Onur824530212008-02-17 23:25:57 -08002135 if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45))
Ville Tervobae1f5d92011-02-10 22:38:53 -03002136 hci_link_tx_to(hdev, ACL_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 }
2138
2139 while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, &quote))) {
2140 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2141 BT_DBG("skb %p len %d", skb, skb->len);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002142
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07002143 hci_conn_enter_active_mode(conn, bt_cb(skb)->force_active);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002144
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 hci_send_frame(skb);
2146 hdev->acl_last_tx = jiffies;
2147
2148 hdev->acl_cnt--;
2149 conn->sent++;
2150 }
2151 }
2152}
2153
2154/* Schedule SCO */
2155static inline void hci_sched_sco(struct hci_dev *hdev)
2156{
2157 struct hci_conn *conn;
2158 struct sk_buff *skb;
2159 int quote;
2160
2161 BT_DBG("%s", hdev->name);
2162
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002163 if (!hci_conn_num(hdev, SCO_LINK))
2164 return;
2165
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, &quote))) {
2167 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2168 BT_DBG("skb %p len %d", skb, skb->len);
2169 hci_send_frame(skb);
2170
2171 conn->sent++;
2172 if (conn->sent == ~0)
2173 conn->sent = 0;
2174 }
2175 }
2176}
2177
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002178static inline void hci_sched_esco(struct hci_dev *hdev)
2179{
2180 struct hci_conn *conn;
2181 struct sk_buff *skb;
2182 int quote;
2183
2184 BT_DBG("%s", hdev->name);
2185
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002186 if (!hci_conn_num(hdev, ESCO_LINK))
2187 return;
2188
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002189 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, &quote))) {
2190 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2191 BT_DBG("skb %p len %d", skb, skb->len);
2192 hci_send_frame(skb);
2193
2194 conn->sent++;
2195 if (conn->sent == ~0)
2196 conn->sent = 0;
2197 }
2198 }
2199}
2200
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002201static inline void hci_sched_le(struct hci_dev *hdev)
2202{
2203 struct hci_conn *conn;
2204 struct sk_buff *skb;
2205 int quote, cnt;
2206
2207 BT_DBG("%s", hdev->name);
2208
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002209 if (!hci_conn_num(hdev, LE_LINK))
2210 return;
2211
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002212 if (!test_bit(HCI_RAW, &hdev->flags)) {
2213 /* LE tx timeout must be longer than maximum
2214 * link supervision timeout (40.9 seconds) */
Ville Tervobae1f5d92011-02-10 22:38:53 -03002215 if (!hdev->le_cnt && hdev->le_pkts &&
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002216 time_after(jiffies, hdev->le_last_tx + HZ * 45))
Ville Tervobae1f5d92011-02-10 22:38:53 -03002217 hci_link_tx_to(hdev, LE_LINK);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002218 }
2219
2220 cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt;
2221 while (cnt && (conn = hci_low_sent(hdev, LE_LINK, &quote))) {
2222 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2223 BT_DBG("skb %p len %d", skb, skb->len);
2224
2225 hci_send_frame(skb);
2226 hdev->le_last_tx = jiffies;
2227
2228 cnt--;
2229 conn->sent++;
2230 }
2231 }
2232 if (hdev->le_pkts)
2233 hdev->le_cnt = cnt;
2234 else
2235 hdev->acl_cnt = cnt;
2236}
2237
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238static void hci_tx_task(unsigned long arg)
2239{
2240 struct hci_dev *hdev = (struct hci_dev *) arg;
2241 struct sk_buff *skb;
2242
2243 read_lock(&hci_task_lock);
2244
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002245 BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt,
2246 hdev->sco_cnt, hdev->le_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247
2248 /* Schedule queues and send stuff to HCI driver */
2249
2250 hci_sched_acl(hdev);
2251
2252 hci_sched_sco(hdev);
2253
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002254 hci_sched_esco(hdev);
2255
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002256 hci_sched_le(hdev);
2257
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 /* Send next queued raw (unknown type) packet */
2259 while ((skb = skb_dequeue(&hdev->raw_q)))
2260 hci_send_frame(skb);
2261
2262 read_unlock(&hci_task_lock);
2263}
2264
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002265/* ----- HCI RX task (incoming data processing) ----- */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266
2267/* ACL data packet */
2268static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb)
2269{
2270 struct hci_acl_hdr *hdr = (void *) skb->data;
2271 struct hci_conn *conn;
2272 __u16 handle, flags;
2273
2274 skb_pull(skb, HCI_ACL_HDR_SIZE);
2275
2276 handle = __le16_to_cpu(hdr->handle);
2277 flags = hci_flags(handle);
2278 handle = hci_handle(handle);
2279
2280 BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags);
2281
2282 hdev->stat.acl_rx++;
2283
2284 hci_dev_lock(hdev);
2285 conn = hci_conn_hash_lookup_handle(hdev, handle);
2286 hci_dev_unlock(hdev);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002287
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 if (conn) {
2289 register struct hci_proto *hp;
2290
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -07002291 hci_conn_enter_active_mode(conn, bt_cb(skb)->force_active);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002292
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 /* Send to upper protocol */
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002294 hp = hci_proto[HCI_PROTO_L2CAP];
2295 if (hp && hp->recv_acldata) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 hp->recv_acldata(conn, skb, flags);
2297 return;
2298 }
2299 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002300 BT_ERR("%s ACL packet for unknown connection handle %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 hdev->name, handle);
2302 }
2303
2304 kfree_skb(skb);
2305}
2306
2307/* SCO data packet */
2308static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb)
2309{
2310 struct hci_sco_hdr *hdr = (void *) skb->data;
2311 struct hci_conn *conn;
2312 __u16 handle;
2313
2314 skb_pull(skb, HCI_SCO_HDR_SIZE);
2315
2316 handle = __le16_to_cpu(hdr->handle);
2317
2318 BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle);
2319
2320 hdev->stat.sco_rx++;
2321
2322 hci_dev_lock(hdev);
2323 conn = hci_conn_hash_lookup_handle(hdev, handle);
2324 hci_dev_unlock(hdev);
2325
2326 if (conn) {
2327 register struct hci_proto *hp;
2328
2329 /* Send to upper protocol */
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002330 hp = hci_proto[HCI_PROTO_SCO];
2331 if (hp && hp->recv_scodata) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 hp->recv_scodata(conn, skb);
2333 return;
2334 }
2335 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002336 BT_ERR("%s SCO packet for unknown connection handle %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 hdev->name, handle);
2338 }
2339
2340 kfree_skb(skb);
2341}
2342
Marcel Holtmann65164552005-10-28 19:20:48 +02002343static void hci_rx_task(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344{
2345 struct hci_dev *hdev = (struct hci_dev *) arg;
2346 struct sk_buff *skb;
2347
2348 BT_DBG("%s", hdev->name);
2349
2350 read_lock(&hci_task_lock);
2351
2352 while ((skb = skb_dequeue(&hdev->rx_q))) {
2353 if (atomic_read(&hdev->promisc)) {
2354 /* Send copy to the sockets */
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02002355 hci_send_to_sock(hdev, skb, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356 }
2357
2358 if (test_bit(HCI_RAW, &hdev->flags)) {
2359 kfree_skb(skb);
2360 continue;
2361 }
2362
2363 if (test_bit(HCI_INIT, &hdev->flags)) {
2364 /* Don't process data packets in this states. */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002365 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 case HCI_ACLDATA_PKT:
2367 case HCI_SCODATA_PKT:
2368 kfree_skb(skb);
2369 continue;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 }
2372
2373 /* Process frame */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002374 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 case HCI_EVENT_PKT:
2376 hci_event_packet(hdev, skb);
2377 break;
2378
2379 case HCI_ACLDATA_PKT:
2380 BT_DBG("%s ACL data packet", hdev->name);
2381 hci_acldata_packet(hdev, skb);
2382 break;
2383
2384 case HCI_SCODATA_PKT:
2385 BT_DBG("%s SCO data packet", hdev->name);
2386 hci_scodata_packet(hdev, skb);
2387 break;
2388
2389 default:
2390 kfree_skb(skb);
2391 break;
2392 }
2393 }
2394
2395 read_unlock(&hci_task_lock);
2396}
2397
2398static void hci_cmd_task(unsigned long arg)
2399{
2400 struct hci_dev *hdev = (struct hci_dev *) arg;
2401 struct sk_buff *skb;
2402
2403 BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt));
2404
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 /* Send queued commands */
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02002406 if (atomic_read(&hdev->cmd_cnt)) {
2407 skb = skb_dequeue(&hdev->cmd_q);
2408 if (!skb)
2409 return;
2410
Wei Yongjun7585b972009-02-25 18:29:52 +08002411 kfree_skb(hdev->sent_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002413 hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC);
2414 if (hdev->sent_cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 atomic_dec(&hdev->cmd_cnt);
2416 hci_send_frame(skb);
Szymon Janc7bdb8a52011-07-26 22:46:54 +02002417 if (test_bit(HCI_RESET, &hdev->flags))
2418 del_timer(&hdev->cmd_timer);
2419 else
2420 mod_timer(&hdev->cmd_timer,
Ville Tervo6bd32322011-02-16 16:32:41 +02002421 jiffies + msecs_to_jiffies(HCI_CMD_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 } else {
2423 skb_queue_head(&hdev->cmd_q, skb);
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002424 tasklet_schedule(&hdev->cmd_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425 }
2426 }
2427}