1 files changed, 278 insertions, 222 deletions

diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index 5caff4d47596..a6720c6a4d2c 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -32,22 +32,23 @@
 #define MGMT_VERSION    0
 #define MGMT_REVISION   1
 
+#define INQUIRY_LEN_BREDR 0x08 /* TGAP(100) */
+
 struct pending_cmd {
         struct list_head list;
-        __u16 opcode;
+        u16 opcode;
         int index;
         void *param;
         struct sock *sk;
         void *user_data;
 };
 
-static LIST_HEAD(cmd_list);
-
 static int cmd_status(struct sock *sk, u16 index, u16 cmd, u8 status)
 {
         struct sk_buff *skb;
         struct mgmt_hdr *hdr;
         struct mgmt_ev_cmd_status *ev;
+        int err;
 
         BT_DBG("sock %p, index %u, cmd %u, status %u", sk, index, cmd, status);
 
@@ -65,10 +66,11 @@ static int cmd_status(struct sock *sk, u16 index, u16 cmd, u8 status)
         ev->status = status;
         put_unaligned_le16(cmd, &ev->opcode);
 
-        if (sock_queue_rcv_skb(sk, skb) < 0)
+        err = sock_queue_rcv_skb(sk, skb);
+        if (err < 0)
                 kfree_skb(skb);
 
-        return 0;
+        return err;
 }
 
 static int cmd_complete(struct sock *sk, u16 index, u16 cmd, void *rp,
@@ -77,6 +79,7 @@ static int cmd_complete(struct sock *sk, u16 index, u16 cmd, void *rp,
         struct sk_buff *skb;
         struct mgmt_hdr *hdr;
         struct mgmt_ev_cmd_complete *ev;
+        int err;
 
         BT_DBG("sock %p", sk);
 
@@ -96,10 +99,11 @@ static int cmd_complete(struct sock *sk, u16 index, u16 cmd, void *rp,
         if (rp)
                 memcpy(ev->data, rp, rp_len);
 
-        if (sock_queue_rcv_skb(sk, skb) < 0)
+        err = sock_queue_rcv_skb(sk, skb);
+        if (err < 0)
                 kfree_skb(skb);
 
-        return 0;
+        return err;;
 }
 
 static int read_version(struct sock *sk)
@@ -119,6 +123,7 @@ static int read_index_list(struct sock *sk)
 {
         struct mgmt_rp_read_index_list *rp;
         struct list_head *p;
+        struct hci_dev *d;
         size_t rp_len;
         u16 count;
         int i, err;
@@ -142,10 +147,9 @@ static int read_index_list(struct sock *sk)
         put_unaligned_le16(count, &rp->num_controllers);
 
         i = 0;
-        list_for_each(p, &hci_dev_list) {
-                struct hci_dev *d = list_entry(p, struct hci_dev, list);
-
-                hci_del_off_timer(d);
+        list_for_each_entry(d, &hci_dev_list, list) {
+                if (test_and_clear_bit(HCI_AUTO_OFF, &d->flags))
+                        cancel_delayed_work(&d->power_off);
 
                 if (test_bit(HCI_SETUP, &d->flags))
                         continue;
@@ -175,7 +179,8 @@ static int read_controller_info(struct sock *sk, u16 index)
         if (!hdev)
                 return cmd_status(sk, index, MGMT_OP_READ_INFO, ENODEV);
 
-        hci_del_off_timer(hdev);
+        if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->flags))
+                cancel_delayed_work_sync(&hdev->power_off);
 
         hci_dev_lock_bh(hdev);
 
@@ -220,7 +225,8 @@ static void mgmt_pending_free(struct pending_cmd *cmd)
 }
 
 static struct pending_cmd *mgmt_pending_add(struct sock *sk, u16 opcode,
-                                                u16 index, void *data, u16 len)
+                                                        struct hci_dev *hdev,
+                                                        void *data, u16 len)
 {
         struct pending_cmd *cmd;
 
@@ -229,7 +235,7 @@ static struct pending_cmd *mgmt_pending_add(struct sock *sk, u16 opcode,
                 return NULL;
 
         cmd->opcode = opcode;
-        cmd->index = index;
+        cmd->index = hdev->id;
 
         cmd->param = kmalloc(len, GFP_ATOMIC);
         if (!cmd->param) {
@@ -243,48 +249,36 @@ static struct pending_cmd *mgmt_pending_add(struct sock *sk, u16 opcode,
         cmd->sk = sk;
         sock_hold(sk);
 
-        list_add(&cmd->list, &cmd_list);
+        list_add(&cmd->list, &hdev->mgmt_pending);
 
         return cmd;
 }
 
-static void mgmt_pending_foreach(u16 opcode, int index,
+static void mgmt_pending_foreach(u16 opcode, struct hci_dev *hdev,
                                 void (*cb)(struct pending_cmd *cmd, void *data),
                                 void *data)
 {
         struct list_head *p, *n;
 
-        list_for_each_safe(p, n, &cmd_list) {
+        list_for_each_safe(p, n, &hdev->mgmt_pending) {
                 struct pending_cmd *cmd;
 
                 cmd = list_entry(p, struct pending_cmd, list);
 
-                if (cmd->opcode != opcode)
-                        continue;
-
-                if (index >= 0 && cmd->index != index)
+                if (opcode > 0 && cmd->opcode != opcode)
                         continue;
 
                 cb(cmd, data);
         }
 }
 
-static struct pending_cmd *mgmt_pending_find(u16 opcode, int index)
+static struct pending_cmd *mgmt_pending_find(u16 opcode, struct hci_dev *hdev)
 {
-        struct list_head *p;
-
-        list_for_each(p, &cmd_list) {
-                struct pending_cmd *cmd;
-
-                cmd = list_entry(p, struct pending_cmd, list);
-
-                if (cmd->opcode != opcode)
-                        continue;
-
-                if (index >= 0 && cmd->index != index)
-                        continue;
+        struct pending_cmd *cmd;
 
-                return cmd;
+        list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
+                if (cmd->opcode == opcode)
+                        return cmd;
         }
 
         return NULL;
@@ -322,12 +316,12 @@ static int set_powered(struct sock *sk, u16 index, unsigned char *data, u16 len)
                 goto failed;
         }
 
-        if (mgmt_pending_find(MGMT_OP_SET_POWERED, index)) {
+        if (mgmt_pending_find(MGMT_OP_SET_POWERED, hdev)) {
                 err = cmd_status(sk, index, MGMT_OP_SET_POWERED, EBUSY);
                 goto failed;
         }
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, index, data, len);
+        cmd = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
@@ -336,7 +330,7 @@ static int set_powered(struct sock *sk, u16 index, unsigned char *data, u16 len)
         if (cp->val)
                 queue_work(hdev->workqueue, &hdev->power_on);
         else
-                queue_work(hdev->workqueue, &hdev->power_off);
+                queue_work(hdev->workqueue, &hdev->power_off.work);
 
         err = 0;
 
@@ -349,7 +343,7 @@ failed:
 static int set_discoverable(struct sock *sk, u16 index, unsigned char *data,
                                                                         u16 len)
 {
-        struct mgmt_mode *cp;
+        struct mgmt_cp_set_discoverable *cp;
         struct hci_dev *hdev;
         struct pending_cmd *cmd;
         u8 scan;
@@ -373,8 +367,8 @@ static int set_discoverable(struct sock *sk, u16 index, unsigned char *data,
                 goto failed;
         }
 
-        if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, index) ||
-                        mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, index)) {
+        if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
+                        mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
                 err = cmd_status(sk, index, MGMT_OP_SET_DISCOVERABLE, EBUSY);
                 goto failed;
         }
@@ -385,7 +379,7 @@ static int set_discoverable(struct sock *sk, u16 index, unsigned char *data,
                 goto failed;
         }
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, index, data, len);
+        cmd = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
@@ -395,11 +389,16 @@ static int set_discoverable(struct sock *sk, u16 index, unsigned char *data,
 
         if (cp->val)
                 scan |= SCAN_INQUIRY;
+        else
+                cancel_delayed_work(&hdev->discov_off);
 
         err = hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
         if (err < 0)
                 mgmt_pending_remove(cmd);
 
+        if (cp->val)
+                hdev->discov_timeout = get_unaligned_le16(&cp->timeout);
+
 failed:
         hci_dev_unlock_bh(hdev);
         hci_dev_put(hdev);
@@ -434,8 +433,8 @@ static int set_connectable(struct sock *sk, u16 index, unsigned char *data,
                 goto failed;
         }
 
-        if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, index) ||
-                        mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, index)) {
+        if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
+                        mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
                 err = cmd_status(sk, index, MGMT_OP_SET_CONNECTABLE, EBUSY);
                 goto failed;
         }
@@ -445,7 +444,7 @@ static int set_connectable(struct sock *sk, u16 index, unsigned char *data,
                 goto failed;
         }
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, index, data, len);
+        cmd = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
@@ -467,8 +466,8 @@ failed:
         return err;
 }
 
