Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / net / bluetooth / hci_core.c
index aeb2982..815269b 100644 (file)
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 #include <linux/rfkill.h>
+#include <linux/timer.h>
 #include <net/sock.h>
 
 #include <asm/system.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/unaligned.h>
 
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>
 
+#define AUTO_OFF_TIMEOUT 2000
+
 static void hci_cmd_task(unsigned long arg);
 static void hci_rx_task(unsigned long arg);
 static void hci_tx_task(unsigned long arg);
-static void hci_notify(struct hci_dev *hdev, int event);
 
 static DEFINE_RWLOCK(hci_task_lock);
 
@@ -91,9 +93,15 @@ static void hci_notify(struct hci_dev *hdev, int event)
 
 /* ---- HCI requests ---- */
 
-void hci_req_complete(struct hci_dev *hdev, int result)
+void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result)
 {
-       BT_DBG("%s result 0x%2.2x", hdev->name, result);
+       BT_DBG("%s command 0x%04x result 0x%2.2x", hdev->name, cmd, result);
+
+       /* If this is the init phase check if the completed command matches
+        * the last init command, and if not just return.
+        */
+       if (test_bit(HCI_INIT, &hdev->flags) && hdev->init_last_cmd != cmd)
+               return;
 
        if (hdev->req_status == HCI_REQ_PEND) {
                hdev->req_result = result;
@@ -115,7 +123,7 @@ static void hci_req_cancel(struct hci_dev *hdev, int err)
 
 /* Execute request and wait for completion. */
 static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt),
-                               unsigned long opt, __u32 timeout)
+                                       unsigned long opt, __u32 timeout)
 {
        DECLARE_WAITQUEUE(wait, current);
        int err = 0;
@@ -157,7 +165,7 @@ static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev,
 }
 
 static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt),
-                               unsigned long opt, __u32 timeout)
+                                       unsigned long opt, __u32 timeout)
 {
        int ret;
 
@@ -177,11 +185,13 @@ static void hci_reset_req(struct hci_dev *hdev, unsigned long opt)
        BT_DBG("%s %ld", hdev->name, opt);
 
        /* Reset device */
+       set_bit(HCI_RESET, &hdev->flags);
        hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
 }
 
 static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
 {
+       struct hci_cp_delete_stored_link_key cp;
        struct sk_buff *skb;
        __le16 param;
        __u8 flt_type;
@@ -203,8 +213,10 @@ static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
        /* Mandatory initialization */
 
        /* Reset */
-       if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks))
+       if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) {
+                       set_bit(HCI_RESET, &hdev->flags);
                        hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
+       }
 
        /* Read Local Supported Features */
        hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL);
@@ -245,13 +257,21 @@ static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
        flt_type = HCI_FLT_CLEAR_ALL;
        hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type);
 
-       /* Page timeout ~20 secs */
-       param = cpu_to_le16(0x8000);
-       hci_send_cmd(hdev, HCI_OP_WRITE_PG_TIMEOUT, 2, &param);
-
        /* Connection accept timeout ~20 secs */
        param = cpu_to_le16(0x7d00);
        hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, &param);
+
+       bacpy(&cp.bdaddr, BDADDR_ANY);
+       cp.delete_all = 1;
+       hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp);
+}
+
+static void hci_le_init_req(struct hci_dev *hdev, unsigned long opt)
+{
+       BT_DBG("%s", hdev->name);
+
+       /* Read LE buffer size */
+       hci_send_cmd(hdev, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL);
 }
 
 static void hci_scan_req(struct hci_dev *hdev, unsigned long opt)
@@ -349,20 +369,23 @@ struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *b
 void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data)
 {
        struct inquiry_cache *cache = &hdev->inq_cache;
-       struct inquiry_entry *e;
+       struct inquiry_entry *ie;
 
        BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr));
 
-       if (!(e = hci_inquiry_cache_lookup(hdev, &data->bdaddr))) {
+       ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr);
+       if (!ie) {
                /* Entry not in the cache. Add new one. */
-               if (!(e = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC)))
+               ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC);
+               if (!ie)
                        return;
-               e->next     = cache->list;
-               cache->list = e;
+
+               ie->next = cache->list;
+               cache->list = ie;
        }
 
-       memcpy(&e->data, data, sizeof(*data));
-       e->timestamp = jiffies;
+       memcpy(&ie->data, data, sizeof(*data));
+       ie->timestamp = jiffies;
        cache->timestamp = jiffies;
 }
 
@@ -417,21 +440,26 @@ int hci_inquiry(void __user *arg)
        if (copy_from_user(&ir, ptr, sizeof(ir)))
                return -EFAULT;
 
-       if (!(hdev = hci_dev_get(ir.dev_id)))
+       hdev = hci_dev_get(ir.dev_id);
+       if (!hdev)
                return -ENODEV;
 
        hci_dev_lock_bh(hdev);
        if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX ||
