blob: 69eb644f0d480c88f1768efa1c079dce1b8a56c7 [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 Padovan6039aa72012-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
Johan Hedberge59fda82012-02-22 18:11:53 +0200864 memset(hdev->eir, 0, sizeof(hdev->eir));
Johan Hedberg09b3c3f2012-02-22 22:01:41 +0200865 memset(hdev->dev_class, 0, sizeof(hdev->dev_class));
Johan Hedberge59fda82012-02-22 18:11:53 +0200866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 hci_req_unlock(hdev);
868
869 hci_dev_put(hdev);
870 return 0;
871}
872
873int hci_dev_close(__u16 dev)
874{
875 struct hci_dev *hdev;
876 int err;
877
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200878 hdev = hci_dev_get(dev);
879 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 return -ENODEV;
Marcel Holtmann8ee56542012-02-21 12:33:48 +0100881
882 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags))
883 cancel_delayed_work(&hdev->power_off);
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 err = hci_dev_do_close(hdev);
Marcel Holtmann8ee56542012-02-21 12:33:48 +0100886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 hci_dev_put(hdev);
888 return err;
889}
890
891int hci_dev_reset(__u16 dev)
892{
893 struct hci_dev *hdev;
894 int ret = 0;
895
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200896 hdev = hci_dev_get(dev);
897 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 return -ENODEV;
899
900 hci_req_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
902 if (!test_bit(HCI_UP, &hdev->flags))
903 goto done;
904
905 /* Drop queues */
906 skb_queue_purge(&hdev->rx_q);
907 skb_queue_purge(&hdev->cmd_q);
908
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300909 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 inquiry_cache_flush(hdev);
911 hci_conn_hash_flush(hdev);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300912 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
914 if (hdev->flush)
915 hdev->flush(hdev);
916
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900917 atomic_set(&hdev->cmd_cnt, 1);
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300918 hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
920 if (!test_bit(HCI_RAW, &hdev->flags))
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300921 ret = __hci_request(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 hci_req_unlock(hdev);
925 hci_dev_put(hdev);
926 return ret;
927}
928
929int hci_dev_reset_stat(__u16 dev)
930{
931 struct hci_dev *hdev;
932 int ret = 0;
933
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200934 hdev = hci_dev_get(dev);
935 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 return -ENODEV;
937
938 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
939
940 hci_dev_put(hdev);
941
942 return ret;
943}
944
945int hci_dev_cmd(unsigned int cmd, void __user *arg)
946{
947 struct hci_dev *hdev;
948 struct hci_dev_req dr;
949 int err = 0;
950
951 if (copy_from_user(&dr, arg, sizeof(dr)))
952 return -EFAULT;
953
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200954 hdev = hci_dev_get(dr.dev_id);
955 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 return -ENODEV;
957
958 switch (cmd) {
959 case HCISETAUTH:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200960 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300961 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 break;
963
964 case HCISETENCRYPT:
965 if (!lmp_encrypt_capable(hdev)) {
966 err = -EOPNOTSUPP;
967 break;
968 }
969
970 if (!test_bit(HCI_AUTH, &hdev->flags)) {
971 /* Auth must be enabled first */
Marcel Holtmann04837f62006-07-03 10:02:33 +0200972 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300973 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 if (err)
975 break;
976 }
977
Marcel Holtmann04837f62006-07-03 10:02:33 +0200978 err = hci_request(hdev, hci_encrypt_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300979 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 break;
981
982 case HCISETSCAN:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200983 err = hci_request(hdev, hci_scan_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300984 HCI_INIT_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 break;
986
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200987 case HCISETLINKPOL:
988 err = hci_request(hdev, hci_linkpol_req, dr.dev_opt,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +0300989 HCI_INIT_TIMEOUT);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200990 break;
991
992 case HCISETLINKMODE:
993 hdev->link_mode = ((__u16) dr.dev_opt) &
994 (HCI_LM_MASTER | HCI_LM_ACCEPT);
995 break;
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 case HCISETPTYPE:
998 hdev->pkt_type = (__u16) dr.dev_opt;
999 break;
1000
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 case HCISETACLMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001002 hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1);
1003 hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 break;
1005
1006 case HCISETSCOMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001007 hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1);
1008 hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 break;
1010
1011 default:
1012 err = -EINVAL;
1013 break;
1014 }
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001015
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 hci_dev_put(hdev);
1017 return err;
1018}
1019
1020int hci_get_dev_list(void __user *arg)
1021{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001022 struct hci_dev *hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 struct hci_dev_list_req *dl;
1024 struct hci_dev_req *dr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 int n = 0, size, err;
1026 __u16 dev_num;
1027
1028 if (get_user(dev_num, (__u16 __user *) arg))
1029 return -EFAULT;
1030
1031 if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr))
1032 return -EINVAL;
1033
1034 size = sizeof(*dl) + dev_num * sizeof(*dr);
1035
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001036 dl = kzalloc(size, GFP_KERNEL);
1037 if (!dl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 return -ENOMEM;
1039
1040 dr = dl->dev_req;
1041
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001042 read_lock(&hci_dev_list_lock);
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001043 list_for_each_entry(hdev, &hci_dev_list, list) {
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001044 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags))
Johan Hedberge0f93092011-11-09 01:44:22 +02001045 cancel_delayed_work(&hdev->power_off);
Johan Hedbergc542a062011-01-26 13:11:03 +02001046
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001047 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
1048 set_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergc542a062011-01-26 13:11:03 +02001049
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 (dr + n)->dev_id = hdev->id;
1051 (dr + n)->dev_opt = hdev->flags;
Johan Hedbergc542a062011-01-26 13:11:03 +02001052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (++n >= dev_num)
1054 break;
1055 }
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001056 read_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
1058 dl->dev_num = n;
1059 size = sizeof(*dl) + n * sizeof(*dr);
1060
1061 err = copy_to_user(arg, dl, size);
1062 kfree(dl);
1063
1064 return err ? -EFAULT : 0;
1065}
1066
1067int hci_get_dev_info(void __user *arg)
1068{
1069 struct hci_dev *hdev;
1070 struct hci_dev_info di;
1071 int err = 0;
1072
1073 if (copy_from_user(&di, arg, sizeof(di)))
1074 return -EFAULT;
1075
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02001076 hdev = hci_dev_get(di.dev_id);
1077 if (!hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 return -ENODEV;
1079
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001080 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags))
Johan Hedberg32435532011-11-07 22:16:04 +02001081 cancel_delayed_work_sync(&hdev->power_off);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001082
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001083 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
1084 set_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergc542a062011-01-26 13:11:03 +02001085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 strcpy(di.name, hdev->name);
1087 di.bdaddr = hdev->bdaddr;
Marcel Holtmann943da252010-02-13 02:28:41 +01001088 di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 di.flags = hdev->flags;
1090 di.pkt_type = hdev->pkt_type;
Johan Hedberg572c7f82012-10-19 20:57:46 +03001091 if (lmp_bredr_capable(hdev)) {
1092 di.acl_mtu = hdev->acl_mtu;
1093 di.acl_pkts = hdev->acl_pkts;
1094 di.sco_mtu = hdev->sco_mtu;
1095 di.sco_pkts = hdev->sco_pkts;
1096 } else {
1097 di.acl_mtu = hdev->le_mtu;
1098 di.acl_pkts = hdev->le_pkts;
1099 di.sco_mtu = 0;
1100 di.sco_pkts = 0;
1101 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 di.link_policy = hdev->link_policy;
1103 di.link_mode = hdev->link_mode;
1104
1105 memcpy(&di.stat, &hdev->stat, sizeof(di.stat));
1106 memcpy(&di.features, &hdev->features, sizeof(di.features));
1107
1108 if (copy_to_user(arg, &di, sizeof(di)))
1109 err = -EFAULT;
1110
1111 hci_dev_put(hdev);
1112
1113 return err;
1114}
1115
1116/* ---- Interface to HCI drivers ---- */
1117
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001118static int hci_rfkill_set_block(void *data, bool blocked)
1119{
1120 struct hci_dev *hdev = data;
1121
1122 BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked);
1123
1124 if (!blocked)
1125 return 0;
1126
1127 hci_dev_do_close(hdev);
1128
1129 return 0;
1130}
1131
1132static const struct rfkill_ops hci_rfkill_ops = {
1133 .set_block = hci_rfkill_set_block,
1134};
1135
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001136static void hci_power_on(struct work_struct *work)
1137{
1138 struct hci_dev *hdev = container_of(work, struct hci_dev, power_on);
1139
1140 BT_DBG("%s", hdev->name);
1141
1142 if (hci_dev_open(hdev->id) < 0)
1143 return;
1144
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001145 if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags))
Andrei Emeltchenko9345d402012-06-15 10:36:42 +03001146 schedule_delayed_work(&hdev->power_off, HCI_AUTO_OFF_TIMEOUT);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001147
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001148 if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +02001149 mgmt_index_added(hdev);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001150}
1151
1152static void hci_power_off(struct work_struct *work)
1153{
Johan Hedberg32435532011-11-07 22:16:04 +02001154 struct hci_dev *hdev = container_of(work, struct hci_dev,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001155 power_off.work);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001156
1157 BT_DBG("%s", hdev->name);
1158
Marcel Holtmann8ee56542012-02-21 12:33:48 +01001159 hci_dev_do_close(hdev);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001160}
1161
Johan Hedberg16ab91a2011-11-07 22:16:02 +02001162static void hci_discov_off(struct work_struct *work)
1163{
1164 struct hci_dev *hdev;
1165 u8 scan = SCAN_PAGE;
1166
1167 hdev = container_of(work, struct hci_dev, discov_off.work);
1168
1169 BT_DBG("%s", hdev->name);
1170
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001171 hci_dev_lock(hdev);
Johan Hedberg16ab91a2011-11-07 22:16:02 +02001172
1173 hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, sizeof(scan), &scan);
1174
1175 hdev->discov_timeout = 0;
1176
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001177 hci_dev_unlock(hdev);
Johan Hedberg16ab91a2011-11-07 22:16:02 +02001178}
1179
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001180int hci_uuids_clear(struct hci_dev *hdev)
1181{
1182 struct list_head *p, *n;
1183
1184 list_for_each_safe(p, n, &hdev->uuids) {
1185 struct bt_uuid *uuid;
1186
1187 uuid = list_entry(p, struct bt_uuid, list);
1188
1189 list_del(p);
1190 kfree(uuid);
1191 }
1192
1193 return 0;
1194}
1195
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001196int hci_link_keys_clear(struct hci_dev *hdev)
1197{
1198 struct list_head *p, *n;
1199
1200 list_for_each_safe(p, n, &hdev->link_keys) {
1201 struct link_key *key;
1202
1203 key = list_entry(p, struct link_key, list);
1204
1205 list_del(p);
1206 kfree(key);
1207 }
1208
1209 return 0;
1210}
1211
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001212int hci_smp_ltks_clear(struct hci_dev *hdev)
1213{
1214 struct smp_ltk *k, *tmp;
1215
1216 list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) {
1217 list_del(&k->list);
1218 kfree(k);
1219 }
1220
1221 return 0;
1222}
1223
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001224struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
1225{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001226 struct link_key *k;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001227
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001228 list_for_each_entry(k, &hdev->link_keys, list)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001229 if (bacmp(bdaddr, &k->bdaddr) == 0)
1230 return k;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001231
1232 return NULL;
1233}
1234
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301235static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001236 u8 key_type, u8 old_key_type)
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001237{
1238 /* Legacy key */
1239 if (key_type < 0x03)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301240 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001241
1242 /* Debug keys are insecure so don't store them persistently */
1243 if (key_type == HCI_LK_DEBUG_COMBINATION)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301244 return false;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001245
1246 /* Changed combination key and there's no previous one */
1247 if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301248 return false;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001249
1250 /* Security mode 3 case */
1251 if (!conn)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301252 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001253
1254 /* Neither local nor remote side had no-bonding as requirement */
1255 if (conn->auth_type > 0x01 && conn->remote_auth > 0x01)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301256 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001257
1258 /* Local side had dedicated bonding as requirement */
1259 if (conn->auth_type == 0x02 || conn->auth_type == 0x03)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301260 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001261
1262 /* Remote side had dedicated bonding as requirement */
1263 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03)
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301264 return true;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001265
1266 /* If none of the above criteria match, then don't store the key
1267 * persistently */
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301268 return false;
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001269}
1270
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001271struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8])
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001272{
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001273 struct smp_ltk *k;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001274
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001275 list_for_each_entry(k, &hdev->long_term_keys, list) {
1276 if (k->ediv != ediv ||
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001277 memcmp(rand, k->rand, sizeof(k->rand)))
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001278 continue;
1279
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001280 return k;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001281 }
1282
1283 return NULL;
1284}
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001285
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001286struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001287 u8 addr_type)
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001288{
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001289 struct smp_ltk *k;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001290
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001291 list_for_each_entry(k, &hdev->long_term_keys, list)
1292 if (addr_type == k->bdaddr_type &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001293 bacmp(bdaddr, &k->bdaddr) == 0)
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001294 return k;
1295
1296 return NULL;
1297}
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001298
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001299int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001300 bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001301{
1302 struct link_key *key, *old_key;
Vishal Agarwal745c0ce2012-04-13 17:43:22 +05301303 u8 old_key_type;
1304 bool persistent;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001305
1306 old_key = hci_find_link_key(hdev, bdaddr);
1307 if (old_key) {
1308 old_key_type = old_key->type;
1309 key = old_key;
1310 } else {
Johan Hedberg12adcf32011-04-28 11:29:00 -07001311 old_key_type = conn ? conn->key_type : 0xff;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001312 key = kzalloc(sizeof(*key), GFP_ATOMIC);
1313 if (!key)
1314 return -ENOMEM;
1315 list_add(&key->list, &hdev->link_keys);
1316 }
1317
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001318 BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001319
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001320 /* Some buggy controller combinations generate a changed
1321 * combination key for legacy pairing even when there's no
1322 * previous key */
1323 if (type == HCI_LK_CHANGED_COMBINATION &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001324 (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) {
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001325 type = HCI_LK_COMBINATION;
Johan Hedberg655fe6e2011-04-28 11:29:01 -07001326 if (conn)
1327 conn->key_type = type;
1328 }
Johan Hedbergd25e28a2011-04-28 11:28:59 -07001329
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001330 bacpy(&key->bdaddr, bdaddr);
Andrei Emeltchenko9b3b4462012-05-23 11:31:20 +03001331 memcpy(key->val, val, HCI_LINK_KEY_SIZE);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001332 key->pin_len = pin_len;
1333
Waldemar Rymarkiewiczb6020ba2011-04-28 12:07:53 +02001334 if (type == HCI_LK_CHANGED_COMBINATION)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001335 key->type = old_key_type;
Johan Hedberg4748fed2011-04-28 11:29:02 -07001336 else
1337 key->type = type;
1338
Johan Hedberg4df378a2011-04-28 11:29:03 -07001339 if (!new_key)
1340 return 0;
1341
1342 persistent = hci_persistent_key(hdev, conn, type, old_key_type);
1343
Johan Hedberg744cf192011-11-08 20:40:14 +02001344 mgmt_new_link_key(hdev, key, persistent);
Johan Hedberg4df378a2011-04-28 11:29:03 -07001345
Vishal Agarwal6ec5bca2012-04-16 14:44:44 +05301346 if (conn)
1347 conn->flush_key = !persistent;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001348
1349 return 0;
1350}
1351
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001352int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type,
Andrei Emeltchenko9a006652012-03-09 12:12:12 +02001353 int new_key, u8 authenticated, u8 tk[16], u8 enc_size, __le16
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001354 ediv, u8 rand[8])
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001355{
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001356 struct smp_ltk *key, *old_key;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001357
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001358 if (!(type & HCI_SMP_STK) && !(type & HCI_SMP_LTK))
1359 return 0;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001360
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001361 old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type);
1362 if (old_key)
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001363 key = old_key;
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001364 else {
1365 key = kzalloc(sizeof(*key), GFP_ATOMIC);
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001366 if (!key)
1367 return -ENOMEM;
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001368 list_add(&key->list, &hdev->long_term_keys);
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001369 }
1370
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001371 bacpy(&key->bdaddr, bdaddr);
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001372 key->bdaddr_type = addr_type;
1373 memcpy(key->val, tk, sizeof(key->val));
1374 key->authenticated = authenticated;
1375 key->ediv = ediv;
1376 key->enc_size = enc_size;
1377 key->type = type;
1378 memcpy(key->rand, rand, sizeof(key->rand));
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001379
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03001380 if (!new_key)
1381 return 0;
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001382
Vinicius Costa Gomes261cc5a2012-02-02 21:08:05 -03001383 if (type & HCI_SMP_LTK)
1384 mgmt_new_ltk(hdev, key, 1);
1385
Vinicius Costa Gomes75d262c2011-07-07 18:59:36 -03001386 return 0;
1387}
1388
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001389int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
1390{
1391 struct link_key *key;
1392
1393 key = hci_find_link_key(hdev, bdaddr);
1394 if (!key)
1395 return -ENOENT;
1396
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001397 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001398
1399 list_del(&key->list);
1400 kfree(key);
1401
1402 return 0;
1403}
1404
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001405int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr)
1406{
1407 struct smp_ltk *k, *tmp;
1408
1409 list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) {
1410 if (bacmp(bdaddr, &k->bdaddr))
1411 continue;
1412
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001413 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001414
1415 list_del(&k->list);
1416 kfree(k);
1417 }
1418
1419 return 0;
1420}
1421
Ville Tervo6bd32322011-02-16 16:32:41 +02001422/* HCI command timer function */
Andrei Emeltchenkobda4f232012-06-11 11:13:08 +03001423static void hci_cmd_timeout(unsigned long arg)
Ville Tervo6bd32322011-02-16 16:32:41 +02001424{
1425 struct hci_dev *hdev = (void *) arg;
1426
Andrei Emeltchenkobda4f232012-06-11 11:13:08 +03001427 if (hdev->sent_cmd) {
1428 struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data;
1429 u16 opcode = __le16_to_cpu(sent->opcode);
1430
1431 BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode);
1432 } else {
1433 BT_ERR("%s command tx timeout", hdev->name);
1434 }
1435
Ville Tervo6bd32322011-02-16 16:32:41 +02001436 atomic_set(&hdev->cmd_cnt, 1);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02001437 queue_work(hdev->workqueue, &hdev->cmd_work);
Ville Tervo6bd32322011-02-16 16:32:41 +02001438}
1439
Szymon Janc2763eda2011-03-22 13:12:22 +01001440struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001441 bdaddr_t *bdaddr)
Szymon Janc2763eda2011-03-22 13:12:22 +01001442{
1443 struct oob_data *data;
1444
1445 list_for_each_entry(data, &hdev->remote_oob_data, list)
1446 if (bacmp(bdaddr, &data->bdaddr) == 0)
1447 return data;
1448
1449 return NULL;
1450}
1451
1452int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr)
1453{
1454 struct oob_data *data;
1455
1456 data = hci_find_remote_oob_data(hdev, bdaddr);
1457 if (!data)
1458 return -ENOENT;
1459
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001460 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
Szymon Janc2763eda2011-03-22 13:12:22 +01001461
1462 list_del(&data->list);
1463 kfree(data);
1464
1465 return 0;
1466}
1467
1468int hci_remote_oob_data_clear(struct hci_dev *hdev)
1469{
1470 struct oob_data *data, *n;
1471
1472 list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) {
1473 list_del(&data->list);
1474 kfree(data);
1475 }
1476
1477 return 0;
1478}
1479
1480int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001481 u8 *randomizer)
Szymon Janc2763eda2011-03-22 13:12:22 +01001482{
1483 struct oob_data *data;
1484
1485 data = hci_find_remote_oob_data(hdev, bdaddr);
1486
1487 if (!data) {
1488 data = kmalloc(sizeof(*data), GFP_ATOMIC);
1489 if (!data)
1490 return -ENOMEM;
1491
1492 bacpy(&data->bdaddr, bdaddr);
1493 list_add(&data->list, &hdev->remote_oob_data);
1494 }
1495
1496 memcpy(data->hash, hash, sizeof(data->hash));
1497 memcpy(data->randomizer, randomizer, sizeof(data->randomizer));
1498
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001499 BT_DBG("%s for %pMR", hdev->name, bdaddr);
Szymon Janc2763eda2011-03-22 13:12:22 +01001500
1501 return 0;
1502}
1503
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001504struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001505{
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001506 struct bdaddr_list *b;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001507
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001508 list_for_each_entry(b, &hdev->blacklist, list)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001509 if (bacmp(bdaddr, &b->bdaddr) == 0)
1510 return b;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001511
1512 return NULL;
1513}
1514
1515int hci_blacklist_clear(struct hci_dev *hdev)
1516{
1517 struct list_head *p, *n;
1518
1519 list_for_each_safe(p, n, &hdev->blacklist) {
1520 struct bdaddr_list *b;
1521
1522 b = list_entry(p, struct bdaddr_list, list);
1523
1524 list_del(p);
1525 kfree(b);
1526 }
1527
1528 return 0;
1529}
1530
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001531int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001532{
1533 struct bdaddr_list *entry;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001534
1535 if (bacmp(bdaddr, BDADDR_ANY) == 0)
1536 return -EBADF;
1537
Antti Julku5e762442011-08-25 16:48:02 +03001538 if (hci_blacklist_lookup(hdev, bdaddr))
1539 return -EEXIST;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001540
1541 entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL);
Antti Julku5e762442011-08-25 16:48:02 +03001542 if (!entry)
1543 return -ENOMEM;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001544
1545 bacpy(&entry->bdaddr, bdaddr);
1546
1547 list_add(&entry->list, &hdev->blacklist);
1548
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001549 return mgmt_device_blocked(hdev, bdaddr, type);
Antti Julkub2a66aa2011-06-15 12:01:14 +03001550}
1551
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001552int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julkub2a66aa2011-06-15 12:01:14 +03001553{
1554 struct bdaddr_list *entry;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001555
Szymon Janc1ec918c2011-11-16 09:32:21 +01001556 if (bacmp(bdaddr, BDADDR_ANY) == 0)
Antti Julku5e762442011-08-25 16:48:02 +03001557 return hci_blacklist_clear(hdev);
Antti Julkub2a66aa2011-06-15 12:01:14 +03001558
1559 entry = hci_blacklist_lookup(hdev, bdaddr);
Szymon Janc1ec918c2011-11-16 09:32:21 +01001560 if (!entry)
Antti Julku5e762442011-08-25 16:48:02 +03001561 return -ENOENT;
Antti Julkub2a66aa2011-06-15 12:01:14 +03001562
1563 list_del(&entry->list);
1564 kfree(entry);
1565
Johan Hedberg88c1fe42012-02-09 15:56:11 +02001566 return mgmt_device_unblocked(hdev, bdaddr, type);
Antti Julkub2a66aa2011-06-15 12:01:14 +03001567}
1568
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001569static void le_scan_param_req(struct hci_dev *hdev, unsigned long opt)
1570{
1571 struct le_scan_params *param = (struct le_scan_params *) opt;
1572 struct hci_cp_le_set_scan_param cp;
1573
1574 memset(&cp, 0, sizeof(cp));
1575 cp.type = param->type;
1576 cp.interval = cpu_to_le16(param->interval);
1577 cp.window = cpu_to_le16(param->window);
1578
1579 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_PARAM, sizeof(cp), &cp);
1580}
1581
1582static void le_scan_enable_req(struct hci_dev *hdev, unsigned long opt)
1583{
1584 struct hci_cp_le_set_scan_enable cp;
1585
1586 memset(&cp, 0, sizeof(cp));
1587 cp.enable = 1;
Andre Guedes0431a432012-05-31 20:01:41 -03001588 cp.filter_dup = 1;
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001589
1590 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp);
1591}
1592
1593static int hci_do_le_scan(struct hci_dev *hdev, u8 type, u16 interval,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001594 u16 window, int timeout)
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001595{
1596 long timeo = msecs_to_jiffies(3000);
1597 struct le_scan_params param;
1598 int err;
1599
1600 BT_DBG("%s", hdev->name);
1601
1602 if (test_bit(HCI_LE_SCAN, &hdev->dev_flags))
1603 return -EINPROGRESS;
1604
1605 param.type = type;
1606 param.interval = interval;
1607 param.window = window;
1608
1609 hci_req_lock(hdev);
1610
1611 err = __hci_request(hdev, le_scan_param_req, (unsigned long) &param,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001612 timeo);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001613 if (!err)
1614 err = __hci_request(hdev, le_scan_enable_req, 0, timeo);
1615
1616 hci_req_unlock(hdev);
1617
1618 if (err < 0)
1619 return err;
1620
1621 schedule_delayed_work(&hdev->le_scan_disable,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001622 msecs_to_jiffies(timeout));
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001623
1624 return 0;
1625}
1626
Andre Guedes7dbfac12012-03-15 16:52:07 -03001627int hci_cancel_le_scan(struct hci_dev *hdev)
1628{
1629 BT_DBG("%s", hdev->name);
1630
1631 if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags))
1632 return -EALREADY;
1633
1634 if (cancel_delayed_work(&hdev->le_scan_disable)) {
1635 struct hci_cp_le_set_scan_enable cp;
1636
1637 /* Send HCI command to disable LE Scan */
1638 memset(&cp, 0, sizeof(cp));
1639 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp);
1640 }
1641
1642 return 0;
1643}
1644
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001645static void le_scan_disable_work(struct work_struct *work)
1646{
1647 struct hci_dev *hdev = container_of(work, struct hci_dev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001648 le_scan_disable.work);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001649 struct hci_cp_le_set_scan_enable cp;
1650
1651 BT_DBG("%s", hdev->name);
1652
1653 memset(&cp, 0, sizeof(cp));
1654
1655 hci_send_cmd(hdev, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp);
1656}
1657
Andre Guedes28b75a82012-02-03 17:48:00 -03001658static void le_scan_work(struct work_struct *work)
1659{
1660 struct hci_dev *hdev = container_of(work, struct hci_dev, le_scan);
1661 struct le_scan_params *param = &hdev->le_scan_params;
1662
1663 BT_DBG("%s", hdev->name);
1664
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001665 hci_do_le_scan(hdev, param->type, param->interval, param->window,
1666 param->timeout);
Andre Guedes28b75a82012-02-03 17:48:00 -03001667}
1668
1669int hci_le_scan(struct hci_dev *hdev, u8 type, u16 interval, u16 window,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001670 int timeout)
Andre Guedes28b75a82012-02-03 17:48:00 -03001671{
1672 struct le_scan_params *param = &hdev->le_scan_params;
1673
1674 BT_DBG("%s", hdev->name);
1675
Johan Hedbergf15504782012-10-24 21:12:03 +03001676 if (test_bit(HCI_LE_PERIPHERAL, &hdev->dev_flags))
1677 return -ENOTSUPP;
1678
Andre Guedes28b75a82012-02-03 17:48:00 -03001679 if (work_busy(&hdev->le_scan))
1680 return -EINPROGRESS;
1681
1682 param->type = type;
1683 param->interval = interval;
1684 param->window = window;
1685 param->timeout = timeout;
1686
1687 queue_work(system_long_wq, &hdev->le_scan);
1688
1689 return 0;
1690}
1691
David Herrmann9be0dab2012-04-22 14:39:57 +02001692/* Alloc HCI device */
1693struct hci_dev *hci_alloc_dev(void)
1694{
1695 struct hci_dev *hdev;
1696
1697 hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL);
1698 if (!hdev)
1699 return NULL;
1700
David Herrmannb1b813d2012-04-22 14:39:58 +02001701 hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1);
1702 hdev->esco_type = (ESCO_HV1);
1703 hdev->link_mode = (HCI_LM_ACCEPT);
1704 hdev->io_capability = 0x03; /* No Input No Output */
Johan Hedbergbbaf4442012-11-08 01:22:59 +01001705 hdev->inq_tx_power = HCI_TX_POWER_INVALID;
1706 hdev->adv_tx_power = HCI_TX_POWER_INVALID;
David Herrmannb1b813d2012-04-22 14:39:58 +02001707
David Herrmannb1b813d2012-04-22 14:39:58 +02001708 hdev->sniff_max_interval = 800;
1709 hdev->sniff_min_interval = 80;
1710
1711 mutex_init(&hdev->lock);
1712 mutex_init(&hdev->req_lock);
1713
1714 INIT_LIST_HEAD(&hdev->mgmt_pending);
1715 INIT_LIST_HEAD(&hdev->blacklist);
1716 INIT_LIST_HEAD(&hdev->uuids);
1717 INIT_LIST_HEAD(&hdev->link_keys);
1718 INIT_LIST_HEAD(&hdev->long_term_keys);
1719 INIT_LIST_HEAD(&hdev->remote_oob_data);
Andrei Emeltchenko6b536b52012-08-31 16:39:28 +03001720 INIT_LIST_HEAD(&hdev->conn_hash.list);
David Herrmannb1b813d2012-04-22 14:39:58 +02001721
1722 INIT_WORK(&hdev->rx_work, hci_rx_work);
1723 INIT_WORK(&hdev->cmd_work, hci_cmd_work);
1724 INIT_WORK(&hdev->tx_work, hci_tx_work);
1725 INIT_WORK(&hdev->power_on, hci_power_on);
1726 INIT_WORK(&hdev->le_scan, le_scan_work);
1727
David Herrmannb1b813d2012-04-22 14:39:58 +02001728 INIT_DELAYED_WORK(&hdev->power_off, hci_power_off);
1729 INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off);
1730 INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work);
1731
David Herrmann9be0dab2012-04-22 14:39:57 +02001732 skb_queue_head_init(&hdev->driver_init);
David Herrmannb1b813d2012-04-22 14:39:58 +02001733 skb_queue_head_init(&hdev->rx_q);
1734 skb_queue_head_init(&hdev->cmd_q);
1735 skb_queue_head_init(&hdev->raw_q);
1736
1737 init_waitqueue_head(&hdev->req_wait_q);
1738
Andrei Emeltchenkobda4f232012-06-11 11:13:08 +03001739 setup_timer(&hdev->cmd_timer, hci_cmd_timeout, (unsigned long) hdev);
David Herrmannb1b813d2012-04-22 14:39:58 +02001740
David Herrmannb1b813d2012-04-22 14:39:58 +02001741 hci_init_sysfs(hdev);
1742 discovery_init(hdev);
David Herrmann9be0dab2012-04-22 14:39:57 +02001743
1744 return hdev;
1745}
1746EXPORT_SYMBOL(hci_alloc_dev);
1747
1748/* Free HCI device */
1749void hci_free_dev(struct hci_dev *hdev)
1750{
1751 skb_queue_purge(&hdev->driver_init);
1752
1753 /* will free via device release */
1754 put_device(&hdev->dev);
1755}
1756EXPORT_SYMBOL(hci_free_dev);
1757
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758/* Register HCI device */
1759int hci_register_dev(struct hci_dev *hdev)
1760{
David Herrmannb1b813d2012-04-22 14:39:58 +02001761 int id, error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762
David Herrmann010666a2012-01-07 15:47:07 +01001763 if (!hdev->open || !hdev->close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 return -EINVAL;
1765
Mat Martineau08add512011-11-02 16:18:36 -07001766 /* Do not allow HCI_AMP devices to register at index 0,
1767 * so the index can be used as the AMP controller ID.
1768 */
Sasha Levin3df92b32012-05-27 22:36:56 +02001769 switch (hdev->dev_type) {
1770 case HCI_BREDR:
1771 id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL);
1772 break;
1773 case HCI_AMP:
1774 id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL);
1775 break;
1776 default:
1777 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 }
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001779
Sasha Levin3df92b32012-05-27 22:36:56 +02001780 if (id < 0)
1781 return id;
1782
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 sprintf(hdev->name, "hci%d", id);
1784 hdev->id = id;
Andrei Emeltchenko2d8b3a12012-04-16 16:32:04 +03001785
1786 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
1787
Sasha Levin3df92b32012-05-27 22:36:56 +02001788 write_lock(&hci_dev_list_lock);
1789 list_add(&hdev->list, &hci_dev_list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001790 write_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
Gustavo F. Padovan32845eb2011-12-17 17:47:30 -02001792 hdev->workqueue = alloc_workqueue(hdev->name, WQ_HIGHPRI | WQ_UNBOUND |
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001793 WQ_MEM_RECLAIM, 1);
David Herrmann33ca9542011-10-08 14:58:49 +02001794 if (!hdev->workqueue) {
1795 error = -ENOMEM;
1796 goto err;
1797 }
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001798
David Herrmann33ca9542011-10-08 14:58:49 +02001799 error = hci_add_sysfs(hdev);
1800 if (error < 0)
1801 goto err_wqueue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001803 hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001804 RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops,
1805 hdev);
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001806 if (hdev->rfkill) {
1807 if (rfkill_register(hdev->rfkill) < 0) {
1808 rfkill_destroy(hdev->rfkill);
1809 hdev->rfkill = NULL;
1810 }
1811 }
1812
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001813 set_bit(HCI_SETUP, &hdev->dev_flags);
Andrei Emeltchenkoce2be9a2012-06-29 15:07:00 +03001814
1815 if (hdev->dev_type != HCI_AMP)
1816 set_bit(HCI_AUTO_OFF, &hdev->dev_flags);
1817
Gustavo F. Padovan7f971042011-12-18 12:40:32 -02001818 schedule_work(&hdev->power_on);
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001819
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 hci_notify(hdev, HCI_DEV_REG);
David Herrmanndc946bd2012-01-07 15:47:24 +01001821 hci_dev_hold(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
1823 return id;
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001824
David Herrmann33ca9542011-10-08 14:58:49 +02001825err_wqueue:
1826 destroy_workqueue(hdev->workqueue);
1827err:
Sasha Levin3df92b32012-05-27 22:36:56 +02001828 ida_simple_remove(&hci_index_ida, hdev->id);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001829 write_lock(&hci_dev_list_lock);
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001830 list_del(&hdev->list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001831 write_unlock(&hci_dev_list_lock);
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001832
David Herrmann33ca9542011-10-08 14:58:49 +02001833 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834}
1835EXPORT_SYMBOL(hci_register_dev);
1836
1837/* Unregister HCI device */
David Herrmann59735632011-10-26 10:43:19 +02001838void hci_unregister_dev(struct hci_dev *hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839{
Sasha Levin3df92b32012-05-27 22:36:56 +02001840 int i, id;
Marcel Holtmannef222012007-07-11 06:42:04 +02001841
Marcel Holtmannc13854c2010-02-08 15:27:07 +01001842 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843
Johan Hovold94324962012-03-15 14:48:41 +01001844 set_bit(HCI_UNREGISTER, &hdev->dev_flags);
1845
Sasha Levin3df92b32012-05-27 22:36:56 +02001846 id = hdev->id;
1847
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001848 write_lock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 list_del(&hdev->list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02001850 write_unlock(&hci_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851
1852 hci_dev_do_close(hdev);
1853
Suraj Sumangalacd4c5392010-07-14 13:02:16 +05301854 for (i = 0; i < NUM_REASSEMBLY; i++)
Marcel Holtmannef222012007-07-11 06:42:04 +02001855 kfree_skb(hdev->reassembly[i]);
1856
Gustavo Padovanb9b5ef12012-11-21 00:50:21 -02001857 cancel_work_sync(&hdev->power_on);
1858
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001859 if (!test_bit(HCI_INIT, &hdev->flags) &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001860 !test_bit(HCI_SETUP, &hdev->dev_flags)) {
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001861 hci_dev_lock(hdev);
Johan Hedberg744cf192011-11-08 20:40:14 +02001862 mgmt_index_removed(hdev);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001863 hci_dev_unlock(hdev);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001864 }
Johan Hedbergab81cbf2010-12-15 13:53:18 +02001865
Johan Hedberg2e58ef32011-11-08 20:40:15 +02001866 /* mgmt_index_removed should take care of emptying the
1867 * pending list */
1868 BUG_ON(!list_empty(&hdev->mgmt_pending));
1869
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 hci_notify(hdev, HCI_DEV_UNREG);
1871
Marcel Holtmann611b30f2009-06-08 14:41:38 +02001872 if (hdev->rfkill) {
1873 rfkill_unregister(hdev->rfkill);
1874 rfkill_destroy(hdev->rfkill);
1875 }
1876
David Herrmannce242972011-10-08 14:58:48 +02001877 hci_del_sysfs(hdev);
Dave Young147e2d52008-03-05 18:45:59 -08001878
Marcel Holtmannf48fd9c2010-03-20 15:20:04 +01001879 destroy_workqueue(hdev->workqueue);
1880
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001881 hci_dev_lock(hdev);
Johan Hedberge2e0cac2011-01-04 12:08:50 +02001882 hci_blacklist_clear(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001883 hci_uuids_clear(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001884 hci_link_keys_clear(hdev);
Vinicius Costa Gomesb899efa2012-02-02 21:08:00 -03001885 hci_smp_ltks_clear(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01001886 hci_remote_oob_data_clear(hdev);
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001887 hci_dev_unlock(hdev);
Johan Hedberge2e0cac2011-01-04 12:08:50 +02001888
David Herrmanndc946bd2012-01-07 15:47:24 +01001889 hci_dev_put(hdev);
Sasha Levin3df92b32012-05-27 22:36:56 +02001890
1891 ida_simple_remove(&hci_index_ida, id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892}
1893EXPORT_SYMBOL(hci_unregister_dev);
1894
1895/* Suspend HCI device */
1896int hci_suspend_dev(struct hci_dev *hdev)
1897{
1898 hci_notify(hdev, HCI_DEV_SUSPEND);
1899 return 0;
1900}
1901EXPORT_SYMBOL(hci_suspend_dev);
1902
1903/* Resume HCI device */
1904int hci_resume_dev(struct hci_dev *hdev)
1905{
1906 hci_notify(hdev, HCI_DEV_RESUME);
1907 return 0;
1908}
1909EXPORT_SYMBOL(hci_resume_dev);
1910
Marcel Holtmann76bca882009-11-18 00:40:39 +01001911/* Receive frame from HCI drivers */
1912int hci_recv_frame(struct sk_buff *skb)
1913{
1914 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
1915 if (!hdev || (!test_bit(HCI_UP, &hdev->flags)
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001916 && !test_bit(HCI_INIT, &hdev->flags))) {
Marcel Holtmann76bca882009-11-18 00:40:39 +01001917 kfree_skb(skb);
1918 return -ENXIO;
1919 }
1920
1921 /* Incomming skb */
1922 bt_cb(skb)->incoming = 1;
1923
1924 /* Time stamp */
1925 __net_timestamp(skb);
1926
Marcel Holtmann76bca882009-11-18 00:40:39 +01001927 skb_queue_tail(&hdev->rx_q, skb);
Marcel Holtmannb78752c2010-08-08 23:06:53 -04001928 queue_work(hdev->workqueue, &hdev->rx_work);
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001929
Marcel Holtmann76bca882009-11-18 00:40:39 +01001930 return 0;
1931}
1932EXPORT_SYMBOL(hci_recv_frame);
1933
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301934static int hci_reassembly(struct hci_dev *hdev, int type, void *data,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001935 int count, __u8 index)
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301936{
1937 int len = 0;
1938 int hlen = 0;
1939 int remain = count;
1940 struct sk_buff *skb;
1941 struct bt_skb_cb *scb;
1942
1943 if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) ||
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03001944 index >= NUM_REASSEMBLY)
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301945 return -EILSEQ;
1946
1947 skb = hdev->reassembly[index];
1948
1949 if (!skb) {
1950 switch (type) {
1951 case HCI_ACLDATA_PKT:
1952 len = HCI_MAX_FRAME_SIZE;
1953 hlen = HCI_ACL_HDR_SIZE;
1954 break;
1955 case HCI_EVENT_PKT:
1956 len = HCI_MAX_EVENT_SIZE;
1957 hlen = HCI_EVENT_HDR_SIZE;
1958 break;
1959 case HCI_SCODATA_PKT:
1960 len = HCI_MAX_SCO_SIZE;
1961 hlen = HCI_SCO_HDR_SIZE;
1962 break;
1963 }
1964
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03001965 skb = bt_skb_alloc(len, GFP_ATOMIC);
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301966 if (!skb)
1967 return -ENOMEM;
1968
1969 scb = (void *) skb->cb;
1970 scb->expect = hlen;
1971 scb->pkt_type = type;
1972
1973 skb->dev = (void *) hdev;
1974 hdev->reassembly[index] = skb;
1975 }
1976
1977 while (count) {
1978 scb = (void *) skb->cb;
Dan Carpenter89bb46d2012-02-28 09:57:59 +03001979 len = min_t(uint, scb->expect, count);
Suraj Sumangala33e882a2010-07-14 13:02:17 +05301980
1981 memcpy(skb_put(skb, len), data, len);
1982
1983 count -= len;
1984 data += len;
1985 scb->expect -= len;
1986 remain = count;
1987
1988 switch (type) {
1989 case HCI_EVENT_PKT:
1990 if (skb->len == HCI_EVENT_HDR_SIZE) {
1991 struct hci_event_hdr *h = hci_event_hdr(skb);
1992 scb->expect = h->plen;
1993
1994 if (skb_tailroom(skb) < scb->expect) {
1995 kfree_skb(skb);
1996 hdev->reassembly[index] = NULL;
1997 return -ENOMEM;
1998 }
1999 }
2000 break;
2001
2002 case HCI_ACLDATA_PKT:
2003 if (skb->len == HCI_ACL_HDR_SIZE) {
2004 struct hci_acl_hdr *h = hci_acl_hdr(skb);
2005 scb->expect = __le16_to_cpu(h->dlen);
2006
2007 if (skb_tailroom(skb) < scb->expect) {
2008 kfree_skb(skb);
2009 hdev->reassembly[index] = NULL;
2010 return -ENOMEM;
2011 }
2012 }
2013 break;
2014
2015 case HCI_SCODATA_PKT:
2016 if (skb->len == HCI_SCO_HDR_SIZE) {
2017 struct hci_sco_hdr *h = hci_sco_hdr(skb);
2018 scb->expect = h->dlen;
2019
2020 if (skb_tailroom(skb) < scb->expect) {
2021 kfree_skb(skb);
2022 hdev->reassembly[index] = NULL;
2023 return -ENOMEM;
2024 }
2025 }
2026 break;
2027 }
2028
2029 if (scb->expect == 0) {
2030 /* Complete frame */
2031
2032 bt_cb(skb)->pkt_type = type;
2033 hci_recv_frame(skb);
2034
2035 hdev->reassembly[index] = NULL;
2036 return remain;
2037 }
2038 }
2039
2040 return remain;
2041}
2042
Marcel Holtmannef222012007-07-11 06:42:04 +02002043int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
2044{
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302045 int rem = 0;
2046
Marcel Holtmannef222012007-07-11 06:42:04 +02002047 if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
2048 return -EILSEQ;
2049
Gustavo F. Padovanda5f6c32010-07-24 01:34:54 -03002050 while (count) {
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03002051 rem = hci_reassembly(hdev, type, data, count, type - 1);
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302052 if (rem < 0)
2053 return rem;
Marcel Holtmannef222012007-07-11 06:42:04 +02002054
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302055 data += (count - rem);
2056 count = rem;
Joe Perchesf81c6222011-06-03 11:51:19 +00002057 }
Marcel Holtmannef222012007-07-11 06:42:04 +02002058
Suraj Sumangalaf39a3c02010-07-14 13:02:18 +05302059 return rem;
Marcel Holtmannef222012007-07-11 06:42:04 +02002060}
2061EXPORT_SYMBOL(hci_recv_fragment);
2062
Suraj Sumangala99811512010-07-14 13:02:19 +05302063#define STREAM_REASSEMBLY 0
2064
2065int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count)
2066{
2067 int type;
2068 int rem = 0;
2069
Gustavo F. Padovanda5f6c32010-07-24 01:34:54 -03002070 while (count) {
Suraj Sumangala99811512010-07-14 13:02:19 +05302071 struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY];
2072
2073 if (!skb) {
2074 struct { char type; } *pkt;
2075
2076 /* Start of the frame */
2077 pkt = data;
2078 type = pkt->type;
2079
2080 data++;
2081 count--;
2082 } else
2083 type = bt_cb(skb)->pkt_type;
2084
Gustavo F. Padovan1e429f32011-04-04 18:25:14 -03002085 rem = hci_reassembly(hdev, type, data, count,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002086 STREAM_REASSEMBLY);
Suraj Sumangala99811512010-07-14 13:02:19 +05302087 if (rem < 0)
2088 return rem;
2089
2090 data += (count - rem);
2091 count = rem;
Joe Perchesf81c6222011-06-03 11:51:19 +00002092 }
Suraj Sumangala99811512010-07-14 13:02:19 +05302093
2094 return rem;
2095}
2096EXPORT_SYMBOL(hci_recv_stream_fragment);
2097
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098/* ---- Interface to upper protocols ---- */
2099
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100int hci_register_cb(struct hci_cb *cb)
2101{
2102 BT_DBG("%p name %s", cb, cb->name);
2103
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002104 write_lock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 list_add(&cb->list, &hci_cb_list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002106 write_unlock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107
2108 return 0;
2109}
2110EXPORT_SYMBOL(hci_register_cb);
2111
2112int hci_unregister_cb(struct hci_cb *cb)
2113{
2114 BT_DBG("%p name %s", cb, cb->name);
2115
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002116 write_lock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 list_del(&cb->list);
Gustavo F. Padovanf20d09d2011-12-22 16:30:27 -02002118 write_unlock(&hci_cb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
2120 return 0;
2121}
2122EXPORT_SYMBOL(hci_unregister_cb);
2123
2124static int hci_send_frame(struct sk_buff *skb)
2125{
2126 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
2127
2128 if (!hdev) {
2129 kfree_skb(skb);
2130 return -ENODEV;
2131 }
2132
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002133 BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134
Marcel Holtmanncd82e612012-02-20 20:34:38 +01002135 /* Time stamp */
2136 __net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137
Marcel Holtmanncd82e612012-02-20 20:34:38 +01002138 /* Send copy to monitor */
2139 hci_send_to_monitor(hdev, skb);
2140
2141 if (atomic_read(&hdev->promisc)) {
2142 /* Send copy to the sockets */
Marcel Holtmann470fe1b2012-02-20 14:50:30 +01002143 hci_send_to_sock(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 }
2145
2146 /* Get rid of skb owner, prior to sending to the driver. */
2147 skb_orphan(skb);
2148
2149 return hdev->send(skb);
2150}
2151
2152/* Send HCI command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002153int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154{
2155 int len = HCI_COMMAND_HDR_SIZE + plen;
2156 struct hci_command_hdr *hdr;
2157 struct sk_buff *skb;
2158
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002159 BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160
2161 skb = bt_skb_alloc(len, GFP_ATOMIC);
2162 if (!skb) {
Marcel Holtmannef222012007-07-11 06:42:04 +02002163 BT_ERR("%s no memory for command", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 return -ENOMEM;
2165 }
2166
2167 hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002168 hdr->opcode = cpu_to_le16(opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 hdr->plen = plen;
2170
2171 if (plen)
2172 memcpy(skb_put(skb, plen), param, plen);
2173
2174 BT_DBG("skb len %d", skb->len);
2175
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002176 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 skb->dev = (void *) hdev;
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002178
Johan Hedberga5040ef2011-01-10 13:28:59 +02002179 if (test_bit(HCI_INIT, &hdev->flags))
2180 hdev->init_last_cmd = opcode;
2181
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 skb_queue_tail(&hdev->cmd_q, skb);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002183 queue_work(hdev->workqueue, &hdev->cmd_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184
2185 return 0;
2186}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
2188/* Get data from the previously sent command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002189void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190{
2191 struct hci_command_hdr *hdr;
2192
2193 if (!hdev->sent_cmd)
2194 return NULL;
2195
2196 hdr = (void *) hdev->sent_cmd->data;
2197
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002198 if (hdr->opcode != cpu_to_le16(opcode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 return NULL;
2200
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002201 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202
2203 return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE;
2204}
2205
2206/* Send ACL data */
2207static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags)
2208{
2209 struct hci_acl_hdr *hdr;
2210 int len = skb->len;
2211
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03002212 skb_push(skb, HCI_ACL_HDR_SIZE);
2213 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07002214 hdr = (struct hci_acl_hdr *)skb_transport_header(skb);
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07002215 hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags));
2216 hdr->dlen = cpu_to_le16(len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217}
2218
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002219static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002220 struct sk_buff *skb, __u16 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221{
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002222 struct hci_conn *conn = chan->conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 struct hci_dev *hdev = conn->hdev;
2224 struct sk_buff *list;
2225
Gustavo Padovan087bfd92012-05-11 13:16:11 -03002226 skb->len = skb_headlen(skb);
2227 skb->data_len = 0;
2228
2229 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Andrei Emeltchenko204a6e52012-10-15 11:58:39 +03002230
2231 switch (hdev->dev_type) {
2232 case HCI_BREDR:
2233 hci_add_acl_hdr(skb, conn->handle, flags);
2234 break;
2235 case HCI_AMP:
2236 hci_add_acl_hdr(skb, chan->handle, flags);
2237 break;
2238 default:
2239 BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type);
2240 return;
2241 }
Gustavo Padovan087bfd92012-05-11 13:16:11 -03002242
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002243 list = skb_shinfo(skb)->frag_list;
2244 if (!list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 /* Non fragmented */
2246 BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len);
2247
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002248 skb_queue_tail(queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 } else {
2250 /* Fragmented */
2251 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
2252
2253 skb_shinfo(skb)->frag_list = NULL;
2254
2255 /* Queue all fragments atomically */
Gustavo F. Padovanaf3e6352011-12-22 16:35:05 -02002256 spin_lock(&queue->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002258 __skb_queue_tail(queue, skb);
Andrei Emeltchenkoe7021122011-01-03 11:14:36 +02002259
2260 flags &= ~ACL_START;
2261 flags |= ACL_CONT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 do {
2263 skb = list; list = list->next;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002264
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002266 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Andrei Emeltchenkoe7021122011-01-03 11:14:36 +02002267 hci_add_acl_hdr(skb, conn->handle, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268
2269 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
2270
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002271 __skb_queue_tail(queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 } while (list);
2273
Gustavo F. Padovanaf3e6352011-12-22 16:35:05 -02002274 spin_unlock(&queue->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 }
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002276}
2277
2278void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags)
2279{
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002280 struct hci_dev *hdev = chan->conn->hdev;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002281
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002282 BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002283
2284 skb->dev = (void *) hdev;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002285
Andrei Emeltchenkoee22be72012-09-21 12:30:04 +03002286 hci_queue_acl(chan, &chan->data_q, skb, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002288 queue_work(hdev->workqueue, &hdev->tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290
2291/* Send SCO data */
Gustavo F. Padovan0d861d82010-05-01 16:15:35 -03002292void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293{
2294 struct hci_dev *hdev = conn->hdev;
2295 struct hci_sco_hdr hdr;
2296
2297 BT_DBG("%s len %d", hdev->name, skb->len);
2298
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07002299 hdr.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 hdr.dlen = skb->len;
2301
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03002302 skb_push(skb, HCI_SCO_HDR_SIZE);
2303 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07002304 memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
2306 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002307 bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002308
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 skb_queue_tail(&conn->data_q, skb);
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002310 queue_work(hdev->workqueue, &hdev->tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312
2313/* ---- HCI TX task (outgoing data) ---- */
2314
2315/* HCI Connection scheduler */
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002316static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type,
2317 int *quote)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318{
2319 struct hci_conn_hash *h = &hdev->conn_hash;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02002320 struct hci_conn *conn = NULL, *c;
Mikel Astizabc5de82012-04-11 08:48:47 +02002321 unsigned int num = 0, min = ~0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002323 /* We don't have to lock device here. Connections are always
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 * added and removed with TX task disabled. */
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002325
2326 rcu_read_lock();
2327
2328 list_for_each_entry_rcu(c, &h->list, list) {
Marcel Holtmann769be972008-07-14 20:13:49 +02002329 if (c->type != type || skb_queue_empty(&c->data_q))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 continue;
Marcel Holtmann769be972008-07-14 20:13:49 +02002331
2332 if (c->state != BT_CONNECTED && c->state != BT_CONFIG)
2333 continue;
2334
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 num++;
2336
2337 if (c->sent < min) {
2338 min = c->sent;
2339 conn = c;
2340 }
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002341
2342 if (hci_conn_num(hdev, type) == num)
2343 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 }
2345
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002346 rcu_read_unlock();
2347
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 if (conn) {
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002349 int cnt, q;
2350
2351 switch (conn->type) {
2352 case ACL_LINK:
2353 cnt = hdev->acl_cnt;
2354 break;
2355 case SCO_LINK:
2356 case ESCO_LINK:
2357 cnt = hdev->sco_cnt;
2358 break;
2359 case LE_LINK:
2360 cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
2361 break;
2362 default:
2363 cnt = 0;
2364 BT_ERR("Unknown link type");
2365 }
2366
2367 q = cnt / num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368 *quote = q ? q : 1;
2369 } else
2370 *quote = 0;
2371
2372 BT_DBG("conn %p quote %d", conn, *quote);
2373 return conn;
2374}
2375
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002376static void hci_link_tx_to(struct hci_dev *hdev, __u8 type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377{
2378 struct hci_conn_hash *h = &hdev->conn_hash;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02002379 struct hci_conn *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380
Ville Tervobae1f5d92011-02-10 22:38:53 -03002381 BT_ERR("%s link tx timeout", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002383 rcu_read_lock();
2384
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 /* Kill stalled connections */
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002386 list_for_each_entry_rcu(c, &h->list, list) {
Ville Tervobae1f5d92011-02-10 22:38:53 -03002387 if (c->type == type && c->sent) {
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03002388 BT_ERR("%s killing stalled connection %pMR",
2389 hdev->name, &c->dst);
Andrei Emeltchenko7490c6c2012-06-01 16:18:25 +03002390 hci_acl_disconn(c, HCI_ERROR_REMOTE_USER_TERM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 }
2392 }
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002393
2394 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395}
2396
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002397static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type,
2398 int *quote)
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002399{
2400 struct hci_conn_hash *h = &hdev->conn_hash;
2401 struct hci_chan *chan = NULL;
Mikel Astizabc5de82012-04-11 08:48:47 +02002402 unsigned int num = 0, min = ~0, cur_prio = 0;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002403 struct hci_conn *conn;
2404 int cnt, q, conn_num = 0;
2405
2406 BT_DBG("%s", hdev->name);
2407
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002408 rcu_read_lock();
2409
2410 list_for_each_entry_rcu(conn, &h->list, list) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002411 struct hci_chan *tmp;
2412
2413 if (conn->type != type)
2414 continue;
2415
2416 if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG)
2417 continue;
2418
2419 conn_num++;
2420
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02002421 list_for_each_entry_rcu(tmp, &conn->chan_list, list) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002422 struct sk_buff *skb;
2423
2424 if (skb_queue_empty(&tmp->data_q))
2425 continue;
2426
2427 skb = skb_peek(&tmp->data_q);
2428 if (skb->priority < cur_prio)
2429 continue;
2430
2431 if (skb->priority > cur_prio) {
2432 num = 0;
2433 min = ~0;
2434 cur_prio = skb->priority;
2435 }
2436
2437 num++;
2438
2439 if (conn->sent < min) {
2440 min = conn->sent;
2441 chan = tmp;
2442 }
2443 }
2444
2445 if (hci_conn_num(hdev, type) == conn_num)
2446 break;
2447 }
2448
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002449 rcu_read_unlock();
2450
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002451 if (!chan)
2452 return NULL;
2453
2454 switch (chan->conn->type) {
2455 case ACL_LINK:
2456 cnt = hdev->acl_cnt;
2457 break;
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002458 case AMP_LINK:
2459 cnt = hdev->block_cnt;
2460 break;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002461 case SCO_LINK:
2462 case ESCO_LINK:
2463 cnt = hdev->sco_cnt;
2464 break;
2465 case LE_LINK:
2466 cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
2467 break;
2468 default:
2469 cnt = 0;
2470 BT_ERR("Unknown link type");
2471 }
2472
2473 q = cnt / num;
2474 *quote = q ? q : 1;
2475 BT_DBG("chan %p quote %d", chan, *quote);
2476 return chan;
2477}
2478
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002479static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type)
2480{
2481 struct hci_conn_hash *h = &hdev->conn_hash;
2482 struct hci_conn *conn;
2483 int num = 0;
2484
2485 BT_DBG("%s", hdev->name);
2486
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002487 rcu_read_lock();
2488
2489 list_for_each_entry_rcu(conn, &h->list, list) {
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002490 struct hci_chan *chan;
2491
2492 if (conn->type != type)
2493 continue;
2494
2495 if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG)
2496 continue;
2497
2498 num++;
2499
Gustavo F. Padovan8192ede2011-12-14 15:08:48 -02002500 list_for_each_entry_rcu(chan, &conn->chan_list, list) {
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002501 struct sk_buff *skb;
2502
2503 if (chan->sent) {
2504 chan->sent = 0;
2505 continue;
2506 }
2507
2508 if (skb_queue_empty(&chan->data_q))
2509 continue;
2510
2511 skb = skb_peek(&chan->data_q);
2512 if (skb->priority >= HCI_PRIO_MAX - 1)
2513 continue;
2514
2515 skb->priority = HCI_PRIO_MAX - 1;
2516
2517 BT_DBG("chan %p skb %p promoted to %d", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002518 skb->priority);
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002519 }
2520
2521 if (hci_conn_num(hdev, type) == num)
2522 break;
2523 }
Gustavo F. Padovanbf4c6322011-12-14 22:54:12 -02002524
2525 rcu_read_unlock();
2526
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002527}
2528
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002529static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb)
2530{
2531 /* Calculate count of blocks used by this packet */
2532 return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len);
2533}
2534
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002535static void __check_timeout(struct hci_dev *hdev, unsigned int cnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537 if (!test_bit(HCI_RAW, &hdev->flags)) {
2538 /* ACL tx timeout must be longer than maximum
2539 * link supervision timeout (40.9 seconds) */
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002540 if (!cnt && time_after(jiffies, hdev->acl_last_tx +
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +03002541 HCI_ACL_TX_TIMEOUT))
Ville Tervobae1f5d92011-02-10 22:38:53 -03002542 hci_link_tx_to(hdev, ACL_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 }
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002544}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002546static void hci_sched_acl_pkt(struct hci_dev *hdev)
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002547{
2548 unsigned int cnt = hdev->acl_cnt;
2549 struct hci_chan *chan;
2550 struct sk_buff *skb;
2551 int quote;
2552
2553 __check_timeout(hdev, cnt);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002554
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002555 while (hdev->acl_cnt &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002556 (chan = hci_chan_sent(hdev, ACL_LINK, &quote))) {
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002557 u32 priority = (skb_peek(&chan->data_q))->priority;
2558 while (quote-- && (skb = skb_peek(&chan->data_q))) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002559 BT_DBG("chan %p skb %p len %d priority %u", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002560 skb->len, skb->priority);
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002561
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002562 /* Stop if priority has changed */
2563 if (skb->priority < priority)
2564 break;
2565
2566 skb = skb_dequeue(&chan->data_q);
2567
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002568 hci_conn_enter_active_mode(chan->conn,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002569 bt_cb(skb)->force_active);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002570
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 hci_send_frame(skb);
2572 hdev->acl_last_tx = jiffies;
2573
2574 hdev->acl_cnt--;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002575 chan->sent++;
2576 chan->conn->sent++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 }
2578 }
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002579
2580 if (cnt != hdev->acl_cnt)
2581 hci_prio_recalculate(hdev, ACL_LINK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582}
2583
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002584static void hci_sched_acl_blk(struct hci_dev *hdev)
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002585{
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002586 unsigned int cnt = hdev->block_cnt;
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002587 struct hci_chan *chan;
2588 struct sk_buff *skb;
2589 int quote;
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002590 u8 type;
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002591
Andrei Emeltchenko63d2bc12012-02-03 16:27:55 +02002592 __check_timeout(hdev, cnt);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002593
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002594 BT_DBG("%s", hdev->name);
2595
2596 if (hdev->dev_type == HCI_AMP)
2597 type = AMP_LINK;
2598 else
2599 type = ACL_LINK;
2600
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002601 while (hdev->block_cnt > 0 &&
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002602 (chan = hci_chan_sent(hdev, type, &quote))) {
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002603 u32 priority = (skb_peek(&chan->data_q))->priority;
2604 while (quote > 0 && (skb = skb_peek(&chan->data_q))) {
2605 int blocks;
2606
2607 BT_DBG("chan %p skb %p len %d priority %u", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002608 skb->len, skb->priority);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002609
2610 /* Stop if priority has changed */
2611 if (skb->priority < priority)
2612 break;
2613
2614 skb = skb_dequeue(&chan->data_q);
2615
2616 blocks = __get_blocks(hdev, skb);
2617 if (blocks > hdev->block_cnt)
2618 return;
2619
2620 hci_conn_enter_active_mode(chan->conn,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002621 bt_cb(skb)->force_active);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002622
2623 hci_send_frame(skb);
2624 hdev->acl_last_tx = jiffies;
2625
2626 hdev->block_cnt -= blocks;
2627 quote -= blocks;
2628
2629 chan->sent += blocks;
2630 chan->conn->sent += blocks;
2631 }
2632 }
2633
2634 if (cnt != hdev->block_cnt)
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002635 hci_prio_recalculate(hdev, type);
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002636}
2637
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002638static void hci_sched_acl(struct hci_dev *hdev)
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002639{
2640 BT_DBG("%s", hdev->name);
2641
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002642 /* No ACL link over BR/EDR controller */
2643 if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR)
2644 return;
2645
2646 /* No AMP link over AMP controller */
2647 if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP)
Andrei Emeltchenkob71d3852012-02-03 16:27:54 +02002648 return;
2649
2650 switch (hdev->flow_ctl_mode) {
2651 case HCI_FLOW_CTL_MODE_PACKET_BASED:
2652 hci_sched_acl_pkt(hdev);
2653 break;
2654
2655 case HCI_FLOW_CTL_MODE_BLOCK_BASED:
2656 hci_sched_acl_blk(hdev);
2657 break;
2658 }
2659}
2660
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661/* Schedule SCO */
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002662static void hci_sched_sco(struct hci_dev *hdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663{
2664 struct hci_conn *conn;
2665 struct sk_buff *skb;
2666 int quote;
2667
2668 BT_DBG("%s", hdev->name);
2669
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002670 if (!hci_conn_num(hdev, SCO_LINK))
2671 return;
2672
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, &quote))) {
2674 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2675 BT_DBG("skb %p len %d", skb, skb->len);
2676 hci_send_frame(skb);
2677
2678 conn->sent++;
2679 if (conn->sent == ~0)
2680 conn->sent = 0;
2681 }
2682 }
2683}
2684
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002685static void hci_sched_esco(struct hci_dev *hdev)
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002686{
2687 struct hci_conn *conn;
2688 struct sk_buff *skb;
2689 int quote;
2690
2691 BT_DBG("%s", hdev->name);
2692
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002693 if (!hci_conn_num(hdev, ESCO_LINK))
2694 return;
2695
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03002696 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK,
2697 &quote))) {
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002698 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
2699 BT_DBG("skb %p len %d", skb, skb->len);
2700 hci_send_frame(skb);
2701
2702 conn->sent++;
2703 if (conn->sent == ~0)
2704 conn->sent = 0;
2705 }
2706 }
2707}
2708
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002709static void hci_sched_le(struct hci_dev *hdev)
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002710{
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002711 struct hci_chan *chan;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002712 struct sk_buff *skb;
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002713 int quote, cnt, tmp;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002714
2715 BT_DBG("%s", hdev->name);
2716
Luiz Augusto von Dentz52087a72011-08-17 16:23:00 +03002717 if (!hci_conn_num(hdev, LE_LINK))
2718 return;
2719
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002720 if (!test_bit(HCI_RAW, &hdev->flags)) {
2721 /* LE tx timeout must be longer than maximum
2722 * link supervision timeout (40.9 seconds) */
Ville Tervobae1f5d92011-02-10 22:38:53 -03002723 if (!hdev->le_cnt && hdev->le_pkts &&
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002724 time_after(jiffies, hdev->le_last_tx + HZ * 45))
Ville Tervobae1f5d92011-02-10 22:38:53 -03002725 hci_link_tx_to(hdev, LE_LINK);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002726 }
2727
2728 cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt;
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002729 tmp = cnt;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002730 while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, &quote))) {
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002731 u32 priority = (skb_peek(&chan->data_q))->priority;
2732 while (quote-- && (skb = skb_peek(&chan->data_q))) {
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002733 BT_DBG("chan %p skb %p len %d priority %u", chan, skb,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002734 skb->len, skb->priority);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002735
Luiz Augusto von Dentzec1cce22011-11-02 15:52:02 +02002736 /* Stop if priority has changed */
2737 if (skb->priority < priority)
2738 break;
2739
2740 skb = skb_dequeue(&chan->data_q);
2741
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002742 hci_send_frame(skb);
2743 hdev->le_last_tx = jiffies;
2744
2745 cnt--;
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002746 chan->sent++;
2747 chan->conn->sent++;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002748 }
2749 }
Luiz Augusto von Dentz73d80de2011-11-02 15:52:01 +02002750
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002751 if (hdev->le_pkts)
2752 hdev->le_cnt = cnt;
2753 else
2754 hdev->acl_cnt = cnt;
Luiz Augusto von Dentz02b20f02011-11-02 15:52:03 +02002755
2756 if (cnt != tmp)
2757 hci_prio_recalculate(hdev, LE_LINK);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002758}
2759
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002760static void hci_tx_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761{
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002762 struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 struct sk_buff *skb;
2764
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002765 BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002766 hdev->sco_cnt, hdev->le_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767
2768 /* Schedule queues and send stuff to HCI driver */
2769
2770 hci_sched_acl(hdev);
2771
2772 hci_sched_sco(hdev);
2773
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002774 hci_sched_esco(hdev);
2775
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002776 hci_sched_le(hdev);
2777
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 /* Send next queued raw (unknown type) packet */
2779 while ((skb = skb_dequeue(&hdev->raw_q)))
2780 hci_send_frame(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781}
2782
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002783/* ----- HCI RX task (incoming data processing) ----- */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784
2785/* ACL data packet */
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002786static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787{
2788 struct hci_acl_hdr *hdr = (void *) skb->data;
2789 struct hci_conn *conn;
2790 __u16 handle, flags;
2791
2792 skb_pull(skb, HCI_ACL_HDR_SIZE);
2793
2794 handle = __le16_to_cpu(hdr->handle);
2795 flags = hci_flags(handle);
2796 handle = hci_handle(handle);
2797
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002798 BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len,
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002799 handle, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
2801 hdev->stat.acl_rx++;
2802
2803 hci_dev_lock(hdev);
2804 conn = hci_conn_hash_lookup_handle(hdev, handle);
2805 hci_dev_unlock(hdev);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002806
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807 if (conn) {
Mat Martineau65983fc2011-12-13 15:06:02 -08002808 hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002809
Johan Hedberg671267b2012-05-12 16:11:50 -03002810 hci_dev_lock(hdev);
2811 if (test_bit(HCI_MGMT, &hdev->dev_flags) &&
2812 !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2813 mgmt_device_connected(hdev, &conn->dst, conn->type,
2814 conn->dst_type, 0, NULL, 0,
2815 conn->dev_class);
2816 hci_dev_unlock(hdev);
2817
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818 /* Send to upper protocol */
Ulisses Furquim686ebf22011-12-21 10:11:33 -02002819 l2cap_recv_acldata(conn, skb, flags);
2820 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002822 BT_ERR("%s ACL packet for unknown connection handle %d",
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002823 hdev->name, handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 }
2825
2826 kfree_skb(skb);
2827}
2828
2829/* SCO data packet */
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002830static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831{
2832 struct hci_sco_hdr *hdr = (void *) skb->data;
2833 struct hci_conn *conn;
2834 __u16 handle;
2835
2836 skb_pull(skb, HCI_SCO_HDR_SIZE);
2837
2838 handle = __le16_to_cpu(hdr->handle);
2839
Andrei Emeltchenkof0e09512012-06-11 11:13:09 +03002840 BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841
2842 hdev->stat.sco_rx++;
2843
2844 hci_dev_lock(hdev);
2845 conn = hci_conn_hash_lookup_handle(hdev, handle);
2846 hci_dev_unlock(hdev);
2847
2848 if (conn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 /* Send to upper protocol */
Ulisses Furquim686ebf22011-12-21 10:11:33 -02002850 sco_recv_scodata(conn, skb);
2851 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09002853 BT_ERR("%s SCO packet for unknown connection handle %d",
Gustavo Padovana8c5fb12012-05-17 00:36:26 -03002854 hdev->name, handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 }
2856
2857 kfree_skb(skb);
2858}
2859
Marcel Holtmannb78752c2010-08-08 23:06:53 -04002860static void hci_rx_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861{
Marcel Holtmannb78752c2010-08-08 23:06:53 -04002862 struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 struct sk_buff *skb;
2864
2865 BT_DBG("%s", hdev->name);
2866
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 while ((skb = skb_dequeue(&hdev->rx_q))) {
Marcel Holtmanncd82e612012-02-20 20:34:38 +01002868 /* Send copy to monitor */
2869 hci_send_to_monitor(hdev, skb);
2870
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 if (atomic_read(&hdev->promisc)) {
2872 /* Send copy to the sockets */
Marcel Holtmann470fe1b2012-02-20 14:50:30 +01002873 hci_send_to_sock(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 }
2875
2876 if (test_bit(HCI_RAW, &hdev->flags)) {
2877 kfree_skb(skb);
2878 continue;
2879 }
2880
2881 if (test_bit(HCI_INIT, &hdev->flags)) {
2882 /* Don't process data packets in this states. */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002883 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884 case HCI_ACLDATA_PKT:
2885 case HCI_SCODATA_PKT:
2886 kfree_skb(skb);
2887 continue;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07002888 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 }
2890
2891 /* Process frame */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002892 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002893 case HCI_EVENT_PKT:
Marcel Holtmannb78752c2010-08-08 23:06:53 -04002894 BT_DBG("%s Event packet", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 hci_event_packet(hdev, skb);
2896 break;
2897
2898 case HCI_ACLDATA_PKT:
2899 BT_DBG("%s ACL data packet", hdev->name);
2900 hci_acldata_packet(hdev, skb);
2901 break;
2902
2903 case HCI_SCODATA_PKT:
2904 BT_DBG("%s SCO data packet", hdev->name);
2905 hci_scodata_packet(hdev, skb);
2906 break;
2907
2908 default:
2909 kfree_skb(skb);
2910 break;
2911 }
2912 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913}
2914
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002915static void hci_cmd_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916{
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002917 struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 struct sk_buff *skb;
2919
Andrei Emeltchenko21047862012-07-10 15:27:47 +03002920 BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name,
2921 atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 /* Send queued commands */
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02002924 if (atomic_read(&hdev->cmd_cnt)) {
2925 skb = skb_dequeue(&hdev->cmd_q);
2926 if (!skb)
2927 return;
2928
Wei Yongjun7585b972009-02-25 18:29:52 +08002929 kfree_skb(hdev->sent_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002931 hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC);
2932 if (hdev->sent_cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933 atomic_dec(&hdev->cmd_cnt);
2934 hci_send_frame(skb);
Szymon Janc7bdb8a52011-07-26 22:46:54 +02002935 if (test_bit(HCI_RESET, &hdev->flags))
2936 del_timer(&hdev->cmd_timer);
2937 else
2938 mod_timer(&hdev->cmd_timer,
Andrei Emeltchenko5f246e82012-06-11 11:13:07 +03002939 jiffies + HCI_CMD_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 } else {
2941 skb_queue_head(&hdev->cmd_q, skb);
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002942 queue_work(hdev->workqueue, &hdev->cmd_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943 }
2944 }
2945}
Andre Guedes2519a1f2011-11-07 11:45:24 -03002946
2947int hci_do_inquiry(struct hci_dev *hdev, u8 length)
2948{
2949 /* General inquiry access code (GIAC) */
2950 u8 lap[3] = { 0x33, 0x8b, 0x9e };
2951 struct hci_cp_inquiry cp;
2952
2953 BT_DBG("%s", hdev->name);
2954
2955 if (test_bit(HCI_INQUIRY, &hdev->flags))
2956 return -EINPROGRESS;
2957
Johan Hedberg46632622012-01-02 16:06:08 +02002958 inquiry_cache_flush(hdev);
2959
Andre Guedes2519a1f2011-11-07 11:45:24 -03002960 memset(&cp, 0, sizeof(cp));
2961 memcpy(&cp.lap, lap, sizeof(cp.lap));
2962 cp.length = length;
2963
2964 return hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp);
2965}
Andre Guedes023d50492011-11-04 14:16:52 -03002966
2967int hci_cancel_inquiry(struct hci_dev *hdev)
2968{
2969 BT_DBG("%s", hdev->name);
2970
2971 if (!test_bit(HCI_INQUIRY, &hdev->flags))
Andre Guedes7537e5c2012-03-20 00:13:38 -03002972 return -EALREADY;
Andre Guedes023d50492011-11-04 14:16:52 -03002973
2974 return hci_send_cmd(hdev, HCI_OP_INQUIRY_CANCEL, 0, NULL);
2975}
Andre Guedes31f79562012-04-24 21:02:53 -03002976
2977u8 bdaddr_to_le(u8 bdaddr_type)
2978{
2979 switch (bdaddr_type) {
2980 case BDADDR_LE_PUBLIC:
2981 return ADDR_LE_DEV_PUBLIC;
2982
2983 default:
2984 /* Fallback to LE Random address type */
2985 return ADDR_LE_DEV_RANDOM;
2986 }
2987}