-static int mgmt_event(u16 event, u16 index, void *data, u16 data_len,
-                                                        struct sock *skip_sk)
+static int mgmt_event(u16 event, struct hci_dev *hdev, void *data,
+                                        u16 data_len, struct sock *skip_sk)
 {
         struct sk_buff *skb;
         struct mgmt_hdr *hdr;
@@ -481,7 +480,10 @@ static int mgmt_event(u16 event, u16 index, void *data, u16 data_len,
 
         hdr = (void *) skb_put(skb, sizeof(*hdr));
         hdr->opcode = cpu_to_le16(event);
-        hdr->index = cpu_to_le16(index);
+        if (hdev)
+                hdr->index = cpu_to_le16(hdev->id);
+        else
+                hdr->index = cpu_to_le16(MGMT_INDEX_NONE);
         hdr->len = cpu_to_le16(data_len);
 
         if (data)
@@ -533,7 +535,7 @@ static int set_pairable(struct sock *sk, u16 index, unsigned char *data,
 
         ev.val = cp->val;
 
-        err = mgmt_event(MGMT_EV_PAIRABLE, index, &ev, sizeof(ev), sk);
+        err = mgmt_event(MGMT_EV_PAIRABLE, hdev, &ev, sizeof(ev), sk);
 
 failed:
         hci_dev_unlock_bh(hdev);
@@ -586,7 +588,7 @@ static void create_eir(struct hci_dev *hdev, u8 *data)
         u16 eir_len = 0;
         u16 uuid16_list[HCI_MAX_EIR_LENGTH / sizeof(u16)];
         int i, truncated = 0;
-        struct list_head *p;
+        struct bt_uuid *uuid;
         size_t name_len;
 
         name_len = strlen(hdev->dev_name);
@@ -611,8 +613,7 @@ static void create_eir(struct hci_dev *hdev, u8 *data)
         memset(uuid16_list, 0, sizeof(uuid16_list));
 
         /* Group all UUID16 types */
-        list_for_each(p, &hdev->uuids) {
-                struct bt_uuid *uuid = list_entry(p, struct bt_uuid, list);
+        list_for_each_entry(uuid, &hdev->uuids, list) {
                 u16 uuid16;
 
                 uuid16 = get_uuid16(uuid->uuid);
@@ -688,14 +689,11 @@ static int update_eir(struct hci_dev *hdev)
 
 static u8 get_service_classes(struct hci_dev *hdev)
 {
-        struct list_head *p;
+        struct bt_uuid *uuid;
         u8 val = 0;
 
-        list_for_each(p, &hdev->uuids) {
-                struct bt_uuid *uuid = list_entry(p, struct bt_uuid, list);
-
+        list_for_each_entry(uuid, &hdev->uuids, list)
                 val |= uuid->svc_hint;
-        }
 
         return val;
 }
@@ -894,6 +892,9 @@ static int set_service_cache(struct sock *sk, u16 index,  unsigned char *data,
         if (err == 0)
                 err = cmd_complete(sk, index, MGMT_OP_SET_SERVICE_CACHE, NULL,
                                                                         0);
+        else
+                cmd_status(sk, index, MGMT_OP_SET_SERVICE_CACHE, -err);
+
 
         hci_dev_unlock_bh(hdev);
         hci_dev_put(hdev);
@@ -901,30 +902,32 @@ static int set_service_cache(struct sock *sk, u16 index,  unsigned char *data,
         return err;
 }
 
-static int load_keys(struct sock *sk, u16 index, unsigned char *data, u16 len)
+static int load_link_keys(struct sock *sk, u16 index, unsigned char *data,
+                                                                u16 len)
 {
         struct hci_dev *hdev;
-        struct mgmt_cp_load_keys *cp;
+        struct mgmt_cp_load_link_keys *cp;
         u16 key_count, expected_len;
         int i;
 
         cp = (void *) data;
 
         if (len < sizeof(*cp))
-                return -EINVAL;
+                return cmd_status(sk, index, MGMT_OP_LOAD_LINK_KEYS, EINVAL);
 
         key_count = get_unaligned_le16(&cp->key_count);
 
-        expected_len = sizeof(*cp) + key_count * sizeof(struct mgmt_key_info);
+        expected_len = sizeof(*cp) + key_count *
+                                        sizeof(struct mgmt_link_key_info);
         if (expected_len != len) {
-                BT_ERR("load_keys: expected %u bytes, got %u bytes",
+                BT_ERR("load_link_keys: expected %u bytes, got %u bytes",
                                                         len, expected_len);
-                return -EINVAL;
+                return cmd_status(sk, index, MGMT_OP_LOAD_LINK_KEYS, EINVAL);
         }
 
         hdev = hci_dev_get(index);
         if (!hdev)
-                return cmd_status(sk, index, MGMT_OP_LOAD_KEYS, ENODEV);
+                return cmd_status(sk, index, MGMT_OP_LOAD_LINK_KEYS, ENODEV);
 
         BT_DBG("hci%u debug_keys %u key_count %u", index, cp->debug_keys,
                                                                 key_count);
@@ -941,7 +944,7 @@ static int load_keys(struct sock *sk, u16 index, unsigned char *data, u16 len)
                 clear_bit(HCI_DEBUG_KEYS, &hdev->flags);
 
         for (i = 0; i < key_count; i++) {
-                struct mgmt_key_info *key = &cp->keys[i];
+                struct mgmt_link_key_info *key = &cp->keys[i];
 
                 hci_add_link_key(hdev, NULL, 0, &key->bdaddr, key->val, key->type,
                                                                 key->pin_len);
@@ -953,27 +956,28 @@ static int load_keys(struct sock *sk, u16 index, unsigned char *data, u16 len)
         return 0;
 }
 
-static int remove_key(struct sock *sk, u16 index, unsigned char *data, u16 len)
+static int remove_keys(struct sock *sk, u16 index, unsigned char *data,
+                                                                u16 len)
 {
         struct hci_dev *hdev;
-        struct mgmt_cp_remove_key *cp;
+        struct mgmt_cp_remove_keys *cp;
         struct hci_conn *conn;
         int err;
 
         cp = (void *) data;
 
         if (len != sizeof(*cp))
-                return cmd_status(sk, index, MGMT_OP_REMOVE_KEY, EINVAL);
+                return cmd_status(sk, index, MGMT_OP_REMOVE_KEYS, EINVAL);
 
         hdev = hci_dev_get(index);
         if (!hdev)
-                return cmd_status(sk, index, MGMT_OP_REMOVE_KEY, ENODEV);
+                return cmd_status(sk, index, MGMT_OP_REMOVE_KEYS, ENODEV);
 
         hci_dev_lock_bh(hdev);
 
         err = hci_remove_link_key(hdev, &cp->bdaddr);
         if (err < 0) {
-                err = cmd_status(sk, index, MGMT_OP_REMOVE_KEY, -err);
+                err = cmd_status(sk, index, MGMT_OP_REMOVE_KEYS, -err);
                 goto unlock;
         }
 
@@ -1025,7 +1029,7 @@ static int disconnect(struct sock *sk, u16 index, unsigned char *data, u16 len)
                 goto failed;
         }
 
-        if (mgmt_pending_find(MGMT_OP_DISCONNECT, index)) {
+        if (mgmt_pending_find(MGMT_OP_DISCONNECT, hdev)) {
                 err = cmd_status(sk, index, MGMT_OP_DISCONNECT, EBUSY);
                 goto failed;
         }
@@ -1039,7 +1043,7 @@ static int disconnect(struct sock *sk, u16 index, unsigned char *data, u16 len)
                 goto failed;
         }
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, index, data, len);
+        cmd = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
@@ -1059,10 +1063,23 @@ failed:
         return err;
 }
 
+static u8 link_to_mgmt(u8 link_type)
+{
+        switch (link_type) {
+        case LE_LINK:
+                return MGMT_ADDR_LE;
+        case ACL_LINK:
+                return MGMT_ADDR_BREDR;
+        default:
+                return MGMT_ADDR_INVALID;
+        }
+}
+
 static int get_connections(struct sock *sk, u16 index)
 {
         struct mgmt_rp_get_connections *rp;
         struct hci_dev *hdev;
+        struct hci_conn *c;
         struct list_head *p;
         size_t rp_len;
         u16 count;
@@ -1081,7 +1098,7 @@ static int get_connections(struct sock *sk, u16 index)
                 count++;
         }
 
-        rp_len = sizeof(*rp) + (count * sizeof(bdaddr_t));
+        rp_len = sizeof(*rp) + (count * sizeof(struct mgmt_addr_info));
         rp = kmalloc(rp_len, GFP_ATOMIC);
         if (!rp) {
                 err = -ENOMEM;
@@ -1091,12 +1108,17 @@ static int get_connections(struct sock *sk, u16 index)
         put_unaligned_le16(count, &rp->conn_count);
 
         i = 0;
-        list_for_each(p, &hdev->conn_hash.list) {
-                struct hci_conn *c = list_entry(p, struct hci_conn, list);
-
-                bacpy(&rp->conn[i++], &c->dst);
+        list_for_each_entry(c, &hdev->conn_hash.list, list) {
+                bacpy(&rp->addr[i].bdaddr, &c->dst);
+                rp->addr[i].type = link_to_mgmt(c->type);
+                if (rp->addr[i].type == MGMT_ADDR_INVALID)
+                        continue;
+                i++;
         }
 
+        /* Recalculate length in case of filtered SCO connections, etc */
+        rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info));
+
         err = cmd_complete(sk, index, MGMT_OP_GET_CONNECTIONS, rp, rp_len);
 
 unlock:
@@ -1112,7 +1134,7 @@ static int send_pin_code_neg_reply(struct sock *sk, u16 index,
         struct pending_cmd *cmd;
         int err;
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_NEG_REPLY, index, cp,
+        cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_NEG_REPLY, hdev, cp,
                                                                 sizeof(*cp));
         if (!cmd)
                 return -ENOMEM;
@@ -1173,7 +1195,7 @@ static int pin_code_reply(struct sock *sk, u16 index, unsigned char *data,
                 goto failed;
         }
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_REPLY, index, data, len);
+        cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_REPLY, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
@@ -1264,19 +1286,12 @@ static int set_io_capability(struct sock *sk, u16 index, unsigned char *data,
 static inline struct pending_cmd *find_pairing(struct hci_conn *conn)
 {
         struct hci_dev *hdev = conn->hdev;
-        struct list_head *p;
-
-        list_for_each(p, &cmd_list) {
-                struct pending_cmd *cmd;
-
-                cmd = list_entry(p, struct pending_cmd, list);
+        struct pending_cmd *cmd;
 
+        list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
                 if (cmd->opcode != MGMT_OP_PAIR_DEVICE)
                         continue;
 
-                if (cmd->index != hdev->id)
-                        continue;
-
                 if (cmd->user_data != conn)
                         continue;
 
@@ -1309,16 +1324,19 @@ static void pairing_complete(struct pending_cmd *cmd, u8 status)
 static void pairing_complete_cb(struct hci_conn *conn, u8 status)
 {
         struct pending_cmd *cmd;
+        struct hci_dev *hdev = conn->hdev;
 
         BT_DBG("status %u", status);
 
+        hci_dev_lock_bh(hdev);
+
         cmd = find_pairing(conn);
-        if (!cmd) {
+        if (!cmd)
                 BT_DBG("Unable to find a pending command");
-                return;
-        }
+        else
+                pairing_complete(cmd, status);
 
-        pairing_complete(cmd, status);
+        hci_dev_unlock_bh(hdev);
 }
 
 static int pair_device(struct sock *sk, u16 index, unsigned char *data, u16 len)
@@ -1369,7 +1387,7 @@ static int pair_device(struct sock *sk, u16 index, unsigned char *data, u16 len)
                 goto unlock;
         }
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_PAIR_DEVICE, index, data, len);
+        cmd = mgmt_pending_add(sk, MGMT_OP_PAIR_DEVICE, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 hci_conn_put(conn);
@@ -1431,7 +1449,7 @@ static int user_confirm_reply(struct sock *sk, u16 index, unsigned char *data,
                 goto failed;
         }
 
-        cmd = mgmt_pending_add(sk, mgmt_op, index, data, len);
+        cmd = mgmt_pending_add(sk, mgmt_op, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
@@ -1468,7 +1486,7 @@ static int set_local_name(struct sock *sk, u16 index, unsigned char *data,
 
         hci_dev_lock_bh(hdev);
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_SET_LOCAL_NAME, index, data, len);
+        cmd = mgmt_pending_add(sk, MGMT_OP_SET_LOCAL_NAME, hdev, data, len);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
@@ -1514,12 +1532,12 @@ static int read_local_oob_data(struct sock *sk, u16 index)
                 goto unlock;
         }
 
-        if (mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, index)) {
+        if (mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev)) {
                 err = cmd_status(sk, index, MGMT_OP_READ_LOCAL_OOB_DATA, EBUSY);
                 goto unlock;
         }
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_READ_LOCAL_OOB_DATA, index, NULL, 0);
+        cmd = mgmt_pending_add(sk, MGMT_OP_READ_LOCAL_OOB_DATA, hdev, NULL, 0);
         if (!cmd) {
                 err = -ENOMEM;
                 goto unlock;
@@ -1606,8 +1624,6 @@ static int remove_remote_oob_data(struct sock *sk, u16 index,
 
 static int start_discovery(struct sock *sk, u16 index)
 {
-        u8 lap[3] = { 0x33, 0x8b, 0x9e };
-        struct hci_cp_inquiry cp;
         struct pending_cmd *cmd;
         struct hci_dev *hdev;
         int err;
@@ -1620,18 +1636,18 @@ static int start_discovery(struct sock *sk, u16 index)
 
         hci_dev_lock_bh(hdev);
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_START_DISCOVERY, index, NULL, 0);
+        if (!test_bit(HCI_UP, &hdev->flags)) {
+                err = cmd_status(sk, index, MGMT_OP_START_DISCOVERY, ENETDOWN);
+                goto failed;
+        }
+
+        cmd = mgmt_pending_add(sk, MGMT_OP_START_DISCOVERY, hdev, NULL, 0);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
         }
 
-        memset(&cp, 0, sizeof(cp));
-        memcpy(&cp.lap, lap, 3);
-        cp.length  = 0x08;
-        cp.num_rsp = 0x00;
-
-        err = hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp);
+        err = hci_do_inquiry(hdev, INQUIRY_LEN_BREDR);
         if (err < 0)
                 mgmt_pending_remove(cmd);
 
@@ -1656,13 +1672,13 @@ static int stop_discovery(struct sock *sk, u16 index)
 
         hci_dev_lock_bh(hdev);
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_STOP_DISCOVERY, index, NULL, 0);
+        cmd = mgmt_pending_add(sk, MGMT_OP_STOP_DISCOVERY, hdev, NULL, 0);
         if (!cmd) {
                 err = -ENOMEM;
                 goto failed;
         }
 
-        err = hci_send_cmd(hdev, HCI_OP_INQUIRY_CANCEL, 0, NULL);
+        err = hci_cancel_inquiry(hdev);
         if (err < 0)
                 mgmt_pending_remove(cmd);
 
@@ -1677,7 +1693,6 @@ static int block_device(struct sock *sk, u16 index, unsigned char *data,
                                                                 u16 len)
 {
         struct hci_dev *hdev;
-        struct pending_cmd *cmd;
         struct mgmt_cp_block_device *cp = (void *) data;
         int err;
 
@@ -1694,23 +1709,13 @@ static int block_device(struct sock *sk, u16 index, unsigned char *data,
 
         hci_dev_lock_bh(hdev);
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_BLOCK_DEVICE, index, NULL, 0);
-        if (!cmd) {
-                err = -ENOMEM;
-                goto failed;
-        }
-
         err = hci_blacklist_add(hdev, &cp->bdaddr);
-
         if (err < 0)
                 err = cmd_status(sk, index, MGMT_OP_BLOCK_DEVICE, -err);
         else
                 err = cmd_complete(sk, index, MGMT_OP_BLOCK_DEVICE,
                                                         NULL, 0);
 
-        mgmt_pending_remove(cmd);
-
-failed:
         hci_dev_unlock_bh(hdev);
         hci_dev_put(hdev);
 
@@ -1721,7 +1726,6 @@ static int unblock_device(struct sock *sk, u16 index, unsigned char *data,
                                                                 u16 len)
 {
         struct hci_dev *hdev;
-        struct pending_cmd *cmd;
         struct mgmt_cp_unblock_device *cp = (void *) data;
         int err;
 
@@ -1738,12 +1742,6 @@ static int unblock_device(struct sock *sk, u16 index, unsigned char *data,
 
         hci_dev_lock_bh(hdev);
 
-        cmd = mgmt_pending_add(sk, MGMT_OP_UNBLOCK_DEVICE, index, NULL, 0);
-        if (!cmd) {
-                err = -ENOMEM;
-                goto failed;
-        }
-
         err = hci_blacklist_del(hdev, &cp->bdaddr);
 
         if (err < 0)
@@ -1752,9 +1750,6 @@ static int unblock_device(struct sock *sk, u16 index, unsigned char *data,
                 err = cmd_complete(sk, index, MGMT_OP_UNBLOCK_DEVICE,
                                                                 NULL, 0);
 
-        mgmt_pending_remove(cmd);
-
-failed:
         hci_dev_unlock_bh(hdev);
         hci_dev_put(hdev);
 
@@ -1882,11 +1877,11 @@ int mgmt_control(struct sock *sk, struct msghdr *msg, size_t msglen)
         case MGMT_OP_SET_SERVICE_CACHE:
                 err = set_service_cache(sk, index, buf + sizeof(*hdr), len);
                 break;
-        case MGMT_OP_LOAD_KEYS:
-                err = load_keys(sk, index, buf + sizeof(*hdr), len);
+        case MGMT_OP_LOAD_LINK_KEYS:
+                err = load_link_keys(sk, index, buf + sizeof(*hdr), len);
                 break;
-        case MGMT_OP_REMOVE_KEY:
-                err = remove_key(sk, index, buf + sizeof(*hdr), len);
+        case MGMT_OP_REMOVE_KEYS:
+                err = remove_keys(sk, index, buf + sizeof(*hdr), len);
                 break;
         case MGMT_OP_DISCONNECT:
                 err = disconnect(sk, index, buf + sizeof(*hdr), len);
@@ -1957,14 +1952,26 @@ done:
         return err;
 }
 
-int mgmt_index_added(u16 index)
+static void cmd_status_rsp(struct pending_cmd *cmd, void *data)
 {
-        return mgmt_event(MGMT_EV_INDEX_ADDED, index, NULL, 0, NULL);
+        u8 *status = data;
+
+        cmd_status(cmd->sk, cmd->index, cmd->opcode, *status);
+        mgmt_pending_remove(cmd);
 }
 
-int mgmt_index_removed(u16 index)
+int mgmt_index_added(struct hci_dev *hdev)
 {
-        return mgmt_event(MGMT_EV_INDEX_REMOVED, index, NULL, 0, NULL);
+        return mgmt_event(MGMT_EV_INDEX_ADDED, hdev, NULL, 0, NULL);
+}
+
+int mgmt_index_removed(struct hci_dev *hdev)
+{
+        u8 status = ENODEV;
+
+        mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status);
+
+        return mgmt_event(MGMT_EV_INDEX_REMOVED, hdev, NULL, 0, NULL);
 }
 
 struct cmd_lookup {
@@ -1992,17 +1999,22 @@ static void mode_rsp(struct pending_cmd *cmd, void *data)
         mgmt_pending_free(cmd);
 }
 
-int mgmt_powered(u16 index, u8 powered)
+int mgmt_powered(struct hci_dev *hdev, u8 powered)
 {
         struct mgmt_mode ev;
         struct cmd_lookup match = { powered, NULL };
         int ret;
 
-        mgmt_pending_foreach(MGMT_OP_SET_POWERED, index, mode_rsp, &match);
+        mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, mode_rsp, &match);
+
+        if (!powered) {
+                u8 status = ENETDOWN;
+                mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status);
+        }
 
         ev.val = powered;
 
-        ret = mgmt_event(MGMT_EV_POWERED, index, &ev, sizeof(ev), match.sk);
+        ret = mgmt_event(MGMT_EV_POWERED, hdev, &ev, sizeof(ev), match.sk);
 
         if (match.sk)
                 sock_put(match.sk);
@@ -2010,17 +2022,17 @@ int mgmt_powered(u16 index, u8 powered)
         return ret;
 }
 
-int mgmt_discoverable(u16 index, u8 discoverable)
+int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable)
 {
         struct mgmt_mode ev;
         struct cmd_lookup match = { discoverable, NULL };
         int ret;
 
-        mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, index, mode_rsp, &match);
+        mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, hdev, mode_rsp, &match);
 
         ev.val = discoverable;
 
-        ret = mgmt_event(MGMT_EV_DISCOVERABLE, index, &ev, sizeof(ev),
+        ret = mgmt_event(MGMT_EV_DISCOVERABLE, hdev, &ev, sizeof(ev),
                                                                 match.sk);
 
         if (match.sk)
@@ -2029,17 +2041,17 @@ int mgmt_discoverable(u16 index, u8 discoverable)
         return ret;
 }
 
-int mgmt_connectable(u16 index, u8 connectable)
+int mgmt_connectable(struct hci_dev *hdev, u8 connectable)
 {
         struct mgmt_mode ev;
         struct cmd_lookup match = { connectable, NULL };
         int ret;
 
-        mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, index, mode_rsp, &match);
+        mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, hdev, mode_rsp, &match);
 
         ev.val = connectable;
 
-        ret = mgmt_event(MGMT_EV_CONNECTABLE, index, &ev, sizeof(ev), match.sk);
+        ret = mgmt_event(MGMT_EV_CONNECTABLE, hdev, &ev, sizeof(ev), match.sk);
 
         if (match.sk)
                 sock_put(match.sk);
@@ -2047,9 +2059,23 @@ int mgmt_connectable(u16 index, u8 connectable)
         return ret;
 }
 