-                                       inquiry_cache_empty(hdev) ||
-                                       ir.flags & IREQ_CACHE_FLUSH) {
+                               inquiry_cache_empty(hdev) ||
+                               ir.flags & IREQ_CACHE_FLUSH) {
                inquiry_cache_flush(hdev);
                do_inquiry = 1;
        }
        hci_dev_unlock_bh(hdev);
 
        timeo = ir.length * msecs_to_jiffies(2000);
-       if (do_inquiry && (err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo)) < 0)
-               goto done;
+
+       if (do_inquiry) {
+               err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo);
+               if (err < 0)
+                       goto done;
+       }
 
        /* for unlimited number of responses we will use buffer with 255 entries */
        max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp;
@@ -439,7 +467,8 @@ int hci_inquiry(void __user *arg)
        /* cache_dump can't sleep. Therefore we allocate temp buffer and then
         * copy it to the user space.
         */
-       if (!(buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL))) {
+       buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL);
+       if (!buf) {
                err = -ENOMEM;
                goto done;
        }
@@ -472,7 +501,8 @@ int hci_dev_open(__u16 dev)
        struct hci_dev *hdev;
        int ret = 0;
 
-       if (!(hdev = hci_dev_get(dev)))
+       hdev = hci_dev_get(dev);
+       if (!hdev)
                return -ENODEV;
 
        BT_DBG("%s %p", hdev->name, hdev);
@@ -504,11 +534,15 @@ int hci_dev_open(__u16 dev)
        if (!test_bit(HCI_RAW, &hdev->flags)) {
                atomic_set(&hdev->cmd_cnt, 1);
                set_bit(HCI_INIT, &hdev->flags);
+               hdev->init_last_cmd = 0;
 
-               //__hci_request(hdev, hci_reset_req, 0, HZ);
                ret = __hci_request(hdev, hci_init_req, 0,
                                        msecs_to_jiffies(HCI_INIT_TIMEOUT));
 
+               if (lmp_le_capable(hdev))
+                       ret = __hci_request(hdev, hci_le_init_req, 0,
+                                       msecs_to_jiffies(HCI_INIT_TIMEOUT));
+
                clear_bit(HCI_INIT, &hdev->flags);
        }
 
@@ -516,6 +550,8 @@ int hci_dev_open(__u16 dev)
                hci_dev_hold(hdev);
                set_bit(HCI_UP, &hdev->flags);
                hci_notify(hdev, HCI_DEV_UP);
