| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * BlueZ - Bluetooth protocol stack for Linux |
| * |
| * Copyright (C) 2021 Intel Corporation |
| */ |
| |
| #include <linux/property.h> |
| |
| #include <net/bluetooth/bluetooth.h> |
| #include <net/bluetooth/hci_core.h> |
| #include <net/bluetooth/mgmt.h> |
| |
| #include "hci_request.h" |
| #include "hci_codec.h" |
| #include "hci_debugfs.h" |
| #include "smp.h" |
| #include "eir.h" |
| #include "msft.h" |
| #include "aosp.h" |
| #include "leds.h" |
| |
| static void hci_cmd_sync_complete(struct hci_dev *hdev, u8 result, u16 opcode, |
| struct sk_buff *skb) |
| { |
| bt_dev_dbg(hdev, "result 0x%2.2x", result); |
| |
| if (hdev->req_status != HCI_REQ_PEND) |
| return; |
| |
| hdev->req_result = result; |
| hdev->req_status = HCI_REQ_DONE; |
| |
| if (skb) { |
| struct sock *sk = hci_skb_sk(skb); |
| |
| /* Drop sk reference if set */ |
| if (sk) |
| sock_put(sk); |
| |
| hdev->req_skb = skb_get(skb); |
| } |
| |
| wake_up_interruptible(&hdev->req_wait_q); |
| } |
| |
| static struct sk_buff *hci_cmd_sync_alloc(struct hci_dev *hdev, u16 opcode, |
| u32 plen, const void *param, |
| struct sock *sk) |
| { |
| int len = HCI_COMMAND_HDR_SIZE + plen; |
| struct hci_command_hdr *hdr; |
| struct sk_buff *skb; |
| |
| skb = bt_skb_alloc(len, GFP_ATOMIC); |
| if (!skb) |
| return NULL; |
| |
| hdr = skb_put(skb, HCI_COMMAND_HDR_SIZE); |
| hdr->opcode = cpu_to_le16(opcode); |
| hdr->plen = plen; |
| |
| if (plen) |
| skb_put_data(skb, param, plen); |
| |
| bt_dev_dbg(hdev, "skb len %d", skb->len); |
| |
| hci_skb_pkt_type(skb) = HCI_COMMAND_PKT; |
| hci_skb_opcode(skb) = opcode; |
| |
| /* Grab a reference if command needs to be associated with a sock (e.g. |
| * likely mgmt socket that initiated the command). |
| */ |
| if (sk) { |
| hci_skb_sk(skb) = sk; |
| sock_hold(sk); |
| } |
| |
| return skb; |
| } |
| |
| static void hci_cmd_sync_add(struct hci_request *req, u16 opcode, u32 plen, |
| const void *param, u8 event, struct sock *sk) |
| { |
| struct hci_dev *hdev = req->hdev; |
| struct sk_buff *skb; |
| |
| bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); |
| |
| /* If an error occurred during request building, there is no point in |
| * queueing the HCI command. We can simply return. |
| */ |
| if (req->err) |
| return; |
| |
| skb = hci_cmd_sync_alloc(hdev, opcode, plen, param, sk); |
| if (!skb) { |
| bt_dev_err(hdev, "no memory for command (opcode 0x%4.4x)", |
| opcode); |
| req->err = -ENOMEM; |
| return; |
| } |
| |
| if (skb_queue_empty(&req->cmd_q)) |
| bt_cb(skb)->hci.req_flags |= HCI_REQ_START; |
| |
| hci_skb_event(skb) = event; |
| |
| skb_queue_tail(&req->cmd_q, skb); |
| } |
| |
| static int hci_cmd_sync_run(struct hci_request *req) |
| { |
| struct hci_dev *hdev = req->hdev; |
| struct sk_buff *skb; |
| unsigned long flags; |
| |
| bt_dev_dbg(hdev, "length %u", skb_queue_len(&req->cmd_q)); |
| |
| /* If an error occurred during request building, remove all HCI |
| * commands queued on the HCI request queue. |
| */ |
| if (req->err) { |
| skb_queue_purge(&req->cmd_q); |
| return req->err; |
| } |
| |
| /* Do not allow empty requests */ |
| if (skb_queue_empty(&req->cmd_q)) |
| return -ENODATA; |
| |
| skb = skb_peek_tail(&req->cmd_q); |
| bt_cb(skb)->hci.req_complete_skb = hci_cmd_sync_complete; |
| bt_cb(skb)->hci.req_flags |= HCI_REQ_SKB; |
| |
| spin_lock_irqsave(&hdev->cmd_q.lock, flags); |
| skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); |
| spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); |
| |
| queue_work(hdev->workqueue, &hdev->cmd_work); |
| |
| return 0; |
| } |
| |
| /* This function requires the caller holds hdev->req_lock. */ |
| struct sk_buff *__hci_cmd_sync_sk(struct hci_dev *hdev, u16 opcode, u32 plen, |
| const void *param, u8 event, u32 timeout, |
| struct sock *sk) |
| { |
| struct hci_request req; |
| struct sk_buff *skb; |
| int err = 0; |
| |
| bt_dev_dbg(hdev, "Opcode 0x%4x", opcode); |
| |
| hci_req_init(&req, hdev); |
| |
| hci_cmd_sync_add(&req, opcode, plen, param, event, sk); |
| |
| hdev->req_status = HCI_REQ_PEND; |
| |
| err = hci_cmd_sync_run(&req); |
| if (err < 0) |
| return ERR_PTR(err); |
| |
| err = wait_event_interruptible_timeout(hdev->req_wait_q, |
| hdev->req_status != HCI_REQ_PEND, |
| timeout); |
| |
| if (err == -ERESTARTSYS) |
| return ERR_PTR(-EINTR); |
| |
| switch (hdev->req_status) { |
| case HCI_REQ_DONE: |
| err = -bt_to_errno(hdev->req_result); |
| break; |
| |
| case HCI_REQ_CANCELED: |
| err = -hdev->req_result; |
| break; |
| |
| default: |
| err = -ETIMEDOUT; |
| break; |
| } |
| |
| hdev->req_status = 0; |
| hdev->req_result = 0; |
| skb = hdev->req_skb; |
| hdev->req_skb = NULL; |
| |
| bt_dev_dbg(hdev, "end: err %d", err); |
| |
| if (err < 0) { |
| kfree_skb(skb); |
| return ERR_PTR(err); |
| } |
| |
| return skb; |
| } |
| EXPORT_SYMBOL(__hci_cmd_sync_sk); |
| |
| /* This function requires the caller holds hdev->req_lock. */ |
| struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, |
| const void *param, u32 timeout) |
| { |
| return __hci_cmd_sync_sk(hdev, opcode, plen, param, 0, timeout, NULL); |
| } |
| EXPORT_SYMBOL(__hci_cmd_sync); |
| |
| /* Send HCI command and wait for command complete event */ |
| struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, |
| const void *param, u32 timeout) |
| { |
| struct sk_buff *skb; |
| |
| if (!test_bit(HCI_UP, &hdev->flags)) |
| return ERR_PTR(-ENETDOWN); |
| |
| bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); |
| |
| hci_req_sync_lock(hdev); |
| skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); |
| hci_req_sync_unlock(hdev); |
| |
| return skb; |
| } |
| EXPORT_SYMBOL(hci_cmd_sync); |
| |
| /* This function requires the caller holds hdev->req_lock. */ |
| struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, |
| const void *param, u8 event, u32 timeout) |
| { |
| return __hci_cmd_sync_sk(hdev, opcode, plen, param, event, timeout, |
| NULL); |
| } |
| EXPORT_SYMBOL(__hci_cmd_sync_ev); |
| |
| /* This function requires the caller holds hdev->req_lock. */ |
| int __hci_cmd_sync_status_sk(struct hci_dev *hdev, u16 opcode, u32 plen, |
| const void *param, u8 event, u32 timeout, |
| struct sock *sk) |
| { |
| struct sk_buff *skb; |
| u8 status; |
| |
| skb = __hci_cmd_sync_sk(hdev, opcode, plen, param, event, timeout, sk); |
| if (IS_ERR(skb)) { |
| if (!event) |
| bt_dev_err(hdev, "Opcode 0x%4x failed: %ld", opcode, |
| PTR_ERR(skb)); |
| return PTR_ERR(skb); |
| } |
| |
| /* If command return a status event skb will be set to NULL as there are |
| * no parameters, in case of failure IS_ERR(skb) would have be set to |
| * the actual error would be found with PTR_ERR(skb). |
| */ |
| if (!skb) |
| return 0; |
| |
| status = skb->data[0]; |
| |
| kfree_skb(skb); |
| |
| return status; |
| } |
| EXPORT_SYMBOL(__hci_cmd_sync_status_sk); |
| |
| int __hci_cmd_sync_status(struct hci_dev *hdev, u16 opcode, u32 plen, |
| const void *param, u32 timeout) |
| { |
| return __hci_cmd_sync_status_sk(hdev, opcode, plen, param, 0, timeout, |
| NULL); |
| } |
| EXPORT_SYMBOL(__hci_cmd_sync_status); |
| |
| static void hci_cmd_sync_work(struct work_struct *work) |
| { |
| struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_sync_work); |
| |
| bt_dev_dbg(hdev, ""); |
| |
| /* Dequeue all entries and run them */ |
| while (1) { |
| struct hci_cmd_sync_work_entry *entry; |
| |
| mutex_lock(&hdev->cmd_sync_work_lock); |
| entry = list_first_entry_or_null(&hdev->cmd_sync_work_list, |
| struct hci_cmd_sync_work_entry, |
| list); |
| if (entry) |
| list_del(&entry->list); |
| mutex_unlock(&hdev->cmd_sync_work_lock); |
| |
| if (!entry) |
| break; |
| |
| bt_dev_dbg(hdev, "entry %p", entry); |
| |
| if (entry->func) { |
| int err; |
| |
| hci_req_sync_lock(hdev); |
| err = entry->func(hdev, entry->data); |
| if (entry->destroy) |
| entry->destroy(hdev, entry->data, err); |
| hci_req_sync_unlock(hdev); |
| } |
| |
| kfree(entry); |
| } |
| } |
| |
| static void hci_cmd_sync_cancel_work(struct work_struct *work) |
| { |
| struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_sync_cancel_work); |
| |
| cancel_delayed_work_sync(&hdev->cmd_timer); |
| cancel_delayed_work_sync(&hdev->ncmd_timer); |
| atomic_set(&hdev->cmd_cnt, 1); |
| |
| wake_up_interruptible(&hdev->req_wait_q); |
| } |
| |
| static int hci_scan_disable_sync(struct hci_dev *hdev); |
| static int scan_disable_sync(struct hci_dev *hdev, void *data) |
| { |
| return hci_scan_disable_sync(hdev); |
| } |
| |
| static int hci_inquiry_sync(struct hci_dev *hdev, u8 length); |
| static int interleaved_inquiry_sync(struct hci_dev *hdev, void *data) |
| { |
| return hci_inquiry_sync(hdev, DISCOV_INTERLEAVED_INQUIRY_LEN); |
| } |
| |
| static void le_scan_disable(struct work_struct *work) |
| { |
| struct hci_dev *hdev = container_of(work, struct hci_dev, |
| le_scan_disable.work); |
| int status; |
| |
| bt_dev_dbg(hdev, ""); |
| hci_dev_lock(hdev); |
| |
| if (!hci_dev_test_flag(hdev, HCI_LE_SCAN)) |
| goto _return; |
| |
| cancel_delayed_work(&hdev->le_scan_restart); |
| |
| status = hci_cmd_sync_queue(hdev, scan_disable_sync, NULL, NULL); |
| if (status) { |
| bt_dev_err(hdev, "failed to disable LE scan: %d", status); |
| goto _return; |
| } |
| |
| hdev->discovery.scan_start = 0; |
| |
| /* If we were running LE only scan, change discovery state. If |
| * we were running both LE and BR/EDR inquiry simultaneously, |
| * and BR/EDR inquiry is already finished, stop discovery, |
| * otherwise BR/EDR inquiry will stop discovery when finished. |
| * If we will resolve remote device name, do not change |
| * discovery state. |
| */ |
| |
| if (hdev->discovery.type == DISCOV_TYPE_LE) |
| goto discov_stopped; |
| |
| if (hdev->discovery.type != DISCOV_TYPE_INTERLEAVED) |
| goto _return; |
| |
| if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks)) { |
| if (!test_bit(HCI_INQUIRY, &hdev->flags) && |
| hdev->discovery.state != DISCOVERY_RESOLVING) |
| goto discov_stopped; |
| |
| goto _return; |
| } |
| |
| status = hci_cmd_sync_queue(hdev, interleaved_inquiry_sync, NULL, NULL); |
| if (status) { |
| bt_dev_err(hdev, "inquiry failed: status %d", status); |
| goto discov_stopped; |
| } |
| |
| goto _return; |
| |
| discov_stopped: |
| hci_discovery_set_state(hdev, DISCOVERY_STOPPED); |
| |
| _return: |
| hci_dev_unlock(hdev); |
| } |
| |
| static int hci_le_set_scan_enable_sync(struct hci_dev *hdev, u8 val, |
| u8 filter_dup); |
| static int hci_le_scan_restart_sync(struct hci_dev *hdev) |
| { |
| /* If controller is not scanning we are done. */ |
| if (!hci_dev_test_flag(hdev, HCI_LE_SCAN)) |
| return 0; |
| |
| if (hdev->scanning_paused) { |
| bt_dev_dbg(hdev, "Scanning is paused for suspend"); |
| return 0; |
| } |
| |
| hci_le_set_scan_enable_sync(hdev, LE_SCAN_DISABLE, 0x00); |
| return hci_le_set_scan_enable_sync(hdev, LE_SCAN_ENABLE, |
| LE_SCAN_FILTER_DUP_ENABLE); |
| } |
| |
| static void le_scan_restart(struct work_struct *work) |
| { |
| struct hci_dev *hdev = container_of(work, struct hci_dev, |
| le_scan_restart.work); |
| unsigned long timeout, duration, scan_start, now; |
| int status; |
| |
| bt_dev_dbg(hdev, ""); |
| |
| status = hci_le_scan_restart_sync(hdev); |
| if (status) { |
| bt_dev_err(hdev, "failed to restart LE scan: status %d", |
| status); |
| return; |
| } |
| |
| hci_dev_lock(hdev); |
| |
| if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) || |
| !hdev->discovery.scan_start) |
| goto unlock; |
| |
| /* When the scan was started, hdev->le_scan_disable has been queued |
| * after duration from scan_start. During scan restart this job |
| * has been canceled, and we need to queue it again after proper |
| * timeout, to make sure that scan does not run indefinitely. |
| */ |
| duration = hdev->discovery.scan_duration; |
| scan_start = hdev->discovery.scan_start; |
| now = jiffies; |
| if (now - scan_start <= duration) { |
| int elapsed; |
| |
| if (now >= scan_start) |
| elapsed = now - scan_start; |
| else |
| elapsed = ULONG_MAX - scan_start + now; |
| |
| timeout = duration - elapsed; |
| } else { |
| timeout = 0; |
| } |
| |
| queue_delayed_work(hdev->req_workqueue, |
| &hdev->le_scan_disable, timeout); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| } |
| |
| static int reenable_adv_sync(struct hci_dev *hdev, void *data) |
| { |
| bt_dev_dbg(hdev, ""); |
| |
| if (!hci_dev_test_flag(hdev, HCI_ADVERTISING) && |
| list_empty(&hdev->adv_instances)) |
| return 0; |
| |
| if (hdev->cur_adv_instance) { |
| return hci_schedule_adv_instance_sync(hdev, |
| hdev->cur_adv_instance, |
| true); |
| } else { |
| if (ext_adv_capable(hdev)) { |
| hci_start_ext_adv_sync(hdev, 0x00); |
| } else { |
| hci_update_adv_data_sync(hdev, 0x00); |
| hci_update_scan_rsp_data_sync(hdev, 0x00); |
| hci_enable_advertising_sync(hdev); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void reenable_adv(struct work_struct *work) |
| { |
| struct hci_dev *hdev = container_of(work, struct hci_dev, |
| reenable_adv_work); |
| int status; |
| |
| bt_dev_dbg(hdev, ""); |
| |
| hci_dev_lock(hdev); |
| |
| status = hci_cmd_sync_queue(hdev, reenable_adv_sync, NULL, NULL); |
| if (status) |
| bt_dev_err(hdev, "failed to reenable ADV: %d", status); |
| |
| hci_dev_unlock(hdev); |
| } |
| |
| static void cancel_adv_timeout(struct hci_dev *hdev) |
| { |
| if (hdev->adv_instance_timeout) { |
| hdev->adv_instance_timeout = 0; |
| cancel_delayed_work(&hdev->adv_instance_expire); |
| } |
| } |
| |
| /* For a single instance: |
| * - force == true: The instance will be removed even when its remaining |
| * lifetime is not zero. |
| * - force == false: the instance will be deactivated but kept stored unless |
| * the remaining lifetime is zero. |
| * |
| * For instance == 0x00: |
| * - force == true: All instances will be removed regardless of their timeout |
| * setting. |
| * - force == false: Only instances that have a timeout will be removed. |
| */ |
| int hci_clear_adv_instance_sync(struct hci_dev *hdev, struct sock *sk, |
| u8 instance, bool force) |
| { |
| struct adv_info *adv_instance, *n, *next_instance = NULL; |
| int err; |
| u8 rem_inst; |
| |
| /* Cancel any timeout concerning the removed instance(s). */ |
| if (!instance || hdev->cur_adv_instance == instance) |
| cancel_adv_timeout(hdev); |
| |
| /* Get the next instance to advertise BEFORE we remove |
| * the current one. This can be the same instance again |
| * if there is only one instance. |
| */ |
| if (instance && hdev->cur_adv_instance == instance) |
| next_instance = hci_get_next_instance(hdev, instance); |
| |
| if (instance == 0x00) { |
| list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, |
| list) { |
| if (!(force || adv_instance->timeout)) |
| continue; |
| |
| rem_inst = adv_instance->instance; |
| err = hci_remove_adv_instance(hdev, rem_inst); |
| if (!err) |
| mgmt_advertising_removed(sk, hdev, rem_inst); |
| } |
| } else { |
| adv_instance = hci_find_adv_instance(hdev, instance); |
| |
| if (force || (adv_instance && adv_instance->timeout && |
| !adv_instance->remaining_time)) { |
| /* Don't advertise a removed instance. */ |
| if (next_instance && |
| next_instance->instance == instance) |
| next_instance = NULL; |
| |
| err = hci_remove_adv_instance(hdev, instance); |
| if (!err) |
| mgmt_advertising_removed(sk, hdev, instance); |
| } |
| } |
| |
| if (!hdev_is_powered(hdev) || hci_dev_test_flag(hdev, HCI_ADVERTISING)) |
| return 0; |
| |
| if (next_instance && !ext_adv_capable(hdev)) |
| return hci_schedule_adv_instance_sync(hdev, |
| next_instance->instance, |
| false); |
| |
| return 0; |
| } |
| |
| static int adv_timeout_expire_sync(struct hci_dev *hdev, void *data) |
| { |
| u8 instance = *(u8 *)data; |
| |
| kfree(data); |
| |
| hci_clear_adv_instance_sync(hdev, NULL, instance, false); |
| |
| if (list_empty(&hdev->adv_instances)) |
| return hci_disable_advertising_sync(hdev); |
| |
| return 0; |
| } |
| |
| static void adv_timeout_expire(struct work_struct *work) |
| { |
| u8 *inst_ptr; |
| struct hci_dev *hdev = container_of(work, struct hci_dev, |
| adv_instance_expire.work); |
| |
| bt_dev_dbg(hdev, ""); |
| |
| hci_dev_lock(hdev); |
| |
| hdev->adv_instance_timeout = 0; |
| |
| if (hdev->cur_adv_instance == 0x00) |
| goto unlock; |
| |
| inst_ptr = kmalloc(1, GFP_KERNEL); |
| if (!inst_ptr) |
| goto unlock; |
| |
| *inst_ptr = hdev->cur_adv_instance; |
| hci_cmd_sync_queue(hdev, adv_timeout_expire_sync, inst_ptr, NULL); |
| |
| unlock: |
| hci_dev_unlock(hdev); |
| } |
| |
| void hci_cmd_sync_init(struct hci_dev *hdev) |
| { |
| INIT_WORK(&hdev->cmd_sync_work, hci_cmd_sync_work); |
| INIT_LIST_HEAD(&hdev->cmd_sync_work_list); |
| mutex_init(&hdev->cmd_sync_work_lock); |
| mutex_init(&hdev->unregister_lock); |
| |
| INIT_WORK(&hdev->cmd_sync_cancel_work, hci_cmd_sync_cancel_work); |
| INIT_WORK(&hdev->reenable_adv_work, reenable_adv); |
| INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable); |
| INIT_DELAYED_WORK(&hdev->le_scan_restart, le_scan_restart); |
| INIT_DELAYED_WORK(&hdev->adv_instance_expire, adv_timeout_expire); |
| } |
| |
| void hci_cmd_sync_clear(struct hci_dev *hdev) |
| { |
| struct hci_cmd_sync_work_entry *entry, *tmp; |
| |
| cancel_work_sync(&hdev->cmd_sync_work); |
| cancel_work_sync(&hdev->reenable_adv_work); |
| |
| mutex_lock(&hdev->cmd_sync_work_lock); |
| list_for_each_entry_safe(entry, tmp, &hdev->cmd_sync_work_list, list) { |
| if (entry->destroy) |
| entry->destroy(hdev, entry->data, -ECANCELED); |
| |
| list_del(&entry->list); |
| kfree(entry); |
| } |
| mutex_unlock(&hdev->cmd_sync_work_lock); |
| } |
| |
| void __hci_cmd_sync_cancel(struct hci_dev *hdev, int err) |
| { |
| bt_dev_dbg(hdev, "err 0x%2.2x", err); |
| |
| if (hdev->req_status == HCI_REQ_PEND) { |
| hdev->req_result = err; |
| hdev->req_status = HCI_REQ_CANCELED; |
| |
| cancel_delayed_work_sync(&hdev->cmd_timer); |
| cancel_delayed_work_sync(&hdev->ncmd_timer); |
| atomic_set(&hdev->cmd_cnt, 1); |
| |
| wake_up_interruptible(&hdev->req_wait_q); |
| } |
| } |
| |
| void hci_cmd_sync_cancel(struct hci_dev *hdev, int err) |
| { |
| bt_dev_dbg(hdev, "err 0x%2.2x", err); |
| |
| if (hdev->req_status == HCI_REQ_PEND) { |
| hdev->req_result = err; |
| hdev->req_status = HCI_REQ_CANCELED; |
| |
| queue_work(hdev->workqueue, &hdev->cmd_sync_cancel_work); |
| } |
| } |
| EXPORT_SYMBOL(hci_cmd_sync_cancel); |
| |
| int hci_cmd_sync_queue(struct hci_dev *hdev, hci_cmd_sync_work_func_t func, |
| void *data, hci_cmd_sync_work_destroy_t destroy) |
| { |
| struct hci_cmd_sync_work_entry *entry; |
| int err = 0; |
| |
| mutex_lock(&hdev->unregister_lock); |
| if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { |
| err = -ENODEV; |
| goto unlock; |
| } |
| |
| entry = kmalloc(sizeof(*entry), GFP_KERNEL); |
| if (!entry) { |
| err = -ENOMEM; |
| goto unlock; |
| } |
| entry->func = func; |
| entry->data = data; |
| entry->destroy = destroy; |
| |
| mutex_lock(&hdev->cmd_sync_work_lock); |
| list_add_tail(&entry->list, &hdev->cmd_sync_work_list); |
| mutex_unlock(&hdev->cmd_sync_work_lock); |
| |
| queue_work(hdev->req_workqueue, &hdev->cmd_sync_work); |
| |
| unlock: |
| mutex_unlock(&hdev->unregister_lock); |
| return err; |
| } |
| EXPORT_SYMBOL(hci_cmd_sync_queue); |
| |
| int hci_update_eir_sync(struct hci_dev *hdev) |
| { |
| struct hci_cp_write_eir cp; |
| |
| bt_dev_dbg(hdev, ""); |
| |
| if (!hdev_is_powered(hdev)) |
| return 0; |
| |
| if (!lmp_ext_inq_capable(hdev)) |
| return 0; |
| |
| if (!hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) |
| return 0; |
| |
| if (hci_dev_test_flag(hdev, HCI_SERVICE_CACHE)) |
| return 0; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| eir_create(hdev, cp.data); |
| |
| if (memcmp(cp.data, hdev->eir, sizeof(cp.data)) == 0) |
| return 0; |
| |
| memcpy(hdev->eir, cp.data, sizeof(cp.data)); |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_WRITE_EIR, sizeof(cp), &cp, |
| HCI_CMD_TIMEOUT); |
| } |
| |
| static u8 get_service_classes(struct hci_dev *hdev) |
| { |
| struct bt_uuid *uuid; |
| u8 val = 0; |
| |
| list_for_each_entry(uuid, &hdev->uuids, list) |
| val |= uuid->svc_hint; |
| |
| return val; |
| } |
| |
| int hci_update_class_sync(struct hci_dev *hdev) |
| { |
| u8 cod[3]; |
| |
| bt_dev_dbg(hdev, ""); |
| |
| if (!hdev_is_powered(hdev)) |
| return 0; |
| |
| if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) |
| return 0; |
| |
| if (hci_dev_test_flag(hdev, HCI_SERVICE_CACHE)) |
| return 0; |
| |
| cod[0] = hdev->minor_class; |
| cod[1] = hdev->major_class; |
| cod[2] = get_service_classes(hdev); |
| |
| if (hci_dev_test_flag(hdev, HCI_LIMITED_DISCOVERABLE)) |
| cod[1] |= 0x20; |
| |
| if (memcmp(cod, hdev->dev_class, 3) == 0) |
| return 0; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_WRITE_CLASS_OF_DEV, |
| sizeof(cod), cod, HCI_CMD_TIMEOUT); |
| } |
| |
| static bool is_advertising_allowed(struct hci_dev *hdev, bool connectable) |
| { |
| /* If there is no connection we are OK to advertise. */ |
| if (hci_conn_num(hdev, LE_LINK) == 0) |
| return true; |
| |
| /* Check le_states if there is any connection in peripheral role. */ |
| if (hdev->conn_hash.le_num_peripheral > 0) { |
| /* Peripheral connection state and non connectable mode |
| * bit 20. |
| */ |
| if (!connectable && !(hdev->le_states[2] & 0x10)) |
| return false; |
| |
| /* Peripheral connection state and connectable mode bit 38 |
| * and scannable bit 21. |
| */ |
| if (connectable && (!(hdev->le_states[4] & 0x40) || |
| !(hdev->le_states[2] & 0x20))) |
| return false; |
| } |
| |
| /* Check le_states if there is any connection in central role. */ |
| if (hci_conn_num(hdev, LE_LINK) != hdev->conn_hash.le_num_peripheral) { |
| /* Central connection state and non connectable mode bit 18. */ |
| if (!connectable && !(hdev->le_states[2] & 0x02)) |
| return false; |
| |
| /* Central connection state and connectable mode bit 35 and |
| * scannable 19. |
| */ |
| if (connectable && (!(hdev->le_states[4] & 0x08) || |
| !(hdev->le_states[2] & 0x08))) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static bool adv_use_rpa(struct hci_dev *hdev, uint32_t flags) |
| { |
| /* If privacy is not enabled don't use RPA */ |
| if (!hci_dev_test_flag(hdev, HCI_PRIVACY)) |
| return false; |
| |
| /* If basic privacy mode is enabled use RPA */ |
| if (!hci_dev_test_flag(hdev, HCI_LIMITED_PRIVACY)) |
| return true; |
| |
| /* If limited privacy mode is enabled don't use RPA if we're |
| * both discoverable and bondable. |
| */ |
| if ((flags & MGMT_ADV_FLAG_DISCOV) && |
| hci_dev_test_flag(hdev, HCI_BONDABLE)) |
| return false; |
| |
| /* We're neither bondable nor discoverable in the limited |
| * privacy mode, therefore use RPA. |
| */ |
| return true; |
| } |
| |
| static int hci_set_random_addr_sync(struct hci_dev *hdev, bdaddr_t *rpa) |
| { |
| /* If we're advertising or initiating an LE connection we can't |
| * go ahead and change the random address at this time. This is |
| * because the eventual initiator address used for the |
| * subsequently created connection will be undefined (some |
| * controllers use the new address and others the one we had |
| * when the operation started). |
| * |
| * In this kind of scenario skip the update and let the random |
| * address be updated at the next cycle. |
| */ |
| if (hci_dev_test_flag(hdev, HCI_LE_ADV) || |
| hci_lookup_le_connect(hdev)) { |
| bt_dev_dbg(hdev, "Deferring random address update"); |
| hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); |
| return 0; |
| } |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_RANDOM_ADDR, |
| 6, rpa, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_update_random_address_sync(struct hci_dev *hdev, bool require_privacy, |
| bool rpa, u8 *own_addr_type) |
| { |
| int err; |
| |
| /* If privacy is enabled use a resolvable private address. If |
| * current RPA has expired or there is something else than |
| * the current RPA in use, then generate a new one. |
| */ |
| if (rpa) { |
| /* If Controller supports LL Privacy use own address type is |
| * 0x03 |
| */ |
| if (use_ll_privacy(hdev)) |
| *own_addr_type = ADDR_LE_DEV_RANDOM_RESOLVED; |
| else |
| *own_addr_type = ADDR_LE_DEV_RANDOM; |
| |
| /* Check if RPA is valid */ |
| if (rpa_valid(hdev)) |
| return 0; |
| |
| err = smp_generate_rpa(hdev, hdev->irk, &hdev->rpa); |
| if (err < 0) { |
| bt_dev_err(hdev, "failed to generate new RPA"); |
| return err; |
| } |
| |
| err = hci_set_random_addr_sync(hdev, &hdev->rpa); |
| if (err) |
| return err; |
| |
| return 0; |
| } |
| |
| /* In case of required privacy without resolvable private address, |
| * use an non-resolvable private address. This is useful for active |
| * scanning and non-connectable advertising. |
| */ |
| if (require_privacy) { |
| bdaddr_t nrpa; |
| |
| while (true) { |
| /* The non-resolvable private address is generated |
| * from random six bytes with the two most significant |
| * bits cleared. |
| */ |
| get_random_bytes(&nrpa, 6); |
| nrpa.b[5] &= 0x3f; |
| |
| /* The non-resolvable private address shall not be |
| * equal to the public address. |
| */ |
| if (bacmp(&hdev->bdaddr, &nrpa)) |
| break; |
| } |
| |
| *own_addr_type = ADDR_LE_DEV_RANDOM; |
| |
| return hci_set_random_addr_sync(hdev, &nrpa); |
| } |
| |
| /* If forcing static address is in use or there is no public |
| * address use the static address as random address (but skip |
| * the HCI command if the current random address is already the |
| * static one. |
| * |
| * In case BR/EDR has been disabled on a dual-mode controller |
| * and a static address has been configured, then use that |
| * address instead of the public BR/EDR address. |
| */ |
| if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || |
| !bacmp(&hdev->bdaddr, BDADDR_ANY) || |
| (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && |
| bacmp(&hdev->static_addr, BDADDR_ANY))) { |
| *own_addr_type = ADDR_LE_DEV_RANDOM; |
| if (bacmp(&hdev->static_addr, &hdev->random_addr)) |
| return hci_set_random_addr_sync(hdev, |
| &hdev->static_addr); |
| return 0; |
| } |
| |
| /* Neither privacy nor static address is being used so use a |
| * public address. |
| */ |
| *own_addr_type = ADDR_LE_DEV_PUBLIC; |
| |
| return 0; |
| } |
| |
| static int hci_disable_ext_adv_instance_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct hci_cp_le_set_ext_adv_enable *cp; |
| struct hci_cp_ext_adv_set *set; |
| u8 data[sizeof(*cp) + sizeof(*set) * 1]; |
| u8 size; |
| |
| /* If request specifies an instance that doesn't exist, fail */ |
| if (instance > 0) { |
| struct adv_info *adv; |
| |
| adv = hci_find_adv_instance(hdev, instance); |
| if (!adv) |
| return -EINVAL; |
| |
| /* If not enabled there is nothing to do */ |
| if (!adv->enabled) |
| return 0; |
| } |
| |
| memset(data, 0, sizeof(data)); |
| |
| cp = (void *)data; |
| set = (void *)cp->data; |
| |
| /* Instance 0x00 indicates all advertising instances will be disabled */ |
| cp->num_of_sets = !!instance; |
| cp->enable = 0x00; |
| |
| set->handle = instance; |
| |
| size = sizeof(*cp) + sizeof(*set) * cp->num_of_sets; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_EXT_ADV_ENABLE, |
| size, data, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_set_adv_set_random_addr_sync(struct hci_dev *hdev, u8 instance, |
| bdaddr_t *random_addr) |
| { |
| struct hci_cp_le_set_adv_set_rand_addr cp; |
| int err; |
| |
| if (!instance) { |
| /* Instance 0x00 doesn't have an adv_info, instead it uses |
| * hdev->random_addr to track its address so whenever it needs |
| * to be updated this also set the random address since |
| * hdev->random_addr is shared with scan state machine. |
| */ |
| err = hci_set_random_addr_sync(hdev, random_addr); |
| if (err) |
| return err; |
| } |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| cp.handle = instance; |
| bacpy(&cp.bdaddr, random_addr); |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_ADV_SET_RAND_ADDR, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_setup_ext_adv_instance_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct hci_cp_le_set_ext_adv_params cp; |
| bool connectable; |
| u32 flags; |
| bdaddr_t random_addr; |
| u8 own_addr_type; |
| int err; |
| struct adv_info *adv; |
| bool secondary_adv; |
| |
| if (instance > 0) { |
| adv = hci_find_adv_instance(hdev, instance); |
| if (!adv) |
| return -EINVAL; |
| } else { |
| adv = NULL; |
| } |
| |
| /* Updating parameters of an active instance will return a |
| * Command Disallowed error, so we must first disable the |
| * instance if it is active. |
| */ |
| if (adv && !adv->pending) { |
| err = hci_disable_ext_adv_instance_sync(hdev, instance); |
| if (err) |
| return err; |
| } |
| |
| flags = hci_adv_instance_flags(hdev, instance); |
| |
| /* If the "connectable" instance flag was not set, then choose between |
| * ADV_IND and ADV_NONCONN_IND based on the global connectable setting. |
| */ |
| connectable = (flags & MGMT_ADV_FLAG_CONNECTABLE) || |
| mgmt_get_connectable(hdev); |
| |
| if (!is_advertising_allowed(hdev, connectable)) |
| return -EPERM; |
| |
| /* Set require_privacy to true only when non-connectable |
| * advertising is used. In that case it is fine to use a |
| * non-resolvable private address. |
| */ |
| err = hci_get_random_address(hdev, !connectable, |
| adv_use_rpa(hdev, flags), adv, |
| &own_addr_type, &random_addr); |
| if (err < 0) |
| return err; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| if (adv) { |
| hci_cpu_to_le24(adv->min_interval, cp.min_interval); |
| hci_cpu_to_le24(adv->max_interval, cp.max_interval); |
| cp.tx_power = adv->tx_power; |
| } else { |
| hci_cpu_to_le24(hdev->le_adv_min_interval, cp.min_interval); |
| hci_cpu_to_le24(hdev->le_adv_max_interval, cp.max_interval); |
| cp.tx_power = HCI_ADV_TX_POWER_NO_PREFERENCE; |
| } |
| |
| secondary_adv = (flags & MGMT_ADV_FLAG_SEC_MASK); |
| |
| if (connectable) { |
| if (secondary_adv) |
| cp.evt_properties = cpu_to_le16(LE_EXT_ADV_CONN_IND); |
| else |
| cp.evt_properties = cpu_to_le16(LE_LEGACY_ADV_IND); |
| } else if (hci_adv_instance_is_scannable(hdev, instance) || |
| (flags & MGMT_ADV_PARAM_SCAN_RSP)) { |
| if (secondary_adv) |
| cp.evt_properties = cpu_to_le16(LE_EXT_ADV_SCAN_IND); |
| else |
| cp.evt_properties = cpu_to_le16(LE_LEGACY_ADV_SCAN_IND); |
| } else { |
| if (secondary_adv) |
| cp.evt_properties = cpu_to_le16(LE_EXT_ADV_NON_CONN_IND); |
| else |
| cp.evt_properties = cpu_to_le16(LE_LEGACY_NONCONN_IND); |
| } |
| |
| /* If Own_Address_Type equals 0x02 or 0x03, the Peer_Address parameter |
| * contains the peer’s Identity Address and the Peer_Address_Type |
| * parameter contains the peer’s Identity Type (i.e., 0x00 or 0x01). |
| * These parameters are used to locate the corresponding local IRK in |
| * the resolving list; this IRK is used to generate their own address |
| * used in the advertisement. |
| */ |
| if (own_addr_type == ADDR_LE_DEV_RANDOM_RESOLVED) |
| hci_copy_identity_address(hdev, &cp.peer_addr, |
| &cp.peer_addr_type); |
| |
| cp.own_addr_type = own_addr_type; |
| cp.channel_map = hdev->le_adv_channel_map; |
| cp.handle = instance; |
| |
| if (flags & MGMT_ADV_FLAG_SEC_2M) { |
| cp.primary_phy = HCI_ADV_PHY_1M; |
| cp.secondary_phy = HCI_ADV_PHY_2M; |
| } else if (flags & MGMT_ADV_FLAG_SEC_CODED) { |
| cp.primary_phy = HCI_ADV_PHY_CODED; |
| cp.secondary_phy = HCI_ADV_PHY_CODED; |
| } else { |
| /* In all other cases use 1M */ |
| cp.primary_phy = HCI_ADV_PHY_1M; |
| cp.secondary_phy = HCI_ADV_PHY_1M; |
| } |
| |
| err = __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_EXT_ADV_PARAMS, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| if (err) |
| return err; |
| |
| if ((own_addr_type == ADDR_LE_DEV_RANDOM || |
| own_addr_type == ADDR_LE_DEV_RANDOM_RESOLVED) && |
| bacmp(&random_addr, BDADDR_ANY)) { |
| /* Check if random address need to be updated */ |
| if (adv) { |
| if (!bacmp(&random_addr, &adv->random_addr)) |
| return 0; |
| } else { |
| if (!bacmp(&random_addr, &hdev->random_addr)) |
| return 0; |
| } |
| |
| return hci_set_adv_set_random_addr_sync(hdev, instance, |
| &random_addr); |
| } |
| |
| return 0; |
| } |
| |
| static int hci_set_ext_scan_rsp_data_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct { |
| struct hci_cp_le_set_ext_scan_rsp_data cp; |
| u8 data[HCI_MAX_EXT_AD_LENGTH]; |
| } pdu; |
| u8 len; |
| struct adv_info *adv = NULL; |
| int err; |
| |
| memset(&pdu, 0, sizeof(pdu)); |
| |
| if (instance) { |
| adv = hci_find_adv_instance(hdev, instance); |
| if (!adv || !adv->scan_rsp_changed) |
| return 0; |
| } |
| |
| len = eir_create_scan_rsp(hdev, instance, pdu.data); |
| |
| pdu.cp.handle = instance; |
| pdu.cp.length = len; |
| pdu.cp.operation = LE_SET_ADV_DATA_OP_COMPLETE; |
| pdu.cp.frag_pref = LE_SET_ADV_DATA_NO_FRAG; |
| |
| err = __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_EXT_SCAN_RSP_DATA, |
| sizeof(pdu.cp) + len, &pdu.cp, |
| HCI_CMD_TIMEOUT); |
| if (err) |
| return err; |
| |
| if (adv) { |
| adv->scan_rsp_changed = false; |
| } else { |
| memcpy(hdev->scan_rsp_data, pdu.data, len); |
| hdev->scan_rsp_data_len = len; |
| } |
| |
| return 0; |
| } |
| |
| static int __hci_set_scan_rsp_data_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct hci_cp_le_set_scan_rsp_data cp; |
| u8 len; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| len = eir_create_scan_rsp(hdev, instance, cp.data); |
| |
| if (hdev->scan_rsp_data_len == len && |
| !memcmp(cp.data, hdev->scan_rsp_data, len)) |
| return 0; |
| |
| memcpy(hdev->scan_rsp_data, cp.data, sizeof(cp.data)); |
| hdev->scan_rsp_data_len = len; |
| |
| cp.length = len; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_SCAN_RSP_DATA, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_update_scan_rsp_data_sync(struct hci_dev *hdev, u8 instance) |
| { |
| if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) |
| return 0; |
| |
| if (ext_adv_capable(hdev)) |
| return hci_set_ext_scan_rsp_data_sync(hdev, instance); |
| |
| return __hci_set_scan_rsp_data_sync(hdev, instance); |
| } |
| |
| int hci_enable_ext_advertising_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct hci_cp_le_set_ext_adv_enable *cp; |
| struct hci_cp_ext_adv_set *set; |
| u8 data[sizeof(*cp) + sizeof(*set) * 1]; |
| struct adv_info *adv; |
| |
| if (instance > 0) { |
| adv = hci_find_adv_instance(hdev, instance); |
| if (!adv) |
| return -EINVAL; |
| /* If already enabled there is nothing to do */ |
| if (adv->enabled) |
| return 0; |
| } else { |
| adv = NULL; |
| } |
| |
| cp = (void *)data; |
| set = (void *)cp->data; |
| |
| memset(cp, 0, sizeof(*cp)); |
| |
| cp->enable = 0x01; |
| cp->num_of_sets = 0x01; |
| |
| memset(set, 0, sizeof(*set)); |
| |
| set->handle = instance; |
| |
| /* Set duration per instance since controller is responsible for |
| * scheduling it. |
| */ |
| if (adv && adv->timeout) { |
| u16 duration = adv->timeout * MSEC_PER_SEC; |
| |
| /* Time = N * 10 ms */ |
| set->duration = cpu_to_le16(duration / 10); |
| } |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_EXT_ADV_ENABLE, |
| sizeof(*cp) + |
| sizeof(*set) * cp->num_of_sets, |
| data, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_start_ext_adv_sync(struct hci_dev *hdev, u8 instance) |
| { |
| int err; |
| |
| err = hci_setup_ext_adv_instance_sync(hdev, instance); |
| if (err) |
| return err; |
| |
| err = hci_set_ext_scan_rsp_data_sync(hdev, instance); |
| if (err) |
| return err; |
| |
| return hci_enable_ext_advertising_sync(hdev, instance); |
| } |
| |
| static int hci_disable_per_advertising_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct hci_cp_le_set_per_adv_enable cp; |
| |
| /* If periodic advertising already disabled there is nothing to do. */ |
| if (!hci_dev_test_flag(hdev, HCI_LE_PER_ADV)) |
| return 0; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| cp.enable = 0x00; |
| cp.handle = instance; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_PER_ADV_ENABLE, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_set_per_adv_params_sync(struct hci_dev *hdev, u8 instance, |
| u16 min_interval, u16 max_interval) |
| { |
| struct hci_cp_le_set_per_adv_params cp; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| if (!min_interval) |
| min_interval = DISCOV_LE_PER_ADV_INT_MIN; |
| |
| if (!max_interval) |
| max_interval = DISCOV_LE_PER_ADV_INT_MAX; |
| |
| cp.handle = instance; |
| cp.min_interval = cpu_to_le16(min_interval); |
| cp.max_interval = cpu_to_le16(max_interval); |
| cp.periodic_properties = 0x0000; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_PER_ADV_PARAMS, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_set_per_adv_data_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct { |
| struct hci_cp_le_set_per_adv_data cp; |
| u8 data[HCI_MAX_PER_AD_LENGTH]; |
| } pdu; |
| u8 len; |
| |
| memset(&pdu, 0, sizeof(pdu)); |
| |
| if (instance) { |
| struct adv_info *adv = hci_find_adv_instance(hdev, instance); |
| |
| if (!adv || !adv->periodic) |
| return 0; |
| } |
| |
| len = eir_create_per_adv_data(hdev, instance, pdu.data); |
| |
| pdu.cp.length = len; |
| pdu.cp.handle = instance; |
| pdu.cp.operation = LE_SET_ADV_DATA_OP_COMPLETE; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_PER_ADV_DATA, |
| sizeof(pdu.cp) + len, &pdu, |
| HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_enable_per_advertising_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct hci_cp_le_set_per_adv_enable cp; |
| |
| /* If periodic advertising already enabled there is nothing to do. */ |
| if (hci_dev_test_flag(hdev, HCI_LE_PER_ADV)) |
| return 0; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| cp.enable = 0x01; |
| cp.handle = instance; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_PER_ADV_ENABLE, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| /* Checks if periodic advertising data contains a Basic Announcement and if it |
| * does generates a Broadcast ID and add Broadcast Announcement. |
| */ |
| static int hci_adv_bcast_annoucement(struct hci_dev *hdev, struct adv_info *adv) |
| { |
| u8 bid[3]; |
| u8 ad[4 + 3]; |
| |
| /* Skip if NULL adv as instance 0x00 is used for general purpose |
| * advertising so it cannot used for the likes of Broadcast Announcement |
| * as it can be overwritten at any point. |
| */ |
| if (!adv) |
| return 0; |
| |
| /* Check if PA data doesn't contains a Basic Audio Announcement then |
| * there is nothing to do. |
| */ |
| if (!eir_get_service_data(adv->per_adv_data, adv->per_adv_data_len, |
| 0x1851, NULL)) |
| return 0; |
| |
| /* Check if advertising data already has a Broadcast Announcement since |
| * the process may want to control the Broadcast ID directly and in that |
| * case the kernel shall no interfere. |
| */ |
| if (eir_get_service_data(adv->adv_data, adv->adv_data_len, 0x1852, |
| NULL)) |
| return 0; |
| |
| /* Generate Broadcast ID */ |
| get_random_bytes(bid, sizeof(bid)); |
| eir_append_service_data(ad, 0, 0x1852, bid, sizeof(bid)); |
| hci_set_adv_instance_data(hdev, adv->instance, sizeof(ad), ad, 0, NULL); |
| |
| return hci_update_adv_data_sync(hdev, adv->instance); |
| } |
| |
| int hci_start_per_adv_sync(struct hci_dev *hdev, u8 instance, u8 data_len, |
| u8 *data, u32 flags, u16 min_interval, |
| u16 max_interval, u16 sync_interval) |
| { |
| struct adv_info *adv = NULL; |
| int err; |
| bool added = false; |
| |
| hci_disable_per_advertising_sync(hdev, instance); |
| |
| if (instance) { |
| adv = hci_find_adv_instance(hdev, instance); |
| /* Create an instance if that could not be found */ |
| if (!adv) { |
| adv = hci_add_per_instance(hdev, instance, flags, |
| data_len, data, |
| sync_interval, |
| sync_interval); |
| if (IS_ERR(adv)) |
| return PTR_ERR(adv); |
| added = true; |
| } |
| } |
| |
| /* Only start advertising if instance 0 or if a dedicated instance has |
| * been added. |
| */ |
| if (!adv || added) { |
| err = hci_start_ext_adv_sync(hdev, instance); |
| if (err < 0) |
| goto fail; |
| |
| err = hci_adv_bcast_annoucement(hdev, adv); |
| if (err < 0) |
| goto fail; |
| } |
| |
| err = hci_set_per_adv_params_sync(hdev, instance, min_interval, |
| max_interval); |
| if (err < 0) |
| goto fail; |
| |
| err = hci_set_per_adv_data_sync(hdev, instance); |
| if (err < 0) |
| goto fail; |
| |
| err = hci_enable_per_advertising_sync(hdev, instance); |
| if (err < 0) |
| goto fail; |
| |
| return 0; |
| |
| fail: |
| if (added) |
| hci_remove_adv_instance(hdev, instance); |
| |
| return err; |
| } |
| |
| static int hci_start_adv_sync(struct hci_dev *hdev, u8 instance) |
| { |
| int err; |
| |
| if (ext_adv_capable(hdev)) |
| return hci_start_ext_adv_sync(hdev, instance); |
| |
| err = hci_update_adv_data_sync(hdev, instance); |
| if (err) |
| return err; |
| |
| err = hci_update_scan_rsp_data_sync(hdev, instance); |
| if (err) |
| return err; |
| |
| return hci_enable_advertising_sync(hdev); |
| } |
| |
| int hci_enable_advertising_sync(struct hci_dev *hdev) |
| { |
| struct adv_info *adv_instance; |
| struct hci_cp_le_set_adv_param cp; |
| u8 own_addr_type, enable = 0x01; |
| bool connectable; |
| u16 adv_min_interval, adv_max_interval; |
| u32 flags; |
| u8 status; |
| |
| if (ext_adv_capable(hdev)) |
| return hci_enable_ext_advertising_sync(hdev, |
| hdev->cur_adv_instance); |
| |
| flags = hci_adv_instance_flags(hdev, hdev->cur_adv_instance); |
| adv_instance = hci_find_adv_instance(hdev, hdev->cur_adv_instance); |
| |
| /* If the "connectable" instance flag was not set, then choose between |
| * ADV_IND and ADV_NONCONN_IND based on the global connectable setting. |
| */ |
| connectable = (flags & MGMT_ADV_FLAG_CONNECTABLE) || |
| mgmt_get_connectable(hdev); |
| |
| if (!is_advertising_allowed(hdev, connectable)) |
| return -EINVAL; |
| |
| status = hci_disable_advertising_sync(hdev); |
| if (status) |
| return status; |
| |
| /* Clear the HCI_LE_ADV bit temporarily so that the |
| * hci_update_random_address knows that it's safe to go ahead |
| * and write a new random address. The flag will be set back on |
| * as soon as the SET_ADV_ENABLE HCI command completes. |
| */ |
| hci_dev_clear_flag(hdev, HCI_LE_ADV); |
| |
| /* Set require_privacy to true only when non-connectable |
| * advertising is used. In that case it is fine to use a |
| * non-resolvable private address. |
| */ |
| status = hci_update_random_address_sync(hdev, !connectable, |
| adv_use_rpa(hdev, flags), |
| &own_addr_type); |
| if (status) |
| return status; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| if (adv_instance) { |
| adv_min_interval = adv_instance->min_interval; |
| adv_max_interval = adv_instance->max_interval; |
| } else { |
| adv_min_interval = hdev->le_adv_min_interval; |
| adv_max_interval = hdev->le_adv_max_interval; |
| } |
| |
| if (connectable) { |
| cp.type = LE_ADV_IND; |
| } else { |
| if (hci_adv_instance_is_scannable(hdev, hdev->cur_adv_instance)) |
| cp.type = LE_ADV_SCAN_IND; |
| else |
| cp.type = LE_ADV_NONCONN_IND; |
| |
| if (!hci_dev_test_flag(hdev, HCI_DISCOVERABLE) || |
| hci_dev_test_flag(hdev, HCI_LIMITED_DISCOVERABLE)) { |
| adv_min_interval = DISCOV_LE_FAST_ADV_INT_MIN; |
| adv_max_interval = DISCOV_LE_FAST_ADV_INT_MAX; |
| } |
| } |
| |
| cp.min_interval = cpu_to_le16(adv_min_interval); |
| cp.max_interval = cpu_to_le16(adv_max_interval); |
| cp.own_address_type = own_addr_type; |
| cp.channel_map = hdev->le_adv_channel_map; |
| |
| status = __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_ADV_PARAM, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| if (status) |
| return status; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_ADV_ENABLE, |
| sizeof(enable), &enable, HCI_CMD_TIMEOUT); |
| } |
| |
| static int enable_advertising_sync(struct hci_dev *hdev, void *data) |
| { |
| return hci_enable_advertising_sync(hdev); |
| } |
| |
| int hci_enable_advertising(struct hci_dev *hdev) |
| { |
| if (!hci_dev_test_flag(hdev, HCI_ADVERTISING) && |
| list_empty(&hdev->adv_instances)) |
| return 0; |
| |
| return hci_cmd_sync_queue(hdev, enable_advertising_sync, NULL, NULL); |
| } |
| |
| int hci_remove_ext_adv_instance_sync(struct hci_dev *hdev, u8 instance, |
| struct sock *sk) |
| { |
| int err; |
| |
| if (!ext_adv_capable(hdev)) |
| return 0; |
| |
| err = hci_disable_ext_adv_instance_sync(hdev, instance); |
| if (err) |
| return err; |
| |
| /* If request specifies an instance that doesn't exist, fail */ |
| if (instance > 0 && !hci_find_adv_instance(hdev, instance)) |
| return -EINVAL; |
| |
| return __hci_cmd_sync_status_sk(hdev, HCI_OP_LE_REMOVE_ADV_SET, |
| sizeof(instance), &instance, 0, |
| HCI_CMD_TIMEOUT, sk); |
| } |
| |
| static int remove_ext_adv_sync(struct hci_dev *hdev, void *data) |
| { |
| struct adv_info *adv = data; |
| u8 instance = 0; |
| |
| if (adv) |
| instance = adv->instance; |
| |
| return hci_remove_ext_adv_instance_sync(hdev, instance, NULL); |
| } |
| |
| int hci_remove_ext_adv_instance(struct hci_dev *hdev, u8 instance) |
| { |
| struct adv_info *adv = NULL; |
| |
| if (instance) { |
| adv = hci_find_adv_instance(hdev, instance); |
| if (!adv) |
| return -EINVAL; |
| } |
| |
| return hci_cmd_sync_queue(hdev, remove_ext_adv_sync, adv, NULL); |
| } |
| |
| int hci_le_terminate_big_sync(struct hci_dev *hdev, u8 handle, u8 reason) |
| { |
| struct hci_cp_le_term_big cp; |
| |
| memset(&cp, 0, sizeof(cp)); |
| cp.handle = handle; |
| cp.reason = reason; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_TERM_BIG, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_set_ext_adv_data_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct { |
| struct hci_cp_le_set_ext_adv_data cp; |
| u8 data[HCI_MAX_EXT_AD_LENGTH]; |
| } pdu; |
| u8 len; |
| struct adv_info *adv = NULL; |
| int err; |
| |
| memset(&pdu, 0, sizeof(pdu)); |
| |
| if (instance) { |
| adv = hci_find_adv_instance(hdev, instance); |
| if (!adv || !adv->adv_data_changed) |
| return 0; |
| } |
| |
| len = eir_create_adv_data(hdev, instance, pdu.data); |
| |
| pdu.cp.length = len; |
| pdu.cp.handle = instance; |
| pdu.cp.operation = LE_SET_ADV_DATA_OP_COMPLETE; |
| pdu.cp.frag_pref = LE_SET_ADV_DATA_NO_FRAG; |
| |
| err = __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_EXT_ADV_DATA, |
| sizeof(pdu.cp) + len, &pdu.cp, |
| HCI_CMD_TIMEOUT); |
| if (err) |
| return err; |
| |
| /* Update data if the command succeed */ |
| if (adv) { |
| adv->adv_data_changed = false; |
| } else { |
| memcpy(hdev->adv_data, pdu.data, len); |
| hdev->adv_data_len = len; |
| } |
| |
| return 0; |
| } |
| |
| static int hci_set_adv_data_sync(struct hci_dev *hdev, u8 instance) |
| { |
| struct hci_cp_le_set_adv_data cp; |
| u8 len; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| len = eir_create_adv_data(hdev, instance, cp.data); |
| |
| /* There's nothing to do if the data hasn't changed */ |
| if (hdev->adv_data_len == len && |
| memcmp(cp.data, hdev->adv_data, len) == 0) |
| return 0; |
| |
| memcpy(hdev->adv_data, cp.data, sizeof(cp.data)); |
| hdev->adv_data_len = len; |
| |
| cp.length = len; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_ADV_DATA, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_update_adv_data_sync(struct hci_dev *hdev, u8 instance) |
| { |
| if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) |
| return 0; |
| |
| if (ext_adv_capable(hdev)) |
| return hci_set_ext_adv_data_sync(hdev, instance); |
| |
| return hci_set_adv_data_sync(hdev, instance); |
| } |
| |
| int hci_schedule_adv_instance_sync(struct hci_dev *hdev, u8 instance, |
| bool force) |
| { |
| struct adv_info *adv = NULL; |
| u16 timeout; |
| |
| if (hci_dev_test_flag(hdev, HCI_ADVERTISING) && !ext_adv_capable(hdev)) |
| return -EPERM; |
| |
| if (hdev->adv_instance_timeout) |
| return -EBUSY; |
| |
| adv = hci_find_adv_instance(hdev, instance); |
| if (!adv) |
| return -ENOENT; |
| |
| /* A zero timeout means unlimited advertising. As long as there is |
| * only one instance, duration should be ignored. We still set a timeout |
| * in case further instances are being added later on. |
| * |
| * If the remaining lifetime of the instance is more than the duration |
| * then the timeout corresponds to the duration, otherwise it will be |
| * reduced to the remaining instance lifetime. |
| */ |
| if (adv->timeout == 0 || adv->duration <= adv->remaining_time) |
| timeout = adv->duration; |
| else |
| timeout = adv->remaining_time; |
| |
| /* The remaining time is being reduced unless the instance is being |
| * advertised without time limit. |
| */ |
| if (adv->timeout) |
| adv->remaining_time = adv->remaining_time - timeout; |
| |
| /* Only use work for scheduling instances with legacy advertising */ |
| if (!ext_adv_capable(hdev)) { |
| hdev->adv_instance_timeout = timeout; |
| queue_delayed_work(hdev->req_workqueue, |
| &hdev->adv_instance_expire, |
| msecs_to_jiffies(timeout * 1000)); |
| } |
| |
| /* If we're just re-scheduling the same instance again then do not |
| * execute any HCI commands. This happens when a single instance is |
| * being advertised. |
| */ |
| if (!force && hdev->cur_adv_instance == instance && |
| hci_dev_test_flag(hdev, HCI_LE_ADV)) |
| return 0; |
| |
| hdev->cur_adv_instance = instance; |
| |
| return hci_start_adv_sync(hdev, instance); |
| } |
| |
| static int hci_clear_adv_sets_sync(struct hci_dev *hdev, struct sock *sk) |
| { |
| int err; |
| |
| if (!ext_adv_capable(hdev)) |
| return 0; |
| |
| /* Disable instance 0x00 to disable all instances */ |
| err = hci_disable_ext_adv_instance_sync(hdev, 0x00); |
| if (err) |
| return err; |
| |
| return __hci_cmd_sync_status_sk(hdev, HCI_OP_LE_CLEAR_ADV_SETS, |
| 0, NULL, 0, HCI_CMD_TIMEOUT, sk); |
| } |
| |
| static int hci_clear_adv_sync(struct hci_dev *hdev, struct sock *sk, bool force) |
| { |
| struct adv_info *adv, *n; |
| int err = 0; |
| |
| if (ext_adv_capable(hdev)) |
| /* Remove all existing sets */ |
| err = hci_clear_adv_sets_sync(hdev, sk); |
| if (ext_adv_capable(hdev)) |
| return err; |
| |
| /* This is safe as long as there is no command send while the lock is |
| * held. |
| */ |
| hci_dev_lock(hdev); |
| |
| /* Cleanup non-ext instances */ |
| list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) { |
| u8 instance = adv->instance; |
| int err; |
| |
| if (!(force || adv->timeout)) |
| continue; |
| |
| err = hci_remove_adv_instance(hdev, instance); |
| if (!err) |
| mgmt_advertising_removed(sk, hdev, instance); |
| } |
| |
| hci_dev_unlock(hdev); |
| |
| return 0; |
| } |
| |
| static int hci_remove_adv_sync(struct hci_dev *hdev, u8 instance, |
| struct sock *sk) |
| { |
| int err = 0; |
| |
| /* If we use extended advertising, instance has to be removed first. */ |
| if (ext_adv_capable(hdev)) |
| err = hci_remove_ext_adv_instance_sync(hdev, instance, sk); |
| if (ext_adv_capable(hdev)) |
| return err; |
| |
| /* This is safe as long as there is no command send while the lock is |
| * held. |
| */ |
| hci_dev_lock(hdev); |
| |
| err = hci_remove_adv_instance(hdev, instance); |
| if (!err) |
| mgmt_advertising_removed(sk, hdev, instance); |
| |
| hci_dev_unlock(hdev); |
| |
| return err; |
| } |
| |
| /* For a single instance: |
| * - force == true: The instance will be removed even when its remaining |
| * lifetime is not zero. |
| * - force == false: the instance will be deactivated but kept stored unless |
| * the remaining lifetime is zero. |
| * |
| * For instance == 0x00: |
| * - force == true: All instances will be removed regardless of their timeout |
| * setting. |
| * - force == false: Only instances that have a timeout will be removed. |
| */ |
| int hci_remove_advertising_sync(struct hci_dev *hdev, struct sock *sk, |
| u8 instance, bool force) |
| { |
| struct adv_info *next = NULL; |
| int err; |
| |
| /* Cancel any timeout concerning the removed instance(s). */ |
| if (!instance || hdev->cur_adv_instance == instance) |
| cancel_adv_timeout(hdev); |
| |
| /* Get the next instance to advertise BEFORE we remove |
| * the current one. This can be the same instance again |
| * if there is only one instance. |
| */ |
| if (hdev->cur_adv_instance == instance) |
| next = hci_get_next_instance(hdev, instance); |
| |
| if (!instance) { |
| err = hci_clear_adv_sync(hdev, sk, force); |
| if (err) |
| return err; |
| } else { |
| struct adv_info *adv = hci_find_adv_instance(hdev, instance); |
| |
| if (force || (adv && adv->timeout && !adv->remaining_time)) { |
| /* Don't advertise a removed instance. */ |
| if (next && next->instance == instance) |
| next = NULL; |
| |
| err = hci_remove_adv_sync(hdev, instance, sk); |
| if (err) |
| return err; |
| } |
| } |
| |
| if (!hdev_is_powered(hdev) || hci_dev_test_flag(hdev, HCI_ADVERTISING)) |
| return 0; |
| |
| if (next && !ext_adv_capable(hdev)) |
| hci_schedule_adv_instance_sync(hdev, next->instance, false); |
| |
| return 0; |
| } |
| |
| int hci_read_rssi_sync(struct hci_dev *hdev, __le16 handle) |
| { |
| struct hci_cp_read_rssi cp; |
| |
| cp.handle = handle; |
| return __hci_cmd_sync_status(hdev, HCI_OP_READ_RSSI, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_read_clock_sync(struct hci_dev *hdev, struct hci_cp_read_clock *cp) |
| { |
| return __hci_cmd_sync_status(hdev, HCI_OP_READ_CLOCK, |
| sizeof(*cp), cp, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_read_tx_power_sync(struct hci_dev *hdev, __le16 handle, u8 type) |
| { |
| struct hci_cp_read_tx_power cp; |
| |
| cp.handle = handle; |
| cp.type = type; |
| return __hci_cmd_sync_status(hdev, HCI_OP_READ_TX_POWER, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_disable_advertising_sync(struct hci_dev *hdev) |
| { |
| u8 enable = 0x00; |
| int err = 0; |
| |
| /* If controller is not advertising we are done. */ |
| if (!hci_dev_test_flag(hdev, HCI_LE_ADV)) |
| return 0; |
| |
| if (ext_adv_capable(hdev)) |
| err = hci_disable_ext_adv_instance_sync(hdev, 0x00); |
| if (ext_adv_capable(hdev)) |
| return err; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_ADV_ENABLE, |
| sizeof(enable), &enable, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_le_set_ext_scan_enable_sync(struct hci_dev *hdev, u8 val, |
| u8 filter_dup) |
| { |
| struct hci_cp_le_set_ext_scan_enable cp; |
| |
| memset(&cp, 0, sizeof(cp)); |
| cp.enable = val; |
| |
| if (hci_dev_test_flag(hdev, HCI_MESH)) |
| cp.filter_dup = LE_SCAN_FILTER_DUP_DISABLE; |
| else |
| cp.filter_dup = filter_dup; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_EXT_SCAN_ENABLE, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_le_set_scan_enable_sync(struct hci_dev *hdev, u8 val, |
| u8 filter_dup) |
| { |
| struct hci_cp_le_set_scan_enable cp; |
| |
| if (use_ext_scan(hdev)) |
| return hci_le_set_ext_scan_enable_sync(hdev, val, filter_dup); |
| |
| memset(&cp, 0, sizeof(cp)); |
| cp.enable = val; |
| |
| if (val && hci_dev_test_flag(hdev, HCI_MESH)) |
| cp.filter_dup = LE_SCAN_FILTER_DUP_DISABLE; |
| else |
| cp.filter_dup = filter_dup; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_SCAN_ENABLE, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_le_set_addr_resolution_enable_sync(struct hci_dev *hdev, u8 val) |
| { |
| if (!use_ll_privacy(hdev)) |
| return 0; |
| |
| /* If controller is not/already resolving we are done. */ |
| if (val == hci_dev_test_flag(hdev, HCI_LL_RPA_RESOLUTION)) |
| return 0; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_ADDR_RESOLV_ENABLE, |
| sizeof(val), &val, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_scan_disable_sync(struct hci_dev *hdev) |
| { |
| int err; |
| |
| /* If controller is not scanning we are done. */ |
| if (!hci_dev_test_flag(hdev, HCI_LE_SCAN)) |
| return 0; |
| |
| if (hdev->scanning_paused) { |
| bt_dev_dbg(hdev, "Scanning is paused for suspend"); |
| return 0; |
| } |
| |
| err = hci_le_set_scan_enable_sync(hdev, LE_SCAN_DISABLE, 0x00); |
| if (err) { |
| bt_dev_err(hdev, "Unable to disable scanning: %d", err); |
| return err; |
| } |
| |
| return err; |
| } |
| |
| static bool scan_use_rpa(struct hci_dev *hdev) |
| { |
| return hci_dev_test_flag(hdev, HCI_PRIVACY); |
| } |
| |
| static void hci_start_interleave_scan(struct hci_dev *hdev) |
| { |
| hdev->interleave_scan_state = INTERLEAVE_SCAN_NO_FILTER; |
| queue_delayed_work(hdev->req_workqueue, |
| &hdev->interleave_scan, 0); |
| } |
| |
| static bool is_interleave_scanning(struct hci_dev *hdev) |
| { |
| return hdev->interleave_scan_state != INTERLEAVE_SCAN_NONE; |
| } |
| |
| static void cancel_interleave_scan(struct hci_dev *hdev) |
| { |
| bt_dev_dbg(hdev, "cancelling interleave scan"); |
| |
| cancel_delayed_work_sync(&hdev->interleave_scan); |
| |
| hdev->interleave_scan_state = INTERLEAVE_SCAN_NONE; |
| } |
| |
| /* Return true if interleave_scan wasn't started until exiting this function, |
| * otherwise, return false |
| */ |
| static bool hci_update_interleaved_scan_sync(struct hci_dev *hdev) |
| { |
| /* Do interleaved scan only if all of the following are true: |
| * - There is at least one ADV monitor |
| * - At least one pending LE connection or one device to be scanned for |
| * - Monitor offloading is not supported |
| * If so, we should alternate between allowlist scan and one without |
| * any filters to save power. |
| */ |
| bool use_interleaving = hci_is_adv_monitoring(hdev) && |
| !(list_empty(&hdev->pend_le_conns) && |
| list_empty(&hdev->pend_le_reports)) && |
| hci_get_adv_monitor_offload_ext(hdev) == |
| HCI_ADV_MONITOR_EXT_NONE; |
| bool is_interleaving = is_interleave_scanning(hdev); |
| |
| if (use_interleaving && !is_interleaving) { |
| hci_start_interleave_scan(hdev); |
| bt_dev_dbg(hdev, "starting interleave scan"); |
| return true; |
| } |
| |
| if (!use_interleaving && is_interleaving) |
| cancel_interleave_scan(hdev); |
| |
| return false; |
| } |
| |
| /* Removes connection to resolve list if needed.*/ |
| static int hci_le_del_resolve_list_sync(struct hci_dev *hdev, |
| bdaddr_t *bdaddr, u8 bdaddr_type) |
| { |
| struct hci_cp_le_del_from_resolv_list cp; |
| struct bdaddr_list_with_irk *entry; |
| |
| if (!use_ll_privacy(hdev)) |
| return 0; |
| |
| /* Check if the IRK has been programmed */ |
| entry = hci_bdaddr_list_lookup_with_irk(&hdev->le_resolv_list, bdaddr, |
| bdaddr_type); |
| if (!entry) |
| return 0; |
| |
| cp.bdaddr_type = bdaddr_type; |
| bacpy(&cp.bdaddr, bdaddr); |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_DEL_FROM_RESOLV_LIST, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_le_del_accept_list_sync(struct hci_dev *hdev, |
| bdaddr_t *bdaddr, u8 bdaddr_type) |
| { |
| struct hci_cp_le_del_from_accept_list cp; |
| int err; |
| |
| /* Check if device is on accept list before removing it */ |
| if (!hci_bdaddr_list_lookup(&hdev->le_accept_list, bdaddr, bdaddr_type)) |
| return 0; |
| |
| cp.bdaddr_type = bdaddr_type; |
| bacpy(&cp.bdaddr, bdaddr); |
| |
| /* Ignore errors when removing from resolving list as that is likely |
| * that the device was never added. |
| */ |
| hci_le_del_resolve_list_sync(hdev, &cp.bdaddr, cp.bdaddr_type); |
| |
| err = __hci_cmd_sync_status(hdev, HCI_OP_LE_DEL_FROM_ACCEPT_LIST, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| if (err) { |
| bt_dev_err(hdev, "Unable to remove from allow list: %d", err); |
| return err; |
| } |
| |
| bt_dev_dbg(hdev, "Remove %pMR (0x%x) from allow list", &cp.bdaddr, |
| cp.bdaddr_type); |
| |
| return 0; |
| } |
| |
| struct conn_params { |
| bdaddr_t addr; |
| u8 addr_type; |
| hci_conn_flags_t flags; |
| u8 privacy_mode; |
| }; |
| |
| /* Adds connection to resolve list if needed. |
| * Setting params to NULL programs local hdev->irk |
| */ |
| static int hci_le_add_resolve_list_sync(struct hci_dev *hdev, |
| struct conn_params *params) |
| { |
| struct hci_cp_le_add_to_resolv_list cp; |
| struct smp_irk *irk; |
| struct bdaddr_list_with_irk *entry; |
| struct hci_conn_params *p; |
| |
| if (!use_ll_privacy(hdev)) |
| return 0; |
| |
| /* Attempt to program local identity address, type and irk if params is |
| * NULL. |
| */ |
| if (!params) { |
| if (!hci_dev_test_flag(hdev, HCI_PRIVACY)) |
| return 0; |
| |
| hci_copy_identity_address(hdev, &cp.bdaddr, &cp.bdaddr_type); |
| memcpy(cp.peer_irk, hdev->irk, 16); |
| goto done; |
| } |
| |
| irk = hci_find_irk_by_addr(hdev, ¶ms->addr, params->addr_type); |
| if (!irk) |
| return 0; |
| |
| /* Check if the IK has _not_ been programmed yet. */ |
| entry = hci_bdaddr_list_lookup_with_irk(&hdev->le_resolv_list, |
| ¶ms->addr, |
| params->addr_type); |
| if (entry) |
| return 0; |
| |
| cp.bdaddr_type = params->addr_type; |
| bacpy(&cp.bdaddr, ¶ms->addr); |
| memcpy(cp.peer_irk, irk->val, 16); |
| |
| /* Default privacy mode is always Network */ |
| params->privacy_mode = HCI_NETWORK_PRIVACY; |
| |
| rcu_read_lock(); |
| p = hci_pend_le_action_lookup(&hdev->pend_le_conns, |
| ¶ms->addr, params->addr_type); |
| if (!p) |
| p = hci_pend_le_action_lookup(&hdev->pend_le_reports, |
| ¶ms->addr, params->addr_type); |
| if (p) |
| WRITE_ONCE(p->privacy_mode, HCI_NETWORK_PRIVACY); |
| rcu_read_unlock(); |
| |
| done: |
| if (hci_dev_test_flag(hdev, HCI_PRIVACY)) |
| memcpy(cp.local_irk, hdev->irk, 16); |
| else |
| memset(cp.local_irk, 0, 16); |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_ADD_TO_RESOLV_LIST, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| /* Set Device Privacy Mode. */ |
| static int hci_le_set_privacy_mode_sync(struct hci_dev *hdev, |
| struct conn_params *params) |
| { |
| struct hci_cp_le_set_privacy_mode cp; |
| struct smp_irk *irk; |
| |
| /* If device privacy mode has already been set there is nothing to do */ |
| if (params->privacy_mode == HCI_DEVICE_PRIVACY) |
| return 0; |
| |
| /* Check if HCI_CONN_FLAG_DEVICE_PRIVACY has been set as it also |
| * indicates that LL Privacy has been enabled and |
| * HCI_OP_LE_SET_PRIVACY_MODE is supported. |
| */ |
| if (!(params->flags & HCI_CONN_FLAG_DEVICE_PRIVACY)) |
| return 0; |
| |
| irk = hci_find_irk_by_addr(hdev, ¶ms->addr, params->addr_type); |
| if (!irk) |
| return 0; |
| |
| memset(&cp, 0, sizeof(cp)); |
| cp.bdaddr_type = irk->addr_type; |
| bacpy(&cp.bdaddr, &irk->bdaddr); |
| cp.mode = HCI_DEVICE_PRIVACY; |
| |
| /* Note: params->privacy_mode is not updated since it is a copy */ |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_PRIVACY_MODE, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| /* Adds connection to allow list if needed, if the device uses RPA (has IRK) |
| * this attempts to program the device in the resolving list as well and |
| * properly set the privacy mode. |
| */ |
| static int hci_le_add_accept_list_sync(struct hci_dev *hdev, |
| struct conn_params *params, |
| u8 *num_entries) |
| { |
| struct hci_cp_le_add_to_accept_list cp; |
| int err; |
| |
| /* During suspend, only wakeable devices can be in acceptlist */ |
| if (hdev->suspended && |
| !(params->flags & HCI_CONN_FLAG_REMOTE_WAKEUP)) |
| return 0; |
| |
| /* Select filter policy to accept all advertising */ |
| if (*num_entries >= hdev->le_accept_list_size) |
| return -ENOSPC; |
| |
| /* Accept list can not be used with RPAs */ |
| if (!use_ll_privacy(hdev) && |
| hci_find_irk_by_addr(hdev, ¶ms->addr, params->addr_type)) |
| return -EINVAL; |
| |
| /* Attempt to program the device in the resolving list first to avoid |
| * having to rollback in case it fails since the resolving list is |
| * dynamic it can probably be smaller than the accept list. |
| */ |
| err = hci_le_add_resolve_list_sync(hdev, params); |
| if (err) { |
| bt_dev_err(hdev, "Unable to add to resolve list: %d", err); |
| return err; |
| } |
| |
| /* Set Privacy Mode */ |
| err = hci_le_set_privacy_mode_sync(hdev, params); |
| if (err) { |
| bt_dev_err(hdev, "Unable to set privacy mode: %d", err); |
| return err; |
| } |
| |
| /* Check if already in accept list */ |
| if (hci_bdaddr_list_lookup(&hdev->le_accept_list, ¶ms->addr, |
| params->addr_type)) |
| return 0; |
| |
| *num_entries += 1; |
| cp.bdaddr_type = params->addr_type; |
| bacpy(&cp.bdaddr, ¶ms->addr); |
| |
| err = __hci_cmd_sync_status(hdev, HCI_OP_LE_ADD_TO_ACCEPT_LIST, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| if (err) { |
| bt_dev_err(hdev, "Unable to add to allow list: %d", err); |
| /* Rollback the device from the resolving list */ |
| hci_le_del_resolve_list_sync(hdev, &cp.bdaddr, cp.bdaddr_type); |
| return err; |
| } |
| |
| bt_dev_dbg(hdev, "Add %pMR (0x%x) to allow list", &cp.bdaddr, |
| cp.bdaddr_type); |
| |
| return 0; |
| } |
| |
| /* This function disables/pause all advertising instances */ |
| static int hci_pause_advertising_sync(struct hci_dev *hdev) |
| { |
| int err; |
| int old_state; |
| |
| /* If already been paused there is nothing to do. */ |
| if (hdev->advertising_paused) |
| return 0; |
| |
| bt_dev_dbg(hdev, "Pausing directed advertising"); |
| |
| /* Stop directed advertising */ |
| old_state = hci_dev_test_flag(hdev, HCI_ADVERTISING); |
| if (old_state) { |
| /* When discoverable timeout triggers, then just make sure |
| * the limited discoverable flag is cleared. Even in the case |
| * of a timeout triggered from general discoverable, it is |
| * safe to unconditionally clear the flag. |
| */ |
| hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); |
| hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); |
| hdev->discov_timeout = 0; |
| } |
| |
| bt_dev_dbg(hdev, "Pausing advertising instances"); |
| |
| /* Call to disable any advertisements active on the controller. |
| * This will succeed even if no advertisements are configured. |
| */ |
| err = hci_disable_advertising_sync(hdev); |
| if (err) |
| return err; |
| |
| /* If we are using software rotation, pause the loop */ |
| if (!ext_adv_capable(hdev)) |
| cancel_adv_timeout(hdev); |
| |
| hdev->advertising_paused = true; |
| hdev->advertising_old_state = old_state; |
| |
| return 0; |
| } |
| |
| /* This function enables all user advertising instances */ |
| static int hci_resume_advertising_sync(struct hci_dev *hdev) |
| { |
| struct adv_info *adv, *tmp; |
| int err; |
| |
| /* If advertising has not been paused there is nothing to do. */ |
| if (!hdev->advertising_paused) |
| return 0; |
| |
| /* Resume directed advertising */ |
| hdev->advertising_paused = false; |
| if (hdev->advertising_old_state) { |
| hci_dev_set_flag(hdev, HCI_ADVERTISING); |
| hdev->advertising_old_state = 0; |
| } |
| |
| bt_dev_dbg(hdev, "Resuming advertising instances"); |
| |
| if (ext_adv_capable(hdev)) { |
| /* Call for each tracked instance to be re-enabled */ |
| list_for_each_entry_safe(adv, tmp, &hdev->adv_instances, list) { |
| err = hci_enable_ext_advertising_sync(hdev, |
| adv->instance); |
| if (!err) |
| continue; |
| |
| /* If the instance cannot be resumed remove it */ |
| hci_remove_ext_adv_instance_sync(hdev, adv->instance, |
| NULL); |
| } |
| } else { |
| /* Schedule for most recent instance to be restarted and begin |
| * the software rotation loop |
| */ |
| err = hci_schedule_adv_instance_sync(hdev, |
| hdev->cur_adv_instance, |
| true); |
| } |
| |
| hdev->advertising_paused = false; |
| |
| return err; |
| } |
| |
| static int hci_pause_addr_resolution(struct hci_dev *hdev) |
| { |
| int err; |
| |
| if (!use_ll_privacy(hdev)) |
| return 0; |
| |
| if (!hci_dev_test_flag(hdev, HCI_LL_RPA_RESOLUTION)) |
| return 0; |
| |
| /* Cannot disable addr resolution if scanning is enabled or |
| * when initiating an LE connection. |
| */ |
| if (hci_dev_test_flag(hdev, HCI_LE_SCAN) || |
| hci_lookup_le_connect(hdev)) { |
| bt_dev_err(hdev, "Command not allowed when scan/LE connect"); |
| return -EPERM; |
| } |
| |
| /* Cannot disable addr resolution if advertising is enabled. */ |
| err = hci_pause_advertising_sync(hdev); |
| if (err) { |
| bt_dev_err(hdev, "Pause advertising failed: %d", err); |
| return err; |
| } |
| |
| err = hci_le_set_addr_resolution_enable_sync(hdev, 0x00); |
| if (err) |
| bt_dev_err(hdev, "Unable to disable Address Resolution: %d", |
| err); |
| |
| /* Return if address resolution is disabled and RPA is not used. */ |
| if (!err && scan_use_rpa(hdev)) |
| return err; |
| |
| hci_resume_advertising_sync(hdev); |
| return err; |
| } |
| |
| struct sk_buff *hci_read_local_oob_data_sync(struct hci_dev *hdev, |
| bool extended, struct sock *sk) |
| { |
| u16 opcode = extended ? HCI_OP_READ_LOCAL_OOB_EXT_DATA : |
| HCI_OP_READ_LOCAL_OOB_DATA; |
| |
| return __hci_cmd_sync_sk(hdev, opcode, 0, NULL, 0, HCI_CMD_TIMEOUT, sk); |
| } |
| |
| static struct conn_params *conn_params_copy(struct list_head *list, size_t *n) |
| { |
| struct hci_conn_params *params; |
| struct conn_params *p; |
| size_t i; |
| |
| rcu_read_lock(); |
| |
| i = 0; |
| list_for_each_entry_rcu(params, list, action) |
| ++i; |
| *n = i; |
| |
| rcu_read_unlock(); |
| |
| p = kvcalloc(*n, sizeof(struct conn_params), GFP_KERNEL); |
| if (!p) |
| return NULL; |
| |
| rcu_read_lock(); |
| |
| i = 0; |
| list_for_each_entry_rcu(params, list, action) { |
| /* Racing adds are handled in next scan update */ |
| if (i >= *n) |
| break; |
| |
| /* No hdev->lock, but: addr, addr_type are immutable. |
| * privacy_mode is only written by us or in |
| * hci_cc_le_set_privacy_mode that we wait for. |
| * We should be idempotent so MGMT updating flags |
| * while we are processing is OK. |
| */ |
| bacpy(&p[i].addr, ¶ms->addr); |
| p[i].addr_type = params->addr_type; |
| p[i].flags = READ_ONCE(params->flags); |
| p[i].privacy_mode = READ_ONCE(params->privacy_mode); |
| ++i; |
| } |
| |
| rcu_read_unlock(); |
| |
| *n = i; |
| return p; |
| } |
| |
| /* Device must not be scanning when updating the accept list. |
| * |
| * Update is done using the following sequence: |
| * |
| * use_ll_privacy((Disable Advertising) -> Disable Resolving List) -> |
| * Remove Devices From Accept List -> |
| * (has IRK && use_ll_privacy(Remove Devices From Resolving List))-> |
| * Add Devices to Accept List -> |
| * (has IRK && use_ll_privacy(Remove Devices From Resolving List)) -> |
| * use_ll_privacy(Enable Resolving List -> (Enable Advertising)) -> |
| * Enable Scanning |
| * |
| * In case of failure advertising shall be restored to its original state and |
| * return would disable accept list since either accept or resolving list could |
| * not be programmed. |
| * |
| */ |
| static u8 hci_update_accept_list_sync(struct hci_dev *hdev) |
| { |
| struct conn_params *params; |
| struct bdaddr_list *b, *t; |
| u8 num_entries = 0; |
| bool pend_conn, pend_report; |
| u8 filter_policy; |
| size_t i, n; |
| int err; |
| |
| /* Pause advertising if resolving list can be used as controllers |
| * cannot accept resolving list modifications while advertising. |
| */ |
| if (use_ll_privacy(hdev)) { |
| err = hci_pause_advertising_sync(hdev); |
| if (err) { |
| bt_dev_err(hdev, "pause advertising failed: %d", err); |
| return 0x00; |
| } |
| } |
| |
| /* Disable address resolution while reprogramming accept list since |
| * devices that do have an IRK will be programmed in the resolving list |
| * when LL Privacy is enabled. |
| */ |
| err = hci_le_set_addr_resolution_enable_sync(hdev, 0x00); |
| if (err) { |
| bt_dev_err(hdev, "Unable to disable LL privacy: %d", err); |
| goto done; |
| } |
| |
| /* Go through the current accept list programmed into the |
| * controller one by one and check if that address is connected or is |
| * still in the list of pending connections or list of devices to |
| * report. If not present in either list, then remove it from |
| * the controller. |
| */ |
| list_for_each_entry_safe(b, t, &hdev->le_accept_list, list) { |
| if (hci_conn_hash_lookup_le(hdev, &b->bdaddr, b->bdaddr_type)) |
| continue; |
| |
| /* Pointers not dereferenced, no locks needed */ |
| pend_conn = hci_pend_le_action_lookup(&hdev->pend_le_conns, |
| &b->bdaddr, |
| b->bdaddr_type); |
| pend_report = hci_pend_le_action_lookup(&hdev->pend_le_reports, |
| &b->bdaddr, |
| b->bdaddr_type); |
| |
| /* If the device is not likely to connect or report, |
| * remove it from the acceptlist. |
| */ |
| if (!pend_conn && !pend_report) { |
| hci_le_del_accept_list_sync(hdev, &b->bdaddr, |
| b->bdaddr_type); |
| continue; |
| } |
| |
| num_entries++; |
| } |
| |
| /* Since all no longer valid accept list entries have been |
| * removed, walk through the list of pending connections |
| * and ensure that any new device gets programmed into |
| * the controller. |
| * |
| * If the list of the devices is larger than the list of |
| * available accept list entries in the controller, then |
| * just abort and return filer policy value to not use the |
| * accept list. |
| * |
| * The list and params may be mutated while we wait for events, |
| * so make a copy and iterate it. |
| */ |
| |
| params = conn_params_copy(&hdev->pend_le_conns, &n); |
| if (!params) { |
| err = -ENOMEM; |
| goto done; |
| } |
| |
| for (i = 0; i < n; ++i) { |
| err = hci_le_add_accept_list_sync(hdev, ¶ms[i], |
| &num_entries); |
| if (err) { |
| kvfree(params); |
| goto done; |
| } |
| } |
| |
| kvfree(params); |
| |
| /* After adding all new pending connections, walk through |
| * the list of pending reports and also add these to the |
| * accept list if there is still space. Abort if space runs out. |
| */ |
| |
| params = conn_params_copy(&hdev->pend_le_reports, &n); |
| if (!params) { |
| err = -ENOMEM; |
| goto done; |
| } |
| |
| for (i = 0; i < n; ++i) { |
| err = hci_le_add_accept_list_sync(hdev, ¶ms[i], |
| &num_entries); |
| if (err) { |
| kvfree(params); |
| goto done; |
| } |
| } |
| |
| kvfree(params); |
| |
| /* Use the allowlist unless the following conditions are all true: |
| * - We are not currently suspending |
| * - There are 1 or more ADV monitors registered and it's not offloaded |
| * - Interleaved scanning is not currently using the allowlist |
| */ |
| if (!idr_is_empty(&hdev->adv_monitors_idr) && !hdev->suspended && |
| hci_get_adv_monitor_offload_ext(hdev) == HCI_ADV_MONITOR_EXT_NONE && |
| hdev->interleave_scan_state != INTERLEAVE_SCAN_ALLOWLIST) |
| err = -EINVAL; |
| |
| done: |
| filter_policy = err ? 0x00 : 0x01; |
| |
| /* Enable address resolution when LL Privacy is enabled. */ |
| err = hci_le_set_addr_resolution_enable_sync(hdev, 0x01); |
| if (err) |
| bt_dev_err(hdev, "Unable to enable LL privacy: %d", err); |
| |
| /* Resume advertising if it was paused */ |
| if (use_ll_privacy(hdev)) |
| hci_resume_advertising_sync(hdev); |
| |
| /* Select filter policy to use accept list */ |
| return filter_policy; |
| } |
| |
| /* Returns true if an le connection is in the scanning state */ |
| static inline bool hci_is_le_conn_scanning(struct hci_dev *hdev) |
| { |
| struct hci_conn_hash *h = &hdev->conn_hash; |
| struct hci_conn *c; |
| |
| rcu_read_lock(); |
| |
| list_for_each_entry_rcu(c, &h->list, list) { |
| if (c->type == LE_LINK && c->state == BT_CONNECT && |
| test_bit(HCI_CONN_SCANNING, &c->flags)) { |
| rcu_read_unlock(); |
| return true; |
| } |
| } |
| |
| rcu_read_unlock(); |
| |
| return false; |
| } |
| |
| static int hci_le_set_ext_scan_param_sync(struct hci_dev *hdev, u8 type, |
| u16 interval, u16 window, |
| u8 own_addr_type, u8 filter_policy) |
| { |
| struct hci_cp_le_set_ext_scan_params *cp; |
| struct hci_cp_le_scan_phy_params *phy; |
| u8 data[sizeof(*cp) + sizeof(*phy) * 2]; |
| u8 num_phy = 0; |
| |
| cp = (void *)data; |
| phy = (void *)cp->data; |
| |
| memset(data, 0, sizeof(data)); |
| |
| cp->own_addr_type = own_addr_type; |
| cp->filter_policy = filter_policy; |
| |
| if (scan_1m(hdev) || scan_2m(hdev)) { |
| cp->scanning_phys |= LE_SCAN_PHY_1M; |
| |
| phy->type = type; |
| phy->interval = cpu_to_le16(interval); |
| phy->window = cpu_to_le16(window); |
| |
| num_phy++; |
| phy++; |
| } |
| |
| if (scan_coded(hdev)) { |
| cp->scanning_phys |= LE_SCAN_PHY_CODED; |
| |
| phy->type = type; |
| phy->interval = cpu_to_le16(interval); |
| phy->window = cpu_to_le16(window); |
| |
| num_phy++; |
| phy++; |
| } |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_EXT_SCAN_PARAMS, |
| sizeof(*cp) + sizeof(*phy) * num_phy, |
| data, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_le_set_scan_param_sync(struct hci_dev *hdev, u8 type, |
| u16 interval, u16 window, |
| u8 own_addr_type, u8 filter_policy) |
| { |
| struct hci_cp_le_set_scan_param cp; |
| |
| if (use_ext_scan(hdev)) |
| return hci_le_set_ext_scan_param_sync(hdev, type, interval, |
| window, own_addr_type, |
| filter_policy); |
| |
| memset(&cp, 0, sizeof(cp)); |
| cp.type = type; |
| cp.interval = cpu_to_le16(interval); |
| cp.window = cpu_to_le16(window); |
| cp.own_address_type = own_addr_type; |
| cp.filter_policy = filter_policy; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_LE_SET_SCAN_PARAM, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_start_scan_sync(struct hci_dev *hdev, u8 type, u16 interval, |
| u16 window, u8 own_addr_type, u8 filter_policy, |
| u8 filter_dup) |
| { |
| int err; |
| |
| if (hdev->scanning_paused) { |
| bt_dev_dbg(hdev, "Scanning is paused for suspend"); |
| return 0; |
| } |
| |
| err = hci_le_set_scan_param_sync(hdev, type, interval, window, |
| own_addr_type, filter_policy); |
| if (err) |
| return err; |
| |
| return hci_le_set_scan_enable_sync(hdev, LE_SCAN_ENABLE, filter_dup); |
| } |
| |
| static int hci_passive_scan_sync(struct hci_dev *hdev) |
| { |
| u8 own_addr_type; |
| u8 filter_policy; |
| u16 window, interval; |
| u8 filter_dups = LE_SCAN_FILTER_DUP_ENABLE; |
| int err; |
| |
| if (hdev->scanning_paused) { |
| bt_dev_dbg(hdev, "Scanning is paused for suspend"); |
| return 0; |
| } |
| |
| err = hci_scan_disable_sync(hdev); |
| if (err) { |
| bt_dev_err(hdev, "disable scanning failed: %d", err); |
| return err; |
| } |
| |
| /* Set require_privacy to false since no SCAN_REQ are send |
| * during passive scanning. Not using an non-resolvable address |
| * here is important so that peer devices using direct |
| * advertising with our address will be correctly reported |
| * by the controller. |
| */ |
| if (hci_update_random_address_sync(hdev, false, scan_use_rpa(hdev), |
| &own_addr_type)) |
| return 0; |
| |
| if (hdev->enable_advmon_interleave_scan && |
| hci_update_interleaved_scan_sync(hdev)) |
| return 0; |
| |
| bt_dev_dbg(hdev, "interleave state %d", hdev->interleave_scan_state); |
| |
| /* Adding or removing entries from the accept list must |
| * happen before enabling scanning. The controller does |
| * not allow accept list modification while scanning. |
| */ |
| filter_policy = hci_update_accept_list_sync(hdev); |
| |
| /* When the controller is using random resolvable addresses and |
| * with that having LE privacy enabled, then controllers with |
| * Extended Scanner Filter Policies support can now enable support |
| * for handling directed advertising. |
| * |
| * So instead of using filter polices 0x00 (no acceptlist) |
| * and 0x01 (acceptlist enabled) use the new filter policies |
| * 0x02 (no acceptlist) and 0x03 (acceptlist enabled). |
| */ |
| if (hci_dev_test_flag(hdev, HCI_PRIVACY) && |
| (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY)) |
| filter_policy |= 0x02; |
| |
| if (hdev->suspended) { |
| window = hdev->le_scan_window_suspend; |
| interval = hdev->le_scan_int_suspend; |
| } else if (hci_is_le_conn_scanning(hdev)) { |
| window = hdev->le_scan_window_connect; |
| interval = hdev->le_scan_int_connect; |
| } else if (hci_is_adv_monitoring(hdev)) { |
| window = hdev->le_scan_window_adv_monitor; |
| interval = hdev->le_scan_int_adv_monitor; |
| } else { |
| window = hdev->le_scan_window; |
| interval = hdev->le_scan_interval; |
| } |
| |
| /* Disable all filtering for Mesh */ |
| if (hci_dev_test_flag(hdev, HCI_MESH)) { |
| filter_policy = 0; |
| filter_dups = LE_SCAN_FILTER_DUP_DISABLE; |
| } |
| |
| bt_dev_dbg(hdev, "LE passive scan with acceptlist = %d", filter_policy); |
| |
| return hci_start_scan_sync(hdev, LE_SCAN_PASSIVE, interval, window, |
| own_addr_type, filter_policy, filter_dups); |
| } |
| |
| /* This function controls the passive scanning based on hdev->pend_le_conns |
| * list. If there are pending LE connection we start the background scanning, |
| * otherwise we stop it in the following sequence: |
| * |
| * If there are devices to scan: |
| * |
| * Disable Scanning -> Update Accept List -> |
| * use_ll_privacy((Disable Advertising) -> Disable Resolving List -> |
| * Update Resolving List -> Enable Resolving List -> (Enable Advertising)) -> |
| * Enable Scanning |
| * |
| * Otherwise: |
| * |
| * Disable Scanning |
| */ |
| int hci_update_passive_scan_sync(struct hci_dev *hdev) |
| { |
| int err; |
| |
| if (!test_bit(HCI_UP, &hdev->flags) || |
| test_bit(HCI_INIT, &hdev->flags) || |
| hci_dev_test_flag(hdev, HCI_SETUP) || |
| hci_dev_test_flag(hdev, HCI_CONFIG) || |
| hci_dev_test_flag(hdev, HCI_AUTO_OFF) || |
| hci_dev_test_flag(hdev, HCI_UNREGISTER)) |
| return 0; |
| |
| /* No point in doing scanning if LE support hasn't been enabled */ |
| if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) |
| return 0; |
| |
| /* If discovery is active don't interfere with it */ |
| if (hdev->discovery.state != DISCOVERY_STOPPED) |
| return 0; |
| |
| /* Reset RSSI and UUID filters when starting background scanning |
| * since these filters are meant for service discovery only. |
| * |
| * The Start Discovery and Start Service Discovery operations |
| * ensure to set proper values for RSSI threshold and UUID |
| * filter list. So it is safe to just reset them here. |
| */ |
| hci_discovery_filter_clear(hdev); |
| |
| bt_dev_dbg(hdev, "ADV monitoring is %s", |
| hci_is_adv_monitoring(hdev) ? "on" : "off"); |
| |
| if (!hci_dev_test_flag(hdev, HCI_MESH) && |
| list_empty(&hdev->pend_le_conns) && |
| list_empty(&hdev->pend_le_reports) && |
| !hci_is_adv_monitoring(hdev) && |
| !hci_dev_test_flag(hdev, HCI_PA_SYNC)) { |
| /* If there is no pending LE connections or devices |
| * to be scanned for or no ADV monitors, we should stop the |
| * background scanning. |
| */ |
| |
| bt_dev_dbg(hdev, "stopping background scanning"); |
| |
| err = hci_scan_disable_sync(hdev); |
| if (err) |
| bt_dev_err(hdev, "stop background scanning failed: %d", |
| err); |
| } else { |
| /* If there is at least one pending LE connection, we should |
| * keep the background scan running. |
| */ |
| |
| /* If controller is connecting, we should not start scanning |
| * since some controllers are not able to scan and connect at |
| * the same time. |
| */ |
| if (hci_lookup_le_connect(hdev)) |
| return 0; |
| |
| bt_dev_dbg(hdev, "start background scanning"); |
| |
| err = hci_passive_scan_sync(hdev); |
| if (err) |
| bt_dev_err(hdev, "start background scanning failed: %d", |
| err); |
| } |
| |
| return err; |
| } |
| |
| static int update_scan_sync(struct hci_dev *hdev, void *data) |
| { |
| return hci_update_scan_sync(hdev); |
| } |
| |
| int hci_update_scan(struct hci_dev *hdev) |
| { |
| return hci_cmd_sync_queue(hdev, update_scan_sync, NULL, NULL); |
| } |
| |
| static int update_passive_scan_sync(struct hci_dev *hdev, void *data) |
| { |
| return hci_update_passive_scan_sync(hdev); |
| } |
| |
| int hci_update_passive_scan(struct hci_dev *hdev) |
| { |
| /* Only queue if it would have any effect */ |
| if (!test_bit(HCI_UP, &hdev->flags) || |
| test_bit(HCI_INIT, &hdev->flags) || |
| hci_dev_test_flag(hdev, HCI_SETUP) || |
| hci_dev_test_flag(hdev, HCI_CONFIG) || |
| hci_dev_test_flag(hdev, HCI_AUTO_OFF) || |
| hci_dev_test_flag(hdev, HCI_UNREGISTER)) |
| return 0; |
| |
| return hci_cmd_sync_queue(hdev, update_passive_scan_sync, NULL, NULL); |
| } |
| |
| int hci_write_sc_support_sync(struct hci_dev *hdev, u8 val) |
| { |
| int err; |
| |
| if (!bredr_sc_enabled(hdev) || lmp_host_sc_capable(hdev)) |
| return 0; |
| |
| err = __hci_cmd_sync_status(hdev, HCI_OP_WRITE_SC_SUPPORT, |
| sizeof(val), &val, HCI_CMD_TIMEOUT); |
| |
| if (!err) { |
| if (val) { |
| hdev->features[1][0] |= LMP_HOST_SC; |
| hci_dev_set_flag(hdev, HCI_SC_ENABLED); |
| } else { |
| hdev->features[1][0] &= ~LMP_HOST_SC; |
| hci_dev_clear_flag(hdev, HCI_SC_ENABLED); |
| } |
| } |
| |
| return err; |
| } |
| |
| int hci_write_ssp_mode_sync(struct hci_dev *hdev, u8 mode) |
| { |
| int err; |
| |
| if (!hci_dev_test_flag(hdev, HCI_SSP_ENABLED) || |
| lmp_host_ssp_capable(hdev)) |
| return 0; |
| |
| if (!mode && hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS)) { |
| __hci_cmd_sync_status(hdev, HCI_OP_WRITE_SSP_DEBUG_MODE, |
| sizeof(mode), &mode, HCI_CMD_TIMEOUT); |
| } |
| |
| err = __hci_cmd_sync_status(hdev, HCI_OP_WRITE_SSP_MODE, |
| sizeof(mode), &mode, HCI_CMD_TIMEOUT); |
| if (err) |
| return err; |
| |
| return hci_write_sc_support_sync(hdev, 0x01); |
| } |
| |
| int hci_write_le_host_supported_sync(struct hci_dev *hdev, u8 le, u8 simul) |
| { |
| struct hci_cp_write_le_host_supported cp; |
| |
| if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) || |
| !lmp_bredr_capable(hdev)) |
| return 0; |
| |
| /* Check first if we already have the right host state |
| * (host features set) |
| */ |
| if (le == lmp_host_le_capable(hdev) && |
| simul == lmp_host_le_br_capable(hdev)) |
| return 0; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| cp.le = le; |
| cp.simul = simul; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| } |
| |
| static int hci_powered_update_adv_sync(struct hci_dev *hdev) |
| { |
| struct adv_info *adv, *tmp; |
| int err; |
| |
| if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) |
| return 0; |
| |
| /* If RPA Resolution has not been enable yet it means the |
| * resolving list is empty and we should attempt to program the |
| * local IRK in order to support using own_addr_type |
| * ADDR_LE_DEV_RANDOM_RESOLVED (0x03). |
| */ |
| if (!hci_dev_test_flag(hdev, HCI_LL_RPA_RESOLUTION)) { |
| hci_le_add_resolve_list_sync(hdev, NULL); |
| hci_le_set_addr_resolution_enable_sync(hdev, 0x01); |
| } |
| |
| /* Make sure the controller has a good default for |
| * advertising data. This also applies to the case |
| * where BR/EDR was toggled during the AUTO_OFF phase. |
| */ |
| if (hci_dev_test_flag(hdev, HCI_ADVERTISING) || |
| list_empty(&hdev->adv_instances)) { |
| if (ext_adv_capable(hdev)) { |
| err = hci_setup_ext_adv_instance_sync(hdev, 0x00); |
| if (!err) |
| hci_update_scan_rsp_data_sync(hdev, 0x00); |
| } else { |
| err = hci_update_adv_data_sync(hdev, 0x00); |
| if (!err) |
| hci_update_scan_rsp_data_sync(hdev, 0x00); |
| } |
| |
| if (hci_dev_test_flag(hdev, HCI_ADVERTISING)) |
| hci_enable_advertising_sync(hdev); |
| } |
| |
| /* Call for each tracked instance to be scheduled */ |
| list_for_each_entry_safe(adv, tmp, &hdev->adv_instances, list) |
| hci_schedule_adv_instance_sync(hdev, adv->instance, true); |
| |
| return 0; |
| } |
| |
| static int hci_write_auth_enable_sync(struct hci_dev *hdev) |
| { |
| u8 link_sec; |
| |
| link_sec = hci_dev_test_flag(hdev, HCI_LINK_SECURITY); |
| if (link_sec == test_bit(HCI_AUTH, &hdev->flags)) |
| return 0; |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_WRITE_AUTH_ENABLE, |
| sizeof(link_sec), &link_sec, |
| HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_write_fast_connectable_sync(struct hci_dev *hdev, bool enable) |
| { |
| struct hci_cp_write_page_scan_activity cp; |
| u8 type; |
| int err = 0; |
| |
| if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) |
| return 0; |
| |
| if (hdev->hci_ver < BLUETOOTH_VER_1_2) |
| return 0; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| if (enable) { |
| type = PAGE_SCAN_TYPE_INTERLACED; |
| |
| /* 160 msec page scan interval */ |
| cp.interval = cpu_to_le16(0x0100); |
| } else { |
| type = hdev->def_page_scan_type; |
| cp.interval = cpu_to_le16(hdev->def_page_scan_int); |
| } |
| |
| cp.window = cpu_to_le16(hdev->def_page_scan_window); |
| |
| if (__cpu_to_le16(hdev->page_scan_interval) != cp.interval || |
| __cpu_to_le16(hdev->page_scan_window) != cp.window) { |
| err = __hci_cmd_sync_status(hdev, |
| HCI_OP_WRITE_PAGE_SCAN_ACTIVITY, |
| sizeof(cp), &cp, HCI_CMD_TIMEOUT); |
| if (err) |
| return err; |
| } |
| |
| if (hdev->page_scan_type != type) |
| err = __hci_cmd_sync_status(hdev, |
| HCI_OP_WRITE_PAGE_SCAN_TYPE, |
| sizeof(type), &type, |
| HCI_CMD_TIMEOUT); |
| |
| return err; |
| } |
| |
| static bool disconnected_accept_list_entries(struct hci_dev *hdev) |
| { |
| struct bdaddr_list *b; |
| |
| list_for_each_entry(b, &hdev->accept_list, list) { |
| struct hci_conn *conn; |
| |
| conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &b->bdaddr); |
| if (!conn) |
| return true; |
| |
| if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static int hci_write_scan_enable_sync(struct hci_dev *hdev, u8 val) |
| { |
| return __hci_cmd_sync_status(hdev, HCI_OP_WRITE_SCAN_ENABLE, |
| sizeof(val), &val, |
| HCI_CMD_TIMEOUT); |
| } |
| |
| int hci_update_scan_sync(struct hci_dev *hdev) |
| { |
| u8 scan; |
| |
| if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) |
| return 0; |
| |
| if (!hdev_is_powered(hdev)) |
| return 0; |
| |
| if (mgmt_powering_down(hdev)) |
| return 0; |
| |
| if (hdev->scanning_paused) |
| return 0; |
| |
| if (hci_dev_test_flag(hdev, HCI_CONNECTABLE) || |
| disconnected_accept_list_entries(hdev)) |
| scan = SCAN_PAGE; |
| else |
| scan = SCAN_DISABLED; |
| |
| if (hci_dev_test_flag(hdev, HCI_DISCOVERABLE)) |
| scan |= SCAN_INQUIRY; |
| |
| if (test_bit(HCI_PSCAN, &hdev->flags) == !!(scan & SCAN_PAGE) && |
| test_bit(HCI_ISCAN, &hdev->flags) == !!(scan & SCAN_INQUIRY)) |
| return 0; |
| |
| return hci_write_scan_enable_sync(hdev, scan); |
| } |
| |
| int hci_update_name_sync(struct hci_dev *hdev) |
| { |
| struct hci_cp_write_local_name cp; |
| |
| memset(&cp, 0, sizeof(cp)); |
| |
| memcpy(cp.name, hdev->dev_name, sizeof(cp.name)); |
| |
| return __hci_cmd_sync_status(hdev, HCI_OP_WRITE_LOCAL_NAME, |
| sizeof(cp), &cp, |
| HCI_CMD_TIMEOUT); |
| } |
| |
| /* This function perform powered update HCI command sequence after the HCI init |
| |