-int mgmt_new_key(u16 index, struct link_key *key, u8 persistent)
+int mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status)
+{
+        if (scan & SCAN_PAGE)
+                mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, hdev,
+                                                cmd_status_rsp, &status);
+
+        if (scan & SCAN_INQUIRY)
+                mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, hdev,
+                                                cmd_status_rsp, &status);
+
+        return 0;
+}
+
+int mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
+                                                                u8 persistent)
 {
-        struct mgmt_ev_new_key ev;
+        struct mgmt_ev_new_link_key ev;
 
         memset(&ev, 0, sizeof(ev));
 
@@ -2059,17 +2085,17 @@ int mgmt_new_key(u16 index, struct link_key *key, u8 persistent)
         memcpy(ev.key.val, key->val, 16);
         ev.key.pin_len = key->pin_len;
 
-        return mgmt_event(MGMT_EV_NEW_KEY, index, &ev, sizeof(ev), NULL);
+        return mgmt_event(MGMT_EV_NEW_LINK_KEY, hdev, &ev, sizeof(ev), NULL);
 }
 
-int mgmt_connected(u16 index, bdaddr_t *bdaddr, u8 link_type)
+int mgmt_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type)
 {
-        struct mgmt_ev_connected ev;
+        struct mgmt_addr_info ev;
 
         bacpy(&ev.bdaddr, bdaddr);
-        ev.link_type = link_type;
+        ev.type = link_to_mgmt(link_type);
 
-        return mgmt_event(MGMT_EV_CONNECTED, index, &ev, sizeof(ev), NULL);
+        return mgmt_event(MGMT_EV_CONNECTED, hdev, &ev, sizeof(ev), NULL);
 }
 
 static void disconnect_rsp(struct pending_cmd *cmd, void *data)