+               if (!test_bit(HCI_SETUP, &hdev->flags))
+                       mgmt_powered(hdev->id, 1);
        } else {
                /* Init failed, cleanup */
                tasklet_kill(&hdev->rx_task);
@@ -551,6 +587,7 @@ static int hci_dev_do_close(struct hci_dev *hdev)
        hci_req_lock(hdev);
 
        if (!test_and_clear_bit(HCI_UP, &hdev->flags)) {
+               del_timer_sync(&hdev->cmd_timer);
                hci_req_unlock(hdev);
                return 0;
        }
@@ -562,7 +599,6 @@ static int hci_dev_do_close(struct hci_dev *hdev)
        hci_dev_lock_bh(hdev);
        inquiry_cache_flush(hdev);
        hci_conn_hash_flush(hdev);
-       hci_blacklist_clear(hdev);
        hci_dev_unlock_bh(hdev);
 
        hci_notify(hdev, HCI_DEV_DOWN);
@@ -590,6 +626,7 @@ static int hci_dev_do_close(struct hci_dev *hdev)
 
        /* Drop last sent command */
        if (hdev->sent_cmd) {
+               del_timer_sync(&hdev->cmd_timer);
                kfree_skb(hdev->sent_cmd);
                hdev->sent_cmd = NULL;
        }
@@ -598,6 +635,8 @@ static int hci_dev_do_close(struct hci_dev *hdev)
         * and no tasks are scheduled. */
        hdev->close(hdev);
 
+       mgmt_powered(hdev->id, 0);
+
        /* Clear flags */
        hdev->flags = 0;
 
@@ -612,7 +651,8 @@ int hci_dev_close(__u16 dev)
        struct hci_dev *hdev;
        int err;
 
-       if (!(hdev = hci_dev_get(dev)))
+       hdev = hci_dev_get(dev);
+       if (!hdev)
                return -ENODEV;
        err = hci_dev_do_close(hdev);
        hci_dev_put(hdev);
@@ -624,7 +664,8 @@ int hci_dev_reset(__u16 dev)
        struct hci_dev *hdev;
        int ret = 0;
 
-       if (!(hdev = hci_dev_get(dev)))
+       hdev = hci_dev_get(dev);
+       if (!hdev)
                return -ENODEV;
 
        hci_req_lock(hdev);
@@ -646,7 +687,7 @@ int hci_dev_reset(__u16 dev)
                hdev->flush(hdev);
 
        atomic_set(&hdev->cmd_cnt, 1);
-       hdev->acl_cnt = 0; hdev->sco_cnt = 0;
+       hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0;
 
        if (!test_bit(HCI_RAW, &hdev->flags))
                ret = __hci_request(hdev, hci_reset_req, 0,
@@ -664,7 +705,8 @@ int hci_dev_reset_stat(__u16 dev)
        struct hci_dev *hdev;
        int ret = 0;
 
-       if (!(hdev = hci_dev_get(dev)))
+       hdev = hci_dev_get(dev);
+       if (!hdev)
                return -ENODEV;
 
        memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
@@ -683,7 +725,8 @@ int hci_dev_cmd(unsigned int cmd, void __user *arg)
        if (copy_from_user(&dr, arg, sizeof(dr)))
                return -EFAULT;
 
-       if (!(hdev = hci_dev_get(dr.dev_id)))
+       hdev = hci_dev_get(dr.dev_id);
+       if (!hdev)
                return -ENODEV;
 
        switch (cmd) {
@@ -764,7 +807,8 @@ int hci_get_dev_list(void __user *arg)
 
        size = sizeof(*dl) + dev_num * sizeof(*dr);
 
-       if (!(dl = kzalloc(size, GFP_KERNEL)))
+       dl = kzalloc(size, GFP_KERNEL);
+       if (!dl)
                return -ENOMEM;
 
        dr = dl->dev_req;
@@ -772,9 +816,17 @@ int hci_get_dev_list(void __user *arg)
        read_lock_bh(&hci_dev_list_lock);
        list_for_each(p, &hci_dev_list) {
                struct hci_dev *hdev;
+
                hdev = list_entry(p, struct hci_dev, list);
+
+               hci_del_off_timer(hdev);
+
+               if (!test_bit(HCI_MGMT, &hdev->flags))
+                       set_bit(HCI_PAIRABLE, &hdev->flags);
+
                (dr + n)->dev_id  = hdev->id;
                (dr + n)->dev_opt = hdev->flags;
+
                if (++n >= dev_num)
                        break;
        }
@@ -798,9 +850,15 @@ int hci_get_dev_info(void __user *arg)
        if (copy_from_user(&di, arg, sizeof(di)))
                return -EFAULT;
 
-       if (!(hdev = hci_dev_get(di.dev_id)))
+       hdev = hci_dev_get(di.dev_id);
+       if (!hdev)
                return -ENODEV;
 
+       hci_del_off_timer(hdev);
+
+       if (!test_bit(HCI_MGMT, &hdev->flags))
+               set_bit(HCI_PAIRABLE, &hdev->flags);
+
        strcpy(di.name, hdev->name);
        di.bdaddr   = hdev->bdaddr;
        di.type     = (hdev->bus & 0x0f) | (hdev->dev_type << 4);
@@ -869,6 +927,281 @@ void hci_free_dev(struct hci_dev *hdev)
 }
 EXPORT_SYMBOL(hci_free_dev);
 
+static void hci_power_on(struct work_struct *work)
+{
+       struct hci_dev *hdev = container_of(work, struct hci_dev, power_on);
+
+       BT_DBG("%s", hdev->name);
+
+       if (hci_dev_open(hdev->id) < 0)
+               return;
+
+       if (test_bit(HCI_AUTO_OFF, &hdev->flags))
+               mod_timer(&hdev->off_timer,
+                               jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT));
+
+       if (test_and_clear_bit(HCI_SETUP, &hdev->flags))
+               mgmt_index_added(hdev->id);
+}
+
+static void hci_power_off(struct work_struct *work)
+{
+       struct hci_dev *hdev = container_of(work, struct hci_dev, power_off);
+
+       BT_DBG("%s", hdev->name);
+
+       hci_dev_close(hdev->id);
+}
+
+static void hci_auto_off(unsigned long data)
+{
+       struct hci_dev *hdev = (struct hci_dev *) data;
+
+       BT_DBG("%s", hdev->name);
+
+       clear_bit(HCI_AUTO_OFF, &hdev->flags);
+
+       queue_work(hdev->workqueue, &hdev->power_off);
+}
+
+void hci_del_off_timer(struct hci_dev *hdev)
+{
+       BT_DBG("%s", hdev->name);
+
+       clear_bit(HCI_AUTO_OFF, &hdev->flags);
+       del_timer(&hdev->off_timer);
+}
+
+int hci_uuids_clear(struct hci_dev *hdev)
+{
+       struct list_head *p, *n;
+
+       list_for_each_safe(p, n, &hdev->uuids) {
+               struct bt_uuid *uuid;
+
+               uuid = list_entry(p, struct bt_uuid, list);
+
+               list_del(p);
+               kfree(uuid);
+       }
+
+       return 0;
+}
+
+int hci_link_keys_clear(struct hci_dev *hdev)
+{
+       struct list_head *p, *n;
+
+       list_for_each_safe(p, n, &hdev->link_keys) {
+               struct link_key *key;
+
+               key = list_entry(p, struct link_key, list);
+
+               list_del(p);
+               kfree(key);
+       }
+
+       return 0;
+}
+
+struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
+{
+       struct list_head *p;
+
+       list_for_each(p, &hdev->link_keys) {
+               struct link_key *k;
+
+               k = list_entry(p, struct link_key, list);
+
+               if (bacmp(bdaddr, &k->bdaddr) == 0)
+                       return k;
+       }
+
+       return NULL;
+}
+
+static int hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn,
+                                               u8 key_type, u8 old_key_type)
+{
+       /* Legacy key */
+       if (key_type < 0x03)
+               return 1;
+
+       /* Debug keys are insecure so don't store them persistently */
+       if (key_type == HCI_LK_DEBUG_COMBINATION)
+               return 0;
+
+       /* Changed combination key and there's no previous one */
+       if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff)
+               return 0;
+
+       /* Security mode 3 case */
+       if (!conn)
+               return 1;
+
+       /* Neither local nor remote side had no-bonding as requirement */
+       if (conn->auth_type > 0x01 && conn->remote_auth > 0x01)
+               return 1;
+
+       /* Local side had dedicated bonding as requirement */
+       if (conn->auth_type == 0x02 || conn->auth_type == 0x03)
+               return 1;
+
+       /* Remote side had dedicated bonding as requirement */
+       if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03)
+               return 1;
+
+       /* If none of the above criteria match, then don't store the key
+        * persistently */
+       return 0;
+}
+
+int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
+                               bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len)
+{
+       struct link_key *key, *old_key;
+       u8 old_key_type, persistent;
+
+       old_key = hci_find_link_key(hdev, bdaddr);
+       if (old_key) {
+               old_key_type = old_key->type;
+               key = old_key;
+       } else {
+               old_key_type = conn ? conn->key_type : 0xff;
+               key = kzalloc(sizeof(*key), GFP_ATOMIC);
+               if (!key)
+                       return -ENOMEM;
+               list_add(&key->list, &hdev->link_keys);
+       }
+
+       BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type);
+
+       /* Some buggy controller combinations generate a changed
+        * combination key for legacy pairing even when there's no
+        * previous key */
+       if (type == HCI_LK_CHANGED_COMBINATION &&
+                                       (!conn || conn->remote_auth == 0xff) &&
+                                       old_key_type == 0xff) {
+               type = HCI_LK_COMBINATION;
+               if (conn)
+                       conn->key_type = type;
+       }
+
+       bacpy(&key->bdaddr, bdaddr);
+       memcpy(key->val, val, 16);
+       key->pin_len = pin_len;
+
+       if (type == HCI_LK_CHANGED_COMBINATION)
+               key->type = old_key_type;
+       else
+               key->type = type;
+
+       if (!new_key)
+               return 0;
+
+       persistent = hci_persistent_key(hdev, conn, type, old_key_type);
+
+       mgmt_new_key(hdev->id, key, persistent);
+
+       if (!persistent) {
+               list_del(&key->list);
+               kfree(key);
+       }
+
+       return 0;
+}
+
+int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr)
+{
+       struct link_key *key;
+
+       key = hci_find_link_key(hdev, bdaddr);
+       if (!key)
+               return -ENOENT;
+
+       BT_DBG("%s removing %s", hdev->name, batostr(bdaddr));
+
+       list_del(&key->list);
+       kfree(key);
+
+       return 0;
+}
+
+/* HCI command timer function */
+static void hci_cmd_timer(unsigned long arg)
+{
+       struct hci_dev *hdev = (void *) arg;
+
+       BT_ERR("%s command tx timeout", hdev->name);
+       atomic_set(&hdev->cmd_cnt, 1);
+       clear_bit(HCI_RESET, &hdev->flags);
+       tasklet_schedule(&hdev->cmd_task);
+}
+
+struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
+                                                       bdaddr_t *bdaddr)
+{
+       struct oob_data *data;
+
+       list_for_each_entry(data, &hdev->remote_oob_data, list)
+               if (bacmp(bdaddr, &data->bdaddr) == 0)
+                       return data;
+
+       return NULL;
+}
+
+int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr)
+{
+       struct oob_data *data;
+
+       data = hci_find_remote_oob_data(hdev, bdaddr);
+       if (!data)
+               return -ENOENT;
+
+       BT_DBG("%s removing %s", hdev->name, batostr(bdaddr));
+
+       list_del(&data->list);
+       kfree(data);
+
+       return 0;
+}
+
+int hci_remote_oob_data_clear(struct hci_dev *hdev)
+{
+       struct oob_data *data, *n;
+
+       list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) {
+               list_del(&data->list);
+               kfree(data);
+       }
+
+       return 0;
+}
+
+int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
+                                                               u8 *randomizer)
+{
+       struct oob_data *data;
+
+       data = hci_find_remote_oob_data(hdev, bdaddr);
+
+       if (!data) {
+               data = kmalloc(sizeof(*data), GFP_ATOMIC);
+               if (!data)
+                       return -ENOMEM;
+
+               bacpy(&data->bdaddr, bdaddr);
+               list_add(&data->list, &hdev->remote_oob_data);
+       }
+
+       memcpy(data->hash, hash, sizeof(data->hash));
+       memcpy(data->randomizer, randomizer, sizeof(data->randomizer));
+
+       BT_DBG("%s for %s", hdev->name, batostr(bdaddr));
+
+       return 0;
+}
+
 /* Register HCI device */
 int hci_register_dev(struct hci_dev *hdev)
 {
@@ -901,12 +1234,13 @@ int hci_register_dev(struct hci_dev *hdev)
        hdev->pkt_type  = (HCI_DM1 | HCI_DH1 | HCI_HV1);
        hdev->esco_type = (ESCO_HV1);
        hdev->link_mode = (HCI_LM_ACCEPT);
+       hdev->io_capability = 0x03; /* No Input No Output */
 
        hdev->idle_timeout = 0;
        hdev->sniff_max_interval = 800;
        hdev->sniff_min_interval = 80;
 
-       tasklet_init(&hdev->cmd_task, hci_cmd_task,(unsigned long) hdev);
+       tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev);
        tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev);
        tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev);
 
