11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 41da177e4SLinus Torvalds 51da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 61da177e4SLinus Torvalds 71da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 81da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 91da177e4SLinus Torvalds published by the Free Software Foundation; 101da177e4SLinus Torvalds 111da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 121da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 131da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 141da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 151da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 161da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 171da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 181da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 211da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 221da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 231da177e4SLinus Torvalds */ 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds /* Bluetooth HCI core. */ 261da177e4SLinus Torvalds 2782453021SS.Çağlar Onur #include <linux/jiffies.h> 281da177e4SLinus Torvalds #include <linux/module.h> 291da177e4SLinus Torvalds #include <linux/kmod.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <linux/types.h> 321da177e4SLinus Torvalds #include <linux/errno.h> 331da177e4SLinus Torvalds #include <linux/kernel.h> 341da177e4SLinus Torvalds #include <linux/sched.h> 351da177e4SLinus Torvalds #include <linux/slab.h> 361da177e4SLinus Torvalds #include <linux/poll.h> 371da177e4SLinus Torvalds #include <linux/fcntl.h> 381da177e4SLinus Torvalds #include <linux/init.h> 391da177e4SLinus Torvalds #include <linux/skbuff.h> 40f48fd9c8SMarcel Holtmann #include <linux/workqueue.h> 411da177e4SLinus Torvalds #include <linux/interrupt.h> 421da177e4SLinus Torvalds #include <linux/notifier.h> 43611b30f7SMarcel Holtmann #include <linux/rfkill.h> 441da177e4SLinus Torvalds #include <net/sock.h> 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds #include <asm/system.h> 4770f23020SAndrei Emeltchenko #include <linux/uaccess.h> 481da177e4SLinus Torvalds #include <asm/unaligned.h> 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 511da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 521da177e4SLinus Torvalds 53ab81cbf9SJohan Hedberg #define AUTO_OFF_TIMEOUT 2000 54ab81cbf9SJohan Hedberg 551da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg); 561da177e4SLinus Torvalds static void hci_rx_task(unsigned long arg); 571da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg); 581da177e4SLinus Torvalds static void hci_notify(struct hci_dev *hdev, int event); 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds static DEFINE_RWLOCK(hci_task_lock); 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds /* HCI device list */ 631da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 641da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /* HCI callback list */ 671da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 681da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds /* HCI protocols */ 711da177e4SLinus Torvalds #define HCI_MAX_PROTO 2 721da177e4SLinus Torvalds struct hci_proto *hci_proto[HCI_MAX_PROTO]; 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* HCI notifiers list */ 75e041c683SAlan Stern static ATOMIC_NOTIFIER_HEAD(hci_notifier); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds int hci_register_notifier(struct notifier_block *nb) 801da177e4SLinus Torvalds { 81e041c683SAlan Stern return atomic_notifier_chain_register(&hci_notifier, nb); 821da177e4SLinus Torvalds } 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds int hci_unregister_notifier(struct notifier_block *nb) 851da177e4SLinus Torvalds { 86e041c683SAlan Stern return atomic_notifier_chain_unregister(&hci_notifier, nb); 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 896516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 901da177e4SLinus Torvalds { 91e041c683SAlan Stern atomic_notifier_call_chain(&hci_notifier, event, hdev); 921da177e4SLinus Torvalds } 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* ---- HCI requests ---- */ 951da177e4SLinus Torvalds 9623bb5763SJohan Hedberg void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result) 971da177e4SLinus Torvalds { 9823bb5763SJohan Hedberg BT_DBG("%s command 0x%04x result 0x%2.2x", hdev->name, cmd, result); 9923bb5763SJohan Hedberg 100a5040efaSJohan Hedberg /* If this is the init phase check if the completed command matches 101a5040efaSJohan Hedberg * the last init command, and if not just return. 102a5040efaSJohan Hedberg */ 103a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && hdev->init_last_cmd != cmd) 10423bb5763SJohan Hedberg return; 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1071da177e4SLinus Torvalds hdev->req_result = result; 1081da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1091da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1141da177e4SLinus Torvalds { 1151da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1181da177e4SLinus Torvalds hdev->req_result = err; 1191da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1201da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1211da177e4SLinus Torvalds } 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds /* Execute request and wait for completion. */ 1251da177e4SLinus Torvalds static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1261da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1291da177e4SLinus Torvalds int err = 0; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds add_wait_queue(&hdev->req_wait_q, &wait); 1361da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds req(hdev, opt); 1391da177e4SLinus Torvalds schedule_timeout(timeout); 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds if (signal_pending(current)) 1441da177e4SLinus Torvalds return -EINTR; 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds switch (hdev->req_status) { 1471da177e4SLinus Torvalds case HCI_REQ_DONE: 1481da177e4SLinus Torvalds err = -bt_err(hdev->req_result); 1491da177e4SLinus Torvalds break; 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds case HCI_REQ_CANCELED: 1521da177e4SLinus Torvalds err = -hdev->req_result; 1531da177e4SLinus Torvalds break; 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds default: 1561da177e4SLinus Torvalds err = -ETIMEDOUT; 1571da177e4SLinus Torvalds break; 1583ff50b79SStephen Hemminger } 1591da177e4SLinus Torvalds 160a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds return err; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1681da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1691da177e4SLinus Torvalds { 1701da177e4SLinus Torvalds int ret; 1711da177e4SLinus Torvalds 1727c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 1737c6a329eSMarcel Holtmann return -ENETDOWN; 1747c6a329eSMarcel Holtmann 1751da177e4SLinus Torvalds /* Serialize all requests */ 1761da177e4SLinus Torvalds hci_req_lock(hdev); 1771da177e4SLinus Torvalds ret = __hci_request(hdev, req, opt, timeout); 1781da177e4SLinus Torvalds hci_req_unlock(hdev); 1791da177e4SLinus Torvalds 1801da177e4SLinus Torvalds return ret; 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds static void hci_reset_req(struct hci_dev *hdev, unsigned long opt) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds /* Reset device */ 188a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1921da177e4SLinus Torvalds { 193b0916ea0SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 1941da177e4SLinus Torvalds struct sk_buff *skb; 1951ebb9252SMarcel Holtmann __le16 param; 19689f2783dSMarcel Holtmann __u8 flt_type; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* Driver initialization */ 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds /* Special commands */ 2031da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 2040d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2051da177e4SLinus Torvalds skb->dev = (void *) hdev; 206c78ae283SMarcel Holtmann 2071da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 208c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds /* Mandatory initialization */ 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* Reset */ 2157a9d4020SMarcel Holtmann if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) 216a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds /* Read Local Supported Features */ 219a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2201da177e4SLinus Torvalds 2211143e5a6SMarcel Holtmann /* Read Local Version */ 222a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2231143e5a6SMarcel Holtmann 2241da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 225a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds #if 0 2281da177e4SLinus Torvalds /* Host buffer size */ 2291da177e4SLinus Torvalds { 2301da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 231aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2321da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 233aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 234aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 235a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds #endif 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds /* Read BD Address */ 240a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 241a9de9248SMarcel Holtmann 242a9de9248SMarcel Holtmann /* Read Class of Device */ 243a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 244a9de9248SMarcel Holtmann 245a9de9248SMarcel Holtmann /* Read Local Name */ 246a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds /* Read Voice Setting */ 249a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* Optional initialization */ 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* Clear Event Filters */ 25489f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 255a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds /* Page timeout ~20 secs */ 258aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x8000); 259a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_PG_TIMEOUT, 2, ¶m); 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 262aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 263a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 264b0916ea0SJohan Hedberg 265b0916ea0SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 266b0916ea0SJohan Hedberg cp.delete_all = 1; 267b0916ea0SJohan Hedberg hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp); 2681da177e4SLinus Torvalds } 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2711da177e4SLinus Torvalds { 2721da177e4SLinus Torvalds __u8 scan = opt; 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds /* Inquiry and Page scans */ 277a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2811da177e4SLinus Torvalds { 2821da177e4SLinus Torvalds __u8 auth = opt; 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds /* Authentication */ 287a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2911da177e4SLinus Torvalds { 2921da177e4SLinus Torvalds __u8 encrypt = opt; 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 2951da177e4SLinus Torvalds 296e4e8e37cSMarcel Holtmann /* Encryption */ 297a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds 300e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 301e4e8e37cSMarcel Holtmann { 302e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 303e4e8e37cSMarcel Holtmann 304a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 305e4e8e37cSMarcel Holtmann 306e4e8e37cSMarcel Holtmann /* Default link policy */ 307e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 308e4e8e37cSMarcel Holtmann } 309e4e8e37cSMarcel Holtmann 3101da177e4SLinus Torvalds /* Get HCI device by index. 3111da177e4SLinus Torvalds * Device is held on return. */ 3121da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3131da177e4SLinus Torvalds { 3141da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3151da177e4SLinus Torvalds struct list_head *p; 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds BT_DBG("%d", index); 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds if (index < 0) 3201da177e4SLinus Torvalds return NULL; 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3231da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3241da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3251da177e4SLinus Torvalds if (d->id == index) { 3261da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3271da177e4SLinus Torvalds break; 3281da177e4SLinus Torvalds } 3291da177e4SLinus Torvalds } 3301da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3311da177e4SLinus Torvalds return hdev; 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3351da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3361da177e4SLinus Torvalds { 3371da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3381da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds cache->list = NULL; 3431da177e4SLinus Torvalds while ((e = next)) { 3441da177e4SLinus Torvalds next = e->next; 3451da177e4SLinus Torvalds kfree(e); 3461da177e4SLinus Torvalds } 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3501da177e4SLinus Torvalds { 3511da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3521da177e4SLinus Torvalds struct inquiry_entry *e; 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3571da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3581da177e4SLinus Torvalds break; 3591da177e4SLinus Torvalds return e; 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3631da177e4SLinus Torvalds { 3641da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 36570f23020SAndrei Emeltchenko struct inquiry_entry *ie; 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3681da177e4SLinus Torvalds 36970f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 37070f23020SAndrei Emeltchenko if (!ie) { 3711da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 37270f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 37370f23020SAndrei Emeltchenko if (!ie) 3741da177e4SLinus Torvalds return; 37570f23020SAndrei Emeltchenko 37670f23020SAndrei Emeltchenko ie->next = cache->list; 37770f23020SAndrei Emeltchenko cache->list = ie; 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds 38070f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 38170f23020SAndrei Emeltchenko ie->timestamp = jiffies; 3821da177e4SLinus Torvalds cache->timestamp = jiffies; 3831da177e4SLinus Torvalds } 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3861da177e4SLinus Torvalds { 3871da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3881da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3891da177e4SLinus Torvalds struct inquiry_entry *e; 3901da177e4SLinus Torvalds int copied = 0; 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 3931da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 3941da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 3951da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 3961da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 3971da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 3981da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 3991da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 4001da177e4SLinus Torvalds info++; 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 4041da177e4SLinus Torvalds return copied; 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 4081da177e4SLinus Torvalds { 4091da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 4101da177e4SLinus Torvalds struct hci_cp_inquiry cp; 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 4151da177e4SLinus Torvalds return; 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds /* Start Inquiry */ 4181da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4191da177e4SLinus Torvalds cp.length = ir->length; 4201da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 421a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4251da177e4SLinus Torvalds { 4261da177e4SLinus Torvalds __u8 __user *ptr = arg; 4271da177e4SLinus Torvalds struct hci_inquiry_req ir; 4281da177e4SLinus Torvalds struct hci_dev *hdev; 4291da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4301da177e4SLinus Torvalds long timeo; 4311da177e4SLinus Torvalds __u8 *buf; 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4341da177e4SLinus Torvalds return -EFAULT; 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds if (!(hdev = hci_dev_get(ir.dev_id))) 4371da177e4SLinus Torvalds return -ENODEV; 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4401da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4411da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4421da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4431da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4441da177e4SLinus Torvalds do_inquiry = 1; 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4471da177e4SLinus Torvalds 44804837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 44970f23020SAndrei Emeltchenko 45070f23020SAndrei Emeltchenko if (do_inquiry) { 45170f23020SAndrei Emeltchenko err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo); 45270f23020SAndrei Emeltchenko if (err < 0) 4531da177e4SLinus Torvalds goto done; 45470f23020SAndrei Emeltchenko } 4551da177e4SLinus Torvalds 4561da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4571da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4601da177e4SLinus Torvalds * copy it to the user space. 4611da177e4SLinus Torvalds */ 46270f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) *max_rsp, GFP_KERNEL); 46370f23020SAndrei Emeltchenko if (!buf) { 4641da177e4SLinus Torvalds err = -ENOMEM; 4651da177e4SLinus Torvalds goto done; 4661da177e4SLinus Torvalds } 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4691da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4701da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4751da177e4SLinus Torvalds ptr += sizeof(ir); 4761da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4771da177e4SLinus Torvalds ir.num_rsp)) 4781da177e4SLinus Torvalds err = -EFAULT; 4791da177e4SLinus Torvalds } else 4801da177e4SLinus Torvalds err = -EFAULT; 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds kfree(buf); 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds done: 4851da177e4SLinus Torvalds hci_dev_put(hdev); 4861da177e4SLinus Torvalds return err; 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 4921da177e4SLinus Torvalds { 4931da177e4SLinus Torvalds struct hci_dev *hdev; 4941da177e4SLinus Torvalds int ret = 0; 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 4971da177e4SLinus Torvalds return -ENODEV; 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds hci_req_lock(hdev); 5021da177e4SLinus Torvalds 503611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 504611b30f7SMarcel Holtmann ret = -ERFKILL; 505611b30f7SMarcel Holtmann goto done; 506611b30f7SMarcel Holtmann } 507611b30f7SMarcel Holtmann 5081da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 5091da177e4SLinus Torvalds ret = -EALREADY; 5101da177e4SLinus Torvalds goto done; 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 5141da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 5151da177e4SLinus Torvalds 516943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 517943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 518943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 519943da25dSMarcel Holtmann 5201da177e4SLinus Torvalds if (hdev->open(hdev)) { 5211da177e4SLinus Torvalds ret = -EIO; 5221da177e4SLinus Torvalds goto done; 5231da177e4SLinus Torvalds } 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5261da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5271da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 528a5040efaSJohan Hedberg hdev->init_last_cmd = 0; 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds //__hci_request(hdev, hci_reset_req, 0, HZ); 53104837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 53204837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5351da177e4SLinus Torvalds } 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds if (!ret) { 5381da177e4SLinus Torvalds hci_dev_hold(hdev); 5391da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5401da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5415add6af8SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->flags)) 5425add6af8SJohan Hedberg mgmt_powered(hdev->id, 1); 5431da177e4SLinus Torvalds } else { 5441da177e4SLinus Torvalds /* Init failed, cleanup */ 5451da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5461da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5471da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5501da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds if (hdev->flush) 5531da177e4SLinus Torvalds hdev->flush(hdev); 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds if (hdev->sent_cmd) { 5561da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5571da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5581da177e4SLinus Torvalds } 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds hdev->close(hdev); 5611da177e4SLinus Torvalds hdev->flags = 0; 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds done: 5651da177e4SLinus Torvalds hci_req_unlock(hdev); 5661da177e4SLinus Torvalds hci_dev_put(hdev); 5671da177e4SLinus Torvalds return ret; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5711da177e4SLinus Torvalds { 5721da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5751da177e4SLinus Torvalds hci_req_lock(hdev); 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 5781da177e4SLinus Torvalds hci_req_unlock(hdev); 5791da177e4SLinus Torvalds return 0; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5831da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5841da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 5871da177e4SLinus Torvalds inquiry_cache_flush(hdev); 5881da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 5891da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds if (hdev->flush) 5941da177e4SLinus Torvalds hdev->flush(hdev); 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds /* Reset device */ 5971da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5981da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5991da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 6001da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 60104837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 60204837f64SMarcel Holtmann msecs_to_jiffies(250)); 6031da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 6041da177e4SLinus Torvalds } 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds /* Kill cmd task */ 6071da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds /* Drop queues */ 6101da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6111da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6121da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds /* Drop last sent command */ 6151da177e4SLinus Torvalds if (hdev->sent_cmd) { 6161da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 6171da177e4SLinus Torvalds hdev->sent_cmd = NULL; 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds /* After this point our queues are empty 6211da177e4SLinus Torvalds * and no tasks are scheduled. */ 6221da177e4SLinus Torvalds hdev->close(hdev); 6231da177e4SLinus Torvalds 6245add6af8SJohan Hedberg mgmt_powered(hdev->id, 0); 6255add6af8SJohan Hedberg 6261da177e4SLinus Torvalds /* Clear flags */ 6271da177e4SLinus Torvalds hdev->flags = 0; 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds hci_req_unlock(hdev); 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds hci_dev_put(hdev); 6321da177e4SLinus Torvalds return 0; 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6361da177e4SLinus Torvalds { 6371da177e4SLinus Torvalds struct hci_dev *hdev; 6381da177e4SLinus Torvalds int err; 6391da177e4SLinus Torvalds 64070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 64170f23020SAndrei Emeltchenko if (!hdev) 6421da177e4SLinus Torvalds return -ENODEV; 6431da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6441da177e4SLinus Torvalds hci_dev_put(hdev); 6451da177e4SLinus Torvalds return err; 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6491da177e4SLinus Torvalds { 6501da177e4SLinus Torvalds struct hci_dev *hdev; 6511da177e4SLinus Torvalds int ret = 0; 6521da177e4SLinus Torvalds 65370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 65470f23020SAndrei Emeltchenko if (!hdev) 6551da177e4SLinus Torvalds return -ENODEV; 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds hci_req_lock(hdev); 6581da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6611da177e4SLinus Torvalds goto done; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds /* Drop queues */ 6641da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6651da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6681da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6691da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6701da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds if (hdev->flush) 6731da177e4SLinus Torvalds hdev->flush(hdev); 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6761da177e4SLinus Torvalds hdev->acl_cnt = 0; hdev->sco_cnt = 0; 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 67904837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 68004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds done: 6831da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6841da177e4SLinus Torvalds hci_req_unlock(hdev); 6851da177e4SLinus Torvalds hci_dev_put(hdev); 6861da177e4SLinus Torvalds return ret; 6871da177e4SLinus Torvalds } 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 6901da177e4SLinus Torvalds { 6911da177e4SLinus Torvalds struct hci_dev *hdev; 6921da177e4SLinus Torvalds int ret = 0; 6931da177e4SLinus Torvalds 69470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 69570f23020SAndrei Emeltchenko if (!hdev) 6961da177e4SLinus Torvalds return -ENODEV; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds hci_dev_put(hdev); 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds return ret; 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 7061da177e4SLinus Torvalds { 7071da177e4SLinus Torvalds struct hci_dev *hdev; 7081da177e4SLinus Torvalds struct hci_dev_req dr; 7091da177e4SLinus Torvalds int err = 0; 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 7121da177e4SLinus Torvalds return -EFAULT; 7131da177e4SLinus Torvalds 71470f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 71570f23020SAndrei Emeltchenko if (!hdev) 7161da177e4SLinus Torvalds return -ENODEV; 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds switch (cmd) { 7191da177e4SLinus Torvalds case HCISETAUTH: 72004837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 72104837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7221da177e4SLinus Torvalds break; 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds case HCISETENCRYPT: 7251da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 7261da177e4SLinus Torvalds err = -EOPNOTSUPP; 7271da177e4SLinus Torvalds break; 7281da177e4SLinus Torvalds } 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7311da177e4SLinus Torvalds /* Auth must be enabled first */ 73204837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 73304837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7341da177e4SLinus Torvalds if (err) 7351da177e4SLinus Torvalds break; 7361da177e4SLinus Torvalds } 7371da177e4SLinus Torvalds 73804837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 73904837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7401da177e4SLinus Torvalds break; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds case HCISETSCAN: 74304837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 74404837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7451da177e4SLinus Torvalds break; 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds case HCISETLINKPOL: 748e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 749e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7501da177e4SLinus Torvalds break; 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds case HCISETLINKMODE: 753e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 754e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 755e4e8e37cSMarcel Holtmann break; 756e4e8e37cSMarcel Holtmann 757e4e8e37cSMarcel Holtmann case HCISETPTYPE: 758e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7591da177e4SLinus Torvalds break; 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds case HCISETACLMTU: 7621da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7631da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7641da177e4SLinus Torvalds break; 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds case HCISETSCOMTU: 7671da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7681da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7691da177e4SLinus Torvalds break; 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds default: 7721da177e4SLinus Torvalds err = -EINVAL; 7731da177e4SLinus Torvalds break; 7741da177e4SLinus Torvalds } 775e4e8e37cSMarcel Holtmann 7761da177e4SLinus Torvalds hci_dev_put(hdev); 7771da177e4SLinus Torvalds return err; 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7811da177e4SLinus Torvalds { 7821da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7831da177e4SLinus Torvalds struct hci_dev_req *dr; 7841da177e4SLinus Torvalds struct list_head *p; 7851da177e4SLinus Torvalds int n = 0, size, err; 7861da177e4SLinus Torvalds __u16 dev_num; 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 7891da177e4SLinus Torvalds return -EFAULT; 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 7921da177e4SLinus Torvalds return -EINVAL; 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 7951da177e4SLinus Torvalds 79670f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 79770f23020SAndrei Emeltchenko if (!dl) 7981da177e4SLinus Torvalds return -ENOMEM; 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds dr = dl->dev_req; 8011da177e4SLinus Torvalds 8021da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 8031da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8041da177e4SLinus Torvalds struct hci_dev *hdev; 805c542a06cSJohan Hedberg 8061da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 807c542a06cSJohan Hedberg 808ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 809c542a06cSJohan Hedberg 810c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 811c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 812c542a06cSJohan Hedberg 8131da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 8141da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 815c542a06cSJohan Hedberg 8161da177e4SLinus Torvalds if (++n >= dev_num) 8171da177e4SLinus Torvalds break; 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 8201da177e4SLinus Torvalds 8211da177e4SLinus Torvalds dl->dev_num = n; 8221da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 8251da177e4SLinus Torvalds kfree(dl); 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds return err ? -EFAULT : 0; 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 8311da177e4SLinus Torvalds { 8321da177e4SLinus Torvalds struct hci_dev *hdev; 8331da177e4SLinus Torvalds struct hci_dev_info di; 8341da177e4SLinus Torvalds int err = 0; 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 8371da177e4SLinus Torvalds return -EFAULT; 8381da177e4SLinus Torvalds 83970f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 84070f23020SAndrei Emeltchenko if (!hdev) 8411da177e4SLinus Torvalds return -ENODEV; 8421da177e4SLinus Torvalds 843ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 844ab81cbf9SJohan Hedberg 845c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 846c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 847c542a06cSJohan Hedberg 8481da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8491da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 850943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8511da177e4SLinus Torvalds di.flags = hdev->flags; 8521da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8531da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8541da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8551da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8561da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8571da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8581da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8611da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8641da177e4SLinus Torvalds err = -EFAULT; 8651da177e4SLinus Torvalds 8661da177e4SLinus Torvalds hci_dev_put(hdev); 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds return err; 8691da177e4SLinus Torvalds } 8701da177e4SLinus Torvalds 8711da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8721da177e4SLinus Torvalds 873611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 874611b30f7SMarcel Holtmann { 875611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 876611b30f7SMarcel Holtmann 877611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 878611b30f7SMarcel Holtmann 879611b30f7SMarcel Holtmann if (!blocked) 880611b30f7SMarcel Holtmann return 0; 881611b30f7SMarcel Holtmann 882611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 883611b30f7SMarcel Holtmann 884611b30f7SMarcel Holtmann return 0; 885611b30f7SMarcel Holtmann } 886611b30f7SMarcel Holtmann 887611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 888611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 889611b30f7SMarcel Holtmann }; 890611b30f7SMarcel Holtmann 8911da177e4SLinus Torvalds /* Alloc HCI device */ 8921da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 8931da177e4SLinus Torvalds { 8941da177e4SLinus Torvalds struct hci_dev *hdev; 8951da177e4SLinus Torvalds 89625ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 8971da177e4SLinus Torvalds if (!hdev) 8981da177e4SLinus Torvalds return NULL; 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds return hdev; 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 9051da177e4SLinus Torvalds 9061da177e4SLinus Torvalds /* Free HCI device */ 9071da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 9081da177e4SLinus Torvalds { 9091da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 9101da177e4SLinus Torvalds 911a91f2e39SMarcel Holtmann /* will free via device release */ 912a91f2e39SMarcel Holtmann put_device(&hdev->dev); 9131da177e4SLinus Torvalds } 9141da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 9151da177e4SLinus Torvalds 916ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 917ab81cbf9SJohan Hedberg { 918ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 919ab81cbf9SJohan Hedberg 920ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 921ab81cbf9SJohan Hedberg 922ab81cbf9SJohan Hedberg if (hci_dev_open(hdev->id) < 0) 923ab81cbf9SJohan Hedberg return; 924ab81cbf9SJohan Hedberg 925ab81cbf9SJohan Hedberg if (test_bit(HCI_AUTO_OFF, &hdev->flags)) 926ab81cbf9SJohan Hedberg mod_timer(&hdev->off_timer, 927ab81cbf9SJohan Hedberg jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT)); 928ab81cbf9SJohan Hedberg 929ab81cbf9SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->flags)) 930ab81cbf9SJohan Hedberg mgmt_index_added(hdev->id); 931ab81cbf9SJohan Hedberg } 932ab81cbf9SJohan Hedberg 933ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 934ab81cbf9SJohan Hedberg { 935ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_off); 936ab81cbf9SJohan Hedberg 937ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 938ab81cbf9SJohan Hedberg 939ab81cbf9SJohan Hedberg hci_dev_close(hdev->id); 940ab81cbf9SJohan Hedberg } 941ab81cbf9SJohan Hedberg 942ab81cbf9SJohan Hedberg static void hci_auto_off(unsigned long data) 943ab81cbf9SJohan Hedberg { 944ab81cbf9SJohan Hedberg struct hci_dev *hdev = (struct hci_dev *) data; 945ab81cbf9SJohan Hedberg 946ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 947ab81cbf9SJohan Hedberg 948ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 949ab81cbf9SJohan Hedberg 950ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_off); 951ab81cbf9SJohan Hedberg } 952ab81cbf9SJohan Hedberg 953ab81cbf9SJohan Hedberg void hci_del_off_timer(struct hci_dev *hdev) 954ab81cbf9SJohan Hedberg { 955ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 956ab81cbf9SJohan Hedberg 957ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 958ab81cbf9SJohan Hedberg del_timer(&hdev->off_timer); 959ab81cbf9SJohan Hedberg } 960ab81cbf9SJohan Hedberg 9612aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 9622aeb9a1aSJohan Hedberg { 9632aeb9a1aSJohan Hedberg struct list_head *p, *n; 9642aeb9a1aSJohan Hedberg 9652aeb9a1aSJohan Hedberg list_for_each_safe(p, n, &hdev->uuids) { 9662aeb9a1aSJohan Hedberg struct bt_uuid *uuid; 9672aeb9a1aSJohan Hedberg 9682aeb9a1aSJohan Hedberg uuid = list_entry(p, struct bt_uuid, list); 9692aeb9a1aSJohan Hedberg 9702aeb9a1aSJohan Hedberg list_del(p); 9712aeb9a1aSJohan Hedberg kfree(uuid); 9722aeb9a1aSJohan Hedberg } 9732aeb9a1aSJohan Hedberg 9742aeb9a1aSJohan Hedberg return 0; 9752aeb9a1aSJohan Hedberg } 9762aeb9a1aSJohan Hedberg 9771da177e4SLinus Torvalds /* Register HCI device */ 9781da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 9791da177e4SLinus Torvalds { 9801da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 981ef222013SMarcel Holtmann int i, id = 0; 9821da177e4SLinus Torvalds 983c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 984c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 9851da177e4SLinus Torvalds 9861da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 9871da177e4SLinus Torvalds return -EINVAL; 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 9901da177e4SLinus Torvalds 9911da177e4SLinus Torvalds /* Find first available device id */ 9921da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 9931da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 9941da177e4SLinus Torvalds break; 9951da177e4SLinus Torvalds head = p; id++; 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 9991da177e4SLinus Torvalds hdev->id = id; 10001da177e4SLinus Torvalds list_add(&hdev->list, head); 10011da177e4SLinus Torvalds 10021da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 10031da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds hdev->flags = 0; 10061da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 10075b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 10081da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 10091da177e4SLinus Torvalds 101004837f64SMarcel Holtmann hdev->idle_timeout = 0; 101104837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 101204837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 101304837f64SMarcel Holtmann 10141da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 10151da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 10161da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 10191da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 10201da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 10211da177e4SLinus Torvalds 1022cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1023ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 1024ef222013SMarcel Holtmann 10251da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 1026a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 10271da177e4SLinus Torvalds 10281da177e4SLinus Torvalds inquiry_cache_init(hdev); 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds hci_conn_hash_init(hdev); 10311da177e4SLinus Torvalds 1032ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1033f0358568SJohan Hedberg 10342aeb9a1aSJohan Hedberg INIT_LIST_HEAD(&hdev->uuids); 10352aeb9a1aSJohan Hedberg 1036ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1037ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1038ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1039ab81cbf9SJohan Hedberg 10401da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 10451da177e4SLinus Torvalds 1046f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1047f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1048f48fd9c8SMarcel Holtmann goto nomem; 1049f48fd9c8SMarcel Holtmann 10501da177e4SLinus Torvalds hci_register_sysfs(hdev); 10511da177e4SLinus Torvalds 1052611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1053611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1054611b30f7SMarcel Holtmann if (hdev->rfkill) { 1055611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1056611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1057611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1058611b30f7SMarcel Holtmann } 1059611b30f7SMarcel Holtmann } 1060611b30f7SMarcel Holtmann 1061ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1062ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1063ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1064ab81cbf9SJohan Hedberg 10651da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds return id; 1068f48fd9c8SMarcel Holtmann 1069f48fd9c8SMarcel Holtmann nomem: 1070f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1071f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1072f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1073f48fd9c8SMarcel Holtmann 1074f48fd9c8SMarcel Holtmann return -ENOMEM; 10751da177e4SLinus Torvalds } 10761da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 10771da177e4SLinus Torvalds 10781da177e4SLinus Torvalds /* Unregister HCI device */ 10791da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 10801da177e4SLinus Torvalds { 1081ef222013SMarcel Holtmann int i; 1082ef222013SMarcel Holtmann 1083c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 10861da177e4SLinus Torvalds list_del(&hdev->list); 10871da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds hci_dev_do_close(hdev); 10901da177e4SLinus Torvalds 1091cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1092ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1093ef222013SMarcel Holtmann 1094ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1095ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1096c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1097ab81cbf9SJohan Hedberg 10981da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 10991da177e4SLinus Torvalds 1100611b30f7SMarcel Holtmann if (hdev->rfkill) { 1101611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1102611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1103611b30f7SMarcel Holtmann } 1104611b30f7SMarcel Holtmann 1105147e2d59SDave Young hci_unregister_sysfs(hdev); 1106147e2d59SDave Young 1107f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1108f48fd9c8SMarcel Holtmann 1109e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1110e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 11112aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 1112e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1113e2e0cacbSJohan Hedberg 11141da177e4SLinus Torvalds __hci_dev_put(hdev); 1115ef222013SMarcel Holtmann 11161da177e4SLinus Torvalds return 0; 11171da177e4SLinus Torvalds } 11181da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 11191da177e4SLinus Torvalds 11201da177e4SLinus Torvalds /* Suspend HCI device */ 11211da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 11221da177e4SLinus Torvalds { 11231da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 11241da177e4SLinus Torvalds return 0; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds /* Resume HCI device */ 11291da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 11301da177e4SLinus Torvalds { 11311da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 11321da177e4SLinus Torvalds return 0; 11331da177e4SLinus Torvalds } 11341da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 11351da177e4SLinus Torvalds 113676bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 113776bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 113876bca880SMarcel Holtmann { 113976bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 114076bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 114176bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 114276bca880SMarcel Holtmann kfree_skb(skb); 114376bca880SMarcel Holtmann return -ENXIO; 114476bca880SMarcel Holtmann } 114576bca880SMarcel Holtmann 114676bca880SMarcel Holtmann /* Incomming skb */ 114776bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 114876bca880SMarcel Holtmann 114976bca880SMarcel Holtmann /* Time stamp */ 115076bca880SMarcel Holtmann __net_timestamp(skb); 115176bca880SMarcel Holtmann 115276bca880SMarcel Holtmann /* Queue frame for rx task */ 115376bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1154c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1155c78ae283SMarcel Holtmann 115676bca880SMarcel Holtmann return 0; 115776bca880SMarcel Holtmann } 115876bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 115976bca880SMarcel Holtmann 116033e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 116133e882a5SSuraj Sumangala int count, __u8 index, gfp_t gfp_mask) 116233e882a5SSuraj Sumangala { 116333e882a5SSuraj Sumangala int len = 0; 116433e882a5SSuraj Sumangala int hlen = 0; 116533e882a5SSuraj Sumangala int remain = count; 116633e882a5SSuraj Sumangala struct sk_buff *skb; 116733e882a5SSuraj Sumangala struct bt_skb_cb *scb; 116833e882a5SSuraj Sumangala 116933e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 117033e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 117133e882a5SSuraj Sumangala return -EILSEQ; 117233e882a5SSuraj Sumangala 117333e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 117433e882a5SSuraj Sumangala 117533e882a5SSuraj Sumangala if (!skb) { 117633e882a5SSuraj Sumangala switch (type) { 117733e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 117833e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 117933e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 118033e882a5SSuraj Sumangala break; 118133e882a5SSuraj Sumangala case HCI_EVENT_PKT: 118233e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 118333e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 118433e882a5SSuraj Sumangala break; 118533e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 118633e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 118733e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 118833e882a5SSuraj Sumangala break; 118933e882a5SSuraj Sumangala } 119033e882a5SSuraj Sumangala 119133e882a5SSuraj Sumangala skb = bt_skb_alloc(len, gfp_mask); 119233e882a5SSuraj Sumangala if (!skb) 119333e882a5SSuraj Sumangala return -ENOMEM; 119433e882a5SSuraj Sumangala 119533e882a5SSuraj Sumangala scb = (void *) skb->cb; 119633e882a5SSuraj Sumangala scb->expect = hlen; 119733e882a5SSuraj Sumangala scb->pkt_type = type; 119833e882a5SSuraj Sumangala 119933e882a5SSuraj Sumangala skb->dev = (void *) hdev; 120033e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 120133e882a5SSuraj Sumangala } 120233e882a5SSuraj Sumangala 120333e882a5SSuraj Sumangala while (count) { 120433e882a5SSuraj Sumangala scb = (void *) skb->cb; 120533e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 120633e882a5SSuraj Sumangala 120733e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 120833e882a5SSuraj Sumangala 120933e882a5SSuraj Sumangala count -= len; 121033e882a5SSuraj Sumangala data += len; 121133e882a5SSuraj Sumangala scb->expect -= len; 121233e882a5SSuraj Sumangala remain = count; 121333e882a5SSuraj Sumangala 121433e882a5SSuraj Sumangala switch (type) { 121533e882a5SSuraj Sumangala case HCI_EVENT_PKT: 121633e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 121733e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 121833e882a5SSuraj Sumangala scb->expect = h->plen; 121933e882a5SSuraj Sumangala 122033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 122133e882a5SSuraj Sumangala kfree_skb(skb); 122233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 122333e882a5SSuraj Sumangala return -ENOMEM; 122433e882a5SSuraj Sumangala } 122533e882a5SSuraj Sumangala } 122633e882a5SSuraj Sumangala break; 122733e882a5SSuraj Sumangala 122833e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 122933e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 123033e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 123133e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 123233e882a5SSuraj Sumangala 123333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 123433e882a5SSuraj Sumangala kfree_skb(skb); 123533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 123633e882a5SSuraj Sumangala return -ENOMEM; 123733e882a5SSuraj Sumangala } 123833e882a5SSuraj Sumangala } 123933e882a5SSuraj Sumangala break; 124033e882a5SSuraj Sumangala 124133e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 124233e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 124333e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 124433e882a5SSuraj Sumangala scb->expect = h->dlen; 124533e882a5SSuraj Sumangala 124633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 124733e882a5SSuraj Sumangala kfree_skb(skb); 124833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 124933e882a5SSuraj Sumangala return -ENOMEM; 125033e882a5SSuraj Sumangala } 125133e882a5SSuraj Sumangala } 125233e882a5SSuraj Sumangala break; 125333e882a5SSuraj Sumangala } 125433e882a5SSuraj Sumangala 125533e882a5SSuraj Sumangala if (scb->expect == 0) { 125633e882a5SSuraj Sumangala /* Complete frame */ 125733e882a5SSuraj Sumangala 125833e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 125933e882a5SSuraj Sumangala hci_recv_frame(skb); 126033e882a5SSuraj Sumangala 126133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 126233e882a5SSuraj Sumangala return remain; 126333e882a5SSuraj Sumangala } 126433e882a5SSuraj Sumangala } 126533e882a5SSuraj Sumangala 126633e882a5SSuraj Sumangala return remain; 126733e882a5SSuraj Sumangala } 126833e882a5SSuraj Sumangala 1269ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1270ef222013SMarcel Holtmann { 1271f39a3c06SSuraj Sumangala int rem = 0; 1272f39a3c06SSuraj Sumangala 1273ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1274ef222013SMarcel Holtmann return -EILSEQ; 1275ef222013SMarcel Holtmann 1276da5f6c37SGustavo F. Padovan while (count) { 1277f39a3c06SSuraj Sumangala rem = hci_reassembly(hdev, type, data, count, 1278f39a3c06SSuraj Sumangala type - 1, GFP_ATOMIC); 1279f39a3c06SSuraj Sumangala if (rem < 0) 1280f39a3c06SSuraj Sumangala return rem; 1281ef222013SMarcel Holtmann 1282f39a3c06SSuraj Sumangala data += (count - rem); 1283f39a3c06SSuraj Sumangala count = rem; 1284da5f6c37SGustavo F. Padovan }; 1285ef222013SMarcel Holtmann 1286f39a3c06SSuraj Sumangala return rem; 1287ef222013SMarcel Holtmann } 1288ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1289ef222013SMarcel Holtmann 129099811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 129199811510SSuraj Sumangala 129299811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 129399811510SSuraj Sumangala { 129499811510SSuraj Sumangala int type; 129599811510SSuraj Sumangala int rem = 0; 129699811510SSuraj Sumangala 1297da5f6c37SGustavo F. Padovan while (count) { 129899811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 129999811510SSuraj Sumangala 130099811510SSuraj Sumangala if (!skb) { 130199811510SSuraj Sumangala struct { char type; } *pkt; 130299811510SSuraj Sumangala 130399811510SSuraj Sumangala /* Start of the frame */ 130499811510SSuraj Sumangala pkt = data; 130599811510SSuraj Sumangala type = pkt->type; 130699811510SSuraj Sumangala 130799811510SSuraj Sumangala data++; 130899811510SSuraj Sumangala count--; 130999811510SSuraj Sumangala } else 131099811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 131199811510SSuraj Sumangala 131299811510SSuraj Sumangala rem = hci_reassembly(hdev, type, data, 131399811510SSuraj Sumangala count, STREAM_REASSEMBLY, GFP_ATOMIC); 131499811510SSuraj Sumangala if (rem < 0) 131599811510SSuraj Sumangala return rem; 131699811510SSuraj Sumangala 131799811510SSuraj Sumangala data += (count - rem); 131899811510SSuraj Sumangala count = rem; 1319da5f6c37SGustavo F. Padovan }; 132099811510SSuraj Sumangala 132199811510SSuraj Sumangala return rem; 132299811510SSuraj Sumangala } 132399811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 132499811510SSuraj Sumangala 13251da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 13261da177e4SLinus Torvalds 13271da177e4SLinus Torvalds /* Register/Unregister protocols. 13281da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 13291da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 13301da177e4SLinus Torvalds { 13311da177e4SLinus Torvalds int err = 0; 13321da177e4SLinus Torvalds 13331da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 13361da177e4SLinus Torvalds return -EINVAL; 13371da177e4SLinus Torvalds 13381da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds if (!hci_proto[hp->id]) 13411da177e4SLinus Torvalds hci_proto[hp->id] = hp; 13421da177e4SLinus Torvalds else 13431da177e4SLinus Torvalds err = -EEXIST; 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 13461da177e4SLinus Torvalds 13471da177e4SLinus Torvalds return err; 13481da177e4SLinus Torvalds } 13491da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 13501da177e4SLinus Torvalds 13511da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 13521da177e4SLinus Torvalds { 13531da177e4SLinus Torvalds int err = 0; 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 13581da177e4SLinus Torvalds return -EINVAL; 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 13611da177e4SLinus Torvalds 13621da177e4SLinus Torvalds if (hci_proto[hp->id]) 13631da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 13641da177e4SLinus Torvalds else 13651da177e4SLinus Torvalds err = -ENOENT; 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds return err; 13701da177e4SLinus Torvalds } 13711da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 13741da177e4SLinus Torvalds { 13751da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 13761da177e4SLinus Torvalds 13771da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 13781da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 13791da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 13801da177e4SLinus Torvalds 13811da177e4SLinus Torvalds return 0; 13821da177e4SLinus Torvalds } 13831da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 13841da177e4SLinus Torvalds 13851da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 13861da177e4SLinus Torvalds { 13871da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 13901da177e4SLinus Torvalds list_del(&cb->list); 13911da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds return 0; 13941da177e4SLinus Torvalds } 13951da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 13981da177e4SLinus Torvalds { 13991da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 14001da177e4SLinus Torvalds 14011da177e4SLinus Torvalds if (!hdev) { 14021da177e4SLinus Torvalds kfree_skb(skb); 14031da177e4SLinus Torvalds return -ENODEV; 14041da177e4SLinus Torvalds } 14051da177e4SLinus Torvalds 14060d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 14091da177e4SLinus Torvalds /* Time stamp */ 1410a61bbcf2SPatrick McHardy __net_timestamp(skb); 14111da177e4SLinus Torvalds 1412eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 14131da177e4SLinus Torvalds } 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 14161da177e4SLinus Torvalds skb_orphan(skb); 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds return hdev->send(skb); 14191da177e4SLinus Torvalds } 14201da177e4SLinus Torvalds 14211da177e4SLinus Torvalds /* Send HCI command */ 1422a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 14231da177e4SLinus Torvalds { 14241da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 14251da177e4SLinus Torvalds struct hci_command_hdr *hdr; 14261da177e4SLinus Torvalds struct sk_buff *skb; 14271da177e4SLinus Torvalds 1428a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 14291da177e4SLinus Torvalds 14301da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 14311da177e4SLinus Torvalds if (!skb) { 1432ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 14331da177e4SLinus Torvalds return -ENOMEM; 14341da177e4SLinus Torvalds } 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1437a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 14381da177e4SLinus Torvalds hdr->plen = plen; 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds if (plen) 14411da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 14441da177e4SLinus Torvalds 14450d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 14461da177e4SLinus Torvalds skb->dev = (void *) hdev; 1447c78ae283SMarcel Holtmann 1448a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags)) 1449a5040efaSJohan Hedberg hdev->init_last_cmd = opcode; 1450a5040efaSJohan Hedberg 14511da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1452c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds return 0; 14551da177e4SLinus Torvalds } 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds /* Get data from the previously sent command */ 1458a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 14591da177e4SLinus Torvalds { 14601da177e4SLinus Torvalds struct hci_command_hdr *hdr; 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds if (!hdev->sent_cmd) 14631da177e4SLinus Torvalds return NULL; 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 14661da177e4SLinus Torvalds 1467a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 14681da177e4SLinus Torvalds return NULL; 14691da177e4SLinus Torvalds 1470a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 14711da177e4SLinus Torvalds 14721da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 14731da177e4SLinus Torvalds } 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds /* Send ACL data */ 14761da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 14771da177e4SLinus Torvalds { 14781da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 14791da177e4SLinus Torvalds int len = skb->len; 14801da177e4SLinus Torvalds 1481badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1482badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 14839c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1484aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1485aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 14861da177e4SLinus Torvalds } 14871da177e4SLinus Torvalds 14889a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 14891da177e4SLinus Torvalds { 14901da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 14911da177e4SLinus Torvalds struct sk_buff *list; 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds skb->dev = (void *) hdev; 14960d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1497e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 14981da177e4SLinus Torvalds 149970f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 150070f23020SAndrei Emeltchenko if (!list) { 15011da177e4SLinus Torvalds /* Non fragmented */ 15021da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 15031da177e4SLinus Torvalds 15041da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 15051da177e4SLinus Torvalds } else { 15061da177e4SLinus Torvalds /* Fragmented */ 15071da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds /* Queue all fragments atomically */ 15121da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 15131da177e4SLinus Torvalds 15141da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1515e702112fSAndrei Emeltchenko 1516e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1517e702112fSAndrei Emeltchenko flags |= ACL_CONT; 15181da177e4SLinus Torvalds do { 15191da177e4SLinus Torvalds skb = list; list = list->next; 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds skb->dev = (void *) hdev; 15220d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1523e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 15241da177e4SLinus Torvalds 15251da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 15281da177e4SLinus Torvalds } while (list); 15291da177e4SLinus Torvalds 15301da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 15311da177e4SLinus Torvalds } 15321da177e4SLinus Torvalds 1533c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 15341da177e4SLinus Torvalds } 15351da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds /* Send SCO data */ 15380d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 15391da177e4SLinus Torvalds { 15401da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 15411da177e4SLinus Torvalds struct hci_sco_hdr hdr; 15421da177e4SLinus Torvalds 15431da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 15441da177e4SLinus Torvalds 1545aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 15461da177e4SLinus Torvalds hdr.dlen = skb->len; 15471da177e4SLinus Torvalds 1548badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1549badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 15509c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 15511da177e4SLinus Torvalds 15521da177e4SLinus Torvalds skb->dev = (void *) hdev; 15530d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1554c78ae283SMarcel Holtmann 15551da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1556c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 15571da177e4SLinus Torvalds } 15581da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 15591da177e4SLinus Torvalds 15601da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 15611da177e4SLinus Torvalds 15621da177e4SLinus Torvalds /* HCI Connection scheduler */ 15631da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 15641da177e4SLinus Torvalds { 15651da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 15661da177e4SLinus Torvalds struct hci_conn *conn = NULL; 15671da177e4SLinus Torvalds int num = 0, min = ~0; 15681da177e4SLinus Torvalds struct list_head *p; 15691da177e4SLinus Torvalds 15701da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 15711da177e4SLinus Torvalds * added and removed with TX task disabled. */ 15721da177e4SLinus Torvalds list_for_each(p, &h->list) { 15731da177e4SLinus Torvalds struct hci_conn *c; 15741da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 15751da177e4SLinus Torvalds 1576769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 15771da177e4SLinus Torvalds continue; 1578769be974SMarcel Holtmann 1579769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1580769be974SMarcel Holtmann continue; 1581769be974SMarcel Holtmann 15821da177e4SLinus Torvalds num++; 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds if (c->sent < min) { 15851da177e4SLinus Torvalds min = c->sent; 15861da177e4SLinus Torvalds conn = c; 15871da177e4SLinus Torvalds } 15881da177e4SLinus Torvalds } 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds if (conn) { 15911da177e4SLinus Torvalds int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt); 15921da177e4SLinus Torvalds int q = cnt / num; 15931da177e4SLinus Torvalds *quote = q ? q : 1; 15941da177e4SLinus Torvalds } else 15951da177e4SLinus Torvalds *quote = 0; 15961da177e4SLinus Torvalds 15971da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 15981da177e4SLinus Torvalds return conn; 15991da177e4SLinus Torvalds } 16001da177e4SLinus Torvalds 16011da177e4SLinus Torvalds static inline void hci_acl_tx_to(struct hci_dev *hdev) 16021da177e4SLinus Torvalds { 16031da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 16041da177e4SLinus Torvalds struct list_head *p; 16051da177e4SLinus Torvalds struct hci_conn *c; 16061da177e4SLinus Torvalds 16071da177e4SLinus Torvalds BT_ERR("%s ACL tx timeout", hdev->name); 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds /* Kill stalled connections */ 16101da177e4SLinus Torvalds list_for_each(p, &h->list) { 16111da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 16121da177e4SLinus Torvalds if (c->type == ACL_LINK && c->sent) { 16131da177e4SLinus Torvalds BT_ERR("%s killing stalled ACL connection %s", 16141da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 16151da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 16161da177e4SLinus Torvalds } 16171da177e4SLinus Torvalds } 16181da177e4SLinus Torvalds } 16191da177e4SLinus Torvalds 16201da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 16211da177e4SLinus Torvalds { 16221da177e4SLinus Torvalds struct hci_conn *conn; 16231da177e4SLinus Torvalds struct sk_buff *skb; 16241da177e4SLinus Torvalds int quote; 16251da177e4SLinus Torvalds 16261da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 16271da177e4SLinus Torvalds 16281da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 16291da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 16301da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 163182453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 16321da177e4SLinus Torvalds hci_acl_tx_to(hdev); 16331da177e4SLinus Torvalds } 16341da177e4SLinus Torvalds 16351da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 16361da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 16371da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 163804837f64SMarcel Holtmann 163904837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 164004837f64SMarcel Holtmann 16411da177e4SLinus Torvalds hci_send_frame(skb); 16421da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 16431da177e4SLinus Torvalds 16441da177e4SLinus Torvalds hdev->acl_cnt--; 16451da177e4SLinus Torvalds conn->sent++; 16461da177e4SLinus Torvalds } 16471da177e4SLinus Torvalds } 16481da177e4SLinus Torvalds } 16491da177e4SLinus Torvalds 16501da177e4SLinus Torvalds /* Schedule SCO */ 16511da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 16521da177e4SLinus Torvalds { 16531da177e4SLinus Torvalds struct hci_conn *conn; 16541da177e4SLinus Torvalds struct sk_buff *skb; 16551da177e4SLinus Torvalds int quote; 16561da177e4SLinus Torvalds 16571da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 16601da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 16611da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 16621da177e4SLinus Torvalds hci_send_frame(skb); 16631da177e4SLinus Torvalds 16641da177e4SLinus Torvalds conn->sent++; 16651da177e4SLinus Torvalds if (conn->sent == ~0) 16661da177e4SLinus Torvalds conn->sent = 0; 16671da177e4SLinus Torvalds } 16681da177e4SLinus Torvalds } 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 1671b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1672b6a0dc82SMarcel Holtmann { 1673b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1674b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1675b6a0dc82SMarcel Holtmann int quote; 1676b6a0dc82SMarcel Holtmann 1677b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1678b6a0dc82SMarcel Holtmann 1679b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1680b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1681b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1682b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1683b6a0dc82SMarcel Holtmann 1684b6a0dc82SMarcel Holtmann conn->sent++; 1685b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1686b6a0dc82SMarcel Holtmann conn->sent = 0; 1687b6a0dc82SMarcel Holtmann } 1688b6a0dc82SMarcel Holtmann } 1689b6a0dc82SMarcel Holtmann } 1690b6a0dc82SMarcel Holtmann 16911da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 16921da177e4SLinus Torvalds { 16931da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 16941da177e4SLinus Torvalds struct sk_buff *skb; 16951da177e4SLinus Torvalds 16961da177e4SLinus Torvalds read_lock(&hci_task_lock); 16971da177e4SLinus Torvalds 16981da177e4SLinus Torvalds BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt); 16991da177e4SLinus Torvalds 17001da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 17011da177e4SLinus Torvalds 17021da177e4SLinus Torvalds hci_sched_acl(hdev); 17031da177e4SLinus Torvalds 17041da177e4SLinus Torvalds hci_sched_sco(hdev); 17051da177e4SLinus Torvalds 1706b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1707b6a0dc82SMarcel Holtmann 17081da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 17091da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 17101da177e4SLinus Torvalds hci_send_frame(skb); 17111da177e4SLinus Torvalds 17121da177e4SLinus Torvalds read_unlock(&hci_task_lock); 17131da177e4SLinus Torvalds } 17141da177e4SLinus Torvalds 17151da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 17161da177e4SLinus Torvalds 17171da177e4SLinus Torvalds /* ACL data packet */ 17181da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 17191da177e4SLinus Torvalds { 17201da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 17211da177e4SLinus Torvalds struct hci_conn *conn; 17221da177e4SLinus Torvalds __u16 handle, flags; 17231da177e4SLinus Torvalds 17241da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 17251da177e4SLinus Torvalds 17261da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 17271da177e4SLinus Torvalds flags = hci_flags(handle); 17281da177e4SLinus Torvalds handle = hci_handle(handle); 17291da177e4SLinus Torvalds 17301da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 17311da177e4SLinus Torvalds 17321da177e4SLinus Torvalds hdev->stat.acl_rx++; 17331da177e4SLinus Torvalds 17341da177e4SLinus Torvalds hci_dev_lock(hdev); 17351da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 17361da177e4SLinus Torvalds hci_dev_unlock(hdev); 17371da177e4SLinus Torvalds 17381da177e4SLinus Torvalds if (conn) { 17391da177e4SLinus Torvalds register struct hci_proto *hp; 17401da177e4SLinus Torvalds 174104837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 174204837f64SMarcel Holtmann 17431da177e4SLinus Torvalds /* Send to upper protocol */ 174470f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 174570f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 17461da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 17471da177e4SLinus Torvalds return; 17481da177e4SLinus Torvalds } 17491da177e4SLinus Torvalds } else { 17501da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 17511da177e4SLinus Torvalds hdev->name, handle); 17521da177e4SLinus Torvalds } 17531da177e4SLinus Torvalds 17541da177e4SLinus Torvalds kfree_skb(skb); 17551da177e4SLinus Torvalds } 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds /* SCO data packet */ 17581da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 17591da177e4SLinus Torvalds { 17601da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 17611da177e4SLinus Torvalds struct hci_conn *conn; 17621da177e4SLinus Torvalds __u16 handle; 17631da177e4SLinus Torvalds 17641da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 17651da177e4SLinus Torvalds 17661da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 17671da177e4SLinus Torvalds 17681da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds hdev->stat.sco_rx++; 17711da177e4SLinus Torvalds 17721da177e4SLinus Torvalds hci_dev_lock(hdev); 17731da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 17741da177e4SLinus Torvalds hci_dev_unlock(hdev); 17751da177e4SLinus Torvalds 17761da177e4SLinus Torvalds if (conn) { 17771da177e4SLinus Torvalds register struct hci_proto *hp; 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds /* Send to upper protocol */ 178070f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 178170f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 17821da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 17831da177e4SLinus Torvalds return; 17841da177e4SLinus Torvalds } 17851da177e4SLinus Torvalds } else { 17861da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 17871da177e4SLinus Torvalds hdev->name, handle); 17881da177e4SLinus Torvalds } 17891da177e4SLinus Torvalds 17901da177e4SLinus Torvalds kfree_skb(skb); 17911da177e4SLinus Torvalds } 17921da177e4SLinus Torvalds 17936516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 17941da177e4SLinus Torvalds { 17951da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 17961da177e4SLinus Torvalds struct sk_buff *skb; 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17991da177e4SLinus Torvalds 18001da177e4SLinus Torvalds read_lock(&hci_task_lock); 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 18031da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 18041da177e4SLinus Torvalds /* Send copy to the sockets */ 1805eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 18061da177e4SLinus Torvalds } 18071da177e4SLinus Torvalds 18081da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 18091da177e4SLinus Torvalds kfree_skb(skb); 18101da177e4SLinus Torvalds continue; 18111da177e4SLinus Torvalds } 18121da177e4SLinus Torvalds 18131da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 18141da177e4SLinus Torvalds /* Don't process data packets in this states. */ 18150d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 18161da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 18171da177e4SLinus Torvalds case HCI_SCODATA_PKT: 18181da177e4SLinus Torvalds kfree_skb(skb); 18191da177e4SLinus Torvalds continue; 18203ff50b79SStephen Hemminger } 18211da177e4SLinus Torvalds } 18221da177e4SLinus Torvalds 18231da177e4SLinus Torvalds /* Process frame */ 18240d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 18251da177e4SLinus Torvalds case HCI_EVENT_PKT: 18261da177e4SLinus Torvalds hci_event_packet(hdev, skb); 18271da177e4SLinus Torvalds break; 18281da177e4SLinus Torvalds 18291da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 18301da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 18311da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 18321da177e4SLinus Torvalds break; 18331da177e4SLinus Torvalds 18341da177e4SLinus Torvalds case HCI_SCODATA_PKT: 18351da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 18361da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 18371da177e4SLinus Torvalds break; 18381da177e4SLinus Torvalds 18391da177e4SLinus Torvalds default: 18401da177e4SLinus Torvalds kfree_skb(skb); 18411da177e4SLinus Torvalds break; 18421da177e4SLinus Torvalds } 18431da177e4SLinus Torvalds } 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds read_unlock(&hci_task_lock); 18461da177e4SLinus Torvalds } 18471da177e4SLinus Torvalds 18481da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 18491da177e4SLinus Torvalds { 18501da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 18511da177e4SLinus Torvalds struct sk_buff *skb; 18521da177e4SLinus Torvalds 18531da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 18541da177e4SLinus Torvalds 185582453021SS.Çağlar Onur if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) { 18561da177e4SLinus Torvalds BT_ERR("%s command tx timeout", hdev->name); 18571da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18581da177e4SLinus Torvalds } 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds /* Send queued commands */ 18611da177e4SLinus Torvalds if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) { 18621da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 18631da177e4SLinus Torvalds 186470f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 186570f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 18661da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 18671da177e4SLinus Torvalds hci_send_frame(skb); 18681da177e4SLinus Torvalds hdev->cmd_last_tx = jiffies; 18691da177e4SLinus Torvalds } else { 18701da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 1871c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds } 18741da177e4SLinus Torvalds } 1875