@@ -2088,17 +2114,18 @@ static void disconnect_rsp(struct pending_cmd *cmd, void *data)
         mgmt_pending_remove(cmd);
 }
 
-int mgmt_disconnected(u16 index, bdaddr_t *bdaddr)
+int mgmt_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
 {
-        struct mgmt_ev_disconnected ev;
+        struct mgmt_addr_info ev;
         struct sock *sk = NULL;
         int err;
 
-        mgmt_pending_foreach(MGMT_OP_DISCONNECT, index, disconnect_rsp, &sk);
+        mgmt_pending_foreach(MGMT_OP_DISCONNECT, hdev, disconnect_rsp, &sk);
 
         bacpy(&ev.bdaddr, bdaddr);
+        ev.type = link_to_mgmt(type);
 
-        err = mgmt_event(MGMT_EV_DISCONNECTED, index, &ev, sizeof(ev), sk);
+        err = mgmt_event(MGMT_EV_DISCONNECTED, hdev, &ev, sizeof(ev), sk);
 
         if (sk)
                 sock_put(sk);
@@ -2106,57 +2133,60 @@ int mgmt_disconnected(u16 index, bdaddr_t *bdaddr)
         return err;
 }
 
-int mgmt_disconnect_failed(u16 index)
+int mgmt_disconnect_failed(struct hci_dev *hdev)
 {
         struct pending_cmd *cmd;
         int err;
 
-        cmd = mgmt_pending_find(MGMT_OP_DISCONNECT, index);
+        cmd = mgmt_pending_find(MGMT_OP_DISCONNECT, hdev);
         if (!cmd)
                 return -ENOENT;
 
-        err = cmd_status(cmd->sk, index, MGMT_OP_DISCONNECT, EIO);
+        err = cmd_status(cmd->sk, hdev->id, MGMT_OP_DISCONNECT, EIO);
 
         mgmt_pending_remove(cmd);
 
         return err;
 }
 