@@ -914,7 +1248,9 @@ int hci_register_dev(struct hci_dev *hdev)
        skb_queue_head_init(&hdev->cmd_q);
        skb_queue_head_init(&hdev->raw_q);
 
-       for (i = 0; i < 3; i++)
+       setup_timer(&hdev->cmd_timer, hci_cmd_timer, (unsigned long) hdev);
+
+       for (i = 0; i < NUM_REASSEMBLY; i++)
                hdev->reassembly[i] = NULL;
 
        init_waitqueue_head(&hdev->req_wait_q);
@@ -924,7 +1260,17 @@ int hci_register_dev(struct hci_dev *hdev)
 
        hci_conn_hash_init(hdev);
 
-       INIT_LIST_HEAD(&hdev->blacklist.list);
+       INIT_LIST_HEAD(&hdev->blacklist);
+
+       INIT_LIST_HEAD(&hdev->uuids);
+
+       INIT_LIST_HEAD(&hdev->link_keys);
+
+       INIT_LIST_HEAD(&hdev->remote_oob_data);
+
+       INIT_WORK(&hdev->power_on, hci_power_on);
+       INIT_WORK(&hdev->power_off, hci_power_off);
+       setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev);
 
        memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
 
@@ -947,6 +1293,10 @@ int hci_register_dev(struct hci_dev *hdev)
                }
        }
 
