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 /* Connection accept timeout ~20 secs */ 258aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 259a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 260b0916ea0SJohan Hedberg 261b0916ea0SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 262b0916ea0SJohan Hedberg cp.delete_all = 1; 263b0916ea0SJohan Hedberg hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp); 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds 2666ed58ec5SVille Tervo static void hci_le_init_req(struct hci_dev *hdev, unsigned long opt) 2676ed58ec5SVille Tervo { 2686ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 2696ed58ec5SVille Tervo 2706ed58ec5SVille Tervo /* Read LE buffer size */ 2716ed58ec5SVille Tervo hci_send_cmd(hdev, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 2726ed58ec5SVille Tervo } 2736ed58ec5SVille Tervo 2741da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2751da177e4SLinus Torvalds { 2761da177e4SLinus Torvalds __u8 scan = opt; 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds /* Inquiry and Page scans */ 281a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2851da177e4SLinus Torvalds { 2861da177e4SLinus Torvalds __u8 auth = opt; 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds /* Authentication */ 291a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2921da177e4SLinus Torvalds } 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2951da177e4SLinus Torvalds { 2961da177e4SLinus Torvalds __u8 encrypt = opt; 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 2991da177e4SLinus Torvalds 300e4e8e37cSMarcel Holtmann /* Encryption */ 301a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 3021da177e4SLinus Torvalds } 3031da177e4SLinus Torvalds 304e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 305e4e8e37cSMarcel Holtmann { 306e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 307e4e8e37cSMarcel Holtmann 308a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 309e4e8e37cSMarcel Holtmann 310e4e8e37cSMarcel Holtmann /* Default link policy */ 311e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 312e4e8e37cSMarcel Holtmann } 313e4e8e37cSMarcel Holtmann 3141da177e4SLinus Torvalds /* Get HCI device by index. 3151da177e4SLinus Torvalds * Device is held on return. */ 3161da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3171da177e4SLinus Torvalds { 3181da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3191da177e4SLinus Torvalds struct list_head *p; 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds BT_DBG("%d", index); 3221da177e4SLinus Torvalds 3231da177e4SLinus Torvalds if (index < 0) 3241da177e4SLinus Torvalds return NULL; 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3271da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3281da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3291da177e4SLinus Torvalds if (d->id == index) { 3301da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3311da177e4SLinus Torvalds break; 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3351da177e4SLinus Torvalds return hdev; 3361da177e4SLinus Torvalds } 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3391da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3401da177e4SLinus Torvalds { 3411da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3421da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds cache->list = NULL; 3471da177e4SLinus Torvalds while ((e = next)) { 3481da177e4SLinus Torvalds next = e->next; 3491da177e4SLinus Torvalds kfree(e); 3501da177e4SLinus Torvalds } 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3541da177e4SLinus Torvalds { 3551da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3561da177e4SLinus Torvalds struct inquiry_entry *e; 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3611da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3621da177e4SLinus Torvalds break; 3631da177e4SLinus Torvalds return e; 3641da177e4SLinus Torvalds } 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3671da177e4SLinus Torvalds { 3681da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 36970f23020SAndrei Emeltchenko struct inquiry_entry *ie; 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3721da177e4SLinus Torvalds 37370f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 37470f23020SAndrei Emeltchenko if (!ie) { 3751da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 37670f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 37770f23020SAndrei Emeltchenko if (!ie) 3781da177e4SLinus Torvalds return; 37970f23020SAndrei Emeltchenko 38070f23020SAndrei Emeltchenko ie->next = cache->list; 38170f23020SAndrei Emeltchenko cache->list = ie; 3821da177e4SLinus Torvalds } 3831da177e4SLinus Torvalds 38470f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 38570f23020SAndrei Emeltchenko ie->timestamp = jiffies; 3861da177e4SLinus Torvalds cache->timestamp = jiffies; 3871da177e4SLinus Torvalds } 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3901da177e4SLinus Torvalds { 3911da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3921da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3931da177e4SLinus Torvalds struct inquiry_entry *e; 3941da177e4SLinus Torvalds int copied = 0; 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 3971da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 3981da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 3991da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 4001da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 4011da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 4021da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 4031da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 4041da177e4SLinus Torvalds info++; 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 4081da177e4SLinus Torvalds return copied; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 4121da177e4SLinus Torvalds { 4131da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 4141da177e4SLinus Torvalds struct hci_cp_inquiry cp; 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 4171da177e4SLinus Torvalds 4181da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 4191da177e4SLinus Torvalds return; 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds /* Start Inquiry */ 4221da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4231da177e4SLinus Torvalds cp.length = ir->length; 4241da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 425a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4291da177e4SLinus Torvalds { 4301da177e4SLinus Torvalds __u8 __user *ptr = arg; 4311da177e4SLinus Torvalds struct hci_inquiry_req ir; 4321da177e4SLinus Torvalds struct hci_dev *hdev; 4331da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4341da177e4SLinus Torvalds long timeo; 4351da177e4SLinus Torvalds __u8 *buf; 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4381da177e4SLinus Torvalds return -EFAULT; 4391da177e4SLinus Torvalds 4405a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 4415a08ecceSAndrei Emeltchenko if (!hdev) 4421da177e4SLinus Torvalds return -ENODEV; 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4451da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4461da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4471da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4481da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4491da177e4SLinus Torvalds do_inquiry = 1; 4501da177e4SLinus Torvalds } 4511da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4521da177e4SLinus Torvalds 45304837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 45470f23020SAndrei Emeltchenko 45570f23020SAndrei Emeltchenko if (do_inquiry) { 45670f23020SAndrei Emeltchenko err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo); 45770f23020SAndrei Emeltchenko if (err < 0) 4581da177e4SLinus Torvalds goto done; 45970f23020SAndrei Emeltchenko } 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4621da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4651da177e4SLinus Torvalds * copy it to the user space. 4661da177e4SLinus Torvalds */ 46770f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) *max_rsp, GFP_KERNEL); 46870f23020SAndrei Emeltchenko if (!buf) { 4691da177e4SLinus Torvalds err = -ENOMEM; 4701da177e4SLinus Torvalds goto done; 4711da177e4SLinus Torvalds } 4721da177e4SLinus Torvalds 4731da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4741da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4751da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4801da177e4SLinus Torvalds ptr += sizeof(ir); 4811da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4821da177e4SLinus Torvalds ir.num_rsp)) 4831da177e4SLinus Torvalds err = -EFAULT; 4841da177e4SLinus Torvalds } else 4851da177e4SLinus Torvalds err = -EFAULT; 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds kfree(buf); 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds done: 4901da177e4SLinus Torvalds hci_dev_put(hdev); 4911da177e4SLinus Torvalds return err; 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 4971da177e4SLinus Torvalds { 4981da177e4SLinus Torvalds struct hci_dev *hdev; 4991da177e4SLinus Torvalds int ret = 0; 5001da177e4SLinus Torvalds 5015a08ecceSAndrei Emeltchenko hdev = hci_dev_get(dev); 5025a08ecceSAndrei Emeltchenko if (!hdev) 5031da177e4SLinus Torvalds return -ENODEV; 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds hci_req_lock(hdev); 5081da177e4SLinus Torvalds 509611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 510611b30f7SMarcel Holtmann ret = -ERFKILL; 511611b30f7SMarcel Holtmann goto done; 512611b30f7SMarcel Holtmann } 513611b30f7SMarcel Holtmann 5141da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 5151da177e4SLinus Torvalds ret = -EALREADY; 5161da177e4SLinus Torvalds goto done; 5171da177e4SLinus Torvalds } 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 5201da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 5211da177e4SLinus Torvalds 522943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 523943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 524943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 525943da25dSMarcel Holtmann 5261da177e4SLinus Torvalds if (hdev->open(hdev)) { 5271da177e4SLinus Torvalds ret = -EIO; 5281da177e4SLinus Torvalds goto done; 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5321da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5331da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 534a5040efaSJohan Hedberg hdev->init_last_cmd = 0; 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds //__hci_request(hdev, hci_reset_req, 0, HZ); 53704837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 53804837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5391da177e4SLinus Torvalds 5406ed58ec5SVille Tervo if (lmp_le_capable(hdev)) 5416ed58ec5SVille Tervo ret = __hci_request(hdev, hci_le_init_req, 0, 5426ed58ec5SVille Tervo msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5436ed58ec5SVille Tervo 5441da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds if (!ret) { 5481da177e4SLinus Torvalds hci_dev_hold(hdev); 5491da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5501da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5515add6af8SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->flags)) 5525add6af8SJohan Hedberg mgmt_powered(hdev->id, 1); 5531da177e4SLinus Torvalds } else { 5541da177e4SLinus Torvalds /* Init failed, cleanup */ 5551da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5561da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5571da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5601da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds if (hdev->flush) 5631da177e4SLinus Torvalds hdev->flush(hdev); 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds if (hdev->sent_cmd) { 5661da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5671da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds hdev->close(hdev); 5711da177e4SLinus Torvalds hdev->flags = 0; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds done: 5751da177e4SLinus Torvalds hci_req_unlock(hdev); 5761da177e4SLinus Torvalds hci_dev_put(hdev); 5771da177e4SLinus Torvalds return ret; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5811da177e4SLinus Torvalds { 5821da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5851da177e4SLinus Torvalds hci_req_lock(hdev); 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 5881da177e4SLinus Torvalds hci_req_unlock(hdev); 5891da177e4SLinus Torvalds return 0; 5901da177e4SLinus Torvalds } 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5931da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5941da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 5971da177e4SLinus Torvalds inquiry_cache_flush(hdev); 5981da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 5991da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds if (hdev->flush) 6041da177e4SLinus Torvalds hdev->flush(hdev); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds /* Reset device */ 6071da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6081da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6091da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 6101da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 61104837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 61204837f64SMarcel Holtmann msecs_to_jiffies(250)); 6131da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds /* Kill cmd task */ 6171da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* Drop queues */ 6201da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6211da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6221da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds /* Drop last sent command */ 6251da177e4SLinus Torvalds if (hdev->sent_cmd) { 6261da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 6271da177e4SLinus Torvalds hdev->sent_cmd = NULL; 6281da177e4SLinus Torvalds } 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds /* After this point our queues are empty 6311da177e4SLinus Torvalds * and no tasks are scheduled. */ 6321da177e4SLinus Torvalds hdev->close(hdev); 6331da177e4SLinus Torvalds 6345add6af8SJohan Hedberg mgmt_powered(hdev->id, 0); 6355add6af8SJohan Hedberg 6361da177e4SLinus Torvalds /* Clear flags */ 6371da177e4SLinus Torvalds hdev->flags = 0; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds hci_req_unlock(hdev); 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds hci_dev_put(hdev); 6421da177e4SLinus Torvalds return 0; 6431da177e4SLinus Torvalds } 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6461da177e4SLinus Torvalds { 6471da177e4SLinus Torvalds struct hci_dev *hdev; 6481da177e4SLinus Torvalds int err; 6491da177e4SLinus Torvalds 65070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 65170f23020SAndrei Emeltchenko if (!hdev) 6521da177e4SLinus Torvalds return -ENODEV; 6531da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6541da177e4SLinus Torvalds hci_dev_put(hdev); 6551da177e4SLinus Torvalds return err; 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6591da177e4SLinus Torvalds { 6601da177e4SLinus Torvalds struct hci_dev *hdev; 6611da177e4SLinus Torvalds int ret = 0; 6621da177e4SLinus Torvalds 66370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 66470f23020SAndrei Emeltchenko if (!hdev) 6651da177e4SLinus Torvalds return -ENODEV; 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds hci_req_lock(hdev); 6681da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6711da177e4SLinus Torvalds goto done; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds /* Drop queues */ 6741da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6751da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6781da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6791da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6801da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds if (hdev->flush) 6831da177e4SLinus Torvalds hdev->flush(hdev); 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6866ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 68904837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 69004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds done: 6931da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6941da177e4SLinus Torvalds hci_req_unlock(hdev); 6951da177e4SLinus Torvalds hci_dev_put(hdev); 6961da177e4SLinus Torvalds return ret; 6971da177e4SLinus Torvalds } 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 7001da177e4SLinus Torvalds { 7011da177e4SLinus Torvalds struct hci_dev *hdev; 7021da177e4SLinus Torvalds int ret = 0; 7031da177e4SLinus Torvalds 70470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 70570f23020SAndrei Emeltchenko if (!hdev) 7061da177e4SLinus Torvalds return -ENODEV; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds hci_dev_put(hdev); 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds return ret; 7131da177e4SLinus Torvalds } 7141da177e4SLinus Torvalds 7151da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 7161da177e4SLinus Torvalds { 7171da177e4SLinus Torvalds struct hci_dev *hdev; 7181da177e4SLinus Torvalds struct hci_dev_req dr; 7191da177e4SLinus Torvalds int err = 0; 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 7221da177e4SLinus Torvalds return -EFAULT; 7231da177e4SLinus Torvalds 72470f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 72570f23020SAndrei Emeltchenko if (!hdev) 7261da177e4SLinus Torvalds return -ENODEV; 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds switch (cmd) { 7291da177e4SLinus Torvalds case HCISETAUTH: 73004837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 73104837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7321da177e4SLinus Torvalds break; 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds case HCISETENCRYPT: 7351da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 7361da177e4SLinus Torvalds err = -EOPNOTSUPP; 7371da177e4SLinus Torvalds break; 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7411da177e4SLinus Torvalds /* Auth must be enabled first */ 74204837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 74304837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7441da177e4SLinus Torvalds if (err) 7451da177e4SLinus Torvalds break; 7461da177e4SLinus Torvalds } 7471da177e4SLinus Torvalds 74804837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 74904837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7501da177e4SLinus Torvalds break; 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds case HCISETSCAN: 75304837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 75404837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7551da177e4SLinus Torvalds break; 7561da177e4SLinus Torvalds 7571da177e4SLinus Torvalds case HCISETLINKPOL: 758e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 759e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7601da177e4SLinus Torvalds break; 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds case HCISETLINKMODE: 763e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 764e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 765e4e8e37cSMarcel Holtmann break; 766e4e8e37cSMarcel Holtmann 767e4e8e37cSMarcel Holtmann case HCISETPTYPE: 768e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7691da177e4SLinus Torvalds break; 7701da177e4SLinus Torvalds 7711da177e4SLinus Torvalds case HCISETACLMTU: 7721da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7731da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7741da177e4SLinus Torvalds break; 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds case HCISETSCOMTU: 7771da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7781da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7791da177e4SLinus Torvalds break; 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds default: 7821da177e4SLinus Torvalds err = -EINVAL; 7831da177e4SLinus Torvalds break; 7841da177e4SLinus Torvalds } 785e4e8e37cSMarcel Holtmann 7861da177e4SLinus Torvalds hci_dev_put(hdev); 7871da177e4SLinus Torvalds return err; 7881da177e4SLinus Torvalds } 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7911da177e4SLinus Torvalds { 7921da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7931da177e4SLinus Torvalds struct hci_dev_req *dr; 7941da177e4SLinus Torvalds struct list_head *p; 7951da177e4SLinus Torvalds int n = 0, size, err; 7961da177e4SLinus Torvalds __u16 dev_num; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 7991da177e4SLinus Torvalds return -EFAULT; 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 8021da177e4SLinus Torvalds return -EINVAL; 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 8051da177e4SLinus Torvalds 80670f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 80770f23020SAndrei Emeltchenko if (!dl) 8081da177e4SLinus Torvalds return -ENOMEM; 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds dr = dl->dev_req; 8111da177e4SLinus Torvalds 8121da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 8131da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8141da177e4SLinus Torvalds struct hci_dev *hdev; 815c542a06cSJohan Hedberg 8161da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 817c542a06cSJohan Hedberg 818ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 819c542a06cSJohan Hedberg 820c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 821c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 822c542a06cSJohan Hedberg 8231da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 8241da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 825c542a06cSJohan Hedberg 8261da177e4SLinus Torvalds if (++n >= dev_num) 8271da177e4SLinus Torvalds break; 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds dl->dev_num = n; 8321da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 8331da177e4SLinus Torvalds 8341da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 8351da177e4SLinus Torvalds kfree(dl); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds return err ? -EFAULT : 0; 8381da177e4SLinus Torvalds } 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 8411da177e4SLinus Torvalds { 8421da177e4SLinus Torvalds struct hci_dev *hdev; 8431da177e4SLinus Torvalds struct hci_dev_info di; 8441da177e4SLinus Torvalds int err = 0; 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 8471da177e4SLinus Torvalds return -EFAULT; 8481da177e4SLinus Torvalds 84970f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 85070f23020SAndrei Emeltchenko if (!hdev) 8511da177e4SLinus Torvalds return -ENODEV; 8521da177e4SLinus Torvalds 853ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 854ab81cbf9SJohan Hedberg 855c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 856c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 857c542a06cSJohan Hedberg 8581da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8591da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 860943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8611da177e4SLinus Torvalds di.flags = hdev->flags; 8621da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8631da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8641da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8651da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8661da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8671da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8681da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8711da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8721da177e4SLinus Torvalds 8731da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8741da177e4SLinus Torvalds err = -EFAULT; 8751da177e4SLinus Torvalds 8761da177e4SLinus Torvalds hci_dev_put(hdev); 8771da177e4SLinus Torvalds 8781da177e4SLinus Torvalds return err; 8791da177e4SLinus Torvalds } 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8821da177e4SLinus Torvalds 883611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 884611b30f7SMarcel Holtmann { 885611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 886611b30f7SMarcel Holtmann 887611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 888611b30f7SMarcel Holtmann 889611b30f7SMarcel Holtmann if (!blocked) 890611b30f7SMarcel Holtmann return 0; 891611b30f7SMarcel Holtmann 892611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 893611b30f7SMarcel Holtmann 894611b30f7SMarcel Holtmann return 0; 895611b30f7SMarcel Holtmann } 896611b30f7SMarcel Holtmann 897611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 898611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 899611b30f7SMarcel Holtmann }; 900611b30f7SMarcel Holtmann 9011da177e4SLinus Torvalds /* Alloc HCI device */ 9021da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 9031da177e4SLinus Torvalds { 9041da177e4SLinus Torvalds struct hci_dev *hdev; 9051da177e4SLinus Torvalds 90625ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 9071da177e4SLinus Torvalds if (!hdev) 9081da177e4SLinus Torvalds return NULL; 9091da177e4SLinus Torvalds 9101da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds return hdev; 9131da177e4SLinus Torvalds } 9141da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds /* Free HCI device */ 9171da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 9181da177e4SLinus Torvalds { 9191da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 9201da177e4SLinus Torvalds 921a91f2e39SMarcel Holtmann /* will free via device release */ 922a91f2e39SMarcel Holtmann put_device(&hdev->dev); 9231da177e4SLinus Torvalds } 9241da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 9251da177e4SLinus Torvalds 926ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 927ab81cbf9SJohan Hedberg { 928ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 929ab81cbf9SJohan Hedberg 930ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 931ab81cbf9SJohan Hedberg 932ab81cbf9SJohan Hedberg if (hci_dev_open(hdev->id) < 0) 933ab81cbf9SJohan Hedberg return; 934ab81cbf9SJohan Hedberg 935ab81cbf9SJohan Hedberg if (test_bit(HCI_AUTO_OFF, &hdev->flags)) 936ab81cbf9SJohan Hedberg mod_timer(&hdev->off_timer, 937ab81cbf9SJohan Hedberg jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT)); 938ab81cbf9SJohan Hedberg 939ab81cbf9SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->flags)) 940ab81cbf9SJohan Hedberg mgmt_index_added(hdev->id); 941ab81cbf9SJohan Hedberg } 942ab81cbf9SJohan Hedberg 943ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 944ab81cbf9SJohan Hedberg { 945ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_off); 946ab81cbf9SJohan Hedberg 947ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 948ab81cbf9SJohan Hedberg 949ab81cbf9SJohan Hedberg hci_dev_close(hdev->id); 950ab81cbf9SJohan Hedberg } 951ab81cbf9SJohan Hedberg 952ab81cbf9SJohan Hedberg static void hci_auto_off(unsigned long data) 953ab81cbf9SJohan Hedberg { 954ab81cbf9SJohan Hedberg struct hci_dev *hdev = (struct hci_dev *) data; 955ab81cbf9SJohan Hedberg 956ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 957ab81cbf9SJohan Hedberg 958ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 959ab81cbf9SJohan Hedberg 960ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_off); 961ab81cbf9SJohan Hedberg } 962ab81cbf9SJohan Hedberg 963ab81cbf9SJohan Hedberg void hci_del_off_timer(struct hci_dev *hdev) 964ab81cbf9SJohan Hedberg { 965ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 966ab81cbf9SJohan Hedberg 967ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 968ab81cbf9SJohan Hedberg del_timer(&hdev->off_timer); 969ab81cbf9SJohan Hedberg } 970ab81cbf9SJohan Hedberg 9712aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 9722aeb9a1aSJohan Hedberg { 9732aeb9a1aSJohan Hedberg struct list_head *p, *n; 9742aeb9a1aSJohan Hedberg 9752aeb9a1aSJohan Hedberg list_for_each_safe(p, n, &hdev->uuids) { 9762aeb9a1aSJohan Hedberg struct bt_uuid *uuid; 9772aeb9a1aSJohan Hedberg 9782aeb9a1aSJohan Hedberg uuid = list_entry(p, struct bt_uuid, list); 9792aeb9a1aSJohan Hedberg 9802aeb9a1aSJohan Hedberg list_del(p); 9812aeb9a1aSJohan Hedberg kfree(uuid); 9822aeb9a1aSJohan Hedberg } 9832aeb9a1aSJohan Hedberg 9842aeb9a1aSJohan Hedberg return 0; 9852aeb9a1aSJohan Hedberg } 9862aeb9a1aSJohan Hedberg 98755ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 98855ed8ca1SJohan Hedberg { 98955ed8ca1SJohan Hedberg struct list_head *p, *n; 99055ed8ca1SJohan Hedberg 99155ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 99255ed8ca1SJohan Hedberg struct link_key *key; 99355ed8ca1SJohan Hedberg 99455ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 99555ed8ca1SJohan Hedberg 99655ed8ca1SJohan Hedberg list_del(p); 99755ed8ca1SJohan Hedberg kfree(key); 99855ed8ca1SJohan Hedberg } 99955ed8ca1SJohan Hedberg 100055ed8ca1SJohan Hedberg return 0; 100155ed8ca1SJohan Hedberg } 100255ed8ca1SJohan Hedberg 100355ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 100455ed8ca1SJohan Hedberg { 100555ed8ca1SJohan Hedberg struct list_head *p; 100655ed8ca1SJohan Hedberg 100755ed8ca1SJohan Hedberg list_for_each(p, &hdev->link_keys) { 100855ed8ca1SJohan Hedberg struct link_key *k; 100955ed8ca1SJohan Hedberg 101055ed8ca1SJohan Hedberg k = list_entry(p, struct link_key, list); 101155ed8ca1SJohan Hedberg 101255ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 101355ed8ca1SJohan Hedberg return k; 101455ed8ca1SJohan Hedberg } 101555ed8ca1SJohan Hedberg 101655ed8ca1SJohan Hedberg return NULL; 101755ed8ca1SJohan Hedberg } 101855ed8ca1SJohan Hedberg 101955ed8ca1SJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, int new_key, bdaddr_t *bdaddr, 102055ed8ca1SJohan Hedberg u8 *val, u8 type, u8 pin_len) 102155ed8ca1SJohan Hedberg { 102255ed8ca1SJohan Hedberg struct link_key *key, *old_key; 102355ed8ca1SJohan Hedberg u8 old_key_type; 102455ed8ca1SJohan Hedberg 102555ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 102655ed8ca1SJohan Hedberg if (old_key) { 102755ed8ca1SJohan Hedberg old_key_type = old_key->type; 102855ed8ca1SJohan Hedberg key = old_key; 102955ed8ca1SJohan Hedberg } else { 103055ed8ca1SJohan Hedberg old_key_type = 0xff; 103155ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 103255ed8ca1SJohan Hedberg if (!key) 103355ed8ca1SJohan Hedberg return -ENOMEM; 103455ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 103555ed8ca1SJohan Hedberg } 103655ed8ca1SJohan Hedberg 103755ed8ca1SJohan Hedberg BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type); 103855ed8ca1SJohan Hedberg 103955ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 104055ed8ca1SJohan Hedberg memcpy(key->val, val, 16); 104155ed8ca1SJohan Hedberg key->type = type; 104255ed8ca1SJohan Hedberg key->pin_len = pin_len; 104355ed8ca1SJohan Hedberg 104455ed8ca1SJohan Hedberg if (new_key) 104555ed8ca1SJohan Hedberg mgmt_new_key(hdev->id, key, old_key_type); 104655ed8ca1SJohan Hedberg 104755ed8ca1SJohan Hedberg if (type == 0x06) 104855ed8ca1SJohan Hedberg key->type = old_key_type; 104955ed8ca1SJohan Hedberg 105055ed8ca1SJohan Hedberg return 0; 105155ed8ca1SJohan Hedberg } 105255ed8ca1SJohan Hedberg 105355ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 105455ed8ca1SJohan Hedberg { 105555ed8ca1SJohan Hedberg struct link_key *key; 105655ed8ca1SJohan Hedberg 105755ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 105855ed8ca1SJohan Hedberg if (!key) 105955ed8ca1SJohan Hedberg return -ENOENT; 106055ed8ca1SJohan Hedberg 106155ed8ca1SJohan Hedberg BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 106255ed8ca1SJohan Hedberg 106355ed8ca1SJohan Hedberg list_del(&key->list); 106455ed8ca1SJohan Hedberg kfree(key); 106555ed8ca1SJohan Hedberg 106655ed8ca1SJohan Hedberg return 0; 106755ed8ca1SJohan Hedberg } 106855ed8ca1SJohan Hedberg 10691da177e4SLinus Torvalds /* Register HCI device */ 10701da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 10711da177e4SLinus Torvalds { 10721da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 1073ef222013SMarcel Holtmann int i, id = 0; 10741da177e4SLinus Torvalds 1075c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 1076c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 10771da177e4SLinus Torvalds 10781da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 10791da177e4SLinus Torvalds return -EINVAL; 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 10821da177e4SLinus Torvalds 10831da177e4SLinus Torvalds /* Find first available device id */ 10841da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 10851da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 10861da177e4SLinus Torvalds break; 10871da177e4SLinus Torvalds head = p; id++; 10881da177e4SLinus Torvalds } 10891da177e4SLinus Torvalds 10901da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 10911da177e4SLinus Torvalds hdev->id = id; 10921da177e4SLinus Torvalds list_add(&hdev->list, head); 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 10951da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds hdev->flags = 0; 10981da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 10995b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 11001da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 110117fa4b9dSJohan Hedberg hdev->io_capability = 0x03; /* No Input No Output */ 11021da177e4SLinus Torvalds 110304837f64SMarcel Holtmann hdev->idle_timeout = 0; 110404837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 110504837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 110604837f64SMarcel Holtmann 11071da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 11081da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 11091da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 11121da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 11131da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 11141da177e4SLinus Torvalds 1115cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1116ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 1117ef222013SMarcel Holtmann 11181da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 1119a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 11201da177e4SLinus Torvalds 11211da177e4SLinus Torvalds inquiry_cache_init(hdev); 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds hci_conn_hash_init(hdev); 11241da177e4SLinus Torvalds 1125ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1126f0358568SJohan Hedberg 11272aeb9a1aSJohan Hedberg INIT_LIST_HEAD(&hdev->uuids); 11282aeb9a1aSJohan Hedberg 112955ed8ca1SJohan Hedberg INIT_LIST_HEAD(&hdev->link_keys); 113055ed8ca1SJohan Hedberg 1131ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1132ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1133ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1134ab81cbf9SJohan Hedberg 11351da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 11361da177e4SLinus Torvalds 11371da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 11401da177e4SLinus Torvalds 1141f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1142f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1143f48fd9c8SMarcel Holtmann goto nomem; 1144f48fd9c8SMarcel Holtmann 11451da177e4SLinus Torvalds hci_register_sysfs(hdev); 11461da177e4SLinus Torvalds 1147611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1148611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1149611b30f7SMarcel Holtmann if (hdev->rfkill) { 1150611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1151611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1152611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1153611b30f7SMarcel Holtmann } 1154611b30f7SMarcel Holtmann } 1155611b30f7SMarcel Holtmann 1156ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1157ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1158ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1159ab81cbf9SJohan Hedberg 11601da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds return id; 1163f48fd9c8SMarcel Holtmann 1164f48fd9c8SMarcel Holtmann nomem: 1165f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1166f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1167f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1168f48fd9c8SMarcel Holtmann 1169f48fd9c8SMarcel Holtmann return -ENOMEM; 11701da177e4SLinus Torvalds } 11711da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 11721da177e4SLinus Torvalds 11731da177e4SLinus Torvalds /* Unregister HCI device */ 11741da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 11751da177e4SLinus Torvalds { 1176ef222013SMarcel Holtmann int i; 1177ef222013SMarcel Holtmann 1178c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 11811da177e4SLinus Torvalds list_del(&hdev->list); 11821da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds hci_dev_do_close(hdev); 11851da177e4SLinus Torvalds 1186cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1187ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1188ef222013SMarcel Holtmann 1189ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1190ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1191c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1192ab81cbf9SJohan Hedberg 11931da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 11941da177e4SLinus Torvalds 1195611b30f7SMarcel Holtmann if (hdev->rfkill) { 1196611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1197611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1198611b30f7SMarcel Holtmann } 1199611b30f7SMarcel Holtmann 1200147e2d59SDave Young hci_unregister_sysfs(hdev); 1201147e2d59SDave Young 1202f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1203f48fd9c8SMarcel Holtmann 1204e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1205e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 12062aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 120755ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 1208e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1209e2e0cacbSJohan Hedberg 12101da177e4SLinus Torvalds __hci_dev_put(hdev); 1211ef222013SMarcel Holtmann 12121da177e4SLinus Torvalds return 0; 12131da177e4SLinus Torvalds } 12141da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds /* Suspend HCI device */ 12171da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 12181da177e4SLinus Torvalds { 12191da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 12201da177e4SLinus Torvalds return 0; 12211da177e4SLinus Torvalds } 12221da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds /* Resume HCI device */ 12251da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 12261da177e4SLinus Torvalds { 12271da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 12281da177e4SLinus Torvalds return 0; 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 12311da177e4SLinus Torvalds 123276bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 123376bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 123476bca880SMarcel Holtmann { 123576bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 123676bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 123776bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 123876bca880SMarcel Holtmann kfree_skb(skb); 123976bca880SMarcel Holtmann return -ENXIO; 124076bca880SMarcel Holtmann } 124176bca880SMarcel Holtmann 124276bca880SMarcel Holtmann /* Incomming skb */ 124376bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 124476bca880SMarcel Holtmann 124576bca880SMarcel Holtmann /* Time stamp */ 124676bca880SMarcel Holtmann __net_timestamp(skb); 124776bca880SMarcel Holtmann 124876bca880SMarcel Holtmann /* Queue frame for rx task */ 124976bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1250c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1251c78ae283SMarcel Holtmann 125276bca880SMarcel Holtmann return 0; 125376bca880SMarcel Holtmann } 125476bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 125576bca880SMarcel Holtmann 125633e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 125733e882a5SSuraj Sumangala int count, __u8 index, gfp_t gfp_mask) 125833e882a5SSuraj Sumangala { 125933e882a5SSuraj Sumangala int len = 0; 126033e882a5SSuraj Sumangala int hlen = 0; 126133e882a5SSuraj Sumangala int remain = count; 126233e882a5SSuraj Sumangala struct sk_buff *skb; 126333e882a5SSuraj Sumangala struct bt_skb_cb *scb; 126433e882a5SSuraj Sumangala 126533e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 126633e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 126733e882a5SSuraj Sumangala return -EILSEQ; 126833e882a5SSuraj Sumangala 126933e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 127033e882a5SSuraj Sumangala 127133e882a5SSuraj Sumangala if (!skb) { 127233e882a5SSuraj Sumangala switch (type) { 127333e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 127433e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 127533e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 127633e882a5SSuraj Sumangala break; 127733e882a5SSuraj Sumangala case HCI_EVENT_PKT: 127833e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 127933e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 128033e882a5SSuraj Sumangala break; 128133e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 128233e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 128333e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 128433e882a5SSuraj Sumangala break; 128533e882a5SSuraj Sumangala } 128633e882a5SSuraj Sumangala 128733e882a5SSuraj Sumangala skb = bt_skb_alloc(len, gfp_mask); 128833e882a5SSuraj Sumangala if (!skb) 128933e882a5SSuraj Sumangala return -ENOMEM; 129033e882a5SSuraj Sumangala 129133e882a5SSuraj Sumangala scb = (void *) skb->cb; 129233e882a5SSuraj Sumangala scb->expect = hlen; 129333e882a5SSuraj Sumangala scb->pkt_type = type; 129433e882a5SSuraj Sumangala 129533e882a5SSuraj Sumangala skb->dev = (void *) hdev; 129633e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 129733e882a5SSuraj Sumangala } 129833e882a5SSuraj Sumangala 129933e882a5SSuraj Sumangala while (count) { 130033e882a5SSuraj Sumangala scb = (void *) skb->cb; 130133e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 130233e882a5SSuraj Sumangala 130333e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 130433e882a5SSuraj Sumangala 130533e882a5SSuraj Sumangala count -= len; 130633e882a5SSuraj Sumangala data += len; 130733e882a5SSuraj Sumangala scb->expect -= len; 130833e882a5SSuraj Sumangala remain = count; 130933e882a5SSuraj Sumangala 131033e882a5SSuraj Sumangala switch (type) { 131133e882a5SSuraj Sumangala case HCI_EVENT_PKT: 131233e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 131333e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 131433e882a5SSuraj Sumangala scb->expect = h->plen; 131533e882a5SSuraj Sumangala 131633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 131733e882a5SSuraj Sumangala kfree_skb(skb); 131833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 131933e882a5SSuraj Sumangala return -ENOMEM; 132033e882a5SSuraj Sumangala } 132133e882a5SSuraj Sumangala } 132233e882a5SSuraj Sumangala break; 132333e882a5SSuraj Sumangala 132433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 132533e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 132633e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 132733e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 132833e882a5SSuraj Sumangala 132933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 133033e882a5SSuraj Sumangala kfree_skb(skb); 133133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 133233e882a5SSuraj Sumangala return -ENOMEM; 133333e882a5SSuraj Sumangala } 133433e882a5SSuraj Sumangala } 133533e882a5SSuraj Sumangala break; 133633e882a5SSuraj Sumangala 133733e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 133833e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 133933e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 134033e882a5SSuraj Sumangala scb->expect = h->dlen; 134133e882a5SSuraj Sumangala 134233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 134333e882a5SSuraj Sumangala kfree_skb(skb); 134433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 134533e882a5SSuraj Sumangala return -ENOMEM; 134633e882a5SSuraj Sumangala } 134733e882a5SSuraj Sumangala } 134833e882a5SSuraj Sumangala break; 134933e882a5SSuraj Sumangala } 135033e882a5SSuraj Sumangala 135133e882a5SSuraj Sumangala if (scb->expect == 0) { 135233e882a5SSuraj Sumangala /* Complete frame */ 135333e882a5SSuraj Sumangala 135433e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 135533e882a5SSuraj Sumangala hci_recv_frame(skb); 135633e882a5SSuraj Sumangala 135733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 135833e882a5SSuraj Sumangala return remain; 135933e882a5SSuraj Sumangala } 136033e882a5SSuraj Sumangala } 136133e882a5SSuraj Sumangala 136233e882a5SSuraj Sumangala return remain; 136333e882a5SSuraj Sumangala } 136433e882a5SSuraj Sumangala 1365ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1366ef222013SMarcel Holtmann { 1367f39a3c06SSuraj Sumangala int rem = 0; 1368f39a3c06SSuraj Sumangala 1369ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1370ef222013SMarcel Holtmann return -EILSEQ; 1371ef222013SMarcel Holtmann 1372da5f6c37SGustavo F. Padovan while (count) { 1373f39a3c06SSuraj Sumangala rem = hci_reassembly(hdev, type, data, count, 1374f39a3c06SSuraj Sumangala type - 1, GFP_ATOMIC); 1375f39a3c06SSuraj Sumangala if (rem < 0) 1376f39a3c06SSuraj Sumangala return rem; 1377ef222013SMarcel Holtmann 1378f39a3c06SSuraj Sumangala data += (count - rem); 1379f39a3c06SSuraj Sumangala count = rem; 1380da5f6c37SGustavo F. Padovan }; 1381ef222013SMarcel Holtmann 1382f39a3c06SSuraj Sumangala return rem; 1383ef222013SMarcel Holtmann } 1384ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1385ef222013SMarcel Holtmann 138699811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 138799811510SSuraj Sumangala 138899811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 138999811510SSuraj Sumangala { 139099811510SSuraj Sumangala int type; 139199811510SSuraj Sumangala int rem = 0; 139299811510SSuraj Sumangala 1393da5f6c37SGustavo F. Padovan while (count) { 139499811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 139599811510SSuraj Sumangala 139699811510SSuraj Sumangala if (!skb) { 139799811510SSuraj Sumangala struct { char type; } *pkt; 139899811510SSuraj Sumangala 139999811510SSuraj Sumangala /* Start of the frame */ 140099811510SSuraj Sumangala pkt = data; 140199811510SSuraj Sumangala type = pkt->type; 140299811510SSuraj Sumangala 140399811510SSuraj Sumangala data++; 140499811510SSuraj Sumangala count--; 140599811510SSuraj Sumangala } else 140699811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 140799811510SSuraj Sumangala 140899811510SSuraj Sumangala rem = hci_reassembly(hdev, type, data, 140999811510SSuraj Sumangala count, STREAM_REASSEMBLY, GFP_ATOMIC); 141099811510SSuraj Sumangala if (rem < 0) 141199811510SSuraj Sumangala return rem; 141299811510SSuraj Sumangala 141399811510SSuraj Sumangala data += (count - rem); 141499811510SSuraj Sumangala count = rem; 1415da5f6c37SGustavo F. Padovan }; 141699811510SSuraj Sumangala 141799811510SSuraj Sumangala return rem; 141899811510SSuraj Sumangala } 141999811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 142099811510SSuraj Sumangala 14211da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 14221da177e4SLinus Torvalds 14231da177e4SLinus Torvalds /* Register/Unregister protocols. 14241da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 14251da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 14261da177e4SLinus Torvalds { 14271da177e4SLinus Torvalds int err = 0; 14281da177e4SLinus Torvalds 14291da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 14301da177e4SLinus Torvalds 14311da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 14321da177e4SLinus Torvalds return -EINVAL; 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds if (!hci_proto[hp->id]) 14371da177e4SLinus Torvalds hci_proto[hp->id] = hp; 14381da177e4SLinus Torvalds else 14391da177e4SLinus Torvalds err = -EEXIST; 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds return err; 14441da177e4SLinus Torvalds } 14451da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 14461da177e4SLinus Torvalds 14471da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 14481da177e4SLinus Torvalds { 14491da177e4SLinus Torvalds int err = 0; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 14541da177e4SLinus Torvalds return -EINVAL; 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 14571da177e4SLinus Torvalds 14581da177e4SLinus Torvalds if (hci_proto[hp->id]) 14591da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 14601da177e4SLinus Torvalds else 14611da177e4SLinus Torvalds err = -ENOENT; 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds return err; 14661da177e4SLinus Torvalds } 14671da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 14681da177e4SLinus Torvalds 14691da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 14701da177e4SLinus Torvalds { 14711da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 14721da177e4SLinus Torvalds 14731da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 14741da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 14751da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 14761da177e4SLinus Torvalds 14771da177e4SLinus Torvalds return 0; 14781da177e4SLinus Torvalds } 14791da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 14801da177e4SLinus Torvalds 14811da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 14821da177e4SLinus Torvalds { 14831da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 14841da177e4SLinus Torvalds 14851da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 14861da177e4SLinus Torvalds list_del(&cb->list); 14871da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds return 0; 14901da177e4SLinus Torvalds } 14911da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 14941da177e4SLinus Torvalds { 14951da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds if (!hdev) { 14981da177e4SLinus Torvalds kfree_skb(skb); 14991da177e4SLinus Torvalds return -ENODEV; 15001da177e4SLinus Torvalds } 15011da177e4SLinus Torvalds 15020d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 15031da177e4SLinus Torvalds 15041da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 15051da177e4SLinus Torvalds /* Time stamp */ 1506a61bbcf2SPatrick McHardy __net_timestamp(skb); 15071da177e4SLinus Torvalds 1508eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 15091da177e4SLinus Torvalds } 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 15121da177e4SLinus Torvalds skb_orphan(skb); 15131da177e4SLinus Torvalds 15141da177e4SLinus Torvalds return hdev->send(skb); 15151da177e4SLinus Torvalds } 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds /* Send HCI command */ 1518a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 15191da177e4SLinus Torvalds { 15201da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 15211da177e4SLinus Torvalds struct hci_command_hdr *hdr; 15221da177e4SLinus Torvalds struct sk_buff *skb; 15231da177e4SLinus Torvalds 1524a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 15251da177e4SLinus Torvalds 15261da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 15271da177e4SLinus Torvalds if (!skb) { 1528ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 15291da177e4SLinus Torvalds return -ENOMEM; 15301da177e4SLinus Torvalds } 15311da177e4SLinus Torvalds 15321da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1533a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 15341da177e4SLinus Torvalds hdr->plen = plen; 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds if (plen) 15371da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 15381da177e4SLinus Torvalds 15391da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 15401da177e4SLinus Torvalds 15410d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 15421da177e4SLinus Torvalds skb->dev = (void *) hdev; 1543c78ae283SMarcel Holtmann 1544a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags)) 1545a5040efaSJohan Hedberg hdev->init_last_cmd = opcode; 1546a5040efaSJohan Hedberg 15471da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1548c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 15491da177e4SLinus Torvalds 15501da177e4SLinus Torvalds return 0; 15511da177e4SLinus Torvalds } 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds /* Get data from the previously sent command */ 1554a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 15551da177e4SLinus Torvalds { 15561da177e4SLinus Torvalds struct hci_command_hdr *hdr; 15571da177e4SLinus Torvalds 15581da177e4SLinus Torvalds if (!hdev->sent_cmd) 15591da177e4SLinus Torvalds return NULL; 15601da177e4SLinus Torvalds 15611da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 15621da177e4SLinus Torvalds 1563a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 15641da177e4SLinus Torvalds return NULL; 15651da177e4SLinus Torvalds 1566a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 15671da177e4SLinus Torvalds 15681da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 15691da177e4SLinus Torvalds } 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds /* Send ACL data */ 15721da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 15731da177e4SLinus Torvalds { 15741da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 15751da177e4SLinus Torvalds int len = skb->len; 15761da177e4SLinus Torvalds 1577badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1578badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 15799c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1580aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1581aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 15821da177e4SLinus Torvalds } 15831da177e4SLinus Torvalds 15849a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 15851da177e4SLinus Torvalds { 15861da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 15871da177e4SLinus Torvalds struct sk_buff *list; 15881da177e4SLinus Torvalds 15891da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds skb->dev = (void *) hdev; 15920d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1593e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 15941da177e4SLinus Torvalds 159570f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 159670f23020SAndrei Emeltchenko if (!list) { 15971da177e4SLinus Torvalds /* Non fragmented */ 15981da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 16011da177e4SLinus Torvalds } else { 16021da177e4SLinus Torvalds /* Fragmented */ 16031da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 16061da177e4SLinus Torvalds 16071da177e4SLinus Torvalds /* Queue all fragments atomically */ 16081da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 16091da177e4SLinus Torvalds 16101da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1611e702112fSAndrei Emeltchenko 1612e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1613e702112fSAndrei Emeltchenko flags |= ACL_CONT; 16141da177e4SLinus Torvalds do { 16151da177e4SLinus Torvalds skb = list; list = list->next; 16161da177e4SLinus Torvalds 16171da177e4SLinus Torvalds skb->dev = (void *) hdev; 16180d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1619e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 16221da177e4SLinus Torvalds 16231da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 16241da177e4SLinus Torvalds } while (list); 16251da177e4SLinus Torvalds 16261da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 16271da177e4SLinus Torvalds } 16281da177e4SLinus Torvalds 1629c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 16301da177e4SLinus Torvalds } 16311da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds /* Send SCO data */ 16340d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 16351da177e4SLinus Torvalds { 16361da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 16371da177e4SLinus Torvalds struct hci_sco_hdr hdr; 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 16401da177e4SLinus Torvalds 1641aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 16421da177e4SLinus Torvalds hdr.dlen = skb->len; 16431da177e4SLinus Torvalds 1644badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1645badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 16469c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 16471da177e4SLinus Torvalds 16481da177e4SLinus Torvalds skb->dev = (void *) hdev; 16490d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1650c78ae283SMarcel Holtmann 16511da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1652c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 16531da177e4SLinus Torvalds } 16541da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 16551da177e4SLinus Torvalds 16561da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 16571da177e4SLinus Torvalds 16581da177e4SLinus Torvalds /* HCI Connection scheduler */ 16591da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 16601da177e4SLinus Torvalds { 16611da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 16621da177e4SLinus Torvalds struct hci_conn *conn = NULL; 16631da177e4SLinus Torvalds int num = 0, min = ~0; 16641da177e4SLinus Torvalds struct list_head *p; 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 16671da177e4SLinus Torvalds * added and removed with TX task disabled. */ 16681da177e4SLinus Torvalds list_for_each(p, &h->list) { 16691da177e4SLinus Torvalds struct hci_conn *c; 16701da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 16711da177e4SLinus Torvalds 1672769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 16731da177e4SLinus Torvalds continue; 1674769be974SMarcel Holtmann 1675769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1676769be974SMarcel Holtmann continue; 1677769be974SMarcel Holtmann 16781da177e4SLinus Torvalds num++; 16791da177e4SLinus Torvalds 16801da177e4SLinus Torvalds if (c->sent < min) { 16811da177e4SLinus Torvalds min = c->sent; 16821da177e4SLinus Torvalds conn = c; 16831da177e4SLinus Torvalds } 16841da177e4SLinus Torvalds } 16851da177e4SLinus Torvalds 16861da177e4SLinus Torvalds if (conn) { 16876ed58ec5SVille Tervo int cnt, q; 16886ed58ec5SVille Tervo 16896ed58ec5SVille Tervo switch (conn->type) { 16906ed58ec5SVille Tervo case ACL_LINK: 16916ed58ec5SVille Tervo cnt = hdev->acl_cnt; 16926ed58ec5SVille Tervo break; 16936ed58ec5SVille Tervo case SCO_LINK: 16946ed58ec5SVille Tervo case ESCO_LINK: 16956ed58ec5SVille Tervo cnt = hdev->sco_cnt; 16966ed58ec5SVille Tervo break; 16976ed58ec5SVille Tervo case LE_LINK: 16986ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 16996ed58ec5SVille Tervo break; 17006ed58ec5SVille Tervo default: 17016ed58ec5SVille Tervo cnt = 0; 17026ed58ec5SVille Tervo BT_ERR("Unknown link type"); 17036ed58ec5SVille Tervo } 17046ed58ec5SVille Tervo 17056ed58ec5SVille Tervo q = cnt / num; 17061da177e4SLinus Torvalds *quote = q ? q : 1; 17071da177e4SLinus Torvalds } else 17081da177e4SLinus Torvalds *quote = 0; 17091da177e4SLinus Torvalds 17101da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 17111da177e4SLinus Torvalds return conn; 17121da177e4SLinus Torvalds } 17131da177e4SLinus Torvalds 1714bae1f5d9SVille Tervo static inline void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 17151da177e4SLinus Torvalds { 17161da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 17171da177e4SLinus Torvalds struct list_head *p; 17181da177e4SLinus Torvalds struct hci_conn *c; 17191da177e4SLinus Torvalds 1720bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 17211da177e4SLinus Torvalds 17221da177e4SLinus Torvalds /* Kill stalled connections */ 17231da177e4SLinus Torvalds list_for_each(p, &h->list) { 17241da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 1725bae1f5d9SVille Tervo if (c->type == type && c->sent) { 1726bae1f5d9SVille Tervo BT_ERR("%s killing stalled connection %s", 17271da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 17281da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 17291da177e4SLinus Torvalds } 17301da177e4SLinus Torvalds } 17311da177e4SLinus Torvalds } 17321da177e4SLinus Torvalds 17331da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 17341da177e4SLinus Torvalds { 17351da177e4SLinus Torvalds struct hci_conn *conn; 17361da177e4SLinus Torvalds struct sk_buff *skb; 17371da177e4SLinus Torvalds int quote; 17381da177e4SLinus Torvalds 17391da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17401da177e4SLinus Torvalds 17411da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 17421da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 17431da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 174482453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 1745bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 17461da177e4SLinus Torvalds } 17471da177e4SLinus Torvalds 17481da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 17491da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 17501da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 175104837f64SMarcel Holtmann 175204837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 175304837f64SMarcel Holtmann 17541da177e4SLinus Torvalds hci_send_frame(skb); 17551da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds hdev->acl_cnt--; 17581da177e4SLinus Torvalds conn->sent++; 17591da177e4SLinus Torvalds } 17601da177e4SLinus Torvalds } 17611da177e4SLinus Torvalds } 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds /* Schedule SCO */ 17641da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 17651da177e4SLinus Torvalds { 17661da177e4SLinus Torvalds struct hci_conn *conn; 17671da177e4SLinus Torvalds struct sk_buff *skb; 17681da177e4SLinus Torvalds int quote; 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17711da177e4SLinus Torvalds 17721da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 17731da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 17741da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 17751da177e4SLinus Torvalds hci_send_frame(skb); 17761da177e4SLinus Torvalds 17771da177e4SLinus Torvalds conn->sent++; 17781da177e4SLinus Torvalds if (conn->sent == ~0) 17791da177e4SLinus Torvalds conn->sent = 0; 17801da177e4SLinus Torvalds } 17811da177e4SLinus Torvalds } 17821da177e4SLinus Torvalds } 17831da177e4SLinus Torvalds 1784b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1785b6a0dc82SMarcel Holtmann { 1786b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1787b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1788b6a0dc82SMarcel Holtmann int quote; 1789b6a0dc82SMarcel Holtmann 1790b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1791b6a0dc82SMarcel Holtmann 1792b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1793b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1794b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1795b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1796b6a0dc82SMarcel Holtmann 1797b6a0dc82SMarcel Holtmann conn->sent++; 1798b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1799b6a0dc82SMarcel Holtmann conn->sent = 0; 1800b6a0dc82SMarcel Holtmann } 1801b6a0dc82SMarcel Holtmann } 1802b6a0dc82SMarcel Holtmann } 1803b6a0dc82SMarcel Holtmann 18046ed58ec5SVille Tervo static inline void hci_sched_le(struct hci_dev *hdev) 18056ed58ec5SVille Tervo { 18066ed58ec5SVille Tervo struct hci_conn *conn; 18076ed58ec5SVille Tervo struct sk_buff *skb; 18086ed58ec5SVille Tervo int quote, cnt; 18096ed58ec5SVille Tervo 18106ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 18116ed58ec5SVille Tervo 18126ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 18136ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 18146ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 1815bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 18166ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 1817bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 18186ed58ec5SVille Tervo } 18196ed58ec5SVille Tervo 18206ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 18216ed58ec5SVille Tervo while (cnt && (conn = hci_low_sent(hdev, LE_LINK, "e))) { 18226ed58ec5SVille Tervo while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 18236ed58ec5SVille Tervo BT_DBG("skb %p len %d", skb, skb->len); 18246ed58ec5SVille Tervo 18256ed58ec5SVille Tervo hci_send_frame(skb); 18266ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 18276ed58ec5SVille Tervo 18286ed58ec5SVille Tervo cnt--; 18296ed58ec5SVille Tervo conn->sent++; 18306ed58ec5SVille Tervo } 18316ed58ec5SVille Tervo } 18326ed58ec5SVille Tervo if (hdev->le_pkts) 18336ed58ec5SVille Tervo hdev->le_cnt = cnt; 18346ed58ec5SVille Tervo else 18356ed58ec5SVille Tervo hdev->acl_cnt = cnt; 18366ed58ec5SVille Tervo } 18376ed58ec5SVille Tervo 18381da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 18391da177e4SLinus Torvalds { 18401da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 18411da177e4SLinus Torvalds struct sk_buff *skb; 18421da177e4SLinus Torvalds 18431da177e4SLinus Torvalds read_lock(&hci_task_lock); 18441da177e4SLinus Torvalds 18456ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 18466ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 18471da177e4SLinus Torvalds 18481da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 18491da177e4SLinus Torvalds 18501da177e4SLinus Torvalds hci_sched_acl(hdev); 18511da177e4SLinus Torvalds 18521da177e4SLinus Torvalds hci_sched_sco(hdev); 18531da177e4SLinus Torvalds 1854b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1855b6a0dc82SMarcel Holtmann 18566ed58ec5SVille Tervo hci_sched_le(hdev); 18576ed58ec5SVille Tervo 18581da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 18591da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 18601da177e4SLinus Torvalds hci_send_frame(skb); 18611da177e4SLinus Torvalds 18621da177e4SLinus Torvalds read_unlock(&hci_task_lock); 18631da177e4SLinus Torvalds } 18641da177e4SLinus Torvalds 18651da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 18661da177e4SLinus Torvalds 18671da177e4SLinus Torvalds /* ACL data packet */ 18681da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 18691da177e4SLinus Torvalds { 18701da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 18711da177e4SLinus Torvalds struct hci_conn *conn; 18721da177e4SLinus Torvalds __u16 handle, flags; 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 18771da177e4SLinus Torvalds flags = hci_flags(handle); 18781da177e4SLinus Torvalds handle = hci_handle(handle); 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 18811da177e4SLinus Torvalds 18821da177e4SLinus Torvalds hdev->stat.acl_rx++; 18831da177e4SLinus Torvalds 18841da177e4SLinus Torvalds hci_dev_lock(hdev); 18851da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 18861da177e4SLinus Torvalds hci_dev_unlock(hdev); 18871da177e4SLinus Torvalds 18881da177e4SLinus Torvalds if (conn) { 18891da177e4SLinus Torvalds register struct hci_proto *hp; 18901da177e4SLinus Torvalds 189104837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 189204837f64SMarcel Holtmann 18931da177e4SLinus Torvalds /* Send to upper protocol */ 189470f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 189570f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 18961da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 18971da177e4SLinus Torvalds return; 18981da177e4SLinus Torvalds } 18991da177e4SLinus Torvalds } else { 19001da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 19011da177e4SLinus Torvalds hdev->name, handle); 19021da177e4SLinus Torvalds } 19031da177e4SLinus Torvalds 19041da177e4SLinus Torvalds kfree_skb(skb); 19051da177e4SLinus Torvalds } 19061da177e4SLinus Torvalds 19071da177e4SLinus Torvalds /* SCO data packet */ 19081da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 19091da177e4SLinus Torvalds { 19101da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 19111da177e4SLinus Torvalds struct hci_conn *conn; 19121da177e4SLinus Torvalds __u16 handle; 19131da177e4SLinus Torvalds 19141da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds hdev->stat.sco_rx++; 19211da177e4SLinus Torvalds 19221da177e4SLinus Torvalds hci_dev_lock(hdev); 19231da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 19241da177e4SLinus Torvalds hci_dev_unlock(hdev); 19251da177e4SLinus Torvalds 19261da177e4SLinus Torvalds if (conn) { 19271da177e4SLinus Torvalds register struct hci_proto *hp; 19281da177e4SLinus Torvalds 19291da177e4SLinus Torvalds /* Send to upper protocol */ 193070f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 193170f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 19321da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 19331da177e4SLinus Torvalds return; 19341da177e4SLinus Torvalds } 19351da177e4SLinus Torvalds } else { 19361da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 19371da177e4SLinus Torvalds hdev->name, handle); 19381da177e4SLinus Torvalds } 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvalds kfree_skb(skb); 19411da177e4SLinus Torvalds } 19421da177e4SLinus Torvalds 19436516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 19441da177e4SLinus Torvalds { 19451da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 19461da177e4SLinus Torvalds struct sk_buff *skb; 19471da177e4SLinus Torvalds 19481da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 19491da177e4SLinus Torvalds 19501da177e4SLinus Torvalds read_lock(&hci_task_lock); 19511da177e4SLinus Torvalds 19521da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 19531da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 19541da177e4SLinus Torvalds /* Send copy to the sockets */ 1955eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 19561da177e4SLinus Torvalds } 19571da177e4SLinus Torvalds 19581da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 19591da177e4SLinus Torvalds kfree_skb(skb); 19601da177e4SLinus Torvalds continue; 19611da177e4SLinus Torvalds } 19621da177e4SLinus Torvalds 19631da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 19641da177e4SLinus Torvalds /* Don't process data packets in this states. */ 19650d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 19661da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 19671da177e4SLinus Torvalds case HCI_SCODATA_PKT: 19681da177e4SLinus Torvalds kfree_skb(skb); 19691da177e4SLinus Torvalds continue; 19703ff50b79SStephen Hemminger } 19711da177e4SLinus Torvalds } 19721da177e4SLinus Torvalds 19731da177e4SLinus Torvalds /* Process frame */ 19740d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 19751da177e4SLinus Torvalds case HCI_EVENT_PKT: 19761da177e4SLinus Torvalds hci_event_packet(hdev, skb); 19771da177e4SLinus Torvalds break; 19781da177e4SLinus Torvalds 19791da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 19801da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 19811da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 19821da177e4SLinus Torvalds break; 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds case HCI_SCODATA_PKT: 19851da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 19861da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 19871da177e4SLinus Torvalds break; 19881da177e4SLinus Torvalds 19891da177e4SLinus Torvalds default: 19901da177e4SLinus Torvalds kfree_skb(skb); 19911da177e4SLinus Torvalds break; 19921da177e4SLinus Torvalds } 19931da177e4SLinus Torvalds } 19941da177e4SLinus Torvalds 19951da177e4SLinus Torvalds read_unlock(&hci_task_lock); 19961da177e4SLinus Torvalds } 19971da177e4SLinus Torvalds 19981da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 19991da177e4SLinus Torvalds { 20001da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 20011da177e4SLinus Torvalds struct sk_buff *skb; 20021da177e4SLinus Torvalds 20031da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 20041da177e4SLinus Torvalds 200582453021SS.Çağlar Onur if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) { 20061da177e4SLinus Torvalds BT_ERR("%s command tx timeout", hdev->name); 20071da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 20081da177e4SLinus Torvalds } 20091da177e4SLinus Torvalds 20101da177e4SLinus Torvalds /* Send queued commands */ 20115a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 20125a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 20135a08ecceSAndrei Emeltchenko if (!skb) 20145a08ecceSAndrei Emeltchenko return; 20155a08ecceSAndrei Emeltchenko 20161da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 20171da177e4SLinus Torvalds 201870f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 201970f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 20201da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 20211da177e4SLinus Torvalds hci_send_frame(skb); 20221da177e4SLinus Torvalds hdev->cmd_last_tx = jiffies; 20231da177e4SLinus Torvalds } else { 20241da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 2025c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 20261da177e4SLinus Torvalds } 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds } 2029