-int mgmt_connect_failed(u16 index, bdaddr_t *bdaddr, u8 status)
+int mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type,
+                                                                u8 status)
 {
         struct mgmt_ev_connect_failed ev;
 
-        bacpy(&ev.bdaddr, bdaddr);
+        bacpy(&ev.addr.bdaddr, bdaddr);
+        ev.addr.type = link_to_mgmt(type);
         ev.status = status;
 
-        return mgmt_event(MGMT_EV_CONNECT_FAILED, index, &ev, sizeof(ev), NULL);
+        return mgmt_event(MGMT_EV_CONNECT_FAILED, hdev, &ev, sizeof(ev), NULL);
 }
 
-int mgmt_pin_code_request(u16 index, bdaddr_t *bdaddr, u8 secure)
+int mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure)
 {
         struct mgmt_ev_pin_code_request ev;
 
         bacpy(&ev.bdaddr, bdaddr);
         ev.secure = secure;
 
-        return mgmt_event(MGMT_EV_PIN_CODE_REQUEST, index, &ev, sizeof(ev),
+        return mgmt_event(MGMT_EV_PIN_CODE_REQUEST, hdev, &ev, sizeof(ev),
                                                                         NULL);
 }
 
-int mgmt_pin_code_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status)
+int mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                                                u8 status)
 {
         struct pending_cmd *cmd;
         struct mgmt_rp_pin_code_reply rp;
         int err;
 
-        cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_REPLY, index);
+        cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_REPLY, hdev);
         if (!cmd)
                 return -ENOENT;
 
         bacpy(&rp.bdaddr, bdaddr);
         rp.status = status;
 