+       set_bit(HCI_AUTO_OFF, &hdev->flags);
+       set_bit(HCI_SETUP, &hdev->flags);
+       queue_work(hdev->workqueue, &hdev->power_on);
+
        hci_notify(hdev, HCI_DEV_REG);
 
        return id;
@@ -973,9 +1323,13 @@ int hci_unregister_dev(struct hci_dev *hdev)
 
        hci_dev_do_close(hdev);
 
-       for (i = 0; i < 3; i++)
+       for (i = 0; i < NUM_REASSEMBLY; i++)
                kfree_skb(hdev->reassembly[i]);
 
+       if (!test_bit(HCI_INIT, &hdev->flags) &&
+                                       !test_bit(HCI_SETUP, &hdev->flags))
+               mgmt_index_removed(hdev->id);
+
        hci_notify(hdev, HCI_DEV_UNREG);
 
        if (hdev->rfkill) {
@@ -985,8 +1339,17 @@ int hci_unregister_dev(struct hci_dev *hdev)
 
        hci_unregister_sysfs(hdev);
 
+       hci_del_off_timer(hdev);
+
        destroy_workqueue(hdev->workqueue);
 
+       hci_dev_lock_bh(hdev);
+       hci_blacklist_clear(hdev);
+       hci_uuids_clear(hdev);
+       hci_link_keys_clear(hdev);
+       hci_remote_oob_data_clear(hdev);
+       hci_dev_unlock_bh(hdev);
+
        __hci_dev_put(hdev);
 
        return 0;
@@ -1033,89 +1396,169 @@ int hci_recv_frame(struct sk_buff *skb)
 }
 EXPORT_SYMBOL(hci_recv_frame);
 
-/* Receive packet type fragment */
-#define __reassembly(hdev, type)  ((hdev)->reassembly[(type) - 2])
-
-int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
+static int hci_reassembly(struct hci_dev *hdev, int type, void *data,
+                                                 int count, __u8 index)
 {
-       if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
+       int len = 0;
+       int hlen = 0;
+       int remain = count;
+       struct sk_buff *skb;
+       struct bt_skb_cb *scb;
+
+       if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) ||
+                               index >= NUM_REASSEMBLY)
                return -EILSEQ;
 
