static void hci_rx_work(struct work_struct *work);
 static void hci_cmd_work(struct work_struct *work);
-static void hci_tx_task(unsigned long arg);
+static void hci_tx_work(struct work_struct *work);
 
 static DEFINE_MUTEX(hci_task_lock);
 
                }
        } else {
                /* Init failed, cleanup */
-               tasklet_kill(&hdev->tx_task);
+               flush_work(&hdev->tx_work);
                flush_work(&hdev->cmd_work);
                flush_work(&hdev->rx_work);
 
                return 0;
        }
 
-       /* Kill RX and TX tasks */
-       tasklet_kill(&hdev->tx_task);
+       /* Flush RX and TX works */
+       flush_work(&hdev->tx_work);
        flush_work(&hdev->rx_work);
 
        if (hdev->discov_timeout > 0) {
                return -ENODEV;
 
        hci_req_lock(hdev);
-       tasklet_disable(&hdev->tx_task);
 
        if (!test_bit(HCI_UP, &hdev->flags))
                goto done;
                                        msecs_to_jiffies(HCI_INIT_TIMEOUT));
 
 done:
-       tasklet_enable(&hdev->tx_task);
        hci_req_unlock(hdev);
        hci_dev_put(hdev);
        return ret;
 
        INIT_WORK(&hdev->rx_work, hci_rx_work);
        INIT_WORK(&hdev->cmd_work, hci_cmd_work);
+       INIT_WORK(&hdev->tx_work, hci_tx_work);
 
-       tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev);
 
        skb_queue_head_init(&hdev->rx_q);
        skb_queue_head_init(&hdev->cmd_q);
 
        hci_queue_acl(conn, &chan->data_q, skb, flags);
 
-       tasklet_schedule(&hdev->tx_task);
+       queue_work(hdev->workqueue, &hdev->tx_work);
 }
 EXPORT_SYMBOL(hci_send_acl);
 
        bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
 
        skb_queue_tail(&conn->data_q, skb);
-       tasklet_schedule(&hdev->tx_task);
+       queue_work(hdev->workqueue, &hdev->tx_work);
 }
 EXPORT_SYMBOL(hci_send_sco);
 
                hci_prio_recalculate(hdev, LE_LINK);
 }
 
-static void hci_tx_task(unsigned long arg)
+static void hci_tx_work(struct work_struct *work)
 {
-       struct hci_dev *hdev = (struct hci_dev *) arg;
+       struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work);
        struct sk_buff *skb;
 
        mutex_lock(&hci_task_lock);
 
 
                if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
                        skb_queue_tail(&hdev->raw_q, skb);
-                       tasklet_schedule(&hdev->tx_task);
+                       queue_work(hdev->workqueue, &hdev->tx_work);
                } else {
                        skb_queue_tail(&hdev->cmd_q, skb);
                        queue_work(hdev->workqueue, &hdev->cmd_work);
                }
 
                skb_queue_tail(&hdev->raw_q, skb);
-               tasklet_schedule(&hdev->tx_task);
+               queue_work(hdev->workqueue, &hdev->tx_work);
        }
 
        err = len;