-        err = cmd_complete(cmd->sk, index, MGMT_OP_PIN_CODE_REPLY, &rp,
+        err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_REPLY, &rp,
                                                                 sizeof(rp));
 
         mgmt_pending_remove(cmd);
@@ -2164,20 +2194,21 @@ int mgmt_pin_code_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status)
         return err;
 }
 
-int mgmt_pin_code_neg_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status)
+int mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                                                u8 status)
 {
         struct pending_cmd *cmd;
         struct mgmt_rp_pin_code_reply rp;
         int err;
 
-        cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_NEG_REPLY, index);
+        cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_NEG_REPLY, hdev);
         if (!cmd)
                 return -ENOENT;
 
         bacpy(&rp.bdaddr, bdaddr);
         rp.status = status;
 
-        err = cmd_complete(cmd->sk, index, MGMT_OP_PIN_CODE_NEG_REPLY, &rp,
+        err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_NEG_REPLY, &rp,
                                                                 sizeof(rp));
 
         mgmt_pending_remove(cmd);
@@ -2185,97 +2216,93 @@ int mgmt_pin_code_neg_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status)
         return err;
 }
 
-int mgmt_user_confirm_request(u16 index, bdaddr_t *bdaddr, __le32 value,
-                                                        u8 confirm_hint)
+int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                                __le32 value, u8 confirm_hint)
 {
         struct mgmt_ev_user_confirm_request ev;
 
-        BT_DBG("hci%u", index);
+        BT_DBG("%s", hdev->name);
 
         bacpy(&ev.bdaddr, bdaddr);
         ev.confirm_hint = confirm_hint;
         put_unaligned_le32(value, &ev.value);
 
-        return mgmt_event(MGMT_EV_USER_CONFIRM_REQUEST, index, &ev, sizeof(ev),
+        return mgmt_event(MGMT_EV_USER_CONFIRM_REQUEST, hdev, &ev, sizeof(ev),
                                                                         NULL);
 }
 
-static int confirm_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status,
-                                                                u8 opcode)
+static int confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                                        u8 status, u8 opcode)
 {
         struct pending_cmd *cmd;
         struct mgmt_rp_user_confirm_reply rp;
         int err;
 
-        cmd = mgmt_pending_find(opcode, index);
+        cmd = mgmt_pending_find(opcode, hdev);
         if (!cmd)
                 return -ENOENT;
 
         bacpy(&rp.bdaddr, bdaddr);
         rp.status = status;
-        err = cmd_complete(cmd->sk, index, opcode, &rp, sizeof(rp));
+        err = cmd_complete(cmd->sk, hdev->id, opcode, &rp, sizeof(rp));
 
         mgmt_pending_remove(cmd);
 
         return err;
 }
 