+       skb = hdev->reassembly[index];
+
+       if (!skb) {
+               switch (type) {
+               case HCI_ACLDATA_PKT:
+                       len = HCI_MAX_FRAME_SIZE;
+                       hlen = HCI_ACL_HDR_SIZE;
+                       break;
+               case HCI_EVENT_PKT:
+                       len = HCI_MAX_EVENT_SIZE;
+                       hlen = HCI_EVENT_HDR_SIZE;
+                       break;
+               case HCI_SCODATA_PKT:
+                       len = HCI_MAX_SCO_SIZE;
+                       hlen = HCI_SCO_HDR_SIZE;
+                       break;
+               }
+
+               skb = bt_skb_alloc(len, GFP_ATOMIC);
+               if (!skb)
+                       return -ENOMEM;
+
+               scb = (void *) skb->cb;
+               scb->expect = hlen;
+               scb->pkt_type = type;
+
+               skb->dev = (void *) hdev;
+               hdev->reassembly[index] = skb;
+       }
+
        while (count) {
-               struct sk_buff *skb = __reassembly(hdev, type);
-               struct { int expect; } *scb;
-               int len = 0;
+               scb = (void *) skb->cb;
+               len = min(scb->expect, (__u16)count);
 
-               if (!skb) {
-                       /* Start of the frame */
+               memcpy(skb_put(skb, len), data, len);
 
-                       switch (type) {
-                       case HCI_EVENT_PKT:
-                               if (count >= HCI_EVENT_HDR_SIZE) {
-                                       struct hci_event_hdr *h = data;
-                                       len = HCI_EVENT_HDR_SIZE + h->plen;
-                               } else
-                                       return -EILSEQ;
-                               break;
+               count -= len;
+               data += len;
+               scb->expect -= len;
+               remain = count;
 
-                       case HCI_ACLDATA_PKT:
-                               if (count >= HCI_ACL_HDR_SIZE) {
-                                       struct hci_acl_hdr *h = data;
-                                       len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
-                               } else
-                                       return -EILSEQ;
-                               break;
+               switch (type) {
+               case HCI_EVENT_PKT:
+                       if (skb->len == HCI_EVENT_HDR_SIZE) {
+                               struct hci_event_hdr *h = hci_event_hdr(skb);
+                               scb->expect = h->plen;
+
+                               if (skb_tailroom(skb) < scb->expect) {
+                                       kfree_skb(skb);
+                                       hdev->reassembly[index] = NULL;
+                                       return -ENOMEM;
+                               }
+                       }
+                       break;
 
-                       case HCI_SCODATA_PKT:
-                               if (count >= HCI_SCO_HDR_SIZE) {
-                                       struct hci_sco_hdr *h = data;
-                                       len = HCI_SCO_HDR_SIZE + h->dlen;
-                               } else
-                                       return -EILSEQ;
-                               break;
+               case HCI_ACLDATA_PKT:
+                       if (skb->len  == HCI_ACL_HDR_SIZE) {
+                               struct hci_acl_hdr *h = hci_acl_hdr(skb);
+                               scb->expect = __le16_to_cpu(h->dlen);
+
+                               if (skb_tailroom(skb) < scb->expect) {
+                                       kfree_skb(skb);
+                                       hdev->reassembly[index] = NULL;
+                                       return -ENOMEM;
+                               }
                        }
+                       break;
 
-                       skb = bt_skb_alloc(len, GFP_ATOMIC);
-                       if (!skb) {
-                               BT_ERR("%s no memory for packet", hdev->name);
-                               return -ENOMEM;
+               case HCI_SCODATA_PKT:
+                       if (skb->len == HCI_SCO_HDR_SIZE) {
+                               struct hci_sco_hdr *h = hci_sco_hdr(skb);
+                               scb->expect = h->dlen;
+
+                               if (skb_tailroom(skb) < scb->expect) {
+                                       kfree_skb(skb);
+                                       hdev->reassembly[index] = NULL;
+                                       return -ENOMEM;
+                               }
                        }
+                       break;
+               }
+
+               if (scb->expect == 0) {
+                       /* Complete frame */
 
-                       skb->dev = (void *) hdev;
                        bt_cb(skb)->pkt_type = type;
+                       hci_recv_frame(skb);
 
-                       __reassembly(hdev, type) = skb;
+                       hdev->reassembly[index] = NULL;
+                       return remain;
+               }
+       }
 
-                       scb = (void *) skb->cb;
-                       scb->expect = len;
-               } else {
-                       /* Continuation */
+       return remain;
+}
 
-                       scb = (void *) skb->cb;
-                       len = scb->expect;
-               }
+int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
+{
+       int rem = 0;
 
-               len = min(len, count);
+       if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
+               return -EILSEQ;
 
-               memcpy(skb_put(skb, len), data, len);
+       while (count) {
+               rem = hci_reassembly(hdev, type, data, count, type - 1);
+               if (rem < 0)
+                       return rem;
 
-               scb->expect -= len;
+               data += (count - rem);
+               count = rem;
+       };
 
-               if (scb->expect == 0) {
-                       /* Complete frame */
+       return rem;
+}
+EXPORT_SYMBOL(hci_recv_fragment);
 
-                       __reassembly(hdev, type) = NULL;
+#define STREAM_REASSEMBLY 0
 
-                       bt_cb(skb)->pkt_type = type;
-                       hci_recv_frame(skb);
-               }
+int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count)
+{
+       int type;
+       int rem = 0;
 
-               count -= len; data += len;
-       }
+       while (count) {
+               struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY];
 
