blob: 596660d37c5e56d6a0178b16b288a2d3c868f965 [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
Gustavo F. Padovan590051d2011-12-18 13:39:33 -02004 Copyright (C) 2011 ProFUSION Embedded Systems
Linus Torvalds1da177e2005-04-16 15:20:36 -07005
6 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License version 2 as
10 published by the Free Software Foundation;
11
12 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
13 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
15 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090016 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
17 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090021 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
22 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 SOFTWARE IS DISCLAIMED.
24*/
25
26/* Bluetooth HCI core. */
27
Gustavo Padovan8c520a52012-05-23 04:04:22 -030028#include <linux/export.h>
Sasha Levin3df92b32012-05-27 22:36:56 +020029#include <linux/idr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Marcel Holtmann611b30f2009-06-08 14:41:38 +020031#include <linux/rfkill.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#include <net/bluetooth/bluetooth.h>
34#include <net/bluetooth/hci_core.h>
35
Marcel Holtmannb78752c2010-08-08 23:06:53 -040036static void hci_rx_work(struct work_struct *work);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -020037static void hci_cmd_work(struct work_struct *work);
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -020038static void hci_tx_work(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Linus Torvalds1da177e2005-04-16 15:20:36 -070040/* HCI device list */
41LIST_HEAD(hci_dev_list);
42DEFINE_RWLOCK(hci_dev_list_lock);
43
44/* HCI callback list */
45LIST_HEAD(hci_cb_list);
46DEFINE_RWLOCK(hci_cb_list_lock);
47
Sasha Levin3df92b32012-05-27 22:36:56 +020048/* HCI ID Numbering */
49static DEFINE_IDA(hci_index_ida);
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051/* ---- HCI notifications ---- */
52
Marcel Holtmann65164552005-10-28 19:20:48 +020053static void hci_notify(struct hci_dev *hdev, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -070054{
Marcel Holtmann040030e2012-02-20 14:50:37 +010055 hci_sock_dev_event(hdev, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056}
57
58/* ---- HCI requests ---- */
59
Johan Hedberg23bb5762010-12-21 23:01:27 +020060void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +030062 BT_DBG("%s command 0x%4.4x result 0x%2.2x", hdev->name, cmd, result);
Johan Hedberg23bb5762010-12-21 23:01:27 +020063
Johan Hedberga5040ef2011-01-10 13:28:59 +020064 /* If this is the init phase check if the completed command matches
65 * the last init command, and if not just return.
66 */
Johan Hedberg75fb0e32012-03-01 21:35:55 +020067 if (test_bit(HCI_INIT, &hdev->flags) && hdev->init_last_cmd != cmd) {
68 struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data;
Andrei Emeltchenko1036b892012-03-12 15:59:33 +020069 u16 opcode = __le16_to_cpu(sent->opcode);
Johan Hedberg75fb0e32012-03-01 21:35:55 +020070 struct sk_buff *skb;
71
72 /* Some CSR based controllers generate a spontaneous
73 * reset complete event during init and any pending
74 * command will never be completed. In such a case we
75 * need to resend whatever was the last sent
76 * command.
77 */
78
Andrei Emeltchenko1036b892012-03-12 15:59:33 +020079 if (cmd != HCI_OP_RESET || opcode == HCI_OP_RESET)
Johan Hedberg75fb0e32012-03-01 21:35:55 +020080 return;
81
82 skb = skb_clone(hdev->sent_cmd, GFP_ATOMIC);
83 if (skb) {
84 skb_queue_head(&hdev->cmd_q, skb);
85 queue_work(hdev->workqueue, &hdev->cmd_work);
86 }
87
Johan Hedberg23bb5762010-12-21 23:01:27 +020088 return;
Johan Hedberg75fb0e32012-03-01 21:35:55 +020089 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91 if (hdev->req_status == HCI_REQ_PEND) {
92 hdev->req_result = result;
93 hdev->req_status = HCI_REQ_DONE;
94 wake_up_interruptible(&hdev->req_wait_q);
95 }
96}
97
98static void hci_req_cancel(struct hci_dev *hdev, int err)
99{
100 BT_DBG("%s err 0x%2.2x", hdev->name, err);
101
102 if (hdev->req_status == HCI_REQ_PEND) {
103 hdev->req_result = err;
104 hdev->req_status = HCI_REQ_CANCELED;
105 wake_up_interruptible(&hdev->req_wait_q);
106 }
107}
108
109/* Execute request and wait for completion. */
Gustavo Padovana8c5fb12012-05-17 00:36:26 -0300110static int __hci_request(struct hci_dev *hdev,
111 void (*req)(struct hci_dev *hdev, unsigned long opt),
112 unsigned long opt, __u32 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
114 DECLARE_WAITQUEUE(wait, current);
115 int err = 0;
116
117 BT_DBG("%s start", hdev->name);
118
119 hdev->req_status = HCI_REQ_PEND;
120
121 add_wait_queue(&hdev->req_wait_q, &wait);
122 set_current_state(TASK_INTERRUPTIBLE);
123
124 req(hdev, opt);
125 schedule_timeout(timeout);
126
127 remove_wait_queue(&hdev->req_wait_q, &wait);
128
129 if (signal_pending(current))
130 return -EINTR;
131
132 switch (hdev->req_status) {
133 case HCI_REQ_DONE:
Joe Perchese1750722011-06-29 18:18:29 -0700134 err = -bt_to_errno(hdev->req_result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 break;
136
137 case HCI_REQ_CANCELED:
138 err = -hdev->req_result;
139 break;
140
141 default:
142 err = -ETIMEDOUT;
143 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700144 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Johan Hedberga5040ef2011-01-10 13:28:59 +0200146 hdev->req_status = hdev->req_result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148 BT_DBG("%s end: err %d", hdev->name, err);
149
150 return err;
151}
152
Gustavo Padovan6039aa732012-05-23 04:04:18 -0300153static int hci_request(struct hci_dev *hdev,
154 void (*req)(struct hci_dev *hdev, unsigned long opt),
155 unsigned long opt, __u32 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156{
157 int ret;
158
Marcel Holtmann7c6a3292008-09-12 03:11:54 +0200159 if (!test_bit(HCI_UP, &hdev->flags))
160 return -ENETDOWN;
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 /* Serialize all requests */
163 hci_req_lock(hdev);
164 ret = __hci_request(hdev, req, opt, timeout);
165 hci_req_unlock(hdev);
166
167 return ret;
168}
169
170static void hci_reset_req(struct hci_dev *hdev, unsigned long opt)
171{
172 BT_DBG("%s %ld", hdev->name, opt);
173
174 /* Reset device */
Gustavo F. Padovanf630cf02011-03-16 15:36:29 -0300175 set_bit(HCI_RESET, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200176 hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177}
178
Andrei Emeltchenkoe61ef4992011-12-19 16:31:27 +0200179static void bredr_init(struct hci_dev *hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
Andrei Emeltchenko2455a3e2011-12-19 16:31:28 +0200181 hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED;
182
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 /* Read Local Supported Features */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200184 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
Marcel Holtmann1143e5a2006-09-23 09:57:20 +0200186 /* Read Local Version */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200187 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188}
189
Andrei Emeltchenkoe61ef4992011-12-19 16:31:27 +0200190static void amp_init(struct hci_dev *hdev)
191{
Andrei Emeltchenko2455a3e2011-12-19 16:31:28 +0200192 hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED;
193
Andrei Emeltchenkoe61ef4992011-12-19 16:31:27 +0200194 /* Read Local Version */
195 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL);
Andrei Emeltchenko6bcbc482012-03-28 16:31:24 +0300196
197 /* Read Local AMP Info */
198 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL);
Andrei Emeltchenkoe71dfab2012-09-06 15:05:46 +0300199
200 /* Read Data Blk size */
201 hci_send_cmd(hdev, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL);
Andrei Emeltchenkoe61ef4992011-12-19 16:31:27 +0200202}
203
204static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
205{
206 struct sk_buff *skb;
207
208 BT_DBG("%s %ld", hdev->name, opt);
209
210 /* Driver initialization */
211
212 /* Special commands */
213 while ((skb = skb_dequeue(&hdev->driver_init))) {
214 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
215 skb->dev = (void *) hdev;
216
217 skb_queue_tail(&hdev->cmd_q, skb);
218 queue_work(hdev->workqueue, &hdev->cmd_work);
219 }
220 skb_queue_purge(&hdev->driver_init);
221
Andrei Emeltchenko11778712012-06-11 11:13:10 +0300222 /* Reset */
223 if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks))
224 hci_reset_req(hdev, 0);
225
Andrei Emeltchenkoe61ef4992011-12-19 16:31:27 +0200226 switch (hdev->dev_type) {
227 case HCI_BREDR:
228 bredr_init(hdev);
229 break;
230
231 case HCI_AMP:
232 amp_init(hdev);
233 break;
234
235 default:
236 BT_ERR("Unknown device type %d", hdev->dev_type);
237 break;
238 }
Andrei Emeltchenkoe61ef4992011-12-19 16:31:27 +0200239}
240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241static void hci_scan_req(struct hci_dev *hdev, unsigned long opt)
242{
243 __u8 scan = opt;
244
245 BT_DBG("%s %x", hdev->name, scan);
246
247 /* Inquiry and Page scans */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200248 hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249}
250
251static void hci_auth_req(struct hci_dev *hdev, unsigned long opt)
252{
253 __u8 auth = opt;
254
255 BT_DBG("%s %x", hdev->name, auth);
256
257 /* Authentication */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200258 hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259}
260
261static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt)
262{
263 __u8 encrypt = opt;
264
265 BT_DBG("%s %x", hdev->name, encrypt);
266
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200267 /* Encryption */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200268 hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200271static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt)
272{
273 __le16 policy = cpu_to_le16(opt);
274
Marcel Holtmanna418b892008-11-30 12:17:28 +0100275 BT_DBG("%s %x", hdev->name, policy);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200276
277 /* Default link policy */
278 hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy);
279}
280
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900281/* Get HCI device by index.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 * Device is held on return. */
283struct hci_dev *hci_dev_get(int index)
284{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200285 struct hci_dev *hdev = NULL, *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 BT_DBG("%d", index);
288
289 if (index < 0)
290 return NULL;
291
292 read_lock(&hci_dev_list_lock);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200293 list_for_each_entry(d, &hci_dev_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 if (d->id == index) {
295 hdev = hci_dev_hold(d);
296 break;
297 }
298 }
299 read_unlock(&hci_dev_list_lock);
300 return hdev;
301}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303/* ---- Inquiry support ---- */
Johan Hedbergff9ef572012-01-04 14:23:45 +0200304
Johan Hedberg30dc78e2012-01-04 15:44:20 +0200305bool hci_discovery_active(struct hci_dev *hdev)
306{
307 struct discovery_state *discov = &hdev->discovery;
308
Andre Guedes6fbe1952012-02-03 17:47:58 -0300309 switch (discov->state) {
Andre Guedes343f9352012-02-17 20:39:37 -0300310 case DISCOVERY_FINDING:
Andre Guedes6fbe1952012-02-03 17:47:58 -0300311 case DISCOVERY_RESOLVING:
Johan Hedberg30dc78e2012-01-04 15:44:20 +0200312 return true;
313
Andre Guedes6fbe1952012-02-03 17:47:58 -0300314 default:
315 return false;
316 }
Johan Hedberg30dc78e2012-01-04 15:44:20 +0200317}
318
Johan Hedbergff9ef572012-01-04 14:23:45 +0200319void hci_discovery_set_state(struct hci_dev *hdev, int state)
320{
321 BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state);
322
323 if (hdev->discovery.state == state)
324 return;
325
326 switch (state) {
327 case DISCOVERY_STOPPED:
Andre Guedes7b99b652012-02-13 15:41:02 -0300328 if (hdev->discovery.state != DISCOVERY_STARTING)
329 mgmt_discovering(hdev, 0);
Johan Hedbergff9ef572012-01-04 14:23:45 +0200330 break;
331 case DISCOVERY_STARTING:
332 break;
Andre Guedes343f9352012-02-17 20:39:37 -0300333 case DISCOVERY_FINDING:
Johan Hedbergff9ef572012-01-04 14:23:45 +0200334 mgmt_discovering(hdev, 1);
335 break;
Johan Hedberg30dc78e2012-01-04 15:44:20 +0200336 case DISCOVERY_RESOLVING:
337 break;
Johan Hedbergff9ef572012-01-04 14:23:45 +0200338 case DISCOVERY_STOPPING:
339 break;
340 }
341
342 hdev->discovery.state = state;
343}
344
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345static void inquiry_cache_flush(struct hci_dev *hdev)
346{
Johan Hedberg30883512012-01-04 14:16:21 +0200347 struct discovery_state *cache = &hdev->discovery;
Johan Hedbergb57c1a52012-01-03 16:03:00 +0200348 struct inquiry_entry *p, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Johan Hedberg561aafb2012-01-04 13:31:59 +0200350 list_for_each_entry_safe(p, n, &cache->all, all) {
351 list_del(&p->all);
Johan Hedbergb57c1a52012-01-03 16:03:00 +0200352 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 }
Johan Hedberg561aafb2012-01-04 13:31:59 +0200354
355 INIT_LIST_HEAD(&cache->unknown);
356 INIT_LIST_HEAD(&cache->resolve);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357}
358
Gustavo Padovana8c5fb12012-05-17 00:36:26 -0300359struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
360 bdaddr_t *bdaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
Johan Hedberg30883512012-01-04 14:16:21 +0200362 struct discovery_state *cache = &hdev->discovery;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 struct inquiry_entry *e;
364
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300365 BT_DBG("cache %p, %pMR", cache, bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Johan Hedberg561aafb2012-01-04 13:31:59 +0200367 list_for_each_entry(e, &cache->all, all) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 if (!bacmp(&e->data.bdaddr, bdaddr))
Johan Hedbergb57c1a52012-01-03 16:03:00 +0200369 return e;
370 }
371
372 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373}
374
Johan Hedberg561aafb2012-01-04 13:31:59 +0200375struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300376 bdaddr_t *bdaddr)
Johan Hedberg561aafb2012-01-04 13:31:59 +0200377{
Johan Hedberg30883512012-01-04 14:16:21 +0200378 struct discovery_state *cache = &hdev->discovery;
Johan Hedberg561aafb2012-01-04 13:31:59 +0200379 struct inquiry_entry *e;
380
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300381 BT_DBG("cache %p, %pMR", cache, bdaddr);
Johan Hedberg561aafb2012-01-04 13:31:59 +0200382
383 list_for_each_entry(e, &cache->unknown, list) {
384 if (!bacmp(&e->data.bdaddr, bdaddr))
385 return e;
386 }
387
388 return NULL;
389}
390
Johan Hedberg30dc78e2012-01-04 15:44:20 +0200391struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300392 bdaddr_t *bdaddr,
393 int state)
Johan Hedberg30dc78e2012-01-04 15:44:20 +0200394{
395 struct discovery_state *cache = &hdev->discovery;
396 struct inquiry_entry *e;
397
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300398 BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state);
Johan Hedberg30dc78e2012-01-04 15:44:20 +0200399
400 list_for_each_entry(e, &cache->resolve, list) {
401 if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state)
402 return e;
403 if (!bacmp(&e->data.bdaddr, bdaddr))
404 return e;
405 }
406
407 return NULL;
408}
409
Johan Hedberga3d4e202012-01-09 00:53:02 +0200410void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300411 struct inquiry_entry *ie)
Johan Hedberga3d4e202012-01-09 00:53:02 +0200412{
413 struct discovery_state *cache = &hdev->discovery;
414 struct list_head *pos = &cache->resolve;
415 struct inquiry_entry *p;
416
417 list_del(&ie->list);
418
419 list_for_each_entry(p, &cache->resolve, list) {
420 if (p->name_state != NAME_PENDING &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -0300421 abs(p->data.rssi) >= abs(ie->data.rssi))
Johan Hedberga3d4e202012-01-09 00:53:02 +0200422 break;
423 pos = &p->list;
424 }
425
426 list_add(&ie->list, pos);
427}
428
Johan Hedberg31754052012-01-04 13:39:52 +0200429bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300430 bool name_known, bool *ssp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431{
Johan Hedberg30883512012-01-04 14:16:21 +0200432 struct discovery_state *cache = &hdev->discovery;
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200433 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +0300435 BT_DBG("cache %p, %pMR", cache, &data->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Szymon Janc2b2fec42012-11-20 11:38:54 +0100437 hci_remove_remote_oob_data(hdev, &data->bdaddr);
438
Johan Hedberg388fc8f2012-02-23 00:38:59 +0200439 if (ssp)
440 *ssp = data->ssp_mode;
441
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200442 ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr);
Johan Hedberga3d4e202012-01-09 00:53:02 +0200443 if (ie) {
Johan Hedberg388fc8f2012-02-23 00:38:59 +0200444 if (ie->data.ssp_mode && ssp)
445 *ssp = true;
446
Johan Hedberga3d4e202012-01-09 00:53:02 +0200447 if (ie->name_state == NAME_NEEDED &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -0300448 data->rssi != ie->data.rssi) {
Johan Hedberga3d4e202012-01-09 00:53:02 +0200449 ie->data.rssi = data->rssi;
450 hci_inquiry_cache_update_resolve(hdev, ie);
451 }
452
Johan Hedberg561aafb2012-01-04 13:31:59 +0200453 goto update;
Johan Hedberga3d4e202012-01-09 00:53:02 +0200454 }
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200455
Johan Hedberg561aafb2012-01-04 13:31:59 +0200456 /* Entry not in the cache. Add new one. */
457 ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC);
458 if (!ie)
Johan Hedberg31754052012-01-04 13:39:52 +0200459 return false;
Johan Hedberg561aafb2012-01-04 13:31:59 +0200460
461 list_add(&ie->all, &cache->all);
462
463 if (name_known) {
464 ie->name_state = NAME_KNOWN;
465 } else {
466 ie->name_state = NAME_NOT_KNOWN;
467 list_add(&ie->list, &cache->unknown);
468 }
469
470update:
471 if (name_known && ie->name_state != NAME_KNOWN &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -0300472 ie->name_state != NAME_PENDING) {
Johan Hedberg561aafb2012-01-04 13:31:59 +0200473 ie->name_state = NAME_KNOWN;
474 list_del(&ie->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 }
476
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200477 memcpy(&ie->data, data, sizeof(*data));
478 ie->timestamp = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 cache->timestamp = jiffies;
Johan Hedberg31754052012-01-04 13:39:52 +0200480
481 if (ie->name_state == NAME_NOT_KNOWN)
482 return false;
483
484 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
487static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf)
488{
Johan Hedberg30883512012-01-04 14:16:21 +0200489 struct discovery_state *cache = &hdev->discovery;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 struct inquiry_info *info = (struct inquiry_info *) buf;
491 struct inquiry_entry *e;
492 int copied = 0;
493
Johan Hedberg561aafb2012-01-04 13:31:59 +0200494 list_for_each_entry(e, &cache->all, all) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 struct inquiry_data *data = &e->data;
Johan Hedbergb57c1a52012-01-03 16:03:00 +0200496
497 if (copied >= num)
498 break;
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 bacpy(&info->bdaddr, &data->bdaddr);
501 info->pscan_rep_mode = data->pscan_rep_mode;
502 info->pscan_period_mode = data->pscan_period_mode;
503 info->pscan_mode = data->pscan_mode;
504 memcpy(info->dev_class, data->dev_class, 3);
505 info->clock_offset = data->clock_offset;
Johan Hedbergb57c1a52012-01-03 16:03:00 +0200506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 info++;
Johan Hedbergb57c1a52012-01-03 16:03:00 +0200508 copied++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
510
511 BT_DBG("cache %p, copied %d", cache, copied);
512 return copied;
513}
514
515static void hci_inq_req(struct hci_dev *hdev, unsigned long opt)
516{
517 struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt;
518 struct hci_cp_inquiry cp;
519
520 BT_DBG("%s", hdev->name);
521
522 if (test_bit(HCI_INQUIRY, &hdev->flags))
523 return;
524
525 /* Start Inquiry */
526 memcpy(&cp.lap, &ir->lap, 3);
527 cp.length = ir->length;
528 cp.num_rsp = ir->num_rsp;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200529 hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530}
531
532int hci_inquiry(void __user *arg)
533{
534 __u8 __user *ptr = arg;
535 struct hci_inquiry_req ir;
536 struct hci_dev *hdev;
537 int err = 0, do_inquiry = 0, max_rsp;
538 long timeo;
539 __u8 *buf;
540
541 if (copy_from_user(&ir, ptr, sizeof(ir)))
542 return -EFAULT;
543
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200544 hdev = hci_dev_get(ir.dev_id);
545 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 return -ENODEV;
547
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300548 hci_dev_lock(hdev);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900549 if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX ||
Gustavo Padovana8c5fb12012-05-17 00:36:26 -0300550 inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 inquiry_cache_flush(hdev);
552 do_inquiry = 1;
553 }
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300554 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Marcel Holtmann04837f62006-07-03 10:02:33 +0200556 timeo = ir.length * msecs_to_jiffies(2000);
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200557
558 if (do_inquiry) {
559 err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo);
560 if (err < 0)
561 goto done;
562 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300564 /* for unlimited number of responses we will use buffer with
565 * 255 entries
566 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp;
568
569 /* cache_dump can't sleep. Therefore we allocate temp buffer and then
570 * copy it to the user space.
571 */
Szymon Janc01df8c32011-02-17 16:46:47 +0100572 buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL);
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200573 if (!buf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 err = -ENOMEM;
575 goto done;
576 }
577
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300578 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300580 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 BT_DBG("num_rsp %d", ir.num_rsp);
583
584 if (!copy_to_user(ptr, &ir, sizeof(ir))) {
585 ptr += sizeof(ir);
586 if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) *
Gustavo Padovana8c5fb12012-05-17 00:36:26 -0300587 ir.num_rsp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 err = -EFAULT;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900589 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 err = -EFAULT;
591
592 kfree(buf);
593
594done:
595 hci_dev_put(hdev);
596 return err;
597}
598
Johan Hedberg3f0f5242012-11-08 01:23:00 +0100599static u8 create_ad(struct hci_dev *hdev, u8 *ptr)
600{
601 u8 ad_len = 0, flags = 0;
602 size_t name_len;
603
604 if (test_bit(HCI_LE_PERIPHERAL, &hdev->dev_flags))
605 flags |= LE_AD_GENERAL;
606
607 if (!lmp_bredr_capable(hdev))
608 flags |= LE_AD_NO_BREDR;
609
610 if (lmp_le_br_capable(hdev))
611 flags |= LE_AD_SIM_LE_BREDR_CTRL;
612
613 if (lmp_host_le_br_capable(hdev))
614 flags |= LE_AD_SIM_LE_BREDR_HOST;
615
616 if (flags) {
617 BT_DBG("adv flags 0x%02x", flags);
618
619 ptr[0] = 2;
620 ptr[1] = EIR_FLAGS;
621 ptr[2] = flags;
622
623 ad_len += 3;
624 ptr += 3;
625 }
626
627 if (hdev->adv_tx_power != HCI_TX_POWER_INVALID) {
628 ptr[0] = 2;
629 ptr[1] = EIR_TX_POWER;
630 ptr[2] = (u8) hdev->adv_tx_power;
631
632 ad_len += 3;
633 ptr += 3;
634 }
635
636 name_len = strlen(hdev->dev_name);
637 if (name_len > 0) {
638 size_t max_len = HCI_MAX_AD_LENGTH - ad_len - 2;
639
640 if (name_len > max_len) {
641 name_len = max_len;
642 ptr[1] = EIR_NAME_SHORT;
643 } else
644 ptr[1] = EIR_NAME_COMPLETE;
645
646 ptr[0] = name_len + 1;
647
648 memcpy(ptr + 2, hdev->dev_name, name_len);
649
650 ad_len += (name_len + 2);
651 ptr += (name_len + 2);
652 }
653
654 return ad_len;
655}
656
657int hci_update_ad(struct hci_dev *hdev)
658{
659 struct hci_cp_le_set_adv_data cp;
660 u8 len;
661 int err;
662
663 hci_dev_lock(hdev);
664
665 if (!lmp_le_capable(hdev)) {
666 err = -EINVAL;
667 goto unlock;
668 }
669
670 memset(&cp, 0, sizeof(cp));
671
672 len = create_ad(hdev, cp.data);
673
674 if (hdev->adv_data_len == len &&
675 memcmp(cp.data, hdev->adv_data, len) == 0) {
676 err = 0;
677 goto unlock;
678 }
679
680 memcpy(hdev->adv_data, cp.data, sizeof(cp.data));
681 hdev->adv_data_len = len;
682
683 cp.length = len;
684 err = hci_send_cmd(hdev, HCI_OP_LE_SET_ADV_DATA, sizeof(cp), &cp);
685
686unlock:
687 hci_dev_unlock(hdev);
688
689 return err;
690}
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692/* ---- HCI ioctl helpers ---- */
693
694int hci_dev_open(__u16 dev)
695{
696 struct hci_dev *hdev;
697 int ret = 0;
698
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200699 hdev = hci_dev_get(dev);
700 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 return -ENODEV;
702
703 BT_DBG("%s %p", hdev->name, hdev);
704
705 hci_req_lock(hdev);
706
Johan Hovold94324962012-03-15 14:48:41 +0100707 if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) {
708 ret = -ENODEV;
709 goto done;
710 }
711
Marcel Holtmann611b30f2009-06-08 14:41:38 +0200712 if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) {
713 ret = -ERFKILL;
714 goto done;
715 }
716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 if (test_bit(HCI_UP, &hdev->flags)) {
718 ret = -EALREADY;
719 goto done;
720 }
721
722 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
723 set_bit(HCI_RAW, &hdev->flags);
724
Andrei Emeltchenko07e3b942011-11-11 17:02:15 +0200725 /* Treat all non BR/EDR controllers as raw devices if
726 enable_hs is not set */
727 if (hdev->dev_type != HCI_BREDR && !enable_hs)
Marcel Holtmann943da252010-02-13 02:28:41 +0100728 set_bit(HCI_RAW, &hdev->flags);
729
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 if (hdev->open(hdev)) {
731 ret = -EIO;
732 goto done;
733 }
734
735 if (!test_bit(HCI_RAW, &hdev->flags)) {
736 atomic_set(&hdev->cmd_cnt, 1);
737 set_bit(HCI_INIT, &hdev->flags);
Johan Hedberga5040ef2011-01-10 13:28:59 +0200738 hdev->init_last_cmd = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300740 ret = __hci_request(hdev, hci_init_req, 0, HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742 clear_bit(HCI_INIT, &hdev->flags);
743 }
744
745 if (!ret) {
746 hci_dev_hold(hdev);
747 set_bit(HCI_UP, &hdev->flags);
748 hci_notify(hdev, HCI_DEV_UP);
Johan Hedberg3f0f5242012-11-08 01:23:00 +0100749 hci_update_ad(hdev);
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +0300750 if (!test_bit(HCI_SETUP, &hdev->dev_flags) &&
751 mgmt_valid_hdev(hdev)) {
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300752 hci_dev_lock(hdev);
Johan Hedberg744cf192011-11-08 20:40:14 +0200753 mgmt_powered(hdev, 1);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300754 hci_dev_unlock(hdev);
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200755 }
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900756 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 /* Init failed, cleanup */
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -0200758 flush_work(&hdev->tx_work);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -0200759 flush_work(&hdev->cmd_work);
Marcel Holtmannb78752c2010-08-08 23:06:53 -0400760 flush_work(&hdev->rx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
762 skb_queue_purge(&hdev->cmd_q);
763 skb_queue_purge(&hdev->rx_q);
764
765 if (hdev->flush)
766 hdev->flush(hdev);
767
768 if (hdev->sent_cmd) {
769 kfree_skb(hdev->sent_cmd);
770 hdev->sent_cmd = NULL;
771 }
772
773 hdev->close(hdev);
774 hdev->flags = 0;
775 }
776
777done:
778 hci_req_unlock(hdev);
779 hci_dev_put(hdev);
780 return ret;
781}
782
783static int hci_dev_do_close(struct hci_dev *hdev)
784{
785 BT_DBG("%s %p", hdev->name, hdev);
786
Andre Guedes28b75a82012-02-03 17:48:00 -0300787 cancel_work_sync(&hdev->le_scan);
788
Vinicius Costa Gomes78c04c02012-09-14 16:34:46 -0300789 cancel_delayed_work(&hdev->power_off);
790
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 hci_req_cancel(hdev, ENODEV);
792 hci_req_lock(hdev);
793
794 if (!test_and_clear_bit(HCI_UP, &hdev->flags)) {
Vinicius Costa Gomesb79f44c2011-04-11 18:46:55 -0300795 del_timer_sync(&hdev->cmd_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 hci_req_unlock(hdev);
797 return 0;
798 }
799
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -0200800 /* Flush RX and TX works */
801 flush_work(&hdev->tx_work);
Marcel Holtmannb78752c2010-08-08 23:06:53 -0400802 flush_work(&hdev->rx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
Johan Hedberg16ab91a2011-11-07 22:16:02 +0200804 if (hdev->discov_timeout > 0) {
Johan Hedberge0f93092011-11-09 01:44:22 +0200805 cancel_delayed_work(&hdev->discov_off);
Johan Hedberg16ab91a2011-11-07 22:16:02 +0200806 hdev->discov_timeout = 0;
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200807 clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
Johan Hedberg16ab91a2011-11-07 22:16:02 +0200808 }
809
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200810 if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
Johan Hedberg7d785252011-12-15 00:47:39 +0200811 cancel_delayed_work(&hdev->service_cache);
812
Andre Guedes7ba8b4b2012-02-03 17:47:59 -0300813 cancel_delayed_work_sync(&hdev->le_scan_disable);
814
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300815 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 inquiry_cache_flush(hdev);
817 hci_conn_hash_flush(hdev);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300818 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
820 hci_notify(hdev, HCI_DEV_DOWN);
821
822 if (hdev->flush)
823 hdev->flush(hdev);
824
825 /* Reset device */
826 skb_queue_purge(&hdev->cmd_q);
827 atomic_set(&hdev->cmd_cnt, 1);
Johan Hedberg8af59462012-02-03 21:29:40 +0200828 if (!test_bit(HCI_RAW, &hdev->flags) &&
Szymon Janca6c511c2012-05-23 12:35:46 +0200829 test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 set_bit(HCI_INIT, &hdev->flags);
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300831 __hci_request(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 clear_bit(HCI_INIT, &hdev->flags);
833 }
834
Gustavo F. Padovanc347b762011-12-14 23:53:47 -0200835 /* flush cmd work */
836 flush_work(&hdev->cmd_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 /* Drop queues */
839 skb_queue_purge(&hdev->rx_q);
840 skb_queue_purge(&hdev->cmd_q);
841 skb_queue_purge(&hdev->raw_q);
842
843 /* Drop last sent command */
844 if (hdev->sent_cmd) {
Vinicius Costa Gomesb79f44c2011-04-11 18:46:55 -0300845 del_timer_sync(&hdev->cmd_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 kfree_skb(hdev->sent_cmd);
847 hdev->sent_cmd = NULL;
848 }
849
850 /* After this point our queues are empty
851 * and no tasks are scheduled. */
852 hdev->close(hdev);
853
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +0300854 if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags) &&
855 mgmt_valid_hdev(hdev)) {
Marcel Holtmann8ee56542012-02-21 12:33:48 +0100856 hci_dev_lock(hdev);
857 mgmt_powered(hdev, 0);
858 hci_dev_unlock(hdev);
859 }
Johan Hedberg5add6af2010-12-16 10:00:37 +0200860
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 /* Clear flags */
862 hdev->flags = 0;
863
Andrei Emeltchenkoced5c332012-11-28 17:59:42 +0200864 /* Controller radio is available but is currently powered down */
865 hdev->amp_status = 0;
866
Johan Hedberge59fda82012-02-22 18:11:53 +0200867 memset(hdev->eir, 0, sizeof(hdev->eir));
Johan Hedberg09b3c3f2012-02-22 22:01:41 +0200868 memset(hdev->dev_class, 0, sizeof(hdev->dev_class));
Johan Hedberge59fda82012-02-22 18:11:53 +0200869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 hci_req_unlock(hdev);
871
872 hci_dev_put(hdev);
873 return 0;
874}
875
876int hci_dev_close(__u16 dev)
877{
878 struct hci_dev *hdev;
879 int err;
880
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200881 hdev = hci_dev_get(dev);
882 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 return -ENODEV;
Marcel Holtmann8ee56542012-02-21 12:33:48 +0100884
885 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags))
886 cancel_delayed_work(&hdev->power_off);
887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 err = hci_dev_do_close(hdev);
Marcel Holtmann8ee56542012-02-21 12:33:48 +0100889
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 hci_dev_put(hdev);
891 return err;
892}
893
894int hci_dev_reset(__u16 dev)
895{
896 struct hci_dev *hdev;
897 int ret = 0;
898
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200899 hdev = hci_dev_get(dev);
900 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 return -ENODEV;
902
903 hci_req_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905 if (!test_bit(HCI_UP, &hdev->flags))
906 goto done;
907
908 /* Drop queues */
909 skb_queue_purge(&hdev->rx_q);
910 skb_queue_purge(&hdev->cmd_q);
911
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300912 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 inquiry_cache_flush(hdev);
914 hci_conn_hash_flush(hdev);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300915 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916
917 if (hdev->flush)
918 hdev->flush(hdev);
919
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900920 atomic_set(&hdev->cmd_cnt, 1);
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300921 hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 if (!test_bit(HCI_RAW, &hdev->flags))
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300924 ret = __hci_request(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 hci_req_unlock(hdev);
928 hci_dev_put(hdev);
929 return ret;
930}
931
932int hci_dev_reset_stat(__u16 dev)
933{
934 struct hci_dev *hdev;
935 int ret = 0;
936
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200937 hdev = hci_dev_get(dev);
938 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 return -ENODEV;
940
941 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
942
943 hci_dev_put(hdev);
944
945 return ret;
946}
947
948int hci_dev_cmd(unsigned int cmd, void __user *arg)
949{
950 struct hci_dev *hdev;
951 struct hci_dev_req dr;
952 int err = 0;
953
954 if (copy_from_user(&dr, arg, sizeof(dr)))
955 return -EFAULT;
956
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200957 hdev = hci_dev_get(dr.dev_id);
958 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 return -ENODEV;
960
961 switch (cmd) {
962 case HCISETAUTH:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200963 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300964 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 break;
966
967 case HCISETENCRYPT:
968 if (!lmp_encrypt_capable(hdev)) {
969 err = -EOPNOTSUPP;
970 break;
971 }
972
973 if (!test_bit(HCI_AUTH, &hdev->flags)) {
974 /* Auth must be enabled first */
Marcel Holtmann04837f62006-07-03 10:02:33 +0200975 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300976 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 if (err)
978 break;
979 }
980
Marcel Holtmann04837f62006-07-03 10:02:33 +0200981 err = hci_request(hdev, hci_encrypt_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300982 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 break;
984
985 case HCISETSCAN:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200986 err = hci_request(hdev, hci_scan_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300987 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 break;
989
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200990 case HCISETLINKPOL:
991 err = hci_request(hdev, hci_linkpol_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300992 HCI_INIT_TIMEOUT);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200993 break;
994
995 case HCISETLINKMODE:
996 hdev->link_mode = ((__u16) dr.dev_opt) &
997 (HCI_LM_MASTER | HCI_LM_ACCEPT);
998 break;
999
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 case HCISETPTYPE:
1001 hdev->pkt_type = (__u16) dr.dev_opt;
1002 break;
1003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 case HCISETACLMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001005 hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1);
1006 hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 break;
1008
1009 case HCISETSCOMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001010 hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1);
1011 hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 break;
1013
1014 default:
1015 err = -EINVAL;
1016 break;
1017 }
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 hci_dev_put(hdev);
1020 return err;
1021}
1022
1023int hci_get_dev_list(void __user *arg)
1024{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001025 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 struct hci_dev_list_req *dl;
1027 struct hci_dev_req *dr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 int n = 0, size, err;
1029 __u16 dev_num;
1030
1031 if (get_user(dev_num, (__u16 __user *) arg))
1032 return -EFAULT;
1033
1034 if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr))
1035 return -EINVAL;
1036
1037 size = sizeof(*dl) + dev_num * sizeof(*dr);
1038
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001039 dl = kzalloc(size, GFP_KERNEL);
1040 if (!dl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 return -ENOMEM;
1042
1043 dr = dl->dev_req;
1044
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001045 read_lock(&hci_dev_list_lock);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001046 list_for_each_entry(hdev, &hci_dev_list, list) {
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001047 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags))
Johan Hedberge0f93092011-11-09 01:44:22 +02001048 cancel_delayed_work(&hdev->power_off);
Johan Hedbergc542a062011-01-26 13:11:03 +02001049
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001050 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
1051 set_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergc542a062011-01-26 13:11:03 +02001052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 (dr + n)->dev_id = hdev->id;
1054 (dr + n)->dev_opt = hdev->flags;
Johan Hedbergc542a062011-01-26 13:11:03 +02001055
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 if (++n >= dev_num)
1057 break;
1058 }
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001059 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
1061 dl->dev_num = n;
1062 size = sizeof(*dl) + n * sizeof(*dr);
1063
1064 err = copy_to_user(arg, dl, size);
1065 kfree(dl);
1066
1067 return err ? -EFAULT : 0;
1068}
1069
1070int hci_get_dev_info(void __user *arg)
1071{
1072 struct hci_dev *hdev;
1073 struct hci_dev_info di;
1074 int err = 0;
1075
1076 if (copy_from_user(&di, arg, sizeof(di)))
1077 return -EFAULT;
1078
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001079 hdev = hci_dev_get(di.dev_id);
1080 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 return -ENODEV;
1082
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001083 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags))
Johan Hedberg32435532011-11-07 22:16:04 +02001084 cancel_delayed_work_sync(&hdev->power_off);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001085
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001086 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
1087 set_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergc542a062011-01-26 13:11:03 +02001088
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 strcpy(di.name, hdev->name);
1090 di.bdaddr = hdev->bdaddr;
Marcel Holtmann943da252010-02-13 02:28:41 +01001091 di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 di.flags = hdev->flags;
1093 di.pkt_type = hdev->pkt_type;
Johan Hedberg572c7f82012-10-19 20:57:46 +03001094 if (lmp_bredr_capable(hdev)) {
1095 di.acl_mtu = hdev->acl_mtu;
1096 di.acl_pkts = hdev->acl_pkts;
1097 di.sco_mtu = hdev->sco_mtu;
1098 di.sco_pkts = hdev->sco_pkts;
1099 } else {
1100 di.acl_mtu = hdev->le_mtu;
1101 di.acl_pkts = hdev->le_pkts;
1102 di.sco_mtu = 0;
1103 di.sco_pkts = 0;
1104 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 di.link_policy = hdev->link_policy;
1106 di.link_mode = hdev->link_mode;
1107
1108 memcpy(&di.stat, &hdev->stat, sizeof(di.stat));
1109 memcpy(&di.features, &hdev->features, sizeof(di.features));
1110
1111 if (copy_to_user(arg, &di, sizeof(di)))
1112 err = -EFAULT;
1113
1114 hci_dev_put(hdev);
1115
1116 return err;
1117}
1118
1119/* ---- Interface to HCI drivers ---- */
1120
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001121static int hci_rfkill_set_block(void *data, bool blocked)
1122{
1123 struct hci_dev *hdev = data;
1124
1125 BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked);
1126
1127 if (!blocked)
1128 return 0;
1129
1130 hci_dev_do_close(hdev);
1131
1132 return 0;
1133}
1134
1135static const struct rfkill_ops hci_rfkill_ops = {
1136 .set_block = hci_rfkill_set_block,
1137};
1138
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001139static void hci_power_on(struct work_struct *work)
1140{
1141 struct hci_dev *hdev = container_of(work, struct hci_dev, power_on);
1142
1143 BT_DBG("%s", hdev->name);
1144
1145 if (hci_dev_open(hdev->id) < 0)
1146 return;
1147
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001148 if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags))
Andrei Emeltchenko9345d402012-06-15 10:36:42 +03001149 schedule_delayed_work(&hdev->power_off, HCI_AUTO_OFF_TIMEOUT);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001150
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001151 if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +02001152 mgmt_index_added(hdev);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001153}
1154
1155static void hci_power_off(struct work_struct *work)
1156{
Johan Hedberg32435532011-11-07 22:16:04 +02001157 struct hci_dev *hdev = container_of(work, struct hci_dev,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001158 power_off.work);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001159
1160 BT_DBG("%s", hdev->name);
1161
Marcel Holtmann8ee56542012-02-21 12:33:48 +01001162 hci_dev_do_close(hdev);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001163}
1164
Johan Hedberg16ab91a2011-11-07 22:16:02 +02001165static void hci_discov_off(struct work_struct *work)
1166{
1167 struct hci_dev *hdev;
1168 u8 scan = SCAN_PAGE;
1169
1170 hdev = container_of(work, struct hci_dev, discov_off.work);
1171
1172 BT_DBG("%s", hdev->name);
1173
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001174 hci_dev_lock(hdev);
Johan Hedberg16ab91a2011-11-07 22:16:02 +02001175
1176 hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, sizeof(scan), &scan);
1177
1178 hdev->discov_timeout = 0;
1179
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001180 hci_dev_unlock(hdev);
Johan Hedberg16ab91a2011-11-07 22:16:02 +02001181}
1182
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001183int hci_uuids_clear(struct hci_dev *hdev)
1184{
1185 struct list_head *p, *n;
1186
1187 list_for_each_safe(p, n, &hdev->uuids) {
1188 struct bt_uuid *uuid;
1189
1190 uuid = list_entry(p, struct bt_uuid, list);
1191
1192 list_del(p);
1193 kfree(uuid);
1194 }
1195
1196 return 0;
1197}
1198
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001199int hci_link_keys_clear(struct hci_dev *hdev)
1200{
1201 struct list_head *p, *n;
1202
1203 list_for_each_safe(p, n, &hdev->link_keys) {
1204 struct link_key *key;
1205
1206 key = list_entry(p, struct link_key, list);
1207
1208 list_del(p);
1209 kfree(key);
1210 }
1211
1212 return 0;
1213}
1214
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001215int hci_smp_ltks_clear(struct hci_dev *hdev)
1216{
1217 struct smp_ltk *k, *tmp;
1218
1219 list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) {
1220 list_del(&k->list);
1221 kfree(k);
1222 }
1223
1224 return 0;
1225}
1226
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001227struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
1228{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001229 struct link_key *k;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001230
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001231 list_for_each_entry(k, &hdev->link_keys, list)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001232 if (bacmp(bdaddr, &k->bdaddr) == 0)
1233 return k;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001234
1235 return NULL;
1236}
1237
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301238static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001239 u8 key_type, u8 old_key_type)
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001240{
1241 /* Legacy key */
1242 if (key_type < 0x03)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301243 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001244
1245 /* Debug keys are insecure so don't store them persistently */
1246 if (key_type == HCI_LK_DEBUG_COMBINATION)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301247 return false;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001248
1249 /* Changed combination key and there's no previous one */
1250 if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301251 return false;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001252
1253 /* Security mode 3 case */
1254 if (!conn)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301255 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001256
1257 /* Neither local nor remote side had no-bonding as requirement */
1258 if (conn->auth_type > 0x01 && conn->remote_auth > 0x01)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301259 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001260
1261 /* Local side had dedicated bonding as requirement */
1262 if (conn->auth_type == 0x02 || conn->auth_type == 0x03)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301263 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001264
1265 /* Remote side had dedicated bonding as requirement */
1266 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301267 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001268
1269 /* If none of the above criteria match, then don't store the key
1270 * persistently */
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301271 return false;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001272}
1273
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001274struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8])
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001275{
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001276 struct smp_ltk *k;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001277
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001278 list_for_each_entry(k, &hdev->long_term_keys, list) {
1279 if (k->ediv != ediv ||
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001280 memcmp(rand, k->rand, sizeof(k->rand)))
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001281 continue;
1282
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001283 return k;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001284 }
1285
1286 return NULL;
1287}
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001288
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001289struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001290 u8 addr_type)
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001291{
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001292 struct smp_ltk *k;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001293
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001294 list_for_each_entry(k, &hdev->long_term_keys, list)
1295 if (addr_type == k->bdaddr_type &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001296 bacmp(bdaddr, &k->bdaddr) == 0)
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001297 return k;
1298
1299 return NULL;
1300}
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001301
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001302int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001303 bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001304{
1305 struct link_key *key, *old_key;
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301306 u8 old_key_type;
1307 bool persistent;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001308
1309 old_key = hci_find_link_key(hdev, bdaddr);
1310 if (old_key) {
1311 old_key_type = old_key->type;
1312 key = old_key;
1313 } else {
Johan Hedberg12adcf32011-04-28 11:29:00 -07001314 old_key_type = conn ? conn->key_type : 0xff;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001315 key = kzalloc(sizeof(*key), GFP_ATOMIC);
1316 if (!key)
1317 return -ENOMEM;
1318 list_add(&key->list, &hdev->link_keys);
1319 }
1320
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001321 BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001322
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001323 /* Some buggy controller combinations generate a changed
1324 * combination key for legacy pairing even when there's no
1325 * previous key */
1326 if (type == HCI_LK_CHANGED_COMBINATION &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001327 (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) {
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001328 type = HCI_LK_COMBINATION;
Johan Hedberg655fe6e2011-04-28 11:29:01 -07001329 if (conn)
1330 conn->key_type = type;
1331 }
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001332
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001333 bacpy(&key->bdaddr, bdaddr);
Andrei Emeltchenko9b3b4462012-05-23 11:31:20 +03001334 memcpy(key->val, val, HCI_LINK_KEY_SIZE);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001335 key->pin_len = pin_len;
1336
Waldemar Rymarkiewiczb6020ba2011-04-28 12:07:53 +02001337 if (type == HCI_LK_CHANGED_COMBINATION)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001338 key->type = old_key_type;
Johan Hedberg4748fed2011-04-28 11:29:02 -07001339 else
1340 key->type = type;
1341
Johan Hedberg4df378a2011-04-28 11:29:03 -07001342 if (!new_key)
1343 return 0;
1344
1345 persistent = hci_persistent_key(hdev, conn, type, old_key_type);
1346
Johan Hedberg744cf192011-11-08 20:40:14 +02001347 mgmt_new_link_key(hdev, key, persistent);
Johan Hedberg4df378a2011-04-28 11:29:03 -07001348
Vishal Agarwal6ec5bca2012-04-16 14:44:44 +05301349 if (conn)
1350 conn->flush_key = !persistent;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001351
1352 return 0;
1353}
1354
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001355int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type,
Andrei Emeltchenko9a006652012-03-09 12:12:12 +02001356 int new_key, u8 authenticated, u8 tk[16], u8 enc_size, __le16
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001357 ediv, u8 rand[8])
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001358{
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001359 struct smp_ltk *key, *old_key;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001360
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001361 if (!(type & HCI_SMP_STK) && !(type & HCI_SMP_LTK))
1362 return 0;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001363
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001364 old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type);
1365 if (old_key)
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001366 key = old_key;
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001367 else {
1368 key = kzalloc(sizeof(*key), GFP_ATOMIC);
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001369 if (!key)
1370 return -ENOMEM;
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001371 list_add(&key->list, &hdev->long_term_keys);
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001372 }
1373
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001374 bacpy(&key->bdaddr, bdaddr);
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001375 key->bdaddr_type = addr_type;
1376 memcpy(key->val, tk, sizeof(key->val));
1377 key->authenticated = authenticated;
1378 key->ediv = ediv;
1379 key->enc_size = enc_size;
1380 key->type = type;
1381 memcpy(key->rand, rand, sizeof(key->rand));
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001382
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001383 if (!new_key)
1384 return 0;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001385
Vinicius Costa Gomes261cc5a2012-02-02 21:08:05 -03001386 if (type & HCI_SMP_LTK)
1387 mgmt_new_ltk(hdev, key, 1);
1388
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001389 return 0;
1390}
1391
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001392int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
1393{
1394 struct link_key *key;
1395
1396 key = hci_find_link_key(hdev, bdaddr);
1397 if (!key)
1398 return -ENOENT;
1399
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001400 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001401
1402 list_del(&key->list);
1403 kfree(key);
1404
1405 return 0;
1406}
1407
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001408int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr)
1409{
1410 struct smp_ltk *k, *tmp;
1411
1412 list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) {
1413 if (bacmp(bdaddr, &k->bdaddr))
1414 continue;
1415
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001416 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001417
1418 list_del(&k->list);
1419 kfree(k);
1420 }
1421
1422 return 0;
1423}
1424
Ville Tervo6bd32322011-02-16 16:32:41 +02001425/* HCI command timer function */
Andrei Emeltchenkobda4f232012-06-11 11:13:08 +03001426static void hci_cmd_timeout(unsigned long arg)
Ville Tervo6bd32322011-02-16 16:32:41 +02001427{
1428 struct hci_dev *hdev = (void *) arg;
1429
Andrei Emeltchenkobda4f232012-06-11 11:13:08 +03001430 if (hdev->sent_cmd) {
1431 struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data;
1432 u16 opcode = __le16_to_cpu(sent->opcode);
1433
1434 BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode);
1435 } else {
1436 BT_ERR("%s command tx timeout", hdev->name);
1437 }
1438
Ville Tervo6bd32322011-02-16 16:32:41 +02001439 atomic_set(&hdev->cmd_cnt, 1);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02001440 queue_work(hdev->workqueue, &hdev->cmd_work);
Ville Tervo6bd32322011-02-16 16:32:41 +02001441}
1442
Szymon Janc2763eda2011-03-22 13:12:22 +01001443struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001444 bdaddr_t *bdaddr)
Szymon Janc2763eda2011-03-22 13:12:22 +01001445{
1446 struct oob_data *data;
1447
1448 list_for_each_entry(data, &hdev->remote_oob_data, list)
1449 if (bacmp(bdaddr, &data->bdaddr) == 0)
1450 return data;
1451
1452 return NULL;
1453}
1454
1455int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr)
1456{
1457 struct oob_data *data;
1458
1459 data = hci_find_remote_oob_data(hdev, bdaddr);
1460 if (!data)
1461 return -ENOENT;
1462
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001463 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
Szymon Janc2763eda2011-03-22 13:12:22 +01001464
1465 list_del(&data->list);
1466 kfree(data);
1467
1468 return 0;
1469}
1470
1471int hci_remote_oob_data_clear(struct hci_dev *hdev)
1472{
1473 struct oob_data *data, *n;
1474
1475 list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) {
1476 list_del(&data->list);
1477 kfree(data);
1478 }
1479
1480 return 0;
1481}
1482
1483int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001484 u8 *randomizer)
Szymon Janc2763eda2011-03-22 13:12:22 +01001485{
1486 struct oob_data *data;
1487
1488 data = hci_find_remote_oob_data(hdev, bdaddr);
1489
1490 if (!data) {
1491 data = kmalloc(sizeof(*data), GFP_ATOMIC);
1492 if (!data)
1493 return -ENOMEM;
1494
1495 bacpy(&data->bdaddr, bdaddr);
1496 list_add(&data->list, &hdev->remote_oob_data);
1497 }
1498
1499 memcpy(data->hash, hash, sizeof(data->hash));
1500 memcpy(data->randomizer, randomizer, sizeof(data->randomizer));
1501
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001502 BT_DBG("%s for %pMR", hdev->name, bdaddr);
Szymon Janc2763eda2011-03-22 13:12:22 +01001503
1504 return 0;
1505}
1506
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001507struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001508{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001509 struct bdaddr_list *b;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001510
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001511 list_for_each_entry(b, &hdev->blacklist, list)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001512 if (bacmp(bdaddr, &b->bdaddr) == 0)
1513 return b;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001514
1515 return NULL;
1516}
1517
1518int hci_blacklist_clear(struct hci_dev *hdev)
1519{
1520 struct list_head *p, *n;
1521
1522 list_for_each_safe(p, n, &hdev->blacklist) {
1523 struct bdaddr_list *b;
1524
1525 b = list_entry(p, struct bdaddr_list, list);
1526
1527 list_del(p);
1528 kfree(b);
1529 }
1530
1531 return 0;
1532}
1533
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001534int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001535{
1536 struct bdaddr_list *entry;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001537
1538 if (bacmp(bdaddr, BDADDR_ANY) == 0)
1539 return -EBADF;
1540
Antti Julku5e762442011-08-25 16:48:02 +03001541 if (hci_blacklist_lookup(hdev, bdaddr))
1542 return -EEXIST;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001543
1544 entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL);
Antti Julku5e762442011-08-25 16:48:02 +03001545 if (!entry)
1546 return -ENOMEM;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001547
1548 bacpy(&entry->bdaddr, bdaddr);
1549
1550 list_add(&entry->list, &hdev->blacklist);
1551
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001552 return mgmt_device_blocked(hdev, bdaddr, type);
Antti Julkub2a66aa2011-06-15 12:01:14 +03001553}
1554
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001555int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001556{
1557 struct bdaddr_list *entry;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001558
Szymon Janc1ec918c2011-11-16 09:32:21 +01001559 if (bacmp(bdaddr, BDADDR_ANY) == 0)
Antti Julku5e762442011-08-25 16:48:02 +03001560 return hci_blacklist_clear(hdev);
Antti Julkub2a66aa2011-06-15 12:01:14 +03001561
1562 entry = hci_blacklist_lookup(hdev, bdaddr);
Szymon Janc1ec918c2011-11-16 09:32:21 +01001563 if (!entry)
Antti Julku5e762442011-08-25 16:48:02 +03001564 return -ENOENT;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001565
1566 list_del(&entry->list);
1567 kfree(entry);
1568
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001569 return mgmt_device_unblocked(hdev, bdaddr, type);
Antti Julkub2a66aa2011-06-15 12:01:14 +03001570}
1571
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001572static void le_scan_param_req(struct hci_dev *hdev, unsigned long opt)
1573{
1574 struct le_scan_params *param = (struct le_scan_params *) opt;
1575 struct hci_cp_le_set_scan_param cp;
1576
1577 memset(&cp, 0, sizeof(cp));
1578 cp.type = param->type;
1579 cp.interval = cpu_to_le16(param->interval);
1580 cp.window = cpu_to_le16(param->window);
1581
1582 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_PARAM, sizeof(cp), &cp);
1583}
1584
1585static void le_scan_enable_req(struct hci_dev *hdev, unsigned long opt)
1586{
1587 struct hci_cp_le_set_scan_enable cp;
1588
1589 memset(&cp, 0, sizeof(cp));
1590 cp.enable = 1;
Andre Guedes0431a432012-05-31 20:01:41 -03001591 cp.filter_dup = 1;
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001592
1593 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp);
1594}
1595
1596static int hci_do_le_scan(struct hci_dev *hdev, u8 type, u16 interval,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001597 u16 window, int timeout)
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001598{
1599 long timeo = msecs_to_jiffies(3000);
1600 struct le_scan_params param;
1601 int err;
1602
1603 BT_DBG("%s", hdev->name);
1604
1605 if (test_bit(HCI_LE_SCAN, &hdev->dev_flags))
1606 return -EINPROGRESS;
1607
1608 param.type = type;
1609 param.interval = interval;
1610 param.window = window;
1611
1612 hci_req_lock(hdev);
1613
1614 err = __hci_request(hdev, le_scan_param_req, (unsigned long) &param,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001615 timeo);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001616 if (!err)
1617 err = __hci_request(hdev, le_scan_enable_req, 0, timeo);
1618
1619 hci_req_unlock(hdev);
1620
1621 if (err < 0)
1622 return err;
1623
1624 schedule_delayed_work(&hdev->le_scan_disable,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001625 msecs_to_jiffies(timeout));
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001626
1627 return 0;
1628}
1629
Andre Guedes7dbfac12012-03-15 16:52:07 -03001630int hci_cancel_le_scan(struct hci_dev *hdev)
1631{
1632 BT_DBG("%s", hdev->name);
1633
1634 if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags))
1635 return -EALREADY;
1636
1637 if (cancel_delayed_work(&hdev->le_scan_disable)) {
1638 struct hci_cp_le_set_scan_enable cp;
1639
1640 /* Send HCI command to disable LE Scan */
1641 memset(&cp, 0, sizeof(cp));
1642 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp);
1643 }
1644
1645 return 0;
1646}
1647
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001648static void le_scan_disable_work(struct work_struct *work)
1649{
1650 struct hci_dev *hdev = container_of(work, struct hci_dev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001651 le_scan_disable.work);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001652 struct hci_cp_le_set_scan_enable cp;
1653
1654 BT_DBG("%s", hdev->name);
1655
1656 memset(&cp, 0, sizeof(cp));
1657
1658 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp);
1659}
1660
Andre Guedes28b75a82012-02-03 17:48:00 -03001661static void le_scan_work(struct work_struct *work)
1662{
1663 struct hci_dev *hdev = container_of(work, struct hci_dev, le_scan);
1664 struct le_scan_params *param = &hdev->le_scan_params;
1665
1666 BT_DBG("%s", hdev->name);
1667
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001668 hci_do_le_scan(hdev, param->type, param->interval, param->window,
1669 param->timeout);
Andre Guedes28b75a82012-02-03 17:48:00 -03001670}
1671
1672int hci_le_scan(struct hci_dev *hdev, u8 type, u16 interval, u16 window,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001673 int timeout)
Andre Guedes28b75a82012-02-03 17:48:00 -03001674{
1675 struct le_scan_params *param = &hdev->le_scan_params;
1676
1677 BT_DBG("%s", hdev->name);
1678
Johan Hedbergf1550472012-10-24 21:12:03 +03001679 if (test_bit(HCI_LE_PERIPHERAL, &hdev->dev_flags))
1680 return -ENOTSUPP;
1681
Andre Guedes28b75a82012-02-03 17:48:00 -03001682 if (work_busy(&hdev->le_scan))
1683 return -EINPROGRESS;
1684
1685 param->type = type;
1686 param->interval = interval;
1687 param->window = window;
1688 param->timeout = timeout;
1689
1690 queue_work(system_long_wq, &hdev->le_scan);
1691
1692 return 0;
1693}
1694
David Herrmann9be0dab2012-04-22 14:39:57 +02001695/* Alloc HCI device */
1696struct hci_dev *hci_alloc_dev(void)
1697{
1698 struct hci_dev *hdev;
1699
1700 hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL);
1701 if (!hdev)
1702 return NULL;
1703
David Herrmannb1b813d2012-04-22 14:39:58 +02001704 hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1);
1705 hdev->esco_type = (ESCO_HV1);
1706 hdev->link_mode = (HCI_LM_ACCEPT);
1707 hdev->io_capability = 0x03; /* No Input No Output */
Johan Hedbergbbaf4442012-11-08 01:22:59 +01001708 hdev->inq_tx_power = HCI_TX_POWER_INVALID;
1709 hdev->adv_tx_power = HCI_TX_POWER_INVALID;
David Herrmannb1b813d2012-04-22 14:39:58 +02001710
David Herrmannb1b813d2012-04-22 14:39:58 +02001711 hdev->sniff_max_interval = 800;
1712 hdev->sniff_min_interval = 80;
1713
1714 mutex_init(&hdev->lock);
1715 mutex_init(&hdev->req_lock);
1716
1717 INIT_LIST_HEAD(&hdev->mgmt_pending);
1718 INIT_LIST_HEAD(&hdev->blacklist);
1719 INIT_LIST_HEAD(&hdev->uuids);
1720 INIT_LIST_HEAD(&hdev->link_keys);
1721 INIT_LIST_HEAD(&hdev->long_term_keys);
1722 INIT_LIST_HEAD(&hdev->remote_oob_data);
Andrei Emeltchenko6b536b52012-08-31 16:39:28 +03001723 INIT_LIST_HEAD(&hdev->conn_hash.list);
David Herrmannb1b813d2012-04-22 14:39:58 +02001724
1725 INIT_WORK(&hdev->rx_work, hci_rx_work);
1726 INIT_WORK(&hdev->cmd_work, hci_cmd_work);
1727 INIT_WORK(&hdev->tx_work, hci_tx_work);
1728 INIT_WORK(&hdev->power_on, hci_power_on);
1729 INIT_WORK(&hdev->le_scan, le_scan_work);
1730
David Herrmannb1b813d2012-04-22 14:39:58 +02001731 INIT_DELAYED_WORK(&hdev->power_off, hci_power_off);
1732 INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off);
1733 INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work);
1734
David Herrmann9be0dab2012-04-22 14:39:57 +02001735 skb_queue_head_init(&hdev->driver_init);
David Herrmannb1b813d2012-04-22 14:39:58 +02001736 skb_queue_head_init(&hdev->rx_q);
1737 skb_queue_head_init(&hdev->cmd_q);
1738 skb_queue_head_init(&hdev->raw_q);
1739
1740 init_waitqueue_head(&hdev->req_wait_q);
1741
Andrei Emeltchenkobda4f232012-06-11 11:13:08 +03001742 setup_timer(&hdev->cmd_timer, hci_cmd_timeout, (unsigned long) hdev);
David Herrmannb1b813d2012-04-22 14:39:58 +02001743
David Herrmannb1b813d2012-04-22 14:39:58 +02001744 hci_init_sysfs(hdev);
1745 discovery_init(hdev);
David Herrmann9be0dab2012-04-22 14:39:57 +02001746
1747 return hdev;
1748}
1749EXPORT_SYMBOL(hci_alloc_dev);
1750
1751/* Free HCI device */
1752void hci_free_dev(struct hci_dev *hdev)
1753{
1754 skb_queue_purge(&hdev->driver_init);
1755
1756 /* will free via device release */
1757 put_device(&hdev->dev);
1758}
1759EXPORT_SYMBOL(hci_free_dev);
1760
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761/* Register HCI device */
1762int hci_register_dev(struct hci_dev *hdev)
1763{
David Herrmannb1b813d2012-04-22 14:39:58 +02001764 int id, error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765
David Herrmann010666a2012-01-07 15:47:07 +01001766 if (!hdev->open || !hdev->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 return -EINVAL;
1768
Mat Martineau08add512011-11-02 16:18:36 -07001769 /* Do not allow HCI_AMP devices to register at index 0,
1770 * so the index can be used as the AMP controller ID.
1771 */
Sasha Levin3df92b32012-05-27 22:36:56 +02001772 switch (hdev->dev_type) {
1773 case HCI_BREDR:
1774 id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL);
1775 break;
1776 case HCI_AMP:
1777 id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL);
1778 break;
1779 default:
1780 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 }
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001782
Sasha Levin3df92b32012-05-27 22:36:56 +02001783 if (id < 0)
1784 return id;
1785
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 sprintf(hdev->name, "hci%d", id);
1787 hdev->id = id;
Andrei Emeltchenko2d8b3a12012-04-16 16:32:04 +03001788
1789 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
1790
Sasha Levin3df92b32012-05-27 22:36:56 +02001791 write_lock(&hci_dev_list_lock);
1792 list_add(&hdev->list, &hci_dev_list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001793 write_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Gustavo F. Padovan32845eb2011-12-17 17:47:30 -02001795 hdev->workqueue = alloc_workqueue(hdev->name, WQ_HIGHPRI | WQ_UNBOUND |
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001796 WQ_MEM_RECLAIM, 1);
David Herrmann33ca9542011-10-08 14:58:49 +02001797 if (!hdev->workqueue) {
1798 error = -ENOMEM;
1799 goto err;
1800 }
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001801
David Herrmann33ca9542011-10-08 14:58:49 +02001802 error = hci_add_sysfs(hdev);
1803 if (error < 0)
1804 goto err_wqueue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001806 hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001807 RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops,
1808 hdev);
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001809 if (hdev->rfkill) {
1810 if (rfkill_register(hdev->rfkill) < 0) {
1811 rfkill_destroy(hdev->rfkill);
1812 hdev->rfkill = NULL;
1813 }
1814 }
1815
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001816 set_bit(HCI_SETUP, &hdev->dev_flags);
Andrei Emeltchenkoce2be9a2012-06-29 15:07:00 +03001817
1818 if (hdev->dev_type != HCI_AMP)
1819 set_bit(HCI_AUTO_OFF, &hdev->dev_flags);
1820
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 hci_notify(hdev, HCI_DEV_REG);
David Herrmanndc946bd2012-01-07 15:47:24 +01001822 hci_dev_hold(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
Marcel Holtmannfbe96d62012-10-30 01:35:40 -07001824 schedule_work(&hdev->power_on);
1825
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 return id;
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001827
David Herrmann33ca9542011-10-08 14:58:49 +02001828err_wqueue:
1829 destroy_workqueue(hdev->workqueue);
1830err:
Sasha Levin3df92b32012-05-27 22:36:56 +02001831 ida_simple_remove(&hci_index_ida, hdev->id);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001832 write_lock(&hci_dev_list_lock);
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001833 list_del(&hdev->list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001834 write_unlock(&hci_dev_list_lock);
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001835
David Herrmann33ca9542011-10-08 14:58:49 +02001836 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837}
1838EXPORT_SYMBOL(hci_register_dev);
1839
1840/* Unregister HCI device */
David Herrmann59735632011-10-26 10:43:19 +02001841void hci_unregister_dev(struct hci_dev *hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842{
Sasha Levin3df92b32012-05-27 22:36:56 +02001843 int i, id;
Marcel Holtmannef222012007-07-11 06:42:04 +02001844
Marcel Holtmannc13854c2010-02-08 15:27:07 +01001845 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
Johan Hovold94324962012-03-15 14:48:41 +01001847 set_bit(HCI_UNREGISTER, &hdev->dev_flags);
1848
Sasha Levin3df92b32012-05-27 22:36:56 +02001849 id = hdev->id;
1850
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001851 write_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 list_del(&hdev->list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001853 write_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
1855 hci_dev_do_close(hdev);
1856
Suraj Sumangalacd4c5392010-07-14 13:02:16 +05301857 for (i = 0; i < NUM_REASSEMBLY; i++)
Marcel Holtmannef222012007-07-11 06:42:04 +02001858 kfree_skb(hdev->reassembly[i]);
1859
Gustavo Padovanb9b5ef12012-11-21 00:50:21 -02001860 cancel_work_sync(&hdev->power_on);
1861
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001862 if (!test_bit(HCI_INIT, &hdev->flags) &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001863 !test_bit(HCI_SETUP, &hdev->dev_flags)) {
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001864 hci_dev_lock(hdev);
Johan Hedberg744cf192011-11-08 20:40:14 +02001865 mgmt_index_removed(hdev);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001866 hci_dev_unlock(hdev);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001867 }
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001868
Johan Hedberg2e58ef32011-11-08 20:40:15 +02001869 /* mgmt_index_removed should take care of emptying the
1870 * pending list */
1871 BUG_ON(!list_empty(&hdev->mgmt_pending));
1872
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 hci_notify(hdev, HCI_DEV_UNREG);
1874
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001875 if (hdev->rfkill) {
1876 rfkill_unregister(hdev->rfkill);
1877 rfkill_destroy(hdev->rfkill);
1878 }
1879
David Herrmannce242972011-10-08 14:58:48 +02001880 hci_del_sysfs(hdev);
Dave Young147e2d52008-03-05 18:45:59 -08001881
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001882 destroy_workqueue(hdev->workqueue);
1883
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001884 hci_dev_lock(hdev);
Johan Hedberge2e0cac2011-01-04 12:08:50 +02001885 hci_blacklist_clear(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001886 hci_uuids_clear(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001887 hci_link_keys_clear(hdev);
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001888 hci_smp_ltks_clear(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01001889 hci_remote_oob_data_clear(hdev);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001890 hci_dev_unlock(hdev);
Johan Hedberge2e0cac2011-01-04 12:08:50 +02001891
David Herrmanndc946bd2012-01-07 15:47:24 +01001892 hci_dev_put(hdev);
Sasha Levin3df92b32012-05-27 22:36:56 +02001893
1894 ida_simple_remove(&hci_index_ida, id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895}
1896EXPORT_SYMBOL(hci_unregister_dev);
1897
1898/* Suspend HCI device */
1899int hci_suspend_dev(struct hci_dev *hdev)
1900{
1901 hci_notify(hdev, HCI_DEV_SUSPEND);
1902 return 0;
1903}
1904EXPORT_SYMBOL(hci_suspend_dev);
1905
1906/* Resume HCI device */
1907int hci_resume_dev(struct hci_dev *hdev)
1908{
1909 hci_notify(hdev, HCI_DEV_RESUME);
1910 return 0;
1911}
1912EXPORT_SYMBOL(hci_resume_dev);
1913
Marcel Holtmann76bca882009-11-18 00:40:39 +01001914/* Receive frame from HCI drivers */
1915int hci_recv_frame(struct sk_buff *skb)
1916{
1917 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
1918 if (!hdev || (!test_bit(HCI_UP, &hdev->flags)
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001919 && !test_bit(HCI_INIT, &hdev->flags))) {
Marcel Holtmann76bca882009-11-18 00:40:39 +01001920 kfree_skb(skb);
1921 return -ENXIO;
1922 }
1923
1924 /* Incomming skb */
1925 bt_cb(skb)->incoming = 1;
1926
1927 /* Time stamp */
1928 __net_timestamp(skb);
1929
Marcel Holtmann76bca882009-11-18 00:40:39 +01001930 skb_queue_tail(&hdev->rx_q, skb);
Marcel Holtmannb78752c2010-08-08 23:06:53 -04001931 queue_work(hdev->workqueue, &hdev->rx_work);
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001932
Marcel Holtmann76bca882009-11-18 00:40:39 +01001933 return 0;
1934}
1935EXPORT_SYMBOL(hci_recv_frame);
1936
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301937static int hci_reassembly(struct hci_dev *hdev, int type, void *data,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001938 int count, __u8 index)
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301939{
1940 int len = 0;
1941 int hlen = 0;
1942 int remain = count;
1943 struct sk_buff *skb;
1944 struct bt_skb_cb *scb;
1945
1946 if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) ||
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001947 index >= NUM_REASSEMBLY)
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301948 return -EILSEQ;
1949
1950 skb = hdev->reassembly[index];
1951
1952 if (!skb) {
1953 switch (type) {
1954 case HCI_ACLDATA_PKT:
1955 len = HCI_MAX_FRAME_SIZE;
1956 hlen = HCI_ACL_HDR_SIZE;
1957 break;
1958 case HCI_EVENT_PKT:
1959 len = HCI_MAX_EVENT_SIZE;
1960 hlen = HCI_EVENT_HDR_SIZE;
1961 break;
1962 case HCI_SCODATA_PKT:
1963 len = HCI_MAX_SCO_SIZE;
1964 hlen = HCI_SCO_HDR_SIZE;
1965 break;
1966 }
1967
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03001968 skb = bt_skb_alloc(len, GFP_ATOMIC);
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301969 if (!skb)
1970 return -ENOMEM;
1971
1972 scb = (void *) skb->cb;
1973 scb->expect = hlen;
1974 scb->pkt_type = type;
1975
1976 skb->dev = (void *) hdev;
1977 hdev->reassembly[index] = skb;
1978 }
1979
1980 while (count) {
1981 scb = (void *) skb->cb;
Dan Carpenter89bb46d2012-02-28 09:57:59 +03001982 len = min_t(uint, scb->expect, count);
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301983
1984 memcpy(skb_put(skb, len), data, len);
1985
1986 count -= len;
1987 data += len;
1988 scb->expect -= len;
1989 remain = count;
1990
1991 switch (type) {
1992 case HCI_EVENT_PKT:
1993 if (skb->len == HCI_EVENT_HDR_SIZE) {
1994 struct hci_event_hdr *h = hci_event_hdr(skb);
1995 scb->expect = h->plen;
1996
1997 if (skb_tailroom(skb) < scb->expect) {
1998 kfree_skb(skb);
1999 hdev->reassembly[index] = NULL;
2000 return -ENOMEM;
2001 }
2002 }
2003 break;
2004
2005 case HCI_ACLDATA_PKT:
2006 if (skb->len == HCI_ACL_HDR_SIZE) {
2007 struct hci_acl_hdr *h = hci_acl_hdr(skb);
2008 scb->expect = __le16_to_cpu(h->dlen);
2009
2010 if (skb_tailroom(skb) < scb->expect) {
2011 kfree_skb(skb);
2012 hdev->reassembly[index] = NULL;
2013 return -ENOMEM;
2014 }
2015 }
2016 break;
2017
2018 case HCI_SCODATA_PKT:
2019 if (skb->len == HCI_SCO_HDR_SIZE) {
2020 struct hci_sco_hdr *h = hci_sco_hdr(skb);
2021 scb->expect = h->dlen;
2022
2023 if (skb_tailroom(skb) < scb->expect) {
2024 kfree_skb(skb);
2025 hdev->reassembly[index] = NULL;
2026 return -ENOMEM;
2027 }
2028 }
2029 break;
2030 }
2031
2032 if (scb->expect == 0) {
2033 /* Complete frame */
2034
2035 bt_cb(skb)->pkt_type = type;
2036 hci_recv_frame(skb);
2037
2038 hdev->reassembly[index] = NULL;
2039 return remain;
2040 }
2041 }
2042
2043 return remain;
2044}
2045
Marcel Holtmannef222012007-07-11 06:42:04 +02002046int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
2047{
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302048 int rem = 0;
2049
Marcel Holtmannef222012007-07-11 06:42:04 +02002050 if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
2051 return -EILSEQ;
2052
Gustavo F. Padovanda5f6c32010-07-24 01:34:54 -03002053 while (count) {
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03002054 rem = hci_reassembly(hdev, type, data, count, type - 1);
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302055 if (rem < 0)
2056 return rem;
Marcel Holtmannef222012007-07-11 06:42:04 +02002057
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302058 data += (count - rem);
2059 count = rem;
Joe Perchesf81c6222011-06-03 11:51:19 +00002060 }
Marcel Holtmannef222012007-07-11 06:42:04 +02002061
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302062 return rem;
Marcel Holtmannef222012007-07-11 06:42:04 +02002063}
2064EXPORT_SYMBOL(hci_recv_fragment);
2065
Suraj Sumangala99811512010-07-14 13:02:19 +05302066#define STREAM_REASSEMBLY 0
2067
2068int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count)
2069{
2070 int type;
2071 int rem = 0;
2072
Gustavo F. Padovanda5f6c32010-07-24 01:34:54 -03002073 while (count) {
Suraj Sumangala99811512010-07-14 13:02:19 +05302074 struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY];
2075
2076 if (!skb) {
2077 struct { char type; } *pkt;
2078
2079 /* Start of the frame */
2080 pkt = data;
2081 type = pkt->type;
2082
2083 data++;
2084 count--;
2085 } else
2086 type = bt_cb(skb)->pkt_type;
2087
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03002088 rem = hci_reassembly(hdev, type, data, count,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002089 STREAM_REASSEMBLY);
Suraj Sumangala99811512010-07-14 13:02:19 +05302090 if (rem < 0)
2091 return rem;
2092
2093 data += (count - rem);
2094 count = rem;
Joe Perchesf81c6222011-06-03 11:51:19 +00002095 }
Suraj Sumangala99811512010-07-14 13:02:19 +05302096
2097 return rem;
2098}
2099EXPORT_SYMBOL(hci_recv_stream_fragment);
2100
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101/* ---- Interface to upper protocols ---- */
2102
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103int hci_register_cb(struct hci_cb *cb)
2104{
2105 BT_DBG("%p name %s", cb, cb->name);
2106
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002107 write_lock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 list_add(&cb->list, &hci_cb_list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002109 write_unlock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110
2111 return 0;
2112}
2113EXPORT_SYMBOL(hci_register_cb);
2114
2115int hci_unregister_cb(struct hci_cb *cb)
2116{
2117 BT_DBG("%p name %s", cb, cb->name);
2118
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002119 write_lock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 list_del(&cb->list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002121 write_unlock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122
2123 return 0;
2124}
2125EXPORT_SYMBOL(hci_unregister_cb);
2126
2127static int hci_send_frame(struct sk_buff *skb)
2128{
2129 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
2130
2131 if (!hdev) {
2132 kfree_skb(skb);
2133 return -ENODEV;
2134 }
2135
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002136 BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137
Marcel Holtmanncd82e612012-02-20 20:34:38 +01002138 /* Time stamp */
2139 __net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140
Marcel Holtmanncd82e612012-02-20 20:34:38 +01002141 /* Send copy to monitor */
2142 hci_send_to_monitor(hdev, skb);
2143
2144 if (atomic_read(&hdev->promisc)) {
2145 /* Send copy to the sockets */
Marcel Holtmann470fe1b2012-02-20 14:50:30 +01002146 hci_send_to_sock(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 }
2148
2149 /* Get rid of skb owner, prior to sending to the driver. */
2150 skb_orphan(skb);
2151
2152 return hdev->send(skb);
2153}
2154
2155/* Send HCI command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002156int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157{
2158 int len = HCI_COMMAND_HDR_SIZE + plen;
2159 struct hci_command_hdr *hdr;
2160 struct sk_buff *skb;
2161
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002162 BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163
2164 skb = bt_skb_alloc(len, GFP_ATOMIC);
2165 if (!skb) {
Marcel Holtmannef222012007-07-11 06:42:04 +02002166 BT_ERR("%s no memory for command", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 return -ENOMEM;
2168 }
2169
2170 hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002171 hdr->opcode = cpu_to_le16(opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 hdr->plen = plen;
2173
2174 if (plen)
2175 memcpy(skb_put(skb, plen), param, plen);
2176
2177 BT_DBG("skb len %d", skb->len);
2178
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002179 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 skb->dev = (void *) hdev;
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002181
Johan Hedberga5040ef2011-01-10 13:28:59 +02002182 if (test_bit(HCI_INIT, &hdev->flags))
2183 hdev->init_last_cmd = opcode;
2184
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 skb_queue_tail(&hdev->cmd_q, skb);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002186 queue_work(hdev->workqueue, &hdev->cmd_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
2188 return 0;
2189}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190
2191/* Get data from the previously sent command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002192void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193{
2194 struct hci_command_hdr *hdr;
2195
2196 if (!hdev->sent_cmd)
2197 return NULL;
2198
2199 hdr = (void *) hdev->sent_cmd->data;
2200
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002201 if (hdr->opcode != cpu_to_le16(opcode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 return NULL;
2203
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002204 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205
2206 return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE;
2207}
2208
2209/* Send ACL data */
2210static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags)
2211{
2212 struct hci_acl_hdr *hdr;
2213 int len = skb->len;
2214
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03002215 skb_push(skb, HCI_ACL_HDR_SIZE);
2216 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07002217 hdr = (struct hci_acl_hdr *)skb_transport_header(skb);
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07002218 hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags));
2219 hdr->dlen = cpu_to_le16(len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220}
2221
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002222static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002223 struct sk_buff *skb, __u16 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224{
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002225 struct hci_conn *conn = chan->conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 struct hci_dev *hdev = conn->hdev;
2227 struct sk_buff *list;
2228
Gustavo Padovan087bfd92012-05-11 13:16:11 -03002229 skb->len = skb_headlen(skb);
2230 skb->data_len = 0;
2231
2232 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Andrei Emeltchenko204a6e52012-10-15 11:58:39 +03002233
2234 switch (hdev->dev_type) {
2235 case HCI_BREDR:
2236 hci_add_acl_hdr(skb, conn->handle, flags);
2237 break;
2238 case HCI_AMP:
2239 hci_add_acl_hdr(skb, chan->handle, flags);
2240 break;
2241 default:
2242 BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type);
2243 return;
2244 }
Gustavo Padovan087bfd92012-05-11 13:16:11 -03002245
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002246 list = skb_shinfo(skb)->frag_list;
2247 if (!list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 /* Non fragmented */
2249 BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len);
2250
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002251 skb_queue_tail(queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 } else {
2253 /* Fragmented */
2254 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
2255
2256 skb_shinfo(skb)->frag_list = NULL;
2257
2258 /* Queue all fragments atomically */
Gustavo F. Padovanaf3e6352011-12-22 16:35:05 -02002259 spin_lock(&queue->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002261 __skb_queue_tail(queue, skb);
Andrei Emeltchenkoe7021122011-01-03 11:14:36 +02002262
2263 flags &= ~ACL_START;
2264 flags |= ACL_CONT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 do {
2266 skb = list; list = list->next;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002267
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002269 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Andrei Emeltchenkoe7021122011-01-03 11:14:36 +02002270 hci_add_acl_hdr(skb, conn->handle, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271
2272 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
2273
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002274 __skb_queue_tail(queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 } while (list);
2276
Gustavo F. Padovanaf3e6352011-12-22 16:35:05 -02002277 spin_unlock(&queue->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 }
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002279}
2280
2281void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags)
2282{
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002283 struct hci_dev *hdev = chan->conn->hdev;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002284
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002285 BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002286
2287 skb->dev = (void *) hdev;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002288
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002289 hci_queue_acl(chan, &chan->data_q, skb, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002291 queue_work(hdev->workqueue, &hdev->tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293
2294/* Send SCO data */
Gustavo F. Padovan0d861d82010-05-01 16:15:35 -03002295void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296{
2297 struct hci_dev *hdev = conn->hdev;
2298 struct hci_sco_hdr hdr;
2299
2300 BT_DBG("%s len %d", hdev->name, skb->len);
2301
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07002302 hdr.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 hdr.dlen = skb->len;
2304
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03002305 skb_push(skb, HCI_SCO_HDR_SIZE);
2306 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07002307 memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308
2309 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002310 bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002311
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 skb_queue_tail(&conn->data_q, skb);
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002313 queue_work(hdev->workqueue, &hdev->tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315
2316/* ---- HCI TX task (outgoing data) ---- */
2317
2318/* HCI Connection scheduler */
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002319static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type,
2320 int *quote)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321{
2322 struct hci_conn_hash *h = &hdev->conn_hash;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02002323 struct hci_conn *conn = NULL, *c;
Mikel Astizabc5de82012-04-11 08:48:47 +02002324 unsigned int num = 0, min = ~0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002326 /* We don't have to lock device here. Connections are always
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 * added and removed with TX task disabled. */
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002328
2329 rcu_read_lock();
2330
2331 list_for_each_entry_rcu(c, &h->list, list) {
Marcel Holtmann769be972008-07-14 20:13:49 +02002332 if (c->type != type || skb_queue_empty(&c->data_q))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 continue;
Marcel Holtmann769be972008-07-14 20:13:49 +02002334
2335 if (c->state != BT_CONNECTED && c->state != BT_CONFIG)
2336 continue;
2337
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 num++;
2339
2340 if (c->sent < min) {
2341 min = c->sent;
2342 conn = c;
2343 }
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002344
2345 if (hci_conn_num(hdev, type) == num)
2346 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 }
2348
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002349 rcu_read_unlock();
2350
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 if (conn) {
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002352 int cnt, q;
2353
2354 switch (conn->type) {
2355 case ACL_LINK:
2356 cnt = hdev->acl_cnt;
2357 break;
2358 case SCO_LINK:
2359 case ESCO_LINK:
2360 cnt = hdev->sco_cnt;
2361 break;
2362 case LE_LINK:
2363 cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
2364 break;
2365 default:
2366 cnt = 0;
2367 BT_ERR("Unknown link type");
2368 }
2369
2370 q = cnt / num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 *quote = q ? q : 1;
2372 } else
2373 *quote = 0;
2374
2375 BT_DBG("conn %p quote %d", conn, *quote);
2376 return conn;
2377}
2378
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002379static void hci_link_tx_to(struct hci_dev *hdev, __u8 type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380{
2381 struct hci_conn_hash *h = &hdev->conn_hash;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02002382 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383
Ville Tervobae1f5d92011-02-10 22:38:53 -03002384 BT_ERR("%s link tx timeout", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002386 rcu_read_lock();
2387
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 /* Kill stalled connections */
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002389 list_for_each_entry_rcu(c, &h->list, list) {
Ville Tervobae1f5d92011-02-10 22:38:53 -03002390 if (c->type == type && c->sent) {
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03002391 BT_ERR("%s killing stalled connection %pMR",
2392 hdev->name, &c->dst);
Andrei Emeltchenko7490c6c2012-06-01 16:18:25 +03002393 hci_acl_disconn(c, HCI_ERROR_REMOTE_USER_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 }
2395 }
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002396
2397 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398}
2399
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002400static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type,
2401 int *quote)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002402{
2403 struct hci_conn_hash *h = &hdev->conn_hash;
2404 struct hci_chan *chan = NULL;
Mikel Astizabc5de82012-04-11 08:48:47 +02002405 unsigned int num = 0, min = ~0, cur_prio = 0;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002406 struct hci_conn *conn;
2407 int cnt, q, conn_num = 0;
2408
2409 BT_DBG("%s", hdev->name);
2410
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002411 rcu_read_lock();
2412
2413 list_for_each_entry_rcu(conn, &h->list, list) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002414 struct hci_chan *tmp;
2415
2416 if (conn->type != type)
2417 continue;
2418
2419 if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG)
2420 continue;
2421
2422 conn_num++;
2423
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02002424 list_for_each_entry_rcu(tmp, &conn->chan_list, list) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002425 struct sk_buff *skb;
2426
2427 if (skb_queue_empty(&tmp->data_q))
2428 continue;
2429
2430 skb = skb_peek(&tmp->data_q);
2431 if (skb->priority < cur_prio)
2432 continue;
2433
2434 if (skb->priority > cur_prio) {
2435 num = 0;
2436 min = ~0;
2437 cur_prio = skb->priority;
2438 }
2439
2440 num++;
2441
2442 if (conn->sent < min) {
2443 min = conn->sent;
2444 chan = tmp;
2445 }
2446 }
2447
2448 if (hci_conn_num(hdev, type) == conn_num)
2449 break;
2450 }
2451
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002452 rcu_read_unlock();
2453
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002454 if (!chan)
2455 return NULL;
2456
2457 switch (chan->conn->type) {
2458 case ACL_LINK:
2459 cnt = hdev->acl_cnt;
2460 break;
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002461 case AMP_LINK:
2462 cnt = hdev->block_cnt;
2463 break;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002464 case SCO_LINK:
2465 case ESCO_LINK:
2466 cnt = hdev->sco_cnt;
2467 break;
2468 case LE_LINK:
2469 cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
2470 break;
2471 default:
2472 cnt = 0;
2473 BT_ERR("Unknown link type");
2474 }
2475
2476 q = cnt / num;
2477 *quote = q ? q : 1;
2478 BT_DBG("chan %p quote %d", chan, *quote);
2479 return chan;
2480}
2481
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002482static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type)
2483{
2484 struct hci_conn_hash *h = &hdev->conn_hash;
2485 struct hci_conn *conn;
2486 int num = 0;
2487
2488 BT_DBG("%s", hdev->name);
2489
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002490 rcu_read_lock();
2491
2492 list_for_each_entry_rcu(conn, &h->list, list) {
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002493 struct hci_chan *chan;
2494
2495 if (conn->type != type)
2496 continue;
2497
2498 if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG)
2499 continue;
2500
2501 num++;
2502
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02002503 list_for_each_entry_rcu(chan, &conn->chan_list, list) {
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002504 struct sk_buff *skb;
2505
2506 if (chan->sent) {
2507 chan->sent = 0;
2508 continue;
2509 }
2510
2511 if (skb_queue_empty(&chan->data_q))
2512 continue;
2513
2514 skb = skb_peek(&chan->data_q);
2515 if (skb->priority >= HCI_PRIO_MAX - 1)
2516 continue;
2517
2518 skb->priority = HCI_PRIO_MAX - 1;
2519
2520 BT_DBG("chan %p skb %p promoted to %d", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002521 skb->priority);
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002522 }
2523
2524 if (hci_conn_num(hdev, type) == num)
2525 break;
2526 }
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002527
2528 rcu_read_unlock();
2529
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002530}
2531
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002532static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb)
2533{
2534 /* Calculate count of blocks used by this packet */
2535 return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len);
2536}
2537
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002538static void __check_timeout(struct hci_dev *hdev, unsigned int cnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 if (!test_bit(HCI_RAW, &hdev->flags)) {
2541 /* ACL tx timeout must be longer than maximum
2542 * link supervision timeout (40.9 seconds) */
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002543 if (!cnt && time_after(jiffies, hdev->acl_last_tx +
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +03002544 HCI_ACL_TX_TIMEOUT))
Ville Tervobae1f5d92011-02-10 22:38:53 -03002545 hci_link_tx_to(hdev, ACL_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 }
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002547}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002549static void hci_sched_acl_pkt(struct hci_dev *hdev)
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002550{
2551 unsigned int cnt = hdev->acl_cnt;
2552 struct hci_chan *chan;
2553 struct sk_buff *skb;
2554 int quote;
2555
2556 __check_timeout(hdev, cnt);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002557
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002558 while (hdev->acl_cnt &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002559 (chan = hci_chan_sent(hdev, ACL_LINK, &quote))) {
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002560 u32 priority = (skb_peek(&chan->data_q))->priority;
2561 while (quote-- && (skb = skb_peek(&chan->data_q))) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002562 BT_DBG("chan %p skb %p len %d priority %u", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002563 skb->len, skb->priority);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002564
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002565 /* Stop if priority has changed */
2566 if (skb->priority < priority)
2567 break;
2568
2569 skb = skb_dequeue(&chan->data_q);
2570
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002571 hci_conn_enter_active_mode(chan->conn,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002572 bt_cb(skb)->force_active);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002573
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574 hci_send_frame(skb);
2575 hdev->acl_last_tx = jiffies;
2576
2577 hdev->acl_cnt--;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002578 chan->sent++;
2579 chan->conn->sent++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 }
2581 }
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002582
2583 if (cnt != hdev->acl_cnt)
2584 hci_prio_recalculate(hdev, ACL_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585}
2586
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002587static void hci_sched_acl_blk(struct hci_dev *hdev)
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002588{
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002589 unsigned int cnt = hdev->block_cnt;
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002590 struct hci_chan *chan;
2591 struct sk_buff *skb;
2592 int quote;
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002593 u8 type;
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002594
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002595 __check_timeout(hdev, cnt);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002596
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002597 BT_DBG("%s", hdev->name);
2598
2599 if (hdev->dev_type == HCI_AMP)
2600 type = AMP_LINK;
2601 else
2602 type = ACL_LINK;
2603
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002604 while (hdev->block_cnt > 0 &&
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002605 (chan = hci_chan_sent(hdev, type, &quote))) {
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002606 u32 priority = (skb_peek(&chan->data_q))->priority;
2607 while (quote > 0 && (skb = skb_peek(&chan->data_q))) {
2608 int blocks;
2609
2610 BT_DBG("chan %p skb %p len %d priority %u", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002611 skb->len, skb->priority);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002612
2613 /* Stop if priority has changed */
2614 if (skb->priority < priority)
2615 break;
2616
2617 skb = skb_dequeue(&chan->data_q);
2618
2619 blocks = __get_blocks(hdev, skb);
2620 if (blocks > hdev->block_cnt)
2621 return;
2622
2623 hci_conn_enter_active_mode(chan->conn,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002624 bt_cb(skb)->force_active);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002625
2626 hci_send_frame(skb);
2627 hdev->acl_last_tx = jiffies;
2628
2629 hdev->block_cnt -= blocks;
2630 quote -= blocks;
2631
2632 chan->sent += blocks;
2633 chan->conn->sent += blocks;
2634 }
2635 }
2636
2637 if (cnt != hdev->block_cnt)
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002638 hci_prio_recalculate(hdev, type);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002639}
2640
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002641static void hci_sched_acl(struct hci_dev *hdev)
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002642{
2643 BT_DBG("%s", hdev->name);
2644
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002645 /* No ACL link over BR/EDR controller */
2646 if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR)
2647 return;
2648
2649 /* No AMP link over AMP controller */
2650 if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP)
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002651 return;
2652
2653 switch (hdev->flow_ctl_mode) {
2654 case HCI_FLOW_CTL_MODE_PACKET_BASED:
2655 hci_sched_acl_pkt(hdev);
2656 break;
2657
2658 case HCI_FLOW_CTL_MODE_BLOCK_BASED:
2659 hci_sched_acl_blk(hdev);
2660 break;
2661 }
2662}
2663
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664/* Schedule SCO */
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002665static void hci_sched_sco(struct hci_dev *hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666{
2667 struct hci_conn *conn;
2668 struct sk_buff *skb;
2669 int quote;
2670
2671 BT_DBG("%s", hdev->name);
2672
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002673 if (!hci_conn_num(hdev, SCO_LINK))
2674 return;
2675
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, &quote))) {
2677 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2678 BT_DBG("skb %p len %d", skb, skb->len);
2679 hci_send_frame(skb);
2680
2681 conn->sent++;
2682 if (conn->sent == ~0)
2683 conn->sent = 0;
2684 }
2685 }
2686}
2687
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002688static void hci_sched_esco(struct hci_dev *hdev)
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002689{
2690 struct hci_conn *conn;
2691 struct sk_buff *skb;
2692 int quote;
2693
2694 BT_DBG("%s", hdev->name);
2695
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002696 if (!hci_conn_num(hdev, ESCO_LINK))
2697 return;
2698
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03002699 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK,
2700 &quote))) {
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002701 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2702 BT_DBG("skb %p len %d", skb, skb->len);
2703 hci_send_frame(skb);
2704
2705 conn->sent++;
2706 if (conn->sent == ~0)
2707 conn->sent = 0;
2708 }
2709 }
2710}
2711
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002712static void hci_sched_le(struct hci_dev *hdev)
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002713{
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002714 struct hci_chan *chan;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002715 struct sk_buff *skb;
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002716 int quote, cnt, tmp;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002717
2718 BT_DBG("%s", hdev->name);
2719
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002720 if (!hci_conn_num(hdev, LE_LINK))
2721 return;
2722
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002723 if (!test_bit(HCI_RAW, &hdev->flags)) {
2724 /* LE tx timeout must be longer than maximum
2725 * link supervision timeout (40.9 seconds) */
Ville Tervobae1f5d92011-02-10 22:38:53 -03002726 if (!hdev->le_cnt && hdev->le_pkts &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002727 time_after(jiffies, hdev->le_last_tx + HZ * 45))
Ville Tervobae1f5d92011-02-10 22:38:53 -03002728 hci_link_tx_to(hdev, LE_LINK);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002729 }
2730
2731 cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt;
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002732 tmp = cnt;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002733 while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, &quote))) {
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002734 u32 priority = (skb_peek(&chan->data_q))->priority;
2735 while (quote-- && (skb = skb_peek(&chan->data_q))) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002736 BT_DBG("chan %p skb %p len %d priority %u", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002737 skb->len, skb->priority);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002738
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002739 /* Stop if priority has changed */
2740 if (skb->priority < priority)
2741 break;
2742
2743 skb = skb_dequeue(&chan->data_q);
2744
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002745 hci_send_frame(skb);
2746 hdev->le_last_tx = jiffies;
2747
2748 cnt--;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002749 chan->sent++;
2750 chan->conn->sent++;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002751 }
2752 }
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002753
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002754 if (hdev->le_pkts)
2755 hdev->le_cnt = cnt;
2756 else
2757 hdev->acl_cnt = cnt;
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002758
2759 if (cnt != tmp)
2760 hci_prio_recalculate(hdev, LE_LINK);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002761}
2762
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002763static void hci_tx_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764{
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002765 struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 struct sk_buff *skb;
2767
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002768 BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002769 hdev->sco_cnt, hdev->le_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770
2771 /* Schedule queues and send stuff to HCI driver */
2772
2773 hci_sched_acl(hdev);
2774
2775 hci_sched_sco(hdev);
2776
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002777 hci_sched_esco(hdev);
2778
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002779 hci_sched_le(hdev);
2780
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781 /* Send next queued raw (unknown type) packet */
2782 while ((skb = skb_dequeue(&hdev->raw_q)))
2783 hci_send_frame(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784}
2785
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002786/* ----- HCI RX task (incoming data processing) ----- */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787
2788/* ACL data packet */
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002789static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790{
2791 struct hci_acl_hdr *hdr = (void *) skb->data;
2792 struct hci_conn *conn;
2793 __u16 handle, flags;
2794
2795 skb_pull(skb, HCI_ACL_HDR_SIZE);
2796
2797 handle = __le16_to_cpu(hdr->handle);
2798 flags = hci_flags(handle);
2799 handle = hci_handle(handle);
2800
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002801 BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002802 handle, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803
2804 hdev->stat.acl_rx++;
2805
2806 hci_dev_lock(hdev);
2807 conn = hci_conn_hash_lookup_handle(hdev, handle);
2808 hci_dev_unlock(hdev);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002809
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 if (conn) {
Mat Martineau65983fc2011-12-13 15:06:02 -08002811 hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002812
Johan Hedberg671267b2012-05-12 16:11:50 -03002813 hci_dev_lock(hdev);
2814 if (test_bit(HCI_MGMT, &hdev->dev_flags) &&
2815 !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2816 mgmt_device_connected(hdev, &conn->dst, conn->type,
2817 conn->dst_type, 0, NULL, 0,
2818 conn->dev_class);
2819 hci_dev_unlock(hdev);
2820
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 /* Send to upper protocol */
Ulisses Furquim686ebf22011-12-21 10:11:33 -02002822 l2cap_recv_acldata(conn, skb, flags);
2823 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002825 BT_ERR("%s ACL packet for unknown connection handle %d",
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002826 hdev->name, handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 }
2828
2829 kfree_skb(skb);
2830}
2831
2832/* SCO data packet */
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002833static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834{
2835 struct hci_sco_hdr *hdr = (void *) skb->data;
2836 struct hci_conn *conn;
2837 __u16 handle;
2838
2839 skb_pull(skb, HCI_SCO_HDR_SIZE);
2840
2841 handle = __le16_to_cpu(hdr->handle);
2842
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002843 BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844
2845 hdev->stat.sco_rx++;
2846
2847 hci_dev_lock(hdev);
2848 conn = hci_conn_hash_lookup_handle(hdev, handle);
2849 hci_dev_unlock(hdev);
2850
2851 if (conn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 /* Send to upper protocol */
Ulisses Furquim686ebf22011-12-21 10:11:33 -02002853 sco_recv_scodata(conn, skb);
2854 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002856 BT_ERR("%s SCO packet for unknown connection handle %d",
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002857 hdev->name, handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 }
2859
2860 kfree_skb(skb);
2861}
2862
Marcel Holtmannb78752c2010-08-08 23:06:53 -04002863static void hci_rx_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864{
Marcel Holtmannb78752c2010-08-08 23:06:53 -04002865 struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 struct sk_buff *skb;
2867
2868 BT_DBG("%s", hdev->name);
2869
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 while ((skb = skb_dequeue(&hdev->rx_q))) {
Marcel Holtmanncd82e612012-02-20 20:34:38 +01002871 /* Send copy to monitor */
2872 hci_send_to_monitor(hdev, skb);
2873
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 if (atomic_read(&hdev->promisc)) {
2875 /* Send copy to the sockets */
Marcel Holtmann470fe1b2012-02-20 14:50:30 +01002876 hci_send_to_sock(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 }
2878
2879 if (test_bit(HCI_RAW, &hdev->flags)) {
2880 kfree_skb(skb);
2881 continue;
2882 }
2883
2884 if (test_bit(HCI_INIT, &hdev->flags)) {
2885 /* Don't process data packets in this states. */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002886 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 case HCI_ACLDATA_PKT:
2888 case HCI_SCODATA_PKT:
2889 kfree_skb(skb);
2890 continue;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002891 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 }
2893
2894 /* Process frame */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002895 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 case HCI_EVENT_PKT:
Marcel Holtmannb78752c2010-08-08 23:06:53 -04002897 BT_DBG("%s Event packet", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 hci_event_packet(hdev, skb);
2899 break;
2900
2901 case HCI_ACLDATA_PKT:
2902 BT_DBG("%s ACL data packet", hdev->name);
2903 hci_acldata_packet(hdev, skb);
2904 break;
2905
2906 case HCI_SCODATA_PKT:
2907 BT_DBG("%s SCO data packet", hdev->name);
2908 hci_scodata_packet(hdev, skb);
2909 break;
2910
2911 default:
2912 kfree_skb(skb);
2913 break;
2914 }
2915 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916}
2917
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002918static void hci_cmd_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919{
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002920 struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921 struct sk_buff *skb;
2922
Andrei Emeltchenko21047862012-07-10 15:27:47 +03002923 BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name,
2924 atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926 /* Send queued commands */
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02002927 if (atomic_read(&hdev->cmd_cnt)) {
2928 skb = skb_dequeue(&hdev->cmd_q);
2929 if (!skb)
2930 return;
2931
Wei Yongjun7585b972009-02-25 18:29:52 +08002932 kfree_skb(hdev->sent_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002934 hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC);
2935 if (hdev->sent_cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936 atomic_dec(&hdev->cmd_cnt);
2937 hci_send_frame(skb);
Szymon Janc7bdb8a52011-07-26 22:46:54 +02002938 if (test_bit(HCI_RESET, &hdev->flags))
2939 del_timer(&hdev->cmd_timer);
2940 else
2941 mod_timer(&hdev->cmd_timer,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +03002942 jiffies + HCI_CMD_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943 } else {
2944 skb_queue_head(&hdev->cmd_q, skb);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002945 queue_work(hdev->workqueue, &hdev->cmd_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946 }
2947 }
2948}
Andre Guedes2519a1f2011-11-07 11:45:24 -03002949
2950int hci_do_inquiry(struct hci_dev *hdev, u8 length)
2951{
2952 /* General inquiry access code (GIAC) */
2953 u8 lap[3] = { 0x33, 0x8b, 0x9e };
2954 struct hci_cp_inquiry cp;
2955
2956 BT_DBG("%s", hdev->name);
2957
2958 if (test_bit(HCI_INQUIRY, &hdev->flags))
2959 return -EINPROGRESS;
2960
Johan Hedberg46632622012-01-02 16:06:08 +02002961 inquiry_cache_flush(hdev);
2962
Andre Guedes2519a1f2011-11-07 11:45:24 -03002963 memset(&cp, 0, sizeof(cp));
2964 memcpy(&cp.lap, lap, sizeof(cp.lap));
2965 cp.length = length;
2966
2967 return hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp);
2968}
Andre Guedes023d50492011-11-04 14:16:52 -03002969
2970int hci_cancel_inquiry(struct hci_dev *hdev)
2971{
2972 BT_DBG("%s", hdev->name);
2973
2974 if (!test_bit(HCI_INQUIRY, &hdev->flags))
Andre Guedes7537e5c2012-03-20 00:13:38 -03002975 return -EALREADY;
Andre Guedes023d50492011-11-04 14:16:52 -03002976
2977 return hci_send_cmd(hdev, HCI_OP_INQUIRY_CANCEL, 0, NULL);
2978}
Andre Guedes31f79562012-04-24 21:02:53 -03002979
2980u8 bdaddr_to_le(u8 bdaddr_type)
2981{
2982 switch (bdaddr_type) {
2983 case BDADDR_LE_PUBLIC:
2984 return ADDR_LE_DEV_PUBLIC;
2985
2986 default:
2987 /* Fallback to LE Random address type */
2988 return ADDR_LE_DEV_RANDOM;
2989 }
2990}