-int mgmt_user_confirm_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status)
+int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                                                u8 status)
 {
-        return confirm_reply_complete(index, bdaddr, status,
+        return confirm_reply_complete(hdev, bdaddr, status,
                                                 MGMT_OP_USER_CONFIRM_REPLY);
 }
 
-int mgmt_user_confirm_neg_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status)
+int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev,
+                                                bdaddr_t *bdaddr, u8 status)
 {
-        return confirm_reply_complete(index, bdaddr, status,
+        return confirm_reply_complete(hdev, bdaddr, status,
                                         MGMT_OP_USER_CONFIRM_NEG_REPLY);
 }
 
-int mgmt_auth_failed(u16 index, bdaddr_t *bdaddr, u8 status)
+int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 status)
 {
         struct mgmt_ev_auth_failed ev;
 
         bacpy(&ev.bdaddr, bdaddr);
         ev.status = status;
 
-        return mgmt_event(MGMT_EV_AUTH_FAILED, index, &ev, sizeof(ev), NULL);
+        return mgmt_event(MGMT_EV_AUTH_FAILED, hdev, &ev, sizeof(ev), NULL);
 }
 
-int mgmt_set_local_name_complete(u16 index, u8 *name, u8 status)
+int mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status)
 {
         struct pending_cmd *cmd;
-        struct hci_dev *hdev;
         struct mgmt_cp_set_local_name ev;
         int err;
 
         memset(&ev, 0, sizeof(ev));
         memcpy(ev.name, name, HCI_MAX_NAME_LENGTH);
 
-        cmd = mgmt_pending_find(MGMT_OP_SET_LOCAL_NAME, index);
+        cmd = mgmt_pending_find(MGMT_OP_SET_LOCAL_NAME, hdev);
         if (!cmd)
                 goto send_event;
 
         if (status) {
-                err = cmd_status(cmd->sk, index, MGMT_OP_SET_LOCAL_NAME, EIO);
+                err = cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME,
+                                                                        EIO);
                 goto failed;
         }
 
-        hdev = hci_dev_get(index);
-        if (hdev) {
-                hci_dev_lock_bh(hdev);
-                update_eir(hdev);
-                hci_dev_unlock_bh(hdev);
-                hci_dev_put(hdev);
-        }
+        update_eir(hdev);
 
-        err = cmd_complete(cmd->sk, index, MGMT_OP_SET_LOCAL_NAME, &ev,
+        err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, &ev,
                                                                 sizeof(ev));
         if (err < 0)
                 goto failed;
 
 send_event:
-        err = mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, index, &ev, sizeof(ev),
+        err = mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, &ev, sizeof(ev),
                                                         cmd ? cmd->sk : NULL);
 
 failed:
@@ -2284,29 +2311,30 @@ failed:
         return err;
 }
 