-       return 0;
+               if (!skb) {
+                       struct { char type; } *pkt;
+
+                       /* Start of the frame */
+                       pkt = data;
+                       type = pkt->type;
+
+                       data++;
+                       count--;
+               } else
+                       type = bt_cb(skb)->pkt_type;
+
+               rem = hci_reassembly(hdev, type, data, count,
+                                                       STREAM_REASSEMBLY);
+               if (rem < 0)
+                       return rem;
+
+               data += (count - rem);
+               count = rem;
+       };
+
+       return rem;
 }
-EXPORT_SYMBOL(hci_recv_fragment);
+EXPORT_SYMBOL(hci_recv_stream_fragment);
 
 /* ---- Interface to upper protocols ---- */
 
@@ -1204,7 +1647,7 @@ static int hci_send_frame(struct sk_buff *skb)
                /* Time stamp */
                __net_timestamp(skb);
 
-               hci_send_to_sock(hdev, skb);
+               hci_send_to_sock(hdev, skb, NULL);
        }
 
        /* Get rid of skb owner, prior to sending to the driver. */
@@ -1240,6 +1683,9 @@ int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param)
        bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
        skb->dev = (void *) hdev;
 
+       if (test_bit(HCI_INIT, &hdev->flags))
+               hdev->init_last_cmd = opcode;
+
        skb_queue_tail(&hdev->cmd_q, skb);
        tasklet_schedule(&hdev->cmd_task);
 
@@ -1286,9 +1732,10 @@ void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags)
 
        skb->dev = (void *) hdev;
        bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
-       hci_add_acl_hdr(skb, conn->handle, flags | ACL_START);
+       hci_add_acl_hdr(skb, conn->handle, flags);
 
-       if (!(list = skb_shinfo(skb)->frag_list)) {
+       list = skb_shinfo(skb)->frag_list;
+       if (!list) {
                /* Non fragmented */
                BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len);
 
@@ -1303,12 +1750,15 @@ void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags)
                spin_lock_bh(&conn->data_q.lock);
 
                __skb_queue_tail(&conn->data_q, skb);
+
+               flags &= ~ACL_START;
+               flags |= ACL_CONT;
                do {
                        skb = list; list = list->next;
 
                        skb->dev = (void *) hdev;
                        bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
-                       hci_add_acl_hdr(skb, conn->handle, flags | ACL_CONT);
+                       hci_add_acl_hdr(skb, conn->handle, flags);
 
                        BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
 
@@ -1376,8 +1826,25 @@ static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int
        }
 
        if (conn) {
-               int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt);
-               int q = cnt / num;
+               int cnt, q;
+
+               switch (conn->type) {
+               case ACL_LINK:
+                       cnt = hdev->acl_cnt;
+                       break;
+               case SCO_LINK:
+               case ESCO_LINK:
+                       cnt = hdev->sco_cnt;
+                       break;
+               case LE_LINK:
+                       cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
+                       break;
+               default:
+                       cnt = 0;
+                       BT_ERR("Unknown link type");
+               }
+
+               q = cnt / num;
                *quote = q ? q : 1;
        } else
                *quote = 0;
@@ -1386,19 +1853,19 @@ static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int
        return conn;
 }
 
-static inline void hci_acl_tx_to(struct hci_dev *hdev)
+static inline void hci_link_tx_to(struct hci_dev *hdev, __u8 type)
 {
        struct hci_conn_hash *h = &hdev->conn_hash;
        struct list_head *p;
        struct hci_conn  *c;
 
-       BT_ERR("%s ACL tx timeout", hdev->name);
+       BT_ERR("%s link tx timeout", hdev->name);
 
        /* Kill stalled connections */
        list_for_each(p, &h->list) {
                c = list_entry(p, struct hci_conn, list);
-               if (c->type == ACL_LINK && c->sent) {
-                       BT_ERR("%s killing stalled ACL connection %s",
+               if (c->type == type && c->sent) {
+                       BT_ERR("%s killing stalled connection %s",
                                hdev->name, batostr(&c->dst));
                        hci_acl_disconn(c, 0x13);
                }
@@ -1417,7 +1884,7 @@ static inline void hci_sched_acl(struct hci_dev *hdev)
                /* ACL tx timeout must be longer than maximum
                 * link supervision timeout (40.9 seconds) */
                if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45))
-                       hci_acl_tx_to(hdev);
+                       hci_link_tx_to(hdev, ACL_LINK);
        }
 
        while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, &quote))) {
@@ -1476,6 +1943,40 @@ static inline void hci_sched_esco(struct hci_dev *hdev)
        }
 }
 
