Bluetooth: Move Stop Discovery to req_workqueue

Since discovery also deals with LE scanning it makes sense to move it
behind the same req_workqueue as other LE scanning changes. This also
simplifies the logic since we do many of the actions in a synchronous
manner.

Part of this refactoring is moving hci_req_stop_discovery() to
hci_request.c. At the same time the function receives support for
properly handling the STOPPING state since that's the state we'll be
in when stopping through the req_workqueue.

Signed-off-by: Johan Hedberg <johan.hedberg@intel.com>
Signed-off-by: Marcel Holtmann <marcel@holtmann.org>

1 files changed, 62 insertions, 0 deletions

diff --git a/net/bluetooth/hci_request.c b/net/bluetooth/hci_request.c
index da1e30b85e77..3219ee66faad 100644
--- a/net/bluetooth/hci_request.c
+++ b/net/bluetooth/hci_request.c
@@ -1221,6 +1221,62 @@ static void start_discovery(struct hci_dev *hdev, u8 *status)
                            timeout);
 }
 
+bool hci_req_stop_discovery(struct hci_request *req)
+{
+        struct hci_dev *hdev = req->hdev;
+        struct discovery_state *d = &hdev->discovery;
+        struct hci_cp_remote_name_req_cancel cp;
+        struct inquiry_entry *e;
+        bool ret = false;
+
+        BT_DBG("%s state %u", hdev->name, hdev->discovery.state);
+
+        if (d->state == DISCOVERY_FINDING || d->state == DISCOVERY_STOPPING) {
+                if (test_bit(HCI_INQUIRY, &hdev->flags))
+                        hci_req_add(req, HCI_OP_INQUIRY_CANCEL, 0, NULL);
+
+                if (hci_dev_test_flag(hdev, HCI_LE_SCAN)) {
+                        cancel_delayed_work(&hdev->le_scan_disable);
+                        hci_req_add_le_scan_disable(req);
+                }
+
+                ret = true;
+        } else {
+                /* Passive scanning */
+                if (hci_dev_test_flag(hdev, HCI_LE_SCAN)) {
+                        hci_req_add_le_scan_disable(req);
+                        ret = true;
+                }
+        }
+
+        /* No further actions needed for LE-only discovery */
+        if (d->type == DISCOV_TYPE_LE)
+                return ret;
+
+        if (d->state == DISCOVERY_RESOLVING || d->state == DISCOVERY_STOPPING) {
+                e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY,
+                                                     NAME_PENDING);
+                if (!e)
+                        return ret;
+
+                bacpy(&cp.bdaddr, &e->data.bdaddr);
+                hci_req_add(req, HCI_OP_REMOTE_NAME_REQ_CANCEL, sizeof(cp),
+                            &cp);
+                ret = true;
+        }
+
+        return ret;
+}
+
+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,
@@ -1236,6 +1292,12 @@ static void discov_update(struct work_struct *work)
                 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;