2 BlueZ - Bluetooth protocol stack for Linux
4 Copyright (C) 2014 Intel Corporation
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License version 2 as
8 published by the Free Software Foundation;
10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
21 SOFTWARE IS DISCLAIMED.
24 #include <net/bluetooth/bluetooth.h>
25 #include <net/bluetooth/hci_core.h>
28 #include "hci_request.h"
30 #define HCI_REQ_DONE 0
31 #define HCI_REQ_PEND 1
32 #define HCI_REQ_CANCELED 2
34 void hci_req_init(struct hci_request
*req
, struct hci_dev
*hdev
)
36 skb_queue_head_init(&req
->cmd_q
);
41 static int req_run(struct hci_request
*req
, hci_req_complete_t complete
,
42 hci_req_complete_skb_t complete_skb
)
44 struct hci_dev
*hdev
= req
->hdev
;
48 BT_DBG("length %u", skb_queue_len(&req
->cmd_q
));
50 /* If an error occurred during request building, remove all HCI
51 * commands queued on the HCI request queue.
54 skb_queue_purge(&req
->cmd_q
);
58 /* Do not allow empty requests */
59 if (skb_queue_empty(&req
->cmd_q
))
62 skb
= skb_peek_tail(&req
->cmd_q
);
64 bt_cb(skb
)->hci
.req_complete
= complete
;
65 } else if (complete_skb
) {
66 bt_cb(skb
)->hci
.req_complete_skb
= complete_skb
;
67 bt_cb(skb
)->hci
.req_flags
|= HCI_REQ_SKB
;
70 spin_lock_irqsave(&hdev
->cmd_q
.lock
, flags
);
71 skb_queue_splice_tail(&req
->cmd_q
, &hdev
->cmd_q
);
72 spin_unlock_irqrestore(&hdev
->cmd_q
.lock
, flags
);
74 queue_work(hdev
->workqueue
, &hdev
->cmd_work
);
79 int hci_req_run(struct hci_request
*req
, hci_req_complete_t complete
)
81 return req_run(req
, complete
, NULL
);
84 int hci_req_run_skb(struct hci_request
*req
, hci_req_complete_skb_t complete
)
86 return req_run(req
, NULL
, complete
);
89 static void hci_req_sync_complete(struct hci_dev
*hdev
, u8 result
, u16 opcode
,
92 BT_DBG("%s result 0x%2.2x", hdev
->name
, result
);
94 if (hdev
->req_status
== HCI_REQ_PEND
) {
95 hdev
->req_result
= result
;
96 hdev
->req_status
= HCI_REQ_DONE
;
98 hdev
->req_skb
= skb_get(skb
);
99 wake_up_interruptible(&hdev
->req_wait_q
);
103 void hci_req_sync_cancel(struct hci_dev
*hdev
, int err
)
105 BT_DBG("%s err 0x%2.2x", hdev
->name
, err
);
107 if (hdev
->req_status
== HCI_REQ_PEND
) {
108 hdev
->req_result
= err
;
109 hdev
->req_status
= HCI_REQ_CANCELED
;
110 wake_up_interruptible(&hdev
->req_wait_q
);
114 struct sk_buff
*__hci_cmd_sync_ev(struct hci_dev
*hdev
, u16 opcode
, u32 plen
,
115 const void *param
, u8 event
, u32 timeout
)
117 DECLARE_WAITQUEUE(wait
, current
);
118 struct hci_request req
;
122 BT_DBG("%s", hdev
->name
);
124 hci_req_init(&req
, hdev
);
126 hci_req_add_ev(&req
, opcode
, plen
, param
, event
);
128 hdev
->req_status
= HCI_REQ_PEND
;
130 add_wait_queue(&hdev
->req_wait_q
, &wait
);
131 set_current_state(TASK_INTERRUPTIBLE
);
133 err
= hci_req_run_skb(&req
, hci_req_sync_complete
);
135 remove_wait_queue(&hdev
->req_wait_q
, &wait
);
136 set_current_state(TASK_RUNNING
);
140 schedule_timeout(timeout
);
142 remove_wait_queue(&hdev
->req_wait_q
, &wait
);
144 if (signal_pending(current
))
145 return ERR_PTR(-EINTR
);
147 switch (hdev
->req_status
) {
149 err
= -bt_to_errno(hdev
->req_result
);
152 case HCI_REQ_CANCELED
:
153 err
= -hdev
->req_result
;
161 hdev
->req_status
= hdev
->req_result
= 0;
163 hdev
->req_skb
= NULL
;
165 BT_DBG("%s end: err %d", hdev
->name
, err
);
173 return ERR_PTR(-ENODATA
);
177 EXPORT_SYMBOL(__hci_cmd_sync_ev
);
179 struct sk_buff
*__hci_cmd_sync(struct hci_dev
*hdev
, u16 opcode
, u32 plen
,
180 const void *param
, u32 timeout
)
182 return __hci_cmd_sync_ev(hdev
, opcode
, plen
, param
, 0, timeout
);
184 EXPORT_SYMBOL(__hci_cmd_sync
);
186 /* Execute request and wait for completion. */
187 int __hci_req_sync(struct hci_dev
*hdev
, void (*func
)(struct hci_request
*req
,
189 unsigned long opt
, u32 timeout
, u8
*hci_status
)
191 struct hci_request req
;
192 DECLARE_WAITQUEUE(wait
, current
);
195 BT_DBG("%s start", hdev
->name
);
197 hci_req_init(&req
, hdev
);
199 hdev
->req_status
= HCI_REQ_PEND
;
203 add_wait_queue(&hdev
->req_wait_q
, &wait
);
204 set_current_state(TASK_INTERRUPTIBLE
);
206 err
= hci_req_run_skb(&req
, hci_req_sync_complete
);
208 hdev
->req_status
= 0;
210 remove_wait_queue(&hdev
->req_wait_q
, &wait
);
211 set_current_state(TASK_RUNNING
);
213 /* ENODATA means the HCI request command queue is empty.
214 * This can happen when a request with conditionals doesn't
215 * trigger any commands to be sent. This is normal behavior
216 * and should not trigger an error return.
224 schedule_timeout(timeout
);
226 remove_wait_queue(&hdev
->req_wait_q
, &wait
);
228 if (signal_pending(current
))
231 switch (hdev
->req_status
) {
233 err
= -bt_to_errno(hdev
->req_result
);
235 *hci_status
= hdev
->req_result
;
238 case HCI_REQ_CANCELED
:
239 err
= -hdev
->req_result
;
241 *hci_status
= HCI_ERROR_UNSPECIFIED
;
247 *hci_status
= HCI_ERROR_UNSPECIFIED
;
251 hdev
->req_status
= hdev
->req_result
= 0;
253 BT_DBG("%s end: err %d", hdev
->name
, err
);
258 int hci_req_sync(struct hci_dev
*hdev
, void (*req
)(struct hci_request
*req
,
260 unsigned long opt
, u32 timeout
, u8
*hci_status
)
264 if (!test_bit(HCI_UP
, &hdev
->flags
))
267 /* Serialize all requests */
268 hci_req_sync_lock(hdev
);
269 ret
= __hci_req_sync(hdev
, req
, opt
, timeout
, hci_status
);
270 hci_req_sync_unlock(hdev
);
275 struct sk_buff
*hci_prepare_cmd(struct hci_dev
*hdev
, u16 opcode
, u32 plen
,
278 int len
= HCI_COMMAND_HDR_SIZE
+ plen
;
279 struct hci_command_hdr
*hdr
;
282 skb
= bt_skb_alloc(len
, GFP_ATOMIC
);
286 hdr
= (struct hci_command_hdr
*) skb_put(skb
, HCI_COMMAND_HDR_SIZE
);
287 hdr
->opcode
= cpu_to_le16(opcode
);
291 memcpy(skb_put(skb
, plen
), param
, plen
);
293 BT_DBG("skb len %d", skb
->len
);
295 hci_skb_pkt_type(skb
) = HCI_COMMAND_PKT
;
296 hci_skb_opcode(skb
) = opcode
;
301 /* Queue a command to an asynchronous HCI request */
302 void hci_req_add_ev(struct hci_request
*req
, u16 opcode
, u32 plen
,
303 const void *param
, u8 event
)
305 struct hci_dev
*hdev
= req
->hdev
;
308 BT_DBG("%s opcode 0x%4.4x plen %d", hdev
->name
, opcode
, plen
);
310 /* If an error occurred during request building, there is no point in
311 * queueing the HCI command. We can simply return.
316 skb
= hci_prepare_cmd(hdev
, opcode
, plen
, param
);
318 BT_ERR("%s no memory for command (opcode 0x%4.4x)",
324 if (skb_queue_empty(&req
->cmd_q
))
325 bt_cb(skb
)->hci
.req_flags
|= HCI_REQ_START
;
327 bt_cb(skb
)->hci
.req_event
= event
;
329 skb_queue_tail(&req
->cmd_q
, skb
);
332 void hci_req_add(struct hci_request
*req
, u16 opcode
, u32 plen
,
335 hci_req_add_ev(req
, opcode
, plen
, param
, 0);
338 void hci_req_add_le_scan_disable(struct hci_request
*req
)
340 struct hci_cp_le_set_scan_enable cp
;
342 memset(&cp
, 0, sizeof(cp
));
343 cp
.enable
= LE_SCAN_DISABLE
;
344 hci_req_add(req
, HCI_OP_LE_SET_SCAN_ENABLE
, sizeof(cp
), &cp
);
347 static void add_to_white_list(struct hci_request
*req
,
348 struct hci_conn_params
*params
)
350 struct hci_cp_le_add_to_white_list cp
;
352 cp
.bdaddr_type
= params
->addr_type
;
353 bacpy(&cp
.bdaddr
, ¶ms
->addr
);
355 hci_req_add(req
, HCI_OP_LE_ADD_TO_WHITE_LIST
, sizeof(cp
), &cp
);
358 static u8
update_white_list(struct hci_request
*req
)
360 struct hci_dev
*hdev
= req
->hdev
;
361 struct hci_conn_params
*params
;
362 struct bdaddr_list
*b
;
363 uint8_t white_list_entries
= 0;
365 /* Go through the current white list programmed into the
366 * controller one by one and check if that address is still
367 * in the list of pending connections or list of devices to
368 * report. If not present in either list, then queue the
369 * command to remove it from the controller.
371 list_for_each_entry(b
, &hdev
->le_white_list
, list
) {
372 struct hci_cp_le_del_from_white_list cp
;
374 if (hci_pend_le_action_lookup(&hdev
->pend_le_conns
,
375 &b
->bdaddr
, b
->bdaddr_type
) ||
376 hci_pend_le_action_lookup(&hdev
->pend_le_reports
,
377 &b
->bdaddr
, b
->bdaddr_type
)) {
378 white_list_entries
++;
382 cp
.bdaddr_type
= b
->bdaddr_type
;
383 bacpy(&cp
.bdaddr
, &b
->bdaddr
);
385 hci_req_add(req
, HCI_OP_LE_DEL_FROM_WHITE_LIST
,
389 /* Since all no longer valid white list entries have been
390 * removed, walk through the list of pending connections
391 * and ensure that any new device gets programmed into
394 * If the list of the devices is larger than the list of
395 * available white list entries in the controller, then
396 * just abort and return filer policy value to not use the
399 list_for_each_entry(params
, &hdev
->pend_le_conns
, action
) {
400 if (hci_bdaddr_list_lookup(&hdev
->le_white_list
,
401 ¶ms
->addr
, params
->addr_type
))
404 if (white_list_entries
>= hdev
->le_white_list_size
) {
405 /* Select filter policy to accept all advertising */
409 if (hci_find_irk_by_addr(hdev
, ¶ms
->addr
,
410 params
->addr_type
)) {
411 /* White list can not be used with RPAs */
415 white_list_entries
++;
416 add_to_white_list(req
, params
);
419 /* After adding all new pending connections, walk through
420 * the list of pending reports and also add these to the
421 * white list if there is still space.
423 list_for_each_entry(params
, &hdev
->pend_le_reports
, action
) {
424 if (hci_bdaddr_list_lookup(&hdev
->le_white_list
,
425 ¶ms
->addr
, params
->addr_type
))
428 if (white_list_entries
>= hdev
->le_white_list_size
) {
429 /* Select filter policy to accept all advertising */
433 if (hci_find_irk_by_addr(hdev
, ¶ms
->addr
,
434 params
->addr_type
)) {
435 /* White list can not be used with RPAs */
439 white_list_entries
++;
440 add_to_white_list(req
, params
);
443 /* Select filter policy to use white list */
447 void hci_req_add_le_passive_scan(struct hci_request
*req
)
449 struct hci_cp_le_set_scan_param param_cp
;
450 struct hci_cp_le_set_scan_enable enable_cp
;
451 struct hci_dev
*hdev
= req
->hdev
;
455 /* Set require_privacy to false since no SCAN_REQ are send
456 * during passive scanning. Not using an non-resolvable address
457 * here is important so that peer devices using direct
458 * advertising with our address will be correctly reported
461 if (hci_update_random_address(req
, false, &own_addr_type
))
464 /* Adding or removing entries from the white list must
465 * happen before enabling scanning. The controller does
466 * not allow white list modification while scanning.
468 filter_policy
= update_white_list(req
);
470 /* When the controller is using random resolvable addresses and
471 * with that having LE privacy enabled, then controllers with
472 * Extended Scanner Filter Policies support can now enable support
473 * for handling directed advertising.
475 * So instead of using filter polices 0x00 (no whitelist)
476 * and 0x01 (whitelist enabled) use the new filter policies
477 * 0x02 (no whitelist) and 0x03 (whitelist enabled).
479 if (hci_dev_test_flag(hdev
, HCI_PRIVACY
) &&
480 (hdev
->le_features
[0] & HCI_LE_EXT_SCAN_POLICY
))
481 filter_policy
|= 0x02;
483 memset(¶m_cp
, 0, sizeof(param_cp
));
484 param_cp
.type
= LE_SCAN_PASSIVE
;
485 param_cp
.interval
= cpu_to_le16(hdev
->le_scan_interval
);
486 param_cp
.window
= cpu_to_le16(hdev
->le_scan_window
);
487 param_cp
.own_address_type
= own_addr_type
;
488 param_cp
.filter_policy
= filter_policy
;
489 hci_req_add(req
, HCI_OP_LE_SET_SCAN_PARAM
, sizeof(param_cp
),
492 memset(&enable_cp
, 0, sizeof(enable_cp
));
493 enable_cp
.enable
= LE_SCAN_ENABLE
;
494 enable_cp
.filter_dup
= LE_SCAN_FILTER_DUP_ENABLE
;
495 hci_req_add(req
, HCI_OP_LE_SET_SCAN_ENABLE
, sizeof(enable_cp
),
499 static void set_random_addr(struct hci_request
*req
, bdaddr_t
*rpa
)
501 struct hci_dev
*hdev
= req
->hdev
;
503 /* If we're advertising or initiating an LE connection we can't
504 * go ahead and change the random address at this time. This is
505 * because the eventual initiator address used for the
506 * subsequently created connection will be undefined (some
507 * controllers use the new address and others the one we had
508 * when the operation started).
510 * In this kind of scenario skip the update and let the random
511 * address be updated at the next cycle.
513 if (hci_dev_test_flag(hdev
, HCI_LE_ADV
) ||
514 hci_lookup_le_connect(hdev
)) {
515 BT_DBG("Deferring random address update");
516 hci_dev_set_flag(hdev
, HCI_RPA_EXPIRED
);
520 hci_req_add(req
, HCI_OP_LE_SET_RANDOM_ADDR
, 6, rpa
);
523 int hci_update_random_address(struct hci_request
*req
, bool require_privacy
,
526 struct hci_dev
*hdev
= req
->hdev
;
529 /* If privacy is enabled use a resolvable private address. If
530 * current RPA has expired or there is something else than
531 * the current RPA in use, then generate a new one.
533 if (hci_dev_test_flag(hdev
, HCI_PRIVACY
)) {
536 *own_addr_type
= ADDR_LE_DEV_RANDOM
;
538 if (!hci_dev_test_and_clear_flag(hdev
, HCI_RPA_EXPIRED
) &&
539 !bacmp(&hdev
->random_addr
, &hdev
->rpa
))
542 err
= smp_generate_rpa(hdev
, hdev
->irk
, &hdev
->rpa
);
544 BT_ERR("%s failed to generate new RPA", hdev
->name
);
548 set_random_addr(req
, &hdev
->rpa
);
550 to
= msecs_to_jiffies(hdev
->rpa_timeout
* 1000);
551 queue_delayed_work(hdev
->workqueue
, &hdev
->rpa_expired
, to
);
556 /* In case of required privacy without resolvable private address,
557 * use an non-resolvable private address. This is useful for active
558 * scanning and non-connectable advertising.
560 if (require_privacy
) {
564 /* The non-resolvable private address is generated
565 * from random six bytes with the two most significant
568 get_random_bytes(&nrpa
, 6);
571 /* The non-resolvable private address shall not be
572 * equal to the public address.
574 if (bacmp(&hdev
->bdaddr
, &nrpa
))
578 *own_addr_type
= ADDR_LE_DEV_RANDOM
;
579 set_random_addr(req
, &nrpa
);
583 /* If forcing static address is in use or there is no public
584 * address use the static address as random address (but skip
585 * the HCI command if the current random address is already the
588 * In case BR/EDR has been disabled on a dual-mode controller
589 * and a static address has been configured, then use that
590 * address instead of the public BR/EDR address.
592 if (hci_dev_test_flag(hdev
, HCI_FORCE_STATIC_ADDR
) ||
593 !bacmp(&hdev
->bdaddr
, BDADDR_ANY
) ||
594 (!hci_dev_test_flag(hdev
, HCI_BREDR_ENABLED
) &&
595 bacmp(&hdev
->static_addr
, BDADDR_ANY
))) {
596 *own_addr_type
= ADDR_LE_DEV_RANDOM
;
597 if (bacmp(&hdev
->static_addr
, &hdev
->random_addr
))
598 hci_req_add(req
, HCI_OP_LE_SET_RANDOM_ADDR
, 6,
603 /* Neither privacy nor static address is being used so use a
606 *own_addr_type
= ADDR_LE_DEV_PUBLIC
;
611 static bool disconnected_whitelist_entries(struct hci_dev
*hdev
)
613 struct bdaddr_list
*b
;
615 list_for_each_entry(b
, &hdev
->whitelist
, list
) {
616 struct hci_conn
*conn
;
618 conn
= hci_conn_hash_lookup_ba(hdev
, ACL_LINK
, &b
->bdaddr
);
622 if (conn
->state
!= BT_CONNECTED
&& conn
->state
!= BT_CONFIG
)
629 void __hci_update_page_scan(struct hci_request
*req
)
631 struct hci_dev
*hdev
= req
->hdev
;
634 if (!hci_dev_test_flag(hdev
, HCI_BREDR_ENABLED
))
637 if (!hdev_is_powered(hdev
))
640 if (mgmt_powering_down(hdev
))
643 if (hci_dev_test_flag(hdev
, HCI_CONNECTABLE
) ||
644 disconnected_whitelist_entries(hdev
))
647 scan
= SCAN_DISABLED
;
649 if (test_bit(HCI_PSCAN
, &hdev
->flags
) == !!(scan
& SCAN_PAGE
))
652 if (hci_dev_test_flag(hdev
, HCI_DISCOVERABLE
))
653 scan
|= SCAN_INQUIRY
;
655 hci_req_add(req
, HCI_OP_WRITE_SCAN_ENABLE
, 1, &scan
);
658 void hci_update_page_scan(struct hci_dev
*hdev
)
660 struct hci_request req
;
662 hci_req_init(&req
, hdev
);
663 __hci_update_page_scan(&req
);
664 hci_req_run(&req
, NULL
);
667 /* This function controls the background scanning based on hdev->pend_le_conns
668 * list. If there are pending LE connection we start the background scanning,
669 * otherwise we stop it.
671 * This function requires the caller holds hdev->lock.
673 static void __hci_update_background_scan(struct hci_request
*req
)
675 struct hci_dev
*hdev
= req
->hdev
;
677 if (!test_bit(HCI_UP
, &hdev
->flags
) ||
678 test_bit(HCI_INIT
, &hdev
->flags
) ||
679 hci_dev_test_flag(hdev
, HCI_SETUP
) ||
680 hci_dev_test_flag(hdev
, HCI_CONFIG
) ||
681 hci_dev_test_flag(hdev
, HCI_AUTO_OFF
) ||
682 hci_dev_test_flag(hdev
, HCI_UNREGISTER
))
685 /* No point in doing scanning if LE support hasn't been enabled */
686 if (!hci_dev_test_flag(hdev
, HCI_LE_ENABLED
))
689 /* If discovery is active don't interfere with it */
690 if (hdev
->discovery
.state
!= DISCOVERY_STOPPED
)
693 /* Reset RSSI and UUID filters when starting background scanning
694 * since these filters are meant for service discovery only.
696 * The Start Discovery and Start Service Discovery operations
697 * ensure to set proper values for RSSI threshold and UUID
698 * filter list. So it is safe to just reset them here.
700 hci_discovery_filter_clear(hdev
);
702 if (list_empty(&hdev
->pend_le_conns
) &&
703 list_empty(&hdev
->pend_le_reports
)) {
704 /* If there is no pending LE connections or devices
705 * to be scanned for, we should stop the background
709 /* If controller is not scanning we are done. */
710 if (!hci_dev_test_flag(hdev
, HCI_LE_SCAN
))
713 hci_req_add_le_scan_disable(req
);
715 BT_DBG("%s stopping background scanning", hdev
->name
);
717 /* If there is at least one pending LE connection, we should
718 * keep the background scan running.
721 /* If controller is connecting, we should not start scanning
722 * since some controllers are not able to scan and connect at
725 if (hci_lookup_le_connect(hdev
))
728 /* If controller is currently scanning, we stop it to ensure we
729 * don't miss any advertising (due to duplicates filter).
731 if (hci_dev_test_flag(hdev
, HCI_LE_SCAN
))
732 hci_req_add_le_scan_disable(req
);
734 hci_req_add_le_passive_scan(req
);
736 BT_DBG("%s starting background scanning", hdev
->name
);
740 void __hci_abort_conn(struct hci_request
*req
, struct hci_conn
*conn
,
743 switch (conn
->state
) {
746 if (conn
->type
== AMP_LINK
) {
747 struct hci_cp_disconn_phy_link cp
;
749 cp
.phy_handle
= HCI_PHY_HANDLE(conn
->handle
);
751 hci_req_add(req
, HCI_OP_DISCONN_PHY_LINK
, sizeof(cp
),
754 struct hci_cp_disconnect dc
;
756 dc
.handle
= cpu_to_le16(conn
->handle
);
758 hci_req_add(req
, HCI_OP_DISCONNECT
, sizeof(dc
), &dc
);
761 conn
->state
= BT_DISCONN
;
765 if (conn
->type
== LE_LINK
) {
766 if (test_bit(HCI_CONN_SCANNING
, &conn
->flags
))
768 hci_req_add(req
, HCI_OP_LE_CREATE_CONN_CANCEL
,
770 } else if (conn
->type
== ACL_LINK
) {
771 if (req
->hdev
->hci_ver
< BLUETOOTH_VER_1_2
)
773 hci_req_add(req
, HCI_OP_CREATE_CONN_CANCEL
,
778 if (conn
->type
== ACL_LINK
) {
779 struct hci_cp_reject_conn_req rej
;
781 bacpy(&rej
.bdaddr
, &conn
->dst
);
784 hci_req_add(req
, HCI_OP_REJECT_CONN_REQ
,
786 } else if (conn
->type
== SCO_LINK
|| conn
->type
== ESCO_LINK
) {
787 struct hci_cp_reject_sync_conn_req rej
;
789 bacpy(&rej
.bdaddr
, &conn
->dst
);
791 /* SCO rejection has its own limited set of
792 * allowed error values (0x0D-0x0F) which isn't
793 * compatible with most values passed to this
794 * function. To be safe hard-code one of the
795 * values that's suitable for SCO.
797 rej
.reason
= HCI_ERROR_REMOTE_LOW_RESOURCES
;
799 hci_req_add(req
, HCI_OP_REJECT_SYNC_CONN_REQ
,
804 conn
->state
= BT_CLOSED
;
809 static void abort_conn_complete(struct hci_dev
*hdev
, u8 status
, u16 opcode
)
812 BT_DBG("Failed to abort connection: status 0x%2.2x", status
);
815 int hci_abort_conn(struct hci_conn
*conn
, u8 reason
)
817 struct hci_request req
;
820 hci_req_init(&req
, conn
->hdev
);
822 __hci_abort_conn(&req
, conn
, reason
);
824 err
= hci_req_run(&req
, abort_conn_complete
);
825 if (err
&& err
!= -ENODATA
) {
826 BT_ERR("Failed to run HCI request: err %d", err
);
833 static void update_bg_scan(struct hci_request
*req
, unsigned long opt
)
835 hci_dev_lock(req
->hdev
);
836 __hci_update_background_scan(req
);
837 hci_dev_unlock(req
->hdev
);
840 static void bg_scan_update(struct work_struct
*work
)
842 struct hci_dev
*hdev
= container_of(work
, struct hci_dev
,
844 struct hci_conn
*conn
;
848 err
= hci_req_sync(hdev
, update_bg_scan
, 0, HCI_CMD_TIMEOUT
, &status
);
854 conn
= hci_conn_hash_lookup_state(hdev
, LE_LINK
, BT_CONNECT
);
856 hci_le_conn_failed(conn
, status
);
858 hci_dev_unlock(hdev
);
861 static void inquiry_complete(struct hci_dev
*hdev
, u8 status
, u16 opcode
)
864 BT_ERR("Failed to start inquiry: status %d", status
);
867 hci_discovery_set_state(hdev
, DISCOVERY_STOPPED
);
868 hci_dev_unlock(hdev
);
873 static void le_scan_disable_work_complete(struct hci_dev
*hdev
, u8 status
)
875 /* General inquiry access code (GIAC) */
876 u8 lap
[3] = { 0x33, 0x8b, 0x9e };
877 struct hci_cp_inquiry cp
;
881 BT_ERR("Failed to disable LE scanning: status %d", status
);
885 hdev
->discovery
.scan_start
= 0;
887 switch (hdev
->discovery
.type
) {
890 hci_discovery_set_state(hdev
, DISCOVERY_STOPPED
);
891 hci_dev_unlock(hdev
);
894 case DISCOV_TYPE_INTERLEAVED
:
897 if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY
,
899 /* If we were running LE only scan, change discovery
900 * state. If we were running both LE and BR/EDR inquiry
901 * simultaneously, and BR/EDR inquiry is already
902 * finished, stop discovery, otherwise BR/EDR inquiry
903 * will stop discovery when finished. If we will resolve
904 * remote device name, do not change discovery state.
906 if (!test_bit(HCI_INQUIRY
, &hdev
->flags
) &&
907 hdev
->discovery
.state
!= DISCOVERY_RESOLVING
)
908 hci_discovery_set_state(hdev
,
911 struct hci_request req
;
913 hci_inquiry_cache_flush(hdev
);
915 hci_req_init(&req
, hdev
);
917 memset(&cp
, 0, sizeof(cp
));
918 memcpy(&cp
.lap
, lap
, sizeof(cp
.lap
));
919 cp
.length
= DISCOV_INTERLEAVED_INQUIRY_LEN
;
920 hci_req_add(&req
, HCI_OP_INQUIRY
, sizeof(cp
), &cp
);
922 err
= hci_req_run(&req
, inquiry_complete
);
924 BT_ERR("Inquiry request failed: err %d", err
);
925 hci_discovery_set_state(hdev
,
930 hci_dev_unlock(hdev
);
935 static void le_scan_disable(struct hci_request
*req
, unsigned long opt
)
937 hci_req_add_le_scan_disable(req
);
940 static void le_scan_disable_work(struct work_struct
*work
)
942 struct hci_dev
*hdev
= container_of(work
, struct hci_dev
,
943 le_scan_disable
.work
);
947 BT_DBG("%s", hdev
->name
);
949 cancel_delayed_work(&hdev
->le_scan_restart
);
951 err
= hci_req_sync(hdev
, le_scan_disable
, 0, HCI_CMD_TIMEOUT
, &status
);
955 le_scan_disable_work_complete(hdev
, status
);
958 static void le_scan_restart_work_complete(struct hci_dev
*hdev
, u8 status
)
960 unsigned long timeout
, duration
, scan_start
, now
;
962 BT_DBG("%s", hdev
->name
);
965 BT_ERR("Failed to restart LE scan: status %d", status
);
971 if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER
, &hdev
->quirks
) ||
972 !hdev
->discovery
.scan_start
)
975 /* When the scan was started, hdev->le_scan_disable has been queued
976 * after duration from scan_start. During scan restart this job
977 * has been canceled, and we need to queue it again after proper
978 * timeout, to make sure that scan does not run indefinitely.
980 duration
= hdev
->discovery
.scan_duration
;
981 scan_start
= hdev
->discovery
.scan_start
;
983 if (now
- scan_start
<= duration
) {
986 if (now
>= scan_start
)
987 elapsed
= now
- scan_start
;
989 elapsed
= ULONG_MAX
- scan_start
+ now
;
991 timeout
= duration
- elapsed
;
996 queue_delayed_work(hdev
->req_workqueue
,
997 &hdev
->le_scan_disable
, timeout
);
1000 hci_dev_unlock(hdev
);
1003 static void le_scan_restart(struct hci_request
*req
, unsigned long opt
)
1005 struct hci_dev
*hdev
= req
->hdev
;
1006 struct hci_cp_le_set_scan_enable cp
;
1008 /* If controller is not scanning we are done. */
1009 if (!hci_dev_test_flag(hdev
, HCI_LE_SCAN
))
1012 hci_req_add_le_scan_disable(req
);
1014 memset(&cp
, 0, sizeof(cp
));
1015 cp
.enable
= LE_SCAN_ENABLE
;
1016 cp
.filter_dup
= LE_SCAN_FILTER_DUP_ENABLE
;
1017 hci_req_add(req
, HCI_OP_LE_SET_SCAN_ENABLE
, sizeof(cp
), &cp
);
1020 static void le_scan_restart_work(struct work_struct
*work
)
1022 struct hci_dev
*hdev
= container_of(work
, struct hci_dev
,
1023 le_scan_restart
.work
);
1027 BT_DBG("%s", hdev
->name
);
1029 err
= hci_req_sync(hdev
, le_scan_restart
, 0, HCI_CMD_TIMEOUT
, &status
);
1033 le_scan_restart_work_complete(hdev
, status
);
1036 void hci_request_setup(struct hci_dev
*hdev
)
1038 INIT_WORK(&hdev
->bg_scan_update
, bg_scan_update
);
1039 INIT_DELAYED_WORK(&hdev
->le_scan_disable
, le_scan_disable_work
);
1040 INIT_DELAYED_WORK(&hdev
->le_scan_restart
, le_scan_restart_work
);
1043 void hci_request_cancel_all(struct hci_dev
*hdev
)
1045 cancel_work_sync(&hdev
->bg_scan_update
);
1046 cancel_delayed_work_sync(&hdev
->le_scan_disable
);
1047 cancel_delayed_work_sync(&hdev
->le_scan_restart
);