+static inline void hci_sched_le(struct hci_dev *hdev)
+{
+       struct hci_conn *conn;
+       struct sk_buff *skb;
+       int quote, cnt;
+
+       BT_DBG("%s", hdev->name);
+
+       if (!test_bit(HCI_RAW, &hdev->flags)) {
+               /* LE tx timeout must be longer than maximum
+                * link supervision timeout (40.9 seconds) */
+               if (!hdev->le_cnt && hdev->le_pkts &&
+                               time_after(jiffies, hdev->le_last_tx + HZ * 45))
+                       hci_link_tx_to(hdev, LE_LINK);
+       }
+
+       cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt;
+       while (cnt && (conn = hci_low_sent(hdev, LE_LINK, &quote))) {
+               while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
+                       BT_DBG("skb %p len %d", skb, skb->len);
+
+                       hci_send_frame(skb);
+                       hdev->le_last_tx = jiffies;
+
+                       cnt--;
+                       conn->sent++;
+               }
+       }
+       if (hdev->le_pkts)
+               hdev->le_cnt = cnt;
+       else
+               hdev->acl_cnt = cnt;
+}
+
 static void hci_tx_task(unsigned long arg)
 {
        struct hci_dev *hdev = (struct hci_dev *) arg;
@@ -1483,7 +1984,8 @@ static void hci_tx_task(unsigned long arg)
 
        read_lock(&hci_task_lock);
 
-       BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt);
+       BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt,
+               hdev->sco_cnt, hdev->le_cnt);
 
        /* Schedule queues and send stuff to HCI driver */
 
@@ -1493,6 +1995,8 @@ static void hci_tx_task(unsigned long arg)
 
        hci_sched_esco(hdev);
 
+       hci_sched_le(hdev);
+
        /* Send next queued raw (unknown type) packet */
        while ((skb = skb_dequeue(&hdev->raw_q)))
                hci_send_frame(skb);
@@ -1500,7 +2004,7 @@ static void hci_tx_task(unsigned long arg)
        read_unlock(&hci_task_lock);
 }
 
-/* ----- HCI RX task (incoming data proccessing) ----- */
+/* ----- HCI RX task (incoming data processing) ----- */
 
 /* ACL data packet */
 static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb)
@@ -1529,7 +2033,8 @@ static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb)
                hci_conn_enter_active_mode(conn);
 
                /* Send to upper protocol */
-               if ((hp = hci_proto[HCI_PROTO_L2CAP]) && hp->recv_acldata) {
+               hp = hci_proto[HCI_PROTO_L2CAP];
+               if (hp && hp->recv_acldata) {
                        hp->recv_acldata(conn, skb, flags);
                        return;
                }
@@ -1564,7 +2069,8 @@ static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb)
                register struct hci_proto *hp;
 
                /* Send to upper protocol */
-               if ((hp = hci_proto[HCI_PROTO_SCO]) && hp->recv_scodata) {
+               hp = hci_proto[HCI_PROTO_SCO];
+               if (hp && hp->recv_scodata) {
                        hp->recv_scodata(conn, skb);
                        return;
                }
@@ -1588,7 +2094,7 @@ static void hci_rx_task(unsigned long arg)
        while ((skb = skb_dequeue(&hdev->rx_q))) {
                if (atomic_read(&hdev->promisc)) {
                        /* Send copy to the sockets */
-                       hci_send_to_sock(hdev, skb);
+                       hci_send_to_sock(hdev, skb, NULL);
                }
 
                if (test_bit(HCI_RAW, &hdev->flags)) {
@@ -1638,19 +2144,20 @@ static void hci_cmd_task(unsigned long arg)
 
        BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt));
 
-       if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) {
-               BT_ERR("%s command tx timeout", hdev->name);
-               atomic_set(&hdev->cmd_cnt, 1);
-       }
-
        /* Send queued commands */
-       if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) {
+       if (atomic_read(&hdev->cmd_cnt)) {
+               skb = skb_dequeue(&hdev->cmd_q);
+               if (!skb)
+                       return;
+
                kfree_skb(hdev->sent_cmd);
 
-               if ((hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC))) {
+               hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC);
+               if (hdev->sent_cmd) {
                        atomic_dec(&hdev->cmd_cnt);
                        hci_send_frame(skb);
-                       hdev->cmd_last_tx = jiffies;
+                       mod_timer(&hdev->cmd_timer,
+                                 jiffies + msecs_to_jiffies(HCI_CMD_TIMEOUT));
                } else {
                        skb_queue_head(&hdev->cmd_q, skb);
                        tasklet_schedule(&hdev->cmd_task);