-int mgmt_read_local_oob_data_reply_complete(u16 index, u8 *hash, u8 *randomizer,
-                                                                u8 status)
+int mgmt_read_local_oob_data_reply_complete(struct hci_dev *hdev, u8 *hash,
+                                                u8 *randomizer, u8 status)
 {
         struct pending_cmd *cmd;
         int err;
 
-        BT_DBG("hci%u status %u", index, status);
+        BT_DBG("%s status %u", hdev->name, status);
 
-        cmd = mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, index);
+        cmd = mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev);
         if (!cmd)
                 return -ENOENT;
 
         if (status) {
-                err = cmd_status(cmd->sk, index, MGMT_OP_READ_LOCAL_OOB_DATA,
-                                                                        EIO);
+                err = cmd_status(cmd->sk, hdev->id,
+                                        MGMT_OP_READ_LOCAL_OOB_DATA, EIO);
         } else {
                 struct mgmt_rp_read_local_oob_data rp;
 
                 memcpy(rp.hash, hash, sizeof(rp.hash));
                 memcpy(rp.randomizer, randomizer, sizeof(rp.randomizer));
 
-                err = cmd_complete(cmd->sk, index, MGMT_OP_READ_LOCAL_OOB_DATA,
-                                                        &rp, sizeof(rp));
+                err = cmd_complete(cmd->sk, hdev->id,
+                                                MGMT_OP_READ_LOCAL_OOB_DATA,
+                                                &rp, sizeof(rp));
         }
 
         mgmt_pending_remove(cmd);
@@ -2314,14 +2342,15 @@ int mgmt_read_local_oob_data_reply_complete(u16 index, u8 *hash, u8 *randomizer,
         return err;
 }
 
-int mgmt_device_found(u16 index, bdaddr_t *bdaddr, u8 *dev_class, s8 rssi,
-                                                                u8 *eir)
+int mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type,
+                                        u8 *dev_class, s8 rssi, u8 *eir)
 {
         struct mgmt_ev_device_found ev;
 
         memset(&ev, 0, sizeof(ev));
 
-        bacpy(&ev.bdaddr, bdaddr);
+        bacpy(&ev.addr.bdaddr, bdaddr);
+        ev.addr.type = link_to_mgmt(type);
         ev.rssi = rssi;
 
         if (eir)
@@ -2330,10 +2359,10 @@ int mgmt_device_found(u16 index, bdaddr_t *bdaddr, u8 *dev_class, s8 rssi,
         if (dev_class)
                 memcpy(ev.dev_class, dev_class, sizeof(ev.dev_class));
 
-        return mgmt_event(MGMT_EV_DEVICE_FOUND, index, &ev, sizeof(ev), NULL);
+        return mgmt_event(MGMT_EV_DEVICE_FOUND, hdev, &ev, sizeof(ev), NULL);
 }
 
-int mgmt_remote_name(u16 index, bdaddr_t *bdaddr, u8 *name)
+int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *name)
 {
         struct mgmt_ev_remote_name ev;
 
@@ -2342,37 +2371,64 @@ int mgmt_remote_name(u16 index, bdaddr_t *bdaddr, u8 *name)
         bacpy(&ev.bdaddr, bdaddr);
         memcpy(ev.name, name, HCI_MAX_NAME_LENGTH);
 
-        return mgmt_event(MGMT_EV_REMOTE_NAME, index, &ev, sizeof(ev), NULL);
+        return mgmt_event(MGMT_EV_REMOTE_NAME, hdev, &ev, sizeof(ev), NULL);
 }
 
-int mgmt_discovering(u16 index, u8 discovering)
+int mgmt_inquiry_failed(struct hci_dev *hdev, u8 status)
 {
-        return mgmt_event(MGMT_EV_DISCOVERING, index, &discovering,
+        struct pending_cmd *cmd;
+        int err;
+
+        cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
+        if (!cmd)
+                return -ENOENT;
+
+        err = cmd_status(cmd->sk, hdev->id, cmd->opcode, status);
+        mgmt_pending_remove(cmd);
+
+        return err;
+}
+
+int mgmt_discovering(struct hci_dev *hdev, u8 discovering)
+{
+        struct pending_cmd *cmd;
+
+        if (discovering)
+                cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
+        else
+                cmd = mgmt_pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
+
+        if (cmd != NULL) {
+                cmd_complete(cmd->sk, hdev->id, cmd->opcode, NULL, 0);
+                mgmt_pending_remove(cmd);
+        }
+
+        return mgmt_event(MGMT_EV_DISCOVERING, hdev, &discovering,
                                                 sizeof(discovering), NULL);
 }
 
-int mgmt_device_blocked(u16 index, bdaddr_t *bdaddr)
+int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr)
 {
         struct pending_cmd *cmd;
         struct mgmt_ev_device_blocked ev;
 
-        cmd = mgmt_pending_find(MGMT_OP_BLOCK_DEVICE, index);
+        cmd = mgmt_pending_find(MGMT_OP_BLOCK_DEVICE, hdev);
 
         bacpy(&ev.bdaddr, bdaddr);
 
-        return mgmt_event(MGMT_EV_DEVICE_BLOCKED, index, &ev, sizeof(ev),
-                                                cmd ? cmd->sk : NULL);
+        return mgmt_event(MGMT_EV_DEVICE_BLOCKED, hdev, &ev, sizeof(ev),
+                                                        cmd ? cmd->sk : NULL);
 }
 
-int mgmt_device_unblocked(u16 index, bdaddr_t *bdaddr)
+int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr)
 {
         struct pending_cmd *cmd;
         struct mgmt_ev_device_unblocked ev;
 
-        cmd = mgmt_pending_find(MGMT_OP_UNBLOCK_DEVICE, index);
+        cmd = mgmt_pending_find(MGMT_OP_UNBLOCK_DEVICE, hdev);
 
         bacpy(&ev.bdaddr, bdaddr);
 
-        return mgmt_event(MGMT_EV_DEVICE_UNBLOCKED, index, &ev, sizeof(ev),
-                                                cmd ? cmd->sk : NULL);
+        return mgmt_event(MGMT_EV_DEVICE_UNBLOCKED, hdev, &ev, sizeof(ev),
+                                                        cmd ? cmd->sk : NULL);
 }