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> 446bd32326SVille Tervo #include <linux/timer.h> 451da177e4SLinus Torvalds #include <net/sock.h> 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds #include <asm/system.h> 4870f23020SAndrei Emeltchenko #include <linux/uaccess.h> 491da177e4SLinus Torvalds #include <asm/unaligned.h> 501da177e4SLinus Torvalds 511da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 521da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 531da177e4SLinus Torvalds 54ab81cbf9SJohan Hedberg #define AUTO_OFF_TIMEOUT 2000 55ab81cbf9SJohan Hedberg 561da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg); 571da177e4SLinus Torvalds static void hci_rx_task(unsigned long arg); 581da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg); 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 */ 18810572132SGustavo F. Padovan set_bit(HCI_RESET, &hdev->flags); 189a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1931da177e4SLinus Torvalds { 194b0916ea0SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 1951da177e4SLinus Torvalds struct sk_buff *skb; 1961ebb9252SMarcel Holtmann __le16 param; 19789f2783dSMarcel Holtmann __u8 flt_type; 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds /* Driver initialization */ 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /* Special commands */ 2041da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 2050d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2061da177e4SLinus Torvalds skb->dev = (void *) hdev; 207c78ae283SMarcel Holtmann 2081da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 209c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2121da177e4SLinus Torvalds 2131da177e4SLinus Torvalds /* Mandatory initialization */ 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds /* Reset */ 21610572132SGustavo F. Padovan if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) { 21710572132SGustavo F. Padovan set_bit(HCI_RESET, &hdev->flags); 218a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 21910572132SGustavo F. Padovan } 2201da177e4SLinus Torvalds 2211da177e4SLinus Torvalds /* Read Local Supported Features */ 222a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2231da177e4SLinus Torvalds 2241143e5a6SMarcel Holtmann /* Read Local Version */ 225a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2261143e5a6SMarcel Holtmann 2271da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 228a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds #if 0 2311da177e4SLinus Torvalds /* Host buffer size */ 2321da177e4SLinus Torvalds { 2331da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 234aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2351da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 236aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 237aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 238a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds #endif 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds /* Read BD Address */ 243a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 244a9de9248SMarcel Holtmann 245a9de9248SMarcel Holtmann /* Read Class of Device */ 246a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 247a9de9248SMarcel Holtmann 248a9de9248SMarcel Holtmann /* Read Local Name */ 249a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* Read Voice Setting */ 252a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds /* Optional initialization */ 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds /* Clear Event Filters */ 25789f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 258a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 261aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 262a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 263b0916ea0SJohan Hedberg 264b0916ea0SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 265b0916ea0SJohan Hedberg cp.delete_all = 1; 266b0916ea0SJohan Hedberg hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp); 2671da177e4SLinus Torvalds } 2681da177e4SLinus Torvalds 2696ed58ec5SVille Tervo static void hci_le_init_req(struct hci_dev *hdev, unsigned long opt) 2706ed58ec5SVille Tervo { 2716ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 2726ed58ec5SVille Tervo 2736ed58ec5SVille Tervo /* Read LE buffer size */ 2746ed58ec5SVille Tervo hci_send_cmd(hdev, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 2756ed58ec5SVille Tervo } 2766ed58ec5SVille Tervo 2771da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2781da177e4SLinus Torvalds { 2791da177e4SLinus Torvalds __u8 scan = opt; 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds /* Inquiry and Page scans */ 284a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2881da177e4SLinus Torvalds { 2891da177e4SLinus Torvalds __u8 auth = opt; 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds /* Authentication */ 294a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2981da177e4SLinus Torvalds { 2991da177e4SLinus Torvalds __u8 encrypt = opt; 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 3021da177e4SLinus Torvalds 303e4e8e37cSMarcel Holtmann /* Encryption */ 304a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 307e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 308e4e8e37cSMarcel Holtmann { 309e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 310e4e8e37cSMarcel Holtmann 311a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 312e4e8e37cSMarcel Holtmann 313e4e8e37cSMarcel Holtmann /* Default link policy */ 314e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 315e4e8e37cSMarcel Holtmann } 316e4e8e37cSMarcel Holtmann 3171da177e4SLinus Torvalds /* Get HCI device by index. 3181da177e4SLinus Torvalds * Device is held on return. */ 3191da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3201da177e4SLinus Torvalds { 3211da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3221da177e4SLinus Torvalds struct list_head *p; 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds BT_DBG("%d", index); 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds if (index < 0) 3271da177e4SLinus Torvalds return NULL; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3301da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3311da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3321da177e4SLinus Torvalds if (d->id == index) { 3331da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3341da177e4SLinus Torvalds break; 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds } 3371da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3381da177e4SLinus Torvalds return hdev; 3391da177e4SLinus Torvalds } 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3421da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3431da177e4SLinus Torvalds { 3441da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3451da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds cache->list = NULL; 3501da177e4SLinus Torvalds while ((e = next)) { 3511da177e4SLinus Torvalds next = e->next; 3521da177e4SLinus Torvalds kfree(e); 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3571da177e4SLinus Torvalds { 3581da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3591da177e4SLinus Torvalds struct inquiry_entry *e; 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3641da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3651da177e4SLinus Torvalds break; 3661da177e4SLinus Torvalds return e; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3701da177e4SLinus Torvalds { 3711da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 37270f23020SAndrei Emeltchenko struct inquiry_entry *ie; 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3751da177e4SLinus Torvalds 37670f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 37770f23020SAndrei Emeltchenko if (!ie) { 3781da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 37970f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 38070f23020SAndrei Emeltchenko if (!ie) 3811da177e4SLinus Torvalds return; 38270f23020SAndrei Emeltchenko 38370f23020SAndrei Emeltchenko ie->next = cache->list; 38470f23020SAndrei Emeltchenko cache->list = ie; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 38770f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 38870f23020SAndrei Emeltchenko ie->timestamp = jiffies; 3891da177e4SLinus Torvalds cache->timestamp = jiffies; 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3931da177e4SLinus Torvalds { 3941da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3951da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3961da177e4SLinus Torvalds struct inquiry_entry *e; 3971da177e4SLinus Torvalds int copied = 0; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 4001da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 4011da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 4021da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 4031da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 4041da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 4051da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 4061da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 4071da177e4SLinus Torvalds info++; 4081da177e4SLinus Torvalds } 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 4111da177e4SLinus Torvalds return copied; 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 4151da177e4SLinus Torvalds { 4161da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 4171da177e4SLinus Torvalds struct hci_cp_inquiry cp; 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 4221da177e4SLinus Torvalds return; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds /* Start Inquiry */ 4251da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4261da177e4SLinus Torvalds cp.length = ir->length; 4271da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 428a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4321da177e4SLinus Torvalds { 4331da177e4SLinus Torvalds __u8 __user *ptr = arg; 4341da177e4SLinus Torvalds struct hci_inquiry_req ir; 4351da177e4SLinus Torvalds struct hci_dev *hdev; 4361da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4371da177e4SLinus Torvalds long timeo; 4381da177e4SLinus Torvalds __u8 *buf; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4411da177e4SLinus Torvalds return -EFAULT; 4421da177e4SLinus Torvalds 4435a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 4445a08ecceSAndrei Emeltchenko if (!hdev) 4451da177e4SLinus Torvalds return -ENODEV; 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4481da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4491da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4501da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4511da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4521da177e4SLinus Torvalds do_inquiry = 1; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4551da177e4SLinus Torvalds 45604837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 45770f23020SAndrei Emeltchenko 45870f23020SAndrei Emeltchenko if (do_inquiry) { 45970f23020SAndrei Emeltchenko err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo); 46070f23020SAndrei Emeltchenko if (err < 0) 4611da177e4SLinus Torvalds goto done; 46270f23020SAndrei Emeltchenko } 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4651da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4681da177e4SLinus Torvalds * copy it to the user space. 4691da177e4SLinus Torvalds */ 47070f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 47170f23020SAndrei Emeltchenko if (!buf) { 4721da177e4SLinus Torvalds err = -ENOMEM; 4731da177e4SLinus Torvalds goto done; 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4771da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4781da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4831da177e4SLinus Torvalds ptr += sizeof(ir); 4841da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4851da177e4SLinus Torvalds ir.num_rsp)) 4861da177e4SLinus Torvalds err = -EFAULT; 4871da177e4SLinus Torvalds } else 4881da177e4SLinus Torvalds err = -EFAULT; 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds kfree(buf); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds done: 4931da177e4SLinus Torvalds hci_dev_put(hdev); 4941da177e4SLinus Torvalds return err; 4951da177e4SLinus Torvalds } 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 5001da177e4SLinus Torvalds { 5011da177e4SLinus Torvalds struct hci_dev *hdev; 5021da177e4SLinus Torvalds int ret = 0; 5031da177e4SLinus Torvalds 5045a08ecceSAndrei Emeltchenko hdev = hci_dev_get(dev); 5055a08ecceSAndrei Emeltchenko if (!hdev) 5061da177e4SLinus Torvalds return -ENODEV; 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds hci_req_lock(hdev); 5111da177e4SLinus Torvalds 512611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 513611b30f7SMarcel Holtmann ret = -ERFKILL; 514611b30f7SMarcel Holtmann goto done; 515611b30f7SMarcel Holtmann } 516611b30f7SMarcel Holtmann 5171da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 5181da177e4SLinus Torvalds ret = -EALREADY; 5191da177e4SLinus Torvalds goto done; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 5231da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 5241da177e4SLinus Torvalds 525943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 526943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 527943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 528943da25dSMarcel Holtmann 5291da177e4SLinus Torvalds if (hdev->open(hdev)) { 5301da177e4SLinus Torvalds ret = -EIO; 5311da177e4SLinus Torvalds goto done; 5321da177e4SLinus Torvalds } 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5351da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5361da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 537a5040efaSJohan Hedberg hdev->init_last_cmd = 0; 5381da177e4SLinus Torvalds 53904837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 54004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5411da177e4SLinus Torvalds 5426ed58ec5SVille Tervo if (lmp_le_capable(hdev)) 5436ed58ec5SVille Tervo ret = __hci_request(hdev, hci_le_init_req, 0, 5446ed58ec5SVille Tervo msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5456ed58ec5SVille Tervo 5461da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds if (!ret) { 5501da177e4SLinus Torvalds hci_dev_hold(hdev); 5511da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5521da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5535add6af8SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->flags)) 5545add6af8SJohan Hedberg mgmt_powered(hdev->id, 1); 5551da177e4SLinus Torvalds } else { 5561da177e4SLinus Torvalds /* Init failed, cleanup */ 5571da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5581da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5591da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5621da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds if (hdev->flush) 5651da177e4SLinus Torvalds hdev->flush(hdev); 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds if (hdev->sent_cmd) { 5681da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5691da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds hdev->close(hdev); 5731da177e4SLinus Torvalds hdev->flags = 0; 5741da177e4SLinus Torvalds } 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds done: 5771da177e4SLinus Torvalds hci_req_unlock(hdev); 5781da177e4SLinus Torvalds hci_dev_put(hdev); 5791da177e4SLinus Torvalds return ret; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5831da177e4SLinus Torvalds { 5841da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5871da177e4SLinus Torvalds hci_req_lock(hdev); 5881da177e4SLinus Torvalds 5896f5ef998SThomas Gleixner /* Stop timer, it might be running */ 5906f5ef998SThomas Gleixner del_timer_sync(&hdev->cmd_timer); 5916f5ef998SThomas Gleixner 5921da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 593b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 5941da177e4SLinus Torvalds hci_req_unlock(hdev); 5951da177e4SLinus Torvalds return 0; 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5991da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 6001da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6031da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6041da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6051da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds if (hdev->flush) 6101da177e4SLinus Torvalds hdev->flush(hdev); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds /* Reset device */ 6131da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6141da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6151da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 6161da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 61704837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 61804837f64SMarcel Holtmann msecs_to_jiffies(250)); 6191da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 6201da177e4SLinus Torvalds } 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds /* Kill cmd task */ 6231da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds /* Drop queues */ 6261da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6271da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6281da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds /* Drop last sent command */ 6311da177e4SLinus Torvalds if (hdev->sent_cmd) { 6321da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 6331da177e4SLinus Torvalds hdev->sent_cmd = NULL; 6341da177e4SLinus Torvalds } 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds /* After this point our queues are empty 6371da177e4SLinus Torvalds * and no tasks are scheduled. */ 6381da177e4SLinus Torvalds hdev->close(hdev); 6391da177e4SLinus Torvalds 6405add6af8SJohan Hedberg mgmt_powered(hdev->id, 0); 6415add6af8SJohan Hedberg 6421da177e4SLinus Torvalds /* Clear flags */ 6431da177e4SLinus Torvalds hdev->flags = 0; 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds hci_req_unlock(hdev); 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds hci_dev_put(hdev); 6481da177e4SLinus Torvalds return 0; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6521da177e4SLinus Torvalds { 6531da177e4SLinus Torvalds struct hci_dev *hdev; 6541da177e4SLinus Torvalds int err; 6551da177e4SLinus Torvalds 65670f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 65770f23020SAndrei Emeltchenko if (!hdev) 6581da177e4SLinus Torvalds return -ENODEV; 6591da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6601da177e4SLinus Torvalds hci_dev_put(hdev); 6611da177e4SLinus Torvalds return err; 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6651da177e4SLinus Torvalds { 6661da177e4SLinus Torvalds struct hci_dev *hdev; 6671da177e4SLinus Torvalds int ret = 0; 6681da177e4SLinus Torvalds 66970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 67070f23020SAndrei Emeltchenko if (!hdev) 6711da177e4SLinus Torvalds return -ENODEV; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds hci_req_lock(hdev); 6741da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6771da177e4SLinus Torvalds goto done; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds /* Drop queues */ 6801da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6811da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6841da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6851da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6861da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds if (hdev->flush) 6891da177e4SLinus Torvalds hdev->flush(hdev); 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6926ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 69504837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 69604837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds done: 6991da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 7001da177e4SLinus Torvalds hci_req_unlock(hdev); 7011da177e4SLinus Torvalds hci_dev_put(hdev); 7021da177e4SLinus Torvalds return ret; 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 7061da177e4SLinus Torvalds { 7071da177e4SLinus Torvalds struct hci_dev *hdev; 7081da177e4SLinus Torvalds int ret = 0; 7091da177e4SLinus Torvalds 71070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 71170f23020SAndrei Emeltchenko if (!hdev) 7121da177e4SLinus Torvalds return -ENODEV; 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds hci_dev_put(hdev); 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds return ret; 7191da177e4SLinus Torvalds } 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 7221da177e4SLinus Torvalds { 7231da177e4SLinus Torvalds struct hci_dev *hdev; 7241da177e4SLinus Torvalds struct hci_dev_req dr; 7251da177e4SLinus Torvalds int err = 0; 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 7281da177e4SLinus Torvalds return -EFAULT; 7291da177e4SLinus Torvalds 73070f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 73170f23020SAndrei Emeltchenko if (!hdev) 7321da177e4SLinus Torvalds return -ENODEV; 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds switch (cmd) { 7351da177e4SLinus Torvalds case HCISETAUTH: 73604837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 73704837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7381da177e4SLinus Torvalds break; 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds case HCISETENCRYPT: 7411da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 7421da177e4SLinus Torvalds err = -EOPNOTSUPP; 7431da177e4SLinus Torvalds break; 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7471da177e4SLinus Torvalds /* Auth must be enabled first */ 74804837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 74904837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7501da177e4SLinus Torvalds if (err) 7511da177e4SLinus Torvalds break; 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds 75404837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 75504837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7561da177e4SLinus Torvalds break; 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds case HCISETSCAN: 75904837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 76004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7611da177e4SLinus Torvalds break; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds case HCISETLINKPOL: 764e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 765e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7661da177e4SLinus Torvalds break; 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds case HCISETLINKMODE: 769e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 770e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 771e4e8e37cSMarcel Holtmann break; 772e4e8e37cSMarcel Holtmann 773e4e8e37cSMarcel Holtmann case HCISETPTYPE: 774e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7751da177e4SLinus Torvalds break; 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds case HCISETACLMTU: 7781da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7791da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7801da177e4SLinus Torvalds break; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds case HCISETSCOMTU: 7831da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7841da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7851da177e4SLinus Torvalds break; 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds default: 7881da177e4SLinus Torvalds err = -EINVAL; 7891da177e4SLinus Torvalds break; 7901da177e4SLinus Torvalds } 791e4e8e37cSMarcel Holtmann 7921da177e4SLinus Torvalds hci_dev_put(hdev); 7931da177e4SLinus Torvalds return err; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7971da177e4SLinus Torvalds { 7981da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7991da177e4SLinus Torvalds struct hci_dev_req *dr; 8001da177e4SLinus Torvalds struct list_head *p; 8011da177e4SLinus Torvalds int n = 0, size, err; 8021da177e4SLinus Torvalds __u16 dev_num; 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 8051da177e4SLinus Torvalds return -EFAULT; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 8081da177e4SLinus Torvalds return -EINVAL; 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 8111da177e4SLinus Torvalds 81270f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 81370f23020SAndrei Emeltchenko if (!dl) 8141da177e4SLinus Torvalds return -ENOMEM; 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds dr = dl->dev_req; 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 8191da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8201da177e4SLinus Torvalds struct hci_dev *hdev; 821c542a06cSJohan Hedberg 8221da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 823c542a06cSJohan Hedberg 824ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 825c542a06cSJohan Hedberg 826c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 827c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 828c542a06cSJohan Hedberg 8291da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 8301da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 831c542a06cSJohan Hedberg 8321da177e4SLinus Torvalds if (++n >= dev_num) 8331da177e4SLinus Torvalds break; 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds dl->dev_num = n; 8381da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 8411da177e4SLinus Torvalds kfree(dl); 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds return err ? -EFAULT : 0; 8441da177e4SLinus Torvalds } 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 8471da177e4SLinus Torvalds { 8481da177e4SLinus Torvalds struct hci_dev *hdev; 8491da177e4SLinus Torvalds struct hci_dev_info di; 8501da177e4SLinus Torvalds int err = 0; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 8531da177e4SLinus Torvalds return -EFAULT; 8541da177e4SLinus Torvalds 85570f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 85670f23020SAndrei Emeltchenko if (!hdev) 8571da177e4SLinus Torvalds return -ENODEV; 8581da177e4SLinus Torvalds 859ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 860ab81cbf9SJohan Hedberg 861c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 862c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 863c542a06cSJohan Hedberg 8641da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8651da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 866943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8671da177e4SLinus Torvalds di.flags = hdev->flags; 8681da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8691da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8701da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8711da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8721da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8731da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8741da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8751da177e4SLinus Torvalds 8761da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8771da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8801da177e4SLinus Torvalds err = -EFAULT; 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds hci_dev_put(hdev); 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds return err; 8851da177e4SLinus Torvalds } 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8881da177e4SLinus Torvalds 889611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 890611b30f7SMarcel Holtmann { 891611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 892611b30f7SMarcel Holtmann 893611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 894611b30f7SMarcel Holtmann 895611b30f7SMarcel Holtmann if (!blocked) 896611b30f7SMarcel Holtmann return 0; 897611b30f7SMarcel Holtmann 898611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 899611b30f7SMarcel Holtmann 900611b30f7SMarcel Holtmann return 0; 901611b30f7SMarcel Holtmann } 902611b30f7SMarcel Holtmann 903611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 904611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 905611b30f7SMarcel Holtmann }; 906611b30f7SMarcel Holtmann 9071da177e4SLinus Torvalds /* Alloc HCI device */ 9081da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 9091da177e4SLinus Torvalds { 9101da177e4SLinus Torvalds struct hci_dev *hdev; 9111da177e4SLinus Torvalds 91225ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 9131da177e4SLinus Torvalds if (!hdev) 9141da177e4SLinus Torvalds return NULL; 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 9171da177e4SLinus Torvalds 9181da177e4SLinus Torvalds return hdev; 9191da177e4SLinus Torvalds } 9201da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds /* Free HCI device */ 9231da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 9241da177e4SLinus Torvalds { 9251da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 9261da177e4SLinus Torvalds 927a91f2e39SMarcel Holtmann /* will free via device release */ 928a91f2e39SMarcel Holtmann put_device(&hdev->dev); 9291da177e4SLinus Torvalds } 9301da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 9311da177e4SLinus Torvalds 932ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 933ab81cbf9SJohan Hedberg { 934ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 935ab81cbf9SJohan Hedberg 936ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 937ab81cbf9SJohan Hedberg 938ab81cbf9SJohan Hedberg if (hci_dev_open(hdev->id) < 0) 939ab81cbf9SJohan Hedberg return; 940ab81cbf9SJohan Hedberg 941ab81cbf9SJohan Hedberg if (test_bit(HCI_AUTO_OFF, &hdev->flags)) 942ab81cbf9SJohan Hedberg mod_timer(&hdev->off_timer, 943ab81cbf9SJohan Hedberg jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT)); 944ab81cbf9SJohan Hedberg 945ab81cbf9SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->flags)) 946ab81cbf9SJohan Hedberg mgmt_index_added(hdev->id); 947ab81cbf9SJohan Hedberg } 948ab81cbf9SJohan Hedberg 949ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 950ab81cbf9SJohan Hedberg { 951ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_off); 952ab81cbf9SJohan Hedberg 953ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 954ab81cbf9SJohan Hedberg 955ab81cbf9SJohan Hedberg hci_dev_close(hdev->id); 956ab81cbf9SJohan Hedberg } 957ab81cbf9SJohan Hedberg 958ab81cbf9SJohan Hedberg static void hci_auto_off(unsigned long data) 959ab81cbf9SJohan Hedberg { 960ab81cbf9SJohan Hedberg struct hci_dev *hdev = (struct hci_dev *) data; 961ab81cbf9SJohan Hedberg 962ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 963ab81cbf9SJohan Hedberg 964ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 965ab81cbf9SJohan Hedberg 966ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_off); 967ab81cbf9SJohan Hedberg } 968ab81cbf9SJohan Hedberg 969ab81cbf9SJohan Hedberg void hci_del_off_timer(struct hci_dev *hdev) 970ab81cbf9SJohan Hedberg { 971ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 972ab81cbf9SJohan Hedberg 973ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 974ab81cbf9SJohan Hedberg del_timer(&hdev->off_timer); 975ab81cbf9SJohan Hedberg } 976ab81cbf9SJohan Hedberg 9772aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 9782aeb9a1aSJohan Hedberg { 9792aeb9a1aSJohan Hedberg struct list_head *p, *n; 9802aeb9a1aSJohan Hedberg 9812aeb9a1aSJohan Hedberg list_for_each_safe(p, n, &hdev->uuids) { 9822aeb9a1aSJohan Hedberg struct bt_uuid *uuid; 9832aeb9a1aSJohan Hedberg 9842aeb9a1aSJohan Hedberg uuid = list_entry(p, struct bt_uuid, list); 9852aeb9a1aSJohan Hedberg 9862aeb9a1aSJohan Hedberg list_del(p); 9872aeb9a1aSJohan Hedberg kfree(uuid); 9882aeb9a1aSJohan Hedberg } 9892aeb9a1aSJohan Hedberg 9902aeb9a1aSJohan Hedberg return 0; 9912aeb9a1aSJohan Hedberg } 9922aeb9a1aSJohan Hedberg 99355ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 99455ed8ca1SJohan Hedberg { 99555ed8ca1SJohan Hedberg struct list_head *p, *n; 99655ed8ca1SJohan Hedberg 99755ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 99855ed8ca1SJohan Hedberg struct link_key *key; 99955ed8ca1SJohan Hedberg 100055ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 100155ed8ca1SJohan Hedberg 100255ed8ca1SJohan Hedberg list_del(p); 100355ed8ca1SJohan Hedberg kfree(key); 100455ed8ca1SJohan Hedberg } 100555ed8ca1SJohan Hedberg 100655ed8ca1SJohan Hedberg return 0; 100755ed8ca1SJohan Hedberg } 100855ed8ca1SJohan Hedberg 100955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 101055ed8ca1SJohan Hedberg { 101155ed8ca1SJohan Hedberg struct list_head *p; 101255ed8ca1SJohan Hedberg 101355ed8ca1SJohan Hedberg list_for_each(p, &hdev->link_keys) { 101455ed8ca1SJohan Hedberg struct link_key *k; 101555ed8ca1SJohan Hedberg 101655ed8ca1SJohan Hedberg k = list_entry(p, struct link_key, list); 101755ed8ca1SJohan Hedberg 101855ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 101955ed8ca1SJohan Hedberg return k; 102055ed8ca1SJohan Hedberg } 102155ed8ca1SJohan Hedberg 102255ed8ca1SJohan Hedberg return NULL; 102355ed8ca1SJohan Hedberg } 102455ed8ca1SJohan Hedberg 1025d25e28abSJohan Hedberg static int hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 1026d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 1027d25e28abSJohan Hedberg { 1028d25e28abSJohan Hedberg /* Legacy key */ 1029d25e28abSJohan Hedberg if (key_type < 0x03) 1030d25e28abSJohan Hedberg return 1; 1031d25e28abSJohan Hedberg 1032d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 1033d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 1034d25e28abSJohan Hedberg return 0; 1035d25e28abSJohan Hedberg 1036d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 1037d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 1038d25e28abSJohan Hedberg return 0; 1039d25e28abSJohan Hedberg 1040d25e28abSJohan Hedberg /* Security mode 3 case */ 1041d25e28abSJohan Hedberg if (!conn) 1042d25e28abSJohan Hedberg return 1; 1043d25e28abSJohan Hedberg 1044d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 1045d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 1046d25e28abSJohan Hedberg return 1; 1047d25e28abSJohan Hedberg 1048d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 1049d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 1050d25e28abSJohan Hedberg return 1; 1051d25e28abSJohan Hedberg 1052d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 1053d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 1054d25e28abSJohan Hedberg return 1; 1055d25e28abSJohan Hedberg 1056d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 1057d25e28abSJohan Hedberg * persistently */ 1058d25e28abSJohan Hedberg return 0; 1059d25e28abSJohan Hedberg } 1060d25e28abSJohan Hedberg 1061d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 1062d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 106355ed8ca1SJohan Hedberg { 106455ed8ca1SJohan Hedberg struct link_key *key, *old_key; 106555ed8ca1SJohan Hedberg u8 old_key_type; 106655ed8ca1SJohan Hedberg 106755ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 106855ed8ca1SJohan Hedberg if (old_key) { 106955ed8ca1SJohan Hedberg old_key_type = old_key->type; 107055ed8ca1SJohan Hedberg key = old_key; 107155ed8ca1SJohan Hedberg } else { 1072*12adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 107355ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 107455ed8ca1SJohan Hedberg if (!key) 107555ed8ca1SJohan Hedberg return -ENOMEM; 107655ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 107755ed8ca1SJohan Hedberg } 107855ed8ca1SJohan Hedberg 107955ed8ca1SJohan Hedberg BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type); 108055ed8ca1SJohan Hedberg 1081d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 1082d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 1083d25e28abSJohan Hedberg * previous key */ 1084d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 1085d25e28abSJohan Hedberg (!conn || conn->remote_auth == 0xff) && 1086d25e28abSJohan Hedberg old_key_type == 0xff) 1087d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 1088d25e28abSJohan Hedberg 1089d25e28abSJohan Hedberg if (new_key && !hci_persistent_key(hdev, conn, type, old_key_type)) { 1090d25e28abSJohan Hedberg list_del(&key->list); 1091d25e28abSJohan Hedberg kfree(key); 1092d25e28abSJohan Hedberg return 0; 1093d25e28abSJohan Hedberg } 1094d25e28abSJohan Hedberg 109555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 109655ed8ca1SJohan Hedberg memcpy(key->val, val, 16); 109755ed8ca1SJohan Hedberg key->type = type; 109855ed8ca1SJohan Hedberg key->pin_len = pin_len; 109955ed8ca1SJohan Hedberg 110055ed8ca1SJohan Hedberg if (new_key) 110155ed8ca1SJohan Hedberg mgmt_new_key(hdev->id, key, old_key_type); 110255ed8ca1SJohan Hedberg 1103b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 110455ed8ca1SJohan Hedberg key->type = old_key_type; 110555ed8ca1SJohan Hedberg 110655ed8ca1SJohan Hedberg return 0; 110755ed8ca1SJohan Hedberg } 110855ed8ca1SJohan Hedberg 110955ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 111055ed8ca1SJohan Hedberg { 111155ed8ca1SJohan Hedberg struct link_key *key; 111255ed8ca1SJohan Hedberg 111355ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 111455ed8ca1SJohan Hedberg if (!key) 111555ed8ca1SJohan Hedberg return -ENOENT; 111655ed8ca1SJohan Hedberg 111755ed8ca1SJohan Hedberg BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 111855ed8ca1SJohan Hedberg 111955ed8ca1SJohan Hedberg list_del(&key->list); 112055ed8ca1SJohan Hedberg kfree(key); 112155ed8ca1SJohan Hedberg 112255ed8ca1SJohan Hedberg return 0; 112355ed8ca1SJohan Hedberg } 112455ed8ca1SJohan Hedberg 11256bd32326SVille Tervo /* HCI command timer function */ 11266bd32326SVille Tervo static void hci_cmd_timer(unsigned long arg) 11276bd32326SVille Tervo { 11286bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 11296bd32326SVille Tervo 11306bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 11316bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 113210572132SGustavo F. Padovan clear_bit(HCI_RESET, &hdev->flags); 11336bd32326SVille Tervo tasklet_schedule(&hdev->cmd_task); 11346bd32326SVille Tervo } 11356bd32326SVille Tervo 11362763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 11372763eda6SSzymon Janc bdaddr_t *bdaddr) 11382763eda6SSzymon Janc { 11392763eda6SSzymon Janc struct oob_data *data; 11402763eda6SSzymon Janc 11412763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 11422763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 11432763eda6SSzymon Janc return data; 11442763eda6SSzymon Janc 11452763eda6SSzymon Janc return NULL; 11462763eda6SSzymon Janc } 11472763eda6SSzymon Janc 11482763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 11492763eda6SSzymon Janc { 11502763eda6SSzymon Janc struct oob_data *data; 11512763eda6SSzymon Janc 11522763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 11532763eda6SSzymon Janc if (!data) 11542763eda6SSzymon Janc return -ENOENT; 11552763eda6SSzymon Janc 11562763eda6SSzymon Janc BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 11572763eda6SSzymon Janc 11582763eda6SSzymon Janc list_del(&data->list); 11592763eda6SSzymon Janc kfree(data); 11602763eda6SSzymon Janc 11612763eda6SSzymon Janc return 0; 11622763eda6SSzymon Janc } 11632763eda6SSzymon Janc 11642763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 11652763eda6SSzymon Janc { 11662763eda6SSzymon Janc struct oob_data *data, *n; 11672763eda6SSzymon Janc 11682763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 11692763eda6SSzymon Janc list_del(&data->list); 11702763eda6SSzymon Janc kfree(data); 11712763eda6SSzymon Janc } 11722763eda6SSzymon Janc 11732763eda6SSzymon Janc return 0; 11742763eda6SSzymon Janc } 11752763eda6SSzymon Janc 11762763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 11772763eda6SSzymon Janc u8 *randomizer) 11782763eda6SSzymon Janc { 11792763eda6SSzymon Janc struct oob_data *data; 11802763eda6SSzymon Janc 11812763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 11822763eda6SSzymon Janc 11832763eda6SSzymon Janc if (!data) { 11842763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 11852763eda6SSzymon Janc if (!data) 11862763eda6SSzymon Janc return -ENOMEM; 11872763eda6SSzymon Janc 11882763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 11892763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 11902763eda6SSzymon Janc } 11912763eda6SSzymon Janc 11922763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 11932763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 11942763eda6SSzymon Janc 11952763eda6SSzymon Janc BT_DBG("%s for %s", hdev->name, batostr(bdaddr)); 11962763eda6SSzymon Janc 11972763eda6SSzymon Janc return 0; 11982763eda6SSzymon Janc } 11992763eda6SSzymon Janc 12001da177e4SLinus Torvalds /* Register HCI device */ 12011da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 12021da177e4SLinus Torvalds { 12031da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 1204ef222013SMarcel Holtmann int i, id = 0; 12051da177e4SLinus Torvalds 1206c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 1207c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 12081da177e4SLinus Torvalds 12091da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 12101da177e4SLinus Torvalds return -EINVAL; 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds /* Find first available device id */ 12151da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 12161da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 12171da177e4SLinus Torvalds break; 12181da177e4SLinus Torvalds head = p; id++; 12191da177e4SLinus Torvalds } 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 12221da177e4SLinus Torvalds hdev->id = id; 12231da177e4SLinus Torvalds list_add(&hdev->list, head); 12241da177e4SLinus Torvalds 12251da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 12261da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 12271da177e4SLinus Torvalds 12281da177e4SLinus Torvalds hdev->flags = 0; 12291da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 12305b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 12311da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 123217fa4b9dSJohan Hedberg hdev->io_capability = 0x03; /* No Input No Output */ 12331da177e4SLinus Torvalds 123404837f64SMarcel Holtmann hdev->idle_timeout = 0; 123504837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 123604837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 123704837f64SMarcel Holtmann 12381da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 12391da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 12401da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 12411da177e4SLinus Torvalds 12421da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 12431da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 12441da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 12451da177e4SLinus Torvalds 12466bd32326SVille Tervo setup_timer(&hdev->cmd_timer, hci_cmd_timer, (unsigned long) hdev); 12476bd32326SVille Tervo 1248cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1249ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 1250ef222013SMarcel Holtmann 12511da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 1252a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds inquiry_cache_init(hdev); 12551da177e4SLinus Torvalds 12561da177e4SLinus Torvalds hci_conn_hash_init(hdev); 12571da177e4SLinus Torvalds 1258ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1259f0358568SJohan Hedberg 12602aeb9a1aSJohan Hedberg INIT_LIST_HEAD(&hdev->uuids); 12612aeb9a1aSJohan Hedberg 126255ed8ca1SJohan Hedberg INIT_LIST_HEAD(&hdev->link_keys); 126355ed8ca1SJohan Hedberg 12642763eda6SSzymon Janc INIT_LIST_HEAD(&hdev->remote_oob_data); 12652763eda6SSzymon Janc 1266ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1267ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1268ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1269ab81cbf9SJohan Hedberg 12701da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 12751da177e4SLinus Torvalds 1276f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1277f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1278f48fd9c8SMarcel Holtmann goto nomem; 1279f48fd9c8SMarcel Holtmann 12801da177e4SLinus Torvalds hci_register_sysfs(hdev); 12811da177e4SLinus Torvalds 1282611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1283611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1284611b30f7SMarcel Holtmann if (hdev->rfkill) { 1285611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1286611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1287611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1288611b30f7SMarcel Holtmann } 1289611b30f7SMarcel Holtmann } 1290611b30f7SMarcel Holtmann 1291ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1292ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1293ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1294ab81cbf9SJohan Hedberg 12951da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 12961da177e4SLinus Torvalds 12971da177e4SLinus Torvalds return id; 1298f48fd9c8SMarcel Holtmann 1299f48fd9c8SMarcel Holtmann nomem: 1300f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1301f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1302f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1303f48fd9c8SMarcel Holtmann 1304f48fd9c8SMarcel Holtmann return -ENOMEM; 13051da177e4SLinus Torvalds } 13061da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds /* Unregister HCI device */ 13091da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 13101da177e4SLinus Torvalds { 1311ef222013SMarcel Holtmann int i; 1312ef222013SMarcel Holtmann 1313c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 13141da177e4SLinus Torvalds 13151da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 13161da177e4SLinus Torvalds list_del(&hdev->list); 13171da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 13181da177e4SLinus Torvalds 13191da177e4SLinus Torvalds hci_dev_do_close(hdev); 13201da177e4SLinus Torvalds 1321cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1322ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1323ef222013SMarcel Holtmann 1324ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1325ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1326c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1327ab81cbf9SJohan Hedberg 13281da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 13291da177e4SLinus Torvalds 1330611b30f7SMarcel Holtmann if (hdev->rfkill) { 1331611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1332611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1333611b30f7SMarcel Holtmann } 1334611b30f7SMarcel Holtmann 1335147e2d59SDave Young hci_unregister_sysfs(hdev); 1336147e2d59SDave Young 1337c6f3c5f7SGustavo F. Padovan hci_del_off_timer(hdev); 1338c6f3c5f7SGustavo F. Padovan 1339f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1340f48fd9c8SMarcel Holtmann 1341e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1342e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 13432aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 134455ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 13452763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 1346e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1347e2e0cacbSJohan Hedberg 13481da177e4SLinus Torvalds __hci_dev_put(hdev); 1349ef222013SMarcel Holtmann 13501da177e4SLinus Torvalds return 0; 13511da177e4SLinus Torvalds } 13521da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds /* Suspend HCI device */ 13551da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 13561da177e4SLinus Torvalds { 13571da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 13581da177e4SLinus Torvalds return 0; 13591da177e4SLinus Torvalds } 13601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 13611da177e4SLinus Torvalds 13621da177e4SLinus Torvalds /* Resume HCI device */ 13631da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 13641da177e4SLinus Torvalds { 13651da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 13661da177e4SLinus Torvalds return 0; 13671da177e4SLinus Torvalds } 13681da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 13691da177e4SLinus Torvalds 137076bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 137176bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 137276bca880SMarcel Holtmann { 137376bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 137476bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 137576bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 137676bca880SMarcel Holtmann kfree_skb(skb); 137776bca880SMarcel Holtmann return -ENXIO; 137876bca880SMarcel Holtmann } 137976bca880SMarcel Holtmann 138076bca880SMarcel Holtmann /* Incomming skb */ 138176bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 138276bca880SMarcel Holtmann 138376bca880SMarcel Holtmann /* Time stamp */ 138476bca880SMarcel Holtmann __net_timestamp(skb); 138576bca880SMarcel Holtmann 138676bca880SMarcel Holtmann /* Queue frame for rx task */ 138776bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1388c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1389c78ae283SMarcel Holtmann 139076bca880SMarcel Holtmann return 0; 139176bca880SMarcel Holtmann } 139276bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 139376bca880SMarcel Holtmann 139433e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 13951e429f38SGustavo F. Padovan int count, __u8 index) 139633e882a5SSuraj Sumangala { 139733e882a5SSuraj Sumangala int len = 0; 139833e882a5SSuraj Sumangala int hlen = 0; 139933e882a5SSuraj Sumangala int remain = count; 140033e882a5SSuraj Sumangala struct sk_buff *skb; 140133e882a5SSuraj Sumangala struct bt_skb_cb *scb; 140233e882a5SSuraj Sumangala 140333e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 140433e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 140533e882a5SSuraj Sumangala return -EILSEQ; 140633e882a5SSuraj Sumangala 140733e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 140833e882a5SSuraj Sumangala 140933e882a5SSuraj Sumangala if (!skb) { 141033e882a5SSuraj Sumangala switch (type) { 141133e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 141233e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 141333e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 141433e882a5SSuraj Sumangala break; 141533e882a5SSuraj Sumangala case HCI_EVENT_PKT: 141633e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 141733e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 141833e882a5SSuraj Sumangala break; 141933e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 142033e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 142133e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 142233e882a5SSuraj Sumangala break; 142333e882a5SSuraj Sumangala } 142433e882a5SSuraj Sumangala 14251e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 142633e882a5SSuraj Sumangala if (!skb) 142733e882a5SSuraj Sumangala return -ENOMEM; 142833e882a5SSuraj Sumangala 142933e882a5SSuraj Sumangala scb = (void *) skb->cb; 143033e882a5SSuraj Sumangala scb->expect = hlen; 143133e882a5SSuraj Sumangala scb->pkt_type = type; 143233e882a5SSuraj Sumangala 143333e882a5SSuraj Sumangala skb->dev = (void *) hdev; 143433e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 143533e882a5SSuraj Sumangala } 143633e882a5SSuraj Sumangala 143733e882a5SSuraj Sumangala while (count) { 143833e882a5SSuraj Sumangala scb = (void *) skb->cb; 143933e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 144033e882a5SSuraj Sumangala 144133e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 144233e882a5SSuraj Sumangala 144333e882a5SSuraj Sumangala count -= len; 144433e882a5SSuraj Sumangala data += len; 144533e882a5SSuraj Sumangala scb->expect -= len; 144633e882a5SSuraj Sumangala remain = count; 144733e882a5SSuraj Sumangala 144833e882a5SSuraj Sumangala switch (type) { 144933e882a5SSuraj Sumangala case HCI_EVENT_PKT: 145033e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 145133e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 145233e882a5SSuraj Sumangala scb->expect = h->plen; 145333e882a5SSuraj Sumangala 145433e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 145533e882a5SSuraj Sumangala kfree_skb(skb); 145633e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 145733e882a5SSuraj Sumangala return -ENOMEM; 145833e882a5SSuraj Sumangala } 145933e882a5SSuraj Sumangala } 146033e882a5SSuraj Sumangala break; 146133e882a5SSuraj Sumangala 146233e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 146333e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 146433e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 146533e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 146633e882a5SSuraj Sumangala 146733e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 146833e882a5SSuraj Sumangala kfree_skb(skb); 146933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 147033e882a5SSuraj Sumangala return -ENOMEM; 147133e882a5SSuraj Sumangala } 147233e882a5SSuraj Sumangala } 147333e882a5SSuraj Sumangala break; 147433e882a5SSuraj Sumangala 147533e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 147633e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 147733e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 147833e882a5SSuraj Sumangala scb->expect = h->dlen; 147933e882a5SSuraj Sumangala 148033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 148133e882a5SSuraj Sumangala kfree_skb(skb); 148233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 148333e882a5SSuraj Sumangala return -ENOMEM; 148433e882a5SSuraj Sumangala } 148533e882a5SSuraj Sumangala } 148633e882a5SSuraj Sumangala break; 148733e882a5SSuraj Sumangala } 148833e882a5SSuraj Sumangala 148933e882a5SSuraj Sumangala if (scb->expect == 0) { 149033e882a5SSuraj Sumangala /* Complete frame */ 149133e882a5SSuraj Sumangala 149233e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 149333e882a5SSuraj Sumangala hci_recv_frame(skb); 149433e882a5SSuraj Sumangala 149533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 149633e882a5SSuraj Sumangala return remain; 149733e882a5SSuraj Sumangala } 149833e882a5SSuraj Sumangala } 149933e882a5SSuraj Sumangala 150033e882a5SSuraj Sumangala return remain; 150133e882a5SSuraj Sumangala } 150233e882a5SSuraj Sumangala 1503ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1504ef222013SMarcel Holtmann { 1505f39a3c06SSuraj Sumangala int rem = 0; 1506f39a3c06SSuraj Sumangala 1507ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1508ef222013SMarcel Holtmann return -EILSEQ; 1509ef222013SMarcel Holtmann 1510da5f6c37SGustavo F. Padovan while (count) { 15111e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 1512f39a3c06SSuraj Sumangala if (rem < 0) 1513f39a3c06SSuraj Sumangala return rem; 1514ef222013SMarcel Holtmann 1515f39a3c06SSuraj Sumangala data += (count - rem); 1516f39a3c06SSuraj Sumangala count = rem; 1517da5f6c37SGustavo F. Padovan }; 1518ef222013SMarcel Holtmann 1519f39a3c06SSuraj Sumangala return rem; 1520ef222013SMarcel Holtmann } 1521ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1522ef222013SMarcel Holtmann 152399811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 152499811510SSuraj Sumangala 152599811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 152699811510SSuraj Sumangala { 152799811510SSuraj Sumangala int type; 152899811510SSuraj Sumangala int rem = 0; 152999811510SSuraj Sumangala 1530da5f6c37SGustavo F. Padovan while (count) { 153199811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 153299811510SSuraj Sumangala 153399811510SSuraj Sumangala if (!skb) { 153499811510SSuraj Sumangala struct { char type; } *pkt; 153599811510SSuraj Sumangala 153699811510SSuraj Sumangala /* Start of the frame */ 153799811510SSuraj Sumangala pkt = data; 153899811510SSuraj Sumangala type = pkt->type; 153999811510SSuraj Sumangala 154099811510SSuraj Sumangala data++; 154199811510SSuraj Sumangala count--; 154299811510SSuraj Sumangala } else 154399811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 154499811510SSuraj Sumangala 15451e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 15461e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 154799811510SSuraj Sumangala if (rem < 0) 154899811510SSuraj Sumangala return rem; 154999811510SSuraj Sumangala 155099811510SSuraj Sumangala data += (count - rem); 155199811510SSuraj Sumangala count = rem; 1552da5f6c37SGustavo F. Padovan }; 155399811510SSuraj Sumangala 155499811510SSuraj Sumangala return rem; 155599811510SSuraj Sumangala } 155699811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 155799811510SSuraj Sumangala 15581da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 15591da177e4SLinus Torvalds 15601da177e4SLinus Torvalds /* Register/Unregister protocols. 15611da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 15621da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 15631da177e4SLinus Torvalds { 15641da177e4SLinus Torvalds int err = 0; 15651da177e4SLinus Torvalds 15661da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 15671da177e4SLinus Torvalds 15681da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 15691da177e4SLinus Torvalds return -EINVAL; 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds if (!hci_proto[hp->id]) 15741da177e4SLinus Torvalds hci_proto[hp->id] = hp; 15751da177e4SLinus Torvalds else 15761da177e4SLinus Torvalds err = -EEXIST; 15771da177e4SLinus Torvalds 15781da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 15791da177e4SLinus Torvalds 15801da177e4SLinus Torvalds return err; 15811da177e4SLinus Torvalds } 15821da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 15851da177e4SLinus Torvalds { 15861da177e4SLinus Torvalds int err = 0; 15871da177e4SLinus Torvalds 15881da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 15911da177e4SLinus Torvalds return -EINVAL; 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds if (hci_proto[hp->id]) 15961da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 15971da177e4SLinus Torvalds else 15981da177e4SLinus Torvalds err = -ENOENT; 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 16011da177e4SLinus Torvalds 16021da177e4SLinus Torvalds return err; 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 16071da177e4SLinus Torvalds { 16081da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 16091da177e4SLinus Torvalds 16101da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 16111da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 16121da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 16131da177e4SLinus Torvalds 16141da177e4SLinus Torvalds return 0; 16151da177e4SLinus Torvalds } 16161da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 16171da177e4SLinus Torvalds 16181da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 16191da177e4SLinus Torvalds { 16201da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 16211da177e4SLinus Torvalds 16221da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 16231da177e4SLinus Torvalds list_del(&cb->list); 16241da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 16251da177e4SLinus Torvalds 16261da177e4SLinus Torvalds return 0; 16271da177e4SLinus Torvalds } 16281da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 16291da177e4SLinus Torvalds 16301da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 16311da177e4SLinus Torvalds { 16321da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 16331da177e4SLinus Torvalds 16341da177e4SLinus Torvalds if (!hdev) { 16351da177e4SLinus Torvalds kfree_skb(skb); 16361da177e4SLinus Torvalds return -ENODEV; 16371da177e4SLinus Torvalds } 16381da177e4SLinus Torvalds 16390d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 16401da177e4SLinus Torvalds 16411da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 16421da177e4SLinus Torvalds /* Time stamp */ 1643a61bbcf2SPatrick McHardy __net_timestamp(skb); 16441da177e4SLinus Torvalds 1645eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 16461da177e4SLinus Torvalds } 16471da177e4SLinus Torvalds 16481da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 16491da177e4SLinus Torvalds skb_orphan(skb); 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds return hdev->send(skb); 16521da177e4SLinus Torvalds } 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds /* Send HCI command */ 1655a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 16561da177e4SLinus Torvalds { 16571da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 16581da177e4SLinus Torvalds struct hci_command_hdr *hdr; 16591da177e4SLinus Torvalds struct sk_buff *skb; 16601da177e4SLinus Torvalds 1661a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 16641da177e4SLinus Torvalds if (!skb) { 1665ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 16661da177e4SLinus Torvalds return -ENOMEM; 16671da177e4SLinus Torvalds } 16681da177e4SLinus Torvalds 16691da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1670a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 16711da177e4SLinus Torvalds hdr->plen = plen; 16721da177e4SLinus Torvalds 16731da177e4SLinus Torvalds if (plen) 16741da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 16751da177e4SLinus Torvalds 16761da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 16771da177e4SLinus Torvalds 16780d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 16791da177e4SLinus Torvalds skb->dev = (void *) hdev; 1680c78ae283SMarcel Holtmann 1681a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags)) 1682a5040efaSJohan Hedberg hdev->init_last_cmd = opcode; 1683a5040efaSJohan Hedberg 16841da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1685c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 16861da177e4SLinus Torvalds 16871da177e4SLinus Torvalds return 0; 16881da177e4SLinus Torvalds } 16891da177e4SLinus Torvalds 16901da177e4SLinus Torvalds /* Get data from the previously sent command */ 1691a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 16921da177e4SLinus Torvalds { 16931da177e4SLinus Torvalds struct hci_command_hdr *hdr; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds if (!hdev->sent_cmd) 16961da177e4SLinus Torvalds return NULL; 16971da177e4SLinus Torvalds 16981da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 16991da177e4SLinus Torvalds 1700a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 17011da177e4SLinus Torvalds return NULL; 17021da177e4SLinus Torvalds 1703a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 17041da177e4SLinus Torvalds 17051da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 17061da177e4SLinus Torvalds } 17071da177e4SLinus Torvalds 17081da177e4SLinus Torvalds /* Send ACL data */ 17091da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 17101da177e4SLinus Torvalds { 17111da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 17121da177e4SLinus Torvalds int len = skb->len; 17131da177e4SLinus Torvalds 1714badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1715badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 17169c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1717aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1718aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 17191da177e4SLinus Torvalds } 17201da177e4SLinus Torvalds 17219a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 17221da177e4SLinus Torvalds { 17231da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 17241da177e4SLinus Torvalds struct sk_buff *list; 17251da177e4SLinus Torvalds 17261da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 17271da177e4SLinus Torvalds 17281da177e4SLinus Torvalds skb->dev = (void *) hdev; 17290d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1730e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 17311da177e4SLinus Torvalds 173270f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 173370f23020SAndrei Emeltchenko if (!list) { 17341da177e4SLinus Torvalds /* Non fragmented */ 17351da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 17361da177e4SLinus Torvalds 17371da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 17381da177e4SLinus Torvalds } else { 17391da177e4SLinus Torvalds /* Fragmented */ 17401da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 17431da177e4SLinus Torvalds 17441da177e4SLinus Torvalds /* Queue all fragments atomically */ 17451da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 17461da177e4SLinus Torvalds 17471da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1748e702112fSAndrei Emeltchenko 1749e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1750e702112fSAndrei Emeltchenko flags |= ACL_CONT; 17511da177e4SLinus Torvalds do { 17521da177e4SLinus Torvalds skb = list; list = list->next; 17531da177e4SLinus Torvalds 17541da177e4SLinus Torvalds skb->dev = (void *) hdev; 17550d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1756e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 17571da177e4SLinus Torvalds 17581da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 17591da177e4SLinus Torvalds 17601da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 17611da177e4SLinus Torvalds } while (list); 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 17641da177e4SLinus Torvalds } 17651da177e4SLinus Torvalds 1766c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 17671da177e4SLinus Torvalds } 17681da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds /* Send SCO data */ 17710d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 17721da177e4SLinus Torvalds { 17731da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 17741da177e4SLinus Torvalds struct hci_sco_hdr hdr; 17751da177e4SLinus Torvalds 17761da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 17771da177e4SLinus Torvalds 1778aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 17791da177e4SLinus Torvalds hdr.dlen = skb->len; 17801da177e4SLinus Torvalds 1781badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1782badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 17839c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds skb->dev = (void *) hdev; 17860d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1787c78ae283SMarcel Holtmann 17881da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1789c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 17901da177e4SLinus Torvalds } 17911da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 17921da177e4SLinus Torvalds 17931da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 17941da177e4SLinus Torvalds 17951da177e4SLinus Torvalds /* HCI Connection scheduler */ 17961da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 17971da177e4SLinus Torvalds { 17981da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 17991da177e4SLinus Torvalds struct hci_conn *conn = NULL; 18001da177e4SLinus Torvalds int num = 0, min = ~0; 18011da177e4SLinus Torvalds struct list_head *p; 18021da177e4SLinus Torvalds 18031da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 18041da177e4SLinus Torvalds * added and removed with TX task disabled. */ 18051da177e4SLinus Torvalds list_for_each(p, &h->list) { 18061da177e4SLinus Torvalds struct hci_conn *c; 18071da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 18081da177e4SLinus Torvalds 1809769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 18101da177e4SLinus Torvalds continue; 1811769be974SMarcel Holtmann 1812769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1813769be974SMarcel Holtmann continue; 1814769be974SMarcel Holtmann 18151da177e4SLinus Torvalds num++; 18161da177e4SLinus Torvalds 18171da177e4SLinus Torvalds if (c->sent < min) { 18181da177e4SLinus Torvalds min = c->sent; 18191da177e4SLinus Torvalds conn = c; 18201da177e4SLinus Torvalds } 18211da177e4SLinus Torvalds } 18221da177e4SLinus Torvalds 18231da177e4SLinus Torvalds if (conn) { 18246ed58ec5SVille Tervo int cnt, q; 18256ed58ec5SVille Tervo 18266ed58ec5SVille Tervo switch (conn->type) { 18276ed58ec5SVille Tervo case ACL_LINK: 18286ed58ec5SVille Tervo cnt = hdev->acl_cnt; 18296ed58ec5SVille Tervo break; 18306ed58ec5SVille Tervo case SCO_LINK: 18316ed58ec5SVille Tervo case ESCO_LINK: 18326ed58ec5SVille Tervo cnt = hdev->sco_cnt; 18336ed58ec5SVille Tervo break; 18346ed58ec5SVille Tervo case LE_LINK: 18356ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 18366ed58ec5SVille Tervo break; 18376ed58ec5SVille Tervo default: 18386ed58ec5SVille Tervo cnt = 0; 18396ed58ec5SVille Tervo BT_ERR("Unknown link type"); 18406ed58ec5SVille Tervo } 18416ed58ec5SVille Tervo 18426ed58ec5SVille Tervo q = cnt / num; 18431da177e4SLinus Torvalds *quote = q ? q : 1; 18441da177e4SLinus Torvalds } else 18451da177e4SLinus Torvalds *quote = 0; 18461da177e4SLinus Torvalds 18471da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 18481da177e4SLinus Torvalds return conn; 18491da177e4SLinus Torvalds } 18501da177e4SLinus Torvalds 1851bae1f5d9SVille Tervo static inline void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 18521da177e4SLinus Torvalds { 18531da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 18541da177e4SLinus Torvalds struct list_head *p; 18551da177e4SLinus Torvalds struct hci_conn *c; 18561da177e4SLinus Torvalds 1857bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 18581da177e4SLinus Torvalds 18591da177e4SLinus Torvalds /* Kill stalled connections */ 18601da177e4SLinus Torvalds list_for_each(p, &h->list) { 18611da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 1862bae1f5d9SVille Tervo if (c->type == type && c->sent) { 1863bae1f5d9SVille Tervo BT_ERR("%s killing stalled connection %s", 18641da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 18651da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 18661da177e4SLinus Torvalds } 18671da177e4SLinus Torvalds } 18681da177e4SLinus Torvalds } 18691da177e4SLinus Torvalds 18701da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 18711da177e4SLinus Torvalds { 18721da177e4SLinus Torvalds struct hci_conn *conn; 18731da177e4SLinus Torvalds struct sk_buff *skb; 18741da177e4SLinus Torvalds int quote; 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 18771da177e4SLinus Torvalds 18781da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 18791da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 18801da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 188182453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 1882bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 18831da177e4SLinus Torvalds } 18841da177e4SLinus Torvalds 18851da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 18861da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 18871da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 188804837f64SMarcel Holtmann 188904837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 189004837f64SMarcel Holtmann 18911da177e4SLinus Torvalds hci_send_frame(skb); 18921da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 18931da177e4SLinus Torvalds 18941da177e4SLinus Torvalds hdev->acl_cnt--; 18951da177e4SLinus Torvalds conn->sent++; 18961da177e4SLinus Torvalds } 18971da177e4SLinus Torvalds } 18981da177e4SLinus Torvalds } 18991da177e4SLinus Torvalds 19001da177e4SLinus Torvalds /* Schedule SCO */ 19011da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 19021da177e4SLinus Torvalds { 19031da177e4SLinus Torvalds struct hci_conn *conn; 19041da177e4SLinus Torvalds struct sk_buff *skb; 19051da177e4SLinus Torvalds int quote; 19061da177e4SLinus Torvalds 19071da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 19101da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 19111da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 19121da177e4SLinus Torvalds hci_send_frame(skb); 19131da177e4SLinus Torvalds 19141da177e4SLinus Torvalds conn->sent++; 19151da177e4SLinus Torvalds if (conn->sent == ~0) 19161da177e4SLinus Torvalds conn->sent = 0; 19171da177e4SLinus Torvalds } 19181da177e4SLinus Torvalds } 19191da177e4SLinus Torvalds } 19201da177e4SLinus Torvalds 1921b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1922b6a0dc82SMarcel Holtmann { 1923b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1924b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1925b6a0dc82SMarcel Holtmann int quote; 1926b6a0dc82SMarcel Holtmann 1927b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1928b6a0dc82SMarcel Holtmann 1929b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1930b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1931b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1932b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1933b6a0dc82SMarcel Holtmann 1934b6a0dc82SMarcel Holtmann conn->sent++; 1935b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1936b6a0dc82SMarcel Holtmann conn->sent = 0; 1937b6a0dc82SMarcel Holtmann } 1938b6a0dc82SMarcel Holtmann } 1939b6a0dc82SMarcel Holtmann } 1940b6a0dc82SMarcel Holtmann 19416ed58ec5SVille Tervo static inline void hci_sched_le(struct hci_dev *hdev) 19426ed58ec5SVille Tervo { 19436ed58ec5SVille Tervo struct hci_conn *conn; 19446ed58ec5SVille Tervo struct sk_buff *skb; 19456ed58ec5SVille Tervo int quote, cnt; 19466ed58ec5SVille Tervo 19476ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 19486ed58ec5SVille Tervo 19496ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 19506ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 19516ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 1952bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 19536ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 1954bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 19556ed58ec5SVille Tervo } 19566ed58ec5SVille Tervo 19576ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 19586ed58ec5SVille Tervo while (cnt && (conn = hci_low_sent(hdev, LE_LINK, "e))) { 19596ed58ec5SVille Tervo while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 19606ed58ec5SVille Tervo BT_DBG("skb %p len %d", skb, skb->len); 19616ed58ec5SVille Tervo 19626ed58ec5SVille Tervo hci_send_frame(skb); 19636ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 19646ed58ec5SVille Tervo 19656ed58ec5SVille Tervo cnt--; 19666ed58ec5SVille Tervo conn->sent++; 19676ed58ec5SVille Tervo } 19686ed58ec5SVille Tervo } 19696ed58ec5SVille Tervo if (hdev->le_pkts) 19706ed58ec5SVille Tervo hdev->le_cnt = cnt; 19716ed58ec5SVille Tervo else 19726ed58ec5SVille Tervo hdev->acl_cnt = cnt; 19736ed58ec5SVille Tervo } 19746ed58ec5SVille Tervo 19751da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 19761da177e4SLinus Torvalds { 19771da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 19781da177e4SLinus Torvalds struct sk_buff *skb; 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds read_lock(&hci_task_lock); 19811da177e4SLinus Torvalds 19826ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 19836ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 19841da177e4SLinus Torvalds 19851da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 19861da177e4SLinus Torvalds 19871da177e4SLinus Torvalds hci_sched_acl(hdev); 19881da177e4SLinus Torvalds 19891da177e4SLinus Torvalds hci_sched_sco(hdev); 19901da177e4SLinus Torvalds 1991b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1992b6a0dc82SMarcel Holtmann 19936ed58ec5SVille Tervo hci_sched_le(hdev); 19946ed58ec5SVille Tervo 19951da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 19961da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 19971da177e4SLinus Torvalds hci_send_frame(skb); 19981da177e4SLinus Torvalds 19991da177e4SLinus Torvalds read_unlock(&hci_task_lock); 20001da177e4SLinus Torvalds } 20011da177e4SLinus Torvalds 20021da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds /* ACL data packet */ 20051da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 20061da177e4SLinus Torvalds { 20071da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 20081da177e4SLinus Torvalds struct hci_conn *conn; 20091da177e4SLinus Torvalds __u16 handle, flags; 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 20141da177e4SLinus Torvalds flags = hci_flags(handle); 20151da177e4SLinus Torvalds handle = hci_handle(handle); 20161da177e4SLinus Torvalds 20171da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 20181da177e4SLinus Torvalds 20191da177e4SLinus Torvalds hdev->stat.acl_rx++; 20201da177e4SLinus Torvalds 20211da177e4SLinus Torvalds hci_dev_lock(hdev); 20221da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 20231da177e4SLinus Torvalds hci_dev_unlock(hdev); 20241da177e4SLinus Torvalds 20251da177e4SLinus Torvalds if (conn) { 20261da177e4SLinus Torvalds register struct hci_proto *hp; 20271da177e4SLinus Torvalds 202804837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 202904837f64SMarcel Holtmann 20301da177e4SLinus Torvalds /* Send to upper protocol */ 203170f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 203270f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 20331da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 20341da177e4SLinus Torvalds return; 20351da177e4SLinus Torvalds } 20361da177e4SLinus Torvalds } else { 20371da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 20381da177e4SLinus Torvalds hdev->name, handle); 20391da177e4SLinus Torvalds } 20401da177e4SLinus Torvalds 20411da177e4SLinus Torvalds kfree_skb(skb); 20421da177e4SLinus Torvalds } 20431da177e4SLinus Torvalds 20441da177e4SLinus Torvalds /* SCO data packet */ 20451da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 20461da177e4SLinus Torvalds { 20471da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 20481da177e4SLinus Torvalds struct hci_conn *conn; 20491da177e4SLinus Torvalds __u16 handle; 20501da177e4SLinus Torvalds 20511da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 20561da177e4SLinus Torvalds 20571da177e4SLinus Torvalds hdev->stat.sco_rx++; 20581da177e4SLinus Torvalds 20591da177e4SLinus Torvalds hci_dev_lock(hdev); 20601da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 20611da177e4SLinus Torvalds hci_dev_unlock(hdev); 20621da177e4SLinus Torvalds 20631da177e4SLinus Torvalds if (conn) { 20641da177e4SLinus Torvalds register struct hci_proto *hp; 20651da177e4SLinus Torvalds 20661da177e4SLinus Torvalds /* Send to upper protocol */ 206770f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 206870f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 20691da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 20701da177e4SLinus Torvalds return; 20711da177e4SLinus Torvalds } 20721da177e4SLinus Torvalds } else { 20731da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 20741da177e4SLinus Torvalds hdev->name, handle); 20751da177e4SLinus Torvalds } 20761da177e4SLinus Torvalds 20771da177e4SLinus Torvalds kfree_skb(skb); 20781da177e4SLinus Torvalds } 20791da177e4SLinus Torvalds 20806516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 20811da177e4SLinus Torvalds { 20821da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 20831da177e4SLinus Torvalds struct sk_buff *skb; 20841da177e4SLinus Torvalds 20851da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 20861da177e4SLinus Torvalds 20871da177e4SLinus Torvalds read_lock(&hci_task_lock); 20881da177e4SLinus Torvalds 20891da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 20901da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 20911da177e4SLinus Torvalds /* Send copy to the sockets */ 2092eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 20931da177e4SLinus Torvalds } 20941da177e4SLinus Torvalds 20951da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 20961da177e4SLinus Torvalds kfree_skb(skb); 20971da177e4SLinus Torvalds continue; 20981da177e4SLinus Torvalds } 20991da177e4SLinus Torvalds 21001da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 21011da177e4SLinus Torvalds /* Don't process data packets in this states. */ 21020d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 21031da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 21041da177e4SLinus Torvalds case HCI_SCODATA_PKT: 21051da177e4SLinus Torvalds kfree_skb(skb); 21061da177e4SLinus Torvalds continue; 21073ff50b79SStephen Hemminger } 21081da177e4SLinus Torvalds } 21091da177e4SLinus Torvalds 21101da177e4SLinus Torvalds /* Process frame */ 21110d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 21121da177e4SLinus Torvalds case HCI_EVENT_PKT: 21131da177e4SLinus Torvalds hci_event_packet(hdev, skb); 21141da177e4SLinus Torvalds break; 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 21171da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 21181da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 21191da177e4SLinus Torvalds break; 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds case HCI_SCODATA_PKT: 21221da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 21231da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 21241da177e4SLinus Torvalds break; 21251da177e4SLinus Torvalds 21261da177e4SLinus Torvalds default: 21271da177e4SLinus Torvalds kfree_skb(skb); 21281da177e4SLinus Torvalds break; 21291da177e4SLinus Torvalds } 21301da177e4SLinus Torvalds } 21311da177e4SLinus Torvalds 21321da177e4SLinus Torvalds read_unlock(&hci_task_lock); 21331da177e4SLinus Torvalds } 21341da177e4SLinus Torvalds 21351da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 21361da177e4SLinus Torvalds { 21371da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 21381da177e4SLinus Torvalds struct sk_buff *skb; 21391da177e4SLinus Torvalds 21401da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 21411da177e4SLinus Torvalds 21421da177e4SLinus Torvalds /* Send queued commands */ 21435a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 21445a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 21455a08ecceSAndrei Emeltchenko if (!skb) 21465a08ecceSAndrei Emeltchenko return; 21475a08ecceSAndrei Emeltchenko 21481da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 21491da177e4SLinus Torvalds 215070f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 215170f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 21521da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 21531da177e4SLinus Torvalds hci_send_frame(skb); 21546bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 21556bd32326SVille Tervo jiffies + msecs_to_jiffies(HCI_CMD_TIMEOUT)); 21561da177e4SLinus Torvalds } else { 21571da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 2158c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 21591da177e4SLinus Torvalds } 21601da177e4SLinus Torvalds } 21611da177e4SLinus Torvalds } 2162