Skip to content

Commit

Permalink
Bluetooth: Remove dead code from hci_request.c
Browse files Browse the repository at this point in the history 
The discov_update work queue is no longer used as a result
of the hci_sync rework.

The __hci_req_hci_power_on() function is no longer referenced in the
code as a result of the hci_sync rework.

Signed-off-by: Brian Gix <brian.gix@intel.com>
Signed-off-by: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
  • Loading branch information
Brian Gix authored and Luiz Augusto von Dentz committed Jul 22, 2022
1 parent 38f230f commit ec2904c
Show file tree
Hide file tree
Showing 3 changed files with 0 additions and 290 deletions.
1 change: 0 additions & 1 deletion include/net/bluetooth/hci_core.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -517,7 +517,6 @@ struct hci_dev {
struct work_struct cmd_work;
struct work_struct tx_work;

struct work_struct discov_update;
struct work_struct scan_update;
struct delayed_work le_scan_disable;
struct delayed_work le_scan_restart;
Expand Down
287 changes: 0 additions & 287 deletions net/bluetooth/hci_request.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2227,146 +2227,6 @@ static void le_scan_restart_work(struct work_struct *work)
hci_dev_unlock(hdev);
}

static int active_scan(struct hci_request *req, unsigned long opt)
{
uint16_t interval = opt;
struct hci_dev *hdev = req->hdev;
u8 own_addr_type;
/* Accept list is not used for discovery */
u8 filter_policy = 0x00;
/* Default is to enable duplicates filter */
u8 filter_dup = LE_SCAN_FILTER_DUP_ENABLE;
/* Discovery doesn't require controller address resolution */
bool addr_resolv = false;
int err;

bt_dev_dbg(hdev, "");

/* If controller is scanning, it means the background scanning is
* running. Thus, we should temporarily stop it in order to set the
* discovery scanning parameters.
*/
if (hci_dev_test_flag(hdev, HCI_LE_SCAN)) {
hci_req_add_le_scan_disable(req, false);
cancel_interleave_scan(hdev);
}

/* All active scans will be done with either a resolvable private
* address (when privacy feature has been enabled) or non-resolvable
* private address.
*/
err = hci_update_random_address(req, true, scan_use_rpa(hdev),
&own_addr_type);
if (err < 0)
own_addr_type = ADDR_LE_DEV_PUBLIC;

hci_dev_lock(hdev);
if (hci_is_adv_monitoring(hdev)) {
/* Duplicate filter should be disabled when some advertisement
* monitor is activated, otherwise AdvMon can only receive one
* advertisement for one peer(*) during active scanning, and
* might report loss to these peers.
*
* Note that different controllers have different meanings of
* |duplicate|. Some of them consider packets with the same
* address as duplicate, and others consider packets with the
* same address and the same RSSI as duplicate. Although in the
* latter case we don't need to disable duplicate filter, but
* it is common to have active scanning for a short period of
* time, the power impact should be neglectable.
*/
filter_dup = LE_SCAN_FILTER_DUP_DISABLE;
}
hci_dev_unlock(hdev);

hci_req_start_scan(req, LE_SCAN_ACTIVE, interval,
hdev->le_scan_window_discovery, own_addr_type,
filter_policy, filter_dup, addr_resolv);
return 0;
}

static int interleaved_discov(struct hci_request *req, unsigned long opt)
{
int err;

bt_dev_dbg(req->hdev, "");

err = active_scan(req, opt);
if (err)
return err;

return bredr_inquiry(req, DISCOV_BREDR_INQUIRY_LEN);
}

static void start_discovery(struct hci_dev *hdev, u8 *status)
{
unsigned long timeout;

bt_dev_dbg(hdev, "type %u", hdev->discovery.type);

switch (hdev->discovery.type) {
case DISCOV_TYPE_BREDR:
if (!hci_dev_test_flag(hdev, HCI_INQUIRY))
hci_req_sync(hdev, bredr_inquiry,
DISCOV_BREDR_INQUIRY_LEN, HCI_CMD_TIMEOUT,
status);
return;
case DISCOV_TYPE_INTERLEAVED:
/* When running simultaneous discovery, the LE scanning time
* should occupy the whole discovery time sine BR/EDR inquiry
* and LE scanning are scheduled by the controller.
*
* For interleaving discovery in comparison, BR/EDR inquiry
* and LE scanning are done sequentially with separate
* timeouts.
*/
if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY,
&hdev->quirks)) {
timeout = msecs_to_jiffies(DISCOV_LE_TIMEOUT);
/* During simultaneous discovery, we double LE scan
* interval. We must leave some time for the controller
* to do BR/EDR inquiry.
*/
hci_req_sync(hdev, interleaved_discov,
hdev->le_scan_int_discovery * 2, HCI_CMD_TIMEOUT,
status);
break;
}

timeout = msecs_to_jiffies(hdev->discov_interleaved_timeout);
hci_req_sync(hdev, active_scan, hdev->le_scan_int_discovery,
HCI_CMD_TIMEOUT, status);
break;
case DISCOV_TYPE_LE:
timeout = msecs_to_jiffies(DISCOV_LE_TIMEOUT);
hci_req_sync(hdev, active_scan, hdev->le_scan_int_discovery,
HCI_CMD_TIMEOUT, status);
break;
default:
*status = HCI_ERROR_UNSPECIFIED;
return;
}

if (*status)
return;

bt_dev_dbg(hdev, "timeout %u ms", jiffies_to_msecs(timeout));

/* When service discovery is used and the controller has a
* strict duplicate filter, it is important to remember the
* start and duration of the scan. This is required for
* restarting scanning during the discovery phase.
*/
if (test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) &&
hdev->discovery.result_filtering) {
hdev->discovery.scan_start = jiffies;
hdev->discovery.scan_duration = timeout;
}

queue_delayed_work(hdev->req_workqueue, &hdev->le_scan_disable,
timeout);
}

bool hci_req_stop_discovery(struct hci_request *req)
{
struct hci_dev *hdev = req->hdev;
Expand Down Expand Up @@ -2462,42 +2322,6 @@ int hci_req_configure_datapath(struct hci_dev *hdev, struct bt_codec *codec)
return err;
}

static int stop_discovery(struct hci_request *req, unsigned long opt)
{
hci_dev_lock(req->hdev);
hci_req_stop_discovery(req);
hci_dev_unlock(req->hdev);

return 0;
}

static void discov_update(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev,
discov_update);
u8 status = 0;

switch (hdev->discovery.state) {
case DISCOVERY_STARTING:
start_discovery(hdev, &status);
mgmt_start_discovery_complete(hdev, status);
if (status)
hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
else
hci_discovery_set_state(hdev, DISCOVERY_FINDING);
break;
case DISCOVERY_STOPPING:
hci_req_sync(hdev, stop_discovery, 0, HCI_CMD_TIMEOUT, &status);
mgmt_stop_discovery_complete(hdev, status);
if (!status)
hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
break;
case DISCOVERY_STOPPED:
default:
return;
}
}

static void discov_off(struct work_struct *work)
{
struct hci_dev *hdev = container_of(work, struct hci_dev,
Expand All @@ -2522,118 +2346,8 @@ static void discov_off(struct work_struct *work)
mgmt_new_settings(hdev);
}

static int powered_update_hci(struct hci_request *req, unsigned long opt)
{
struct hci_dev *hdev = req->hdev;
u8 link_sec;

hci_dev_lock(hdev);

if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
!lmp_host_ssp_capable(hdev)) {
u8 mode = 0x01;

hci_req_add(req, HCI_OP_WRITE_SSP_MODE, sizeof(mode), &mode);

if (bredr_sc_enabled(hdev) && !lmp_host_sc_capable(hdev)) {
u8 support = 0x01;

hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT,
sizeof(support), &support);
}
}

if (hci_dev_test_flag(hdev, HCI_LE_ENABLED) &&
lmp_bredr_capable(hdev)) {
struct hci_cp_write_le_host_supported cp;

cp.le = 0x01;
cp.simul = 0x00;

/* Check first if we already have the right
* host state (host features set)
*/
if (cp.le != lmp_host_le_capable(hdev) ||
cp.simul != lmp_host_le_br_capable(hdev))
hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED,
sizeof(cp), &cp);
}

if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
/* 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)) {
int err;

if (ext_adv_capable(hdev)) {
err = __hci_req_setup_ext_adv_instance(req,
0x00);
if (!err)
__hci_req_update_scan_rsp_data(req,
0x00);
} else {
err = 0;
__hci_req_update_adv_data(req, 0x00);
__hci_req_update_scan_rsp_data(req, 0x00);
}

if (hci_dev_test_flag(hdev, HCI_ADVERTISING)) {
if (!ext_adv_capable(hdev))
__hci_req_enable_advertising(req);
else if (!err)
__hci_req_enable_ext_advertising(req,
0x00);
}
} else if (!list_empty(&hdev->adv_instances)) {
struct adv_info *adv_instance;

adv_instance = list_first_entry(&hdev->adv_instances,
struct adv_info, list);
__hci_req_schedule_adv_instance(req,
adv_instance->instance,
true);
}
}

link_sec = hci_dev_test_flag(hdev, HCI_LINK_SECURITY);
if (link_sec != test_bit(HCI_AUTH, &hdev->flags))
hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE,
sizeof(link_sec), &link_sec);

if (lmp_bredr_capable(hdev)) {
if (hci_dev_test_flag(hdev, HCI_FAST_CONNECTABLE))
__hci_req_write_fast_connectable(req, true);
else
__hci_req_write_fast_connectable(req, false);
__hci_req_update_scan(req);
__hci_req_update_class(req);
__hci_req_update_name(req);
__hci_req_update_eir(req);
}

hci_dev_unlock(hdev);
return 0;
}

int __hci_req_hci_power_on(struct hci_dev *hdev)
{
/* Register the available SMP channels (BR/EDR and LE) only when
* successfully powering on the controller. This late
* registration is required so that LE SMP can clearly decide if
* the public address or static address is used.
*/
smp_register(hdev);

return __hci_req_sync(hdev, powered_update_hci, 0, HCI_CMD_TIMEOUT,
NULL);
}

void hci_request_setup(struct hci_dev *hdev)
{
INIT_WORK(&hdev->discov_update, discov_update);
INIT_WORK(&hdev->scan_update, scan_update_work);
INIT_DELAYED_WORK(&hdev->discov_off, discov_off);
INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work);
Expand All @@ -2646,7 +2360,6 @@ void hci_request_cancel_all(struct hci_dev *hdev)
{
__hci_cmd_sync_cancel(hdev, ENODEV);

cancel_work_sync(&hdev->discov_update);
cancel_work_sync(&hdev->scan_update);
cancel_delayed_work_sync(&hdev->discov_off);
cancel_delayed_work_sync(&hdev->le_scan_disable);
Expand Down
2 changes: 0 additions & 2 deletions net/bluetooth/hci_request.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -68,8 +68,6 @@ int __hci_req_sync(struct hci_dev *hdev, int (*func)(struct hci_request *req,
struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, u32 plen,
const void *param);

int __hci_req_hci_power_on(struct hci_dev *hdev);

void __hci_req_write_fast_connectable(struct hci_request *req, bool enable);
void __hci_req_update_name(struct hci_request *req);
void __hci_req_update_eir(struct hci_request *req);
Expand Down

0 comments on commit ec2904c

Please sign in to comment.