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 */ 188f630cf0dSGustavo 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 */ 216f630cf0dSGustavo F. Padovan if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) { 217f630cf0dSGustavo F. Padovan set_bit(HCI_RESET, &hdev->flags); 218a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 219f630cf0dSGustavo 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 5891da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 590b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 5911da177e4SLinus Torvalds hci_req_unlock(hdev); 5921da177e4SLinus Torvalds return 0; 5931da177e4SLinus Torvalds } 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5961da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5971da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6001da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6011da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6021da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds if (hdev->flush) 6071da177e4SLinus Torvalds hdev->flush(hdev); 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds /* Reset device */ 6101da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6111da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6121da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 6131da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 61404837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 61504837f64SMarcel Holtmann msecs_to_jiffies(250)); 6161da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 6171da177e4SLinus Torvalds } 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds /* Kill cmd task */ 6201da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds /* Drop queues */ 6231da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6241da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6251da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* Drop last sent command */ 6281da177e4SLinus Torvalds if (hdev->sent_cmd) { 629b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 6301da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 6311da177e4SLinus Torvalds hdev->sent_cmd = NULL; 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds /* After this point our queues are empty 6351da177e4SLinus Torvalds * and no tasks are scheduled. */ 6361da177e4SLinus Torvalds hdev->close(hdev); 6371da177e4SLinus Torvalds 6385add6af8SJohan Hedberg mgmt_powered(hdev->id, 0); 6395add6af8SJohan Hedberg 6401da177e4SLinus Torvalds /* Clear flags */ 6411da177e4SLinus Torvalds hdev->flags = 0; 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds hci_req_unlock(hdev); 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds hci_dev_put(hdev); 6461da177e4SLinus Torvalds return 0; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6501da177e4SLinus Torvalds { 6511da177e4SLinus Torvalds struct hci_dev *hdev; 6521da177e4SLinus Torvalds int err; 6531da177e4SLinus Torvalds 65470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 65570f23020SAndrei Emeltchenko if (!hdev) 6561da177e4SLinus Torvalds return -ENODEV; 6571da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6581da177e4SLinus Torvalds hci_dev_put(hdev); 6591da177e4SLinus Torvalds return err; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6631da177e4SLinus Torvalds { 6641da177e4SLinus Torvalds struct hci_dev *hdev; 6651da177e4SLinus Torvalds int ret = 0; 6661da177e4SLinus Torvalds 66770f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 66870f23020SAndrei Emeltchenko if (!hdev) 6691da177e4SLinus Torvalds return -ENODEV; 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds hci_req_lock(hdev); 6721da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6751da177e4SLinus Torvalds goto done; 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds /* Drop queues */ 6781da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6791da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6801da177e4SLinus Torvalds 6811da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6821da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6831da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6841da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds if (hdev->flush) 6871da177e4SLinus Torvalds hdev->flush(hdev); 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6906ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 69304837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 69404837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds done: 6971da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6981da177e4SLinus Torvalds hci_req_unlock(hdev); 6991da177e4SLinus Torvalds hci_dev_put(hdev); 7001da177e4SLinus Torvalds return ret; 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 7041da177e4SLinus Torvalds { 7051da177e4SLinus Torvalds struct hci_dev *hdev; 7061da177e4SLinus Torvalds int ret = 0; 7071da177e4SLinus Torvalds 70870f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 70970f23020SAndrei Emeltchenko if (!hdev) 7101da177e4SLinus Torvalds return -ENODEV; 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds hci_dev_put(hdev); 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds return ret; 7171da177e4SLinus Torvalds } 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 7201da177e4SLinus Torvalds { 7211da177e4SLinus Torvalds struct hci_dev *hdev; 7221da177e4SLinus Torvalds struct hci_dev_req dr; 7231da177e4SLinus Torvalds int err = 0; 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 7261da177e4SLinus Torvalds return -EFAULT; 7271da177e4SLinus Torvalds 72870f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 72970f23020SAndrei Emeltchenko if (!hdev) 7301da177e4SLinus Torvalds return -ENODEV; 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds switch (cmd) { 7331da177e4SLinus Torvalds case HCISETAUTH: 73404837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 73504837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7361da177e4SLinus Torvalds break; 7371da177e4SLinus Torvalds 7381da177e4SLinus Torvalds case HCISETENCRYPT: 7391da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 7401da177e4SLinus Torvalds err = -EOPNOTSUPP; 7411da177e4SLinus Torvalds break; 7421da177e4SLinus Torvalds } 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7451da177e4SLinus Torvalds /* Auth must be enabled first */ 74604837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 74704837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7481da177e4SLinus Torvalds if (err) 7491da177e4SLinus Torvalds break; 7501da177e4SLinus Torvalds } 7511da177e4SLinus Torvalds 75204837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 75304837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7541da177e4SLinus Torvalds break; 7551da177e4SLinus Torvalds 7561da177e4SLinus Torvalds case HCISETSCAN: 75704837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 75804837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7591da177e4SLinus Torvalds break; 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds case HCISETLINKPOL: 762e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 763e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7641da177e4SLinus Torvalds break; 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds case HCISETLINKMODE: 767e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 768e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 769e4e8e37cSMarcel Holtmann break; 770e4e8e37cSMarcel Holtmann 771e4e8e37cSMarcel Holtmann case HCISETPTYPE: 772e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7731da177e4SLinus Torvalds break; 7741da177e4SLinus Torvalds 7751da177e4SLinus Torvalds case HCISETACLMTU: 7761da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7771da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7781da177e4SLinus Torvalds break; 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds case HCISETSCOMTU: 7811da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7821da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7831da177e4SLinus Torvalds break; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds default: 7861da177e4SLinus Torvalds err = -EINVAL; 7871da177e4SLinus Torvalds break; 7881da177e4SLinus Torvalds } 789e4e8e37cSMarcel Holtmann 7901da177e4SLinus Torvalds hci_dev_put(hdev); 7911da177e4SLinus Torvalds return err; 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7951da177e4SLinus Torvalds { 7961da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7971da177e4SLinus Torvalds struct hci_dev_req *dr; 7981da177e4SLinus Torvalds struct list_head *p; 7991da177e4SLinus Torvalds int n = 0, size, err; 8001da177e4SLinus Torvalds __u16 dev_num; 8011da177e4SLinus Torvalds 8021da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 8031da177e4SLinus Torvalds return -EFAULT; 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 8061da177e4SLinus Torvalds return -EINVAL; 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 8091da177e4SLinus Torvalds 81070f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 81170f23020SAndrei Emeltchenko if (!dl) 8121da177e4SLinus Torvalds return -ENOMEM; 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds dr = dl->dev_req; 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 8171da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8181da177e4SLinus Torvalds struct hci_dev *hdev; 819c542a06cSJohan Hedberg 8201da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 821c542a06cSJohan Hedberg 822ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 823c542a06cSJohan Hedberg 824c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 825c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 826c542a06cSJohan Hedberg 8271da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 8281da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 829c542a06cSJohan Hedberg 8301da177e4SLinus Torvalds if (++n >= dev_num) 8311da177e4SLinus Torvalds break; 8321da177e4SLinus Torvalds } 8331da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds dl->dev_num = n; 8361da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 8391da177e4SLinus Torvalds kfree(dl); 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds return err ? -EFAULT : 0; 8421da177e4SLinus Torvalds } 8431da177e4SLinus Torvalds 8441da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 8451da177e4SLinus Torvalds { 8461da177e4SLinus Torvalds struct hci_dev *hdev; 8471da177e4SLinus Torvalds struct hci_dev_info di; 8481da177e4SLinus Torvalds int err = 0; 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 8511da177e4SLinus Torvalds return -EFAULT; 8521da177e4SLinus Torvalds 85370f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 85470f23020SAndrei Emeltchenko if (!hdev) 8551da177e4SLinus Torvalds return -ENODEV; 8561da177e4SLinus Torvalds 857ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 858ab81cbf9SJohan Hedberg 859c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 860c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 861c542a06cSJohan Hedberg 8621da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8631da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 864943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8651da177e4SLinus Torvalds di.flags = hdev->flags; 8661da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8671da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8681da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8691da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8701da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8711da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8721da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8751da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8761da177e4SLinus Torvalds 8771da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8781da177e4SLinus Torvalds err = -EFAULT; 8791da177e4SLinus Torvalds 8801da177e4SLinus Torvalds hci_dev_put(hdev); 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds return err; 8831da177e4SLinus Torvalds } 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8861da177e4SLinus Torvalds 887611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 888611b30f7SMarcel Holtmann { 889611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 890611b30f7SMarcel Holtmann 891611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 892611b30f7SMarcel Holtmann 893611b30f7SMarcel Holtmann if (!blocked) 894611b30f7SMarcel Holtmann return 0; 895611b30f7SMarcel Holtmann 896611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 897611b30f7SMarcel Holtmann 898611b30f7SMarcel Holtmann return 0; 899611b30f7SMarcel Holtmann } 900611b30f7SMarcel Holtmann 901611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 902611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 903611b30f7SMarcel Holtmann }; 904611b30f7SMarcel Holtmann 9051da177e4SLinus Torvalds /* Alloc HCI device */ 9061da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 9071da177e4SLinus Torvalds { 9081da177e4SLinus Torvalds struct hci_dev *hdev; 9091da177e4SLinus Torvalds 91025ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 9111da177e4SLinus Torvalds if (!hdev) 9121da177e4SLinus Torvalds return NULL; 9131da177e4SLinus Torvalds 9141da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds return hdev; 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds /* Free HCI device */ 9211da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 9221da177e4SLinus Torvalds { 9231da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 9241da177e4SLinus Torvalds 925a91f2e39SMarcel Holtmann /* will free via device release */ 926a91f2e39SMarcel Holtmann put_device(&hdev->dev); 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 9291da177e4SLinus Torvalds 930ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 931ab81cbf9SJohan Hedberg { 932ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 933ab81cbf9SJohan Hedberg 934ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 935ab81cbf9SJohan Hedberg 936ab81cbf9SJohan Hedberg if (hci_dev_open(hdev->id) < 0) 937ab81cbf9SJohan Hedberg return; 938ab81cbf9SJohan Hedberg 939ab81cbf9SJohan Hedberg if (test_bit(HCI_AUTO_OFF, &hdev->flags)) 940ab81cbf9SJohan Hedberg mod_timer(&hdev->off_timer, 941ab81cbf9SJohan Hedberg jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT)); 942ab81cbf9SJohan Hedberg 943ab81cbf9SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->flags)) 944ab81cbf9SJohan Hedberg mgmt_index_added(hdev->id); 945ab81cbf9SJohan Hedberg } 946ab81cbf9SJohan Hedberg 947ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 948ab81cbf9SJohan Hedberg { 949ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_off); 950ab81cbf9SJohan Hedberg 951ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 952ab81cbf9SJohan Hedberg 953ab81cbf9SJohan Hedberg hci_dev_close(hdev->id); 954ab81cbf9SJohan Hedberg } 955ab81cbf9SJohan Hedberg 956ab81cbf9SJohan Hedberg static void hci_auto_off(unsigned long data) 957ab81cbf9SJohan Hedberg { 958ab81cbf9SJohan Hedberg struct hci_dev *hdev = (struct hci_dev *) data; 959ab81cbf9SJohan Hedberg 960ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 961ab81cbf9SJohan Hedberg 962ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 963ab81cbf9SJohan Hedberg 964ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_off); 965ab81cbf9SJohan Hedberg } 966ab81cbf9SJohan Hedberg 967ab81cbf9SJohan Hedberg void hci_del_off_timer(struct hci_dev *hdev) 968ab81cbf9SJohan Hedberg { 969ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 970ab81cbf9SJohan Hedberg 971ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 972ab81cbf9SJohan Hedberg del_timer(&hdev->off_timer); 973ab81cbf9SJohan Hedberg } 974ab81cbf9SJohan Hedberg 9752aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 9762aeb9a1aSJohan Hedberg { 9772aeb9a1aSJohan Hedberg struct list_head *p, *n; 9782aeb9a1aSJohan Hedberg 9792aeb9a1aSJohan Hedberg list_for_each_safe(p, n, &hdev->uuids) { 9802aeb9a1aSJohan Hedberg struct bt_uuid *uuid; 9812aeb9a1aSJohan Hedberg 9822aeb9a1aSJohan Hedberg uuid = list_entry(p, struct bt_uuid, list); 9832aeb9a1aSJohan Hedberg 9842aeb9a1aSJohan Hedberg list_del(p); 9852aeb9a1aSJohan Hedberg kfree(uuid); 9862aeb9a1aSJohan Hedberg } 9872aeb9a1aSJohan Hedberg 9882aeb9a1aSJohan Hedberg return 0; 9892aeb9a1aSJohan Hedberg } 9902aeb9a1aSJohan Hedberg 99155ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 99255ed8ca1SJohan Hedberg { 99355ed8ca1SJohan Hedberg struct list_head *p, *n; 99455ed8ca1SJohan Hedberg 99555ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 99655ed8ca1SJohan Hedberg struct link_key *key; 99755ed8ca1SJohan Hedberg 99855ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 99955ed8ca1SJohan Hedberg 100055ed8ca1SJohan Hedberg list_del(p); 100155ed8ca1SJohan Hedberg kfree(key); 100255ed8ca1SJohan Hedberg } 100355ed8ca1SJohan Hedberg 100455ed8ca1SJohan Hedberg return 0; 100555ed8ca1SJohan Hedberg } 100655ed8ca1SJohan Hedberg 100755ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 100855ed8ca1SJohan Hedberg { 100955ed8ca1SJohan Hedberg struct list_head *p; 101055ed8ca1SJohan Hedberg 101155ed8ca1SJohan Hedberg list_for_each(p, &hdev->link_keys) { 101255ed8ca1SJohan Hedberg struct link_key *k; 101355ed8ca1SJohan Hedberg 101455ed8ca1SJohan Hedberg k = list_entry(p, struct link_key, list); 101555ed8ca1SJohan Hedberg 101655ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 101755ed8ca1SJohan Hedberg return k; 101855ed8ca1SJohan Hedberg } 101955ed8ca1SJohan Hedberg 102055ed8ca1SJohan Hedberg return NULL; 102155ed8ca1SJohan Hedberg } 102255ed8ca1SJohan Hedberg 1023d25e28abSJohan Hedberg static int hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 1024d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 1025d25e28abSJohan Hedberg { 1026d25e28abSJohan Hedberg /* Legacy key */ 1027d25e28abSJohan Hedberg if (key_type < 0x03) 1028d25e28abSJohan Hedberg return 1; 1029d25e28abSJohan Hedberg 1030d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 1031d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 1032d25e28abSJohan Hedberg return 0; 1033d25e28abSJohan Hedberg 1034d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 1035d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 1036d25e28abSJohan Hedberg return 0; 1037d25e28abSJohan Hedberg 1038d25e28abSJohan Hedberg /* Security mode 3 case */ 1039d25e28abSJohan Hedberg if (!conn) 1040d25e28abSJohan Hedberg return 1; 1041d25e28abSJohan Hedberg 1042d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 1043d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 1044d25e28abSJohan Hedberg return 1; 1045d25e28abSJohan Hedberg 1046d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 1047d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 1048d25e28abSJohan Hedberg return 1; 1049d25e28abSJohan Hedberg 1050d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 1051d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 1052d25e28abSJohan Hedberg return 1; 1053d25e28abSJohan Hedberg 1054d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 1055d25e28abSJohan Hedberg * persistently */ 1056d25e28abSJohan Hedberg return 0; 1057d25e28abSJohan Hedberg } 1058d25e28abSJohan Hedberg 1059d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 1060d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 106155ed8ca1SJohan Hedberg { 106255ed8ca1SJohan Hedberg struct link_key *key, *old_key; 10634df378a1SJohan Hedberg u8 old_key_type, persistent; 106455ed8ca1SJohan Hedberg 106555ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 106655ed8ca1SJohan Hedberg if (old_key) { 106755ed8ca1SJohan Hedberg old_key_type = old_key->type; 106855ed8ca1SJohan Hedberg key = old_key; 106955ed8ca1SJohan Hedberg } else { 107012adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 107155ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 107255ed8ca1SJohan Hedberg if (!key) 107355ed8ca1SJohan Hedberg return -ENOMEM; 107455ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 107555ed8ca1SJohan Hedberg } 107655ed8ca1SJohan Hedberg 107755ed8ca1SJohan Hedberg BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type); 107855ed8ca1SJohan Hedberg 1079d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 1080d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 1081d25e28abSJohan Hedberg * previous key */ 1082d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 1083d25e28abSJohan Hedberg (!conn || conn->remote_auth == 0xff) && 1084655fe6ecSJohan Hedberg old_key_type == 0xff) { 1085d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 1086655fe6ecSJohan Hedberg if (conn) 1087655fe6ecSJohan Hedberg conn->key_type = type; 1088655fe6ecSJohan Hedberg } 1089d25e28abSJohan Hedberg 109055ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 109155ed8ca1SJohan Hedberg memcpy(key->val, val, 16); 109255ed8ca1SJohan Hedberg key->pin_len = pin_len; 109355ed8ca1SJohan Hedberg 1094b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 109555ed8ca1SJohan Hedberg key->type = old_key_type; 10964748fed2SJohan Hedberg else 10974748fed2SJohan Hedberg key->type = type; 10984748fed2SJohan Hedberg 10994df378a1SJohan Hedberg if (!new_key) 11004df378a1SJohan Hedberg return 0; 11014df378a1SJohan Hedberg 11024df378a1SJohan Hedberg persistent = hci_persistent_key(hdev, conn, type, old_key_type); 11034df378a1SJohan Hedberg 11044df378a1SJohan Hedberg mgmt_new_key(hdev->id, key, persistent); 11054df378a1SJohan Hedberg 11064df378a1SJohan Hedberg if (!persistent) { 11074df378a1SJohan Hedberg list_del(&key->list); 11084df378a1SJohan Hedberg kfree(key); 11094df378a1SJohan Hedberg } 111055ed8ca1SJohan Hedberg 111155ed8ca1SJohan Hedberg return 0; 111255ed8ca1SJohan Hedberg } 111355ed8ca1SJohan Hedberg 111455ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 111555ed8ca1SJohan Hedberg { 111655ed8ca1SJohan Hedberg struct link_key *key; 111755ed8ca1SJohan Hedberg 111855ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 111955ed8ca1SJohan Hedberg if (!key) 112055ed8ca1SJohan Hedberg return -ENOENT; 112155ed8ca1SJohan Hedberg 112255ed8ca1SJohan Hedberg BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 112355ed8ca1SJohan Hedberg 112455ed8ca1SJohan Hedberg list_del(&key->list); 112555ed8ca1SJohan Hedberg kfree(key); 112655ed8ca1SJohan Hedberg 112755ed8ca1SJohan Hedberg return 0; 112855ed8ca1SJohan Hedberg } 112955ed8ca1SJohan Hedberg 11306bd32326SVille Tervo /* HCI command timer function */ 11316bd32326SVille Tervo static void hci_cmd_timer(unsigned long arg) 11326bd32326SVille Tervo { 11336bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 11346bd32326SVille Tervo 11356bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 11366bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 1137f630cf0dSGustavo F. Padovan clear_bit(HCI_RESET, &hdev->flags); 11386bd32326SVille Tervo tasklet_schedule(&hdev->cmd_task); 11396bd32326SVille Tervo } 11406bd32326SVille Tervo 11412763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 11422763eda6SSzymon Janc bdaddr_t *bdaddr) 11432763eda6SSzymon Janc { 11442763eda6SSzymon Janc struct oob_data *data; 11452763eda6SSzymon Janc 11462763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 11472763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 11482763eda6SSzymon Janc return data; 11492763eda6SSzymon Janc 11502763eda6SSzymon Janc return NULL; 11512763eda6SSzymon Janc } 11522763eda6SSzymon Janc 11532763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 11542763eda6SSzymon Janc { 11552763eda6SSzymon Janc struct oob_data *data; 11562763eda6SSzymon Janc 11572763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 11582763eda6SSzymon Janc if (!data) 11592763eda6SSzymon Janc return -ENOENT; 11602763eda6SSzymon Janc 11612763eda6SSzymon Janc BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 11622763eda6SSzymon Janc 11632763eda6SSzymon Janc list_del(&data->list); 11642763eda6SSzymon Janc kfree(data); 11652763eda6SSzymon Janc 11662763eda6SSzymon Janc return 0; 11672763eda6SSzymon Janc } 11682763eda6SSzymon Janc 11692763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 11702763eda6SSzymon Janc { 11712763eda6SSzymon Janc struct oob_data *data, *n; 11722763eda6SSzymon Janc 11732763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 11742763eda6SSzymon Janc list_del(&data->list); 11752763eda6SSzymon Janc kfree(data); 11762763eda6SSzymon Janc } 11772763eda6SSzymon Janc 11782763eda6SSzymon Janc return 0; 11792763eda6SSzymon Janc } 11802763eda6SSzymon Janc 11812763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 11822763eda6SSzymon Janc u8 *randomizer) 11832763eda6SSzymon Janc { 11842763eda6SSzymon Janc struct oob_data *data; 11852763eda6SSzymon Janc 11862763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 11872763eda6SSzymon Janc 11882763eda6SSzymon Janc if (!data) { 11892763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 11902763eda6SSzymon Janc if (!data) 11912763eda6SSzymon Janc return -ENOMEM; 11922763eda6SSzymon Janc 11932763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 11942763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 11952763eda6SSzymon Janc } 11962763eda6SSzymon Janc 11972763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 11982763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 11992763eda6SSzymon Janc 12002763eda6SSzymon Janc BT_DBG("%s for %s", hdev->name, batostr(bdaddr)); 12012763eda6SSzymon Janc 12022763eda6SSzymon Janc return 0; 12032763eda6SSzymon Janc } 12042763eda6SSzymon Janc 12051da177e4SLinus Torvalds /* Register HCI device */ 12061da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 12071da177e4SLinus Torvalds { 12081da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 1209ef222013SMarcel Holtmann int i, id = 0; 12101da177e4SLinus Torvalds 1211c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 1212c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 12151da177e4SLinus Torvalds return -EINVAL; 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds /* Find first available device id */ 12201da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 12211da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 12221da177e4SLinus Torvalds break; 12231da177e4SLinus Torvalds head = p; id++; 12241da177e4SLinus Torvalds } 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 12271da177e4SLinus Torvalds hdev->id = id; 12281da177e4SLinus Torvalds list_add(&hdev->list, head); 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 12311da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds hdev->flags = 0; 12341da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 12355b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 12361da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 123717fa4b9dSJohan Hedberg hdev->io_capability = 0x03; /* No Input No Output */ 12381da177e4SLinus Torvalds 123904837f64SMarcel Holtmann hdev->idle_timeout = 0; 124004837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 124104837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 124204837f64SMarcel Holtmann 12431da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 12441da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 12451da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 12461da177e4SLinus Torvalds 12471da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 12481da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 12491da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 12501da177e4SLinus Torvalds 12516bd32326SVille Tervo setup_timer(&hdev->cmd_timer, hci_cmd_timer, (unsigned long) hdev); 12526bd32326SVille Tervo 1253cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1254ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 1255ef222013SMarcel Holtmann 12561da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 1257a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds inquiry_cache_init(hdev); 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds hci_conn_hash_init(hdev); 12621da177e4SLinus Torvalds 1263ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1264f0358568SJohan Hedberg 12652aeb9a1aSJohan Hedberg INIT_LIST_HEAD(&hdev->uuids); 12662aeb9a1aSJohan Hedberg 126755ed8ca1SJohan Hedberg INIT_LIST_HEAD(&hdev->link_keys); 126855ed8ca1SJohan Hedberg 12692763eda6SSzymon Janc INIT_LIST_HEAD(&hdev->remote_oob_data); 12702763eda6SSzymon Janc 1271ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1272ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1273ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1274ab81cbf9SJohan Hedberg 12751da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 12801da177e4SLinus Torvalds 1281f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1282f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1283f48fd9c8SMarcel Holtmann goto nomem; 1284f48fd9c8SMarcel Holtmann 12851da177e4SLinus Torvalds hci_register_sysfs(hdev); 12861da177e4SLinus Torvalds 1287611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1288611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1289611b30f7SMarcel Holtmann if (hdev->rfkill) { 1290611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1291611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1292611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1293611b30f7SMarcel Holtmann } 1294611b30f7SMarcel Holtmann } 1295611b30f7SMarcel Holtmann 1296ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1297ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1298ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1299ab81cbf9SJohan Hedberg 13001da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 13011da177e4SLinus Torvalds 13021da177e4SLinus Torvalds return id; 1303f48fd9c8SMarcel Holtmann 1304f48fd9c8SMarcel Holtmann nomem: 1305f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1306f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1307f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1308f48fd9c8SMarcel Holtmann 1309f48fd9c8SMarcel Holtmann return -ENOMEM; 13101da177e4SLinus Torvalds } 13111da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds /* Unregister HCI device */ 13141da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 13151da177e4SLinus Torvalds { 1316ef222013SMarcel Holtmann int i; 1317ef222013SMarcel Holtmann 1318c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 13191da177e4SLinus Torvalds 13201da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 13211da177e4SLinus Torvalds list_del(&hdev->list); 13221da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 13231da177e4SLinus Torvalds 13241da177e4SLinus Torvalds hci_dev_do_close(hdev); 13251da177e4SLinus Torvalds 1326cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1327ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1328ef222013SMarcel Holtmann 1329ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1330ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1331c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1332ab81cbf9SJohan Hedberg 13331da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 13341da177e4SLinus Torvalds 1335611b30f7SMarcel Holtmann if (hdev->rfkill) { 1336611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1337611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1338611b30f7SMarcel Holtmann } 1339611b30f7SMarcel Holtmann 1340147e2d59SDave Young hci_unregister_sysfs(hdev); 1341147e2d59SDave Young 1342c6f3c5f7SGustavo F. Padovan hci_del_off_timer(hdev); 1343c6f3c5f7SGustavo F. Padovan 1344f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1345f48fd9c8SMarcel Holtmann 1346e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1347e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 13482aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 134955ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 13502763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 1351e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1352e2e0cacbSJohan Hedberg 13531da177e4SLinus Torvalds __hci_dev_put(hdev); 1354ef222013SMarcel Holtmann 13551da177e4SLinus Torvalds return 0; 13561da177e4SLinus Torvalds } 13571da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 13581da177e4SLinus Torvalds 13591da177e4SLinus Torvalds /* Suspend HCI device */ 13601da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 13611da177e4SLinus Torvalds { 13621da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 13631da177e4SLinus Torvalds return 0; 13641da177e4SLinus Torvalds } 13651da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds /* Resume HCI device */ 13681da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 13691da177e4SLinus Torvalds { 13701da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 13711da177e4SLinus Torvalds return 0; 13721da177e4SLinus Torvalds } 13731da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 13741da177e4SLinus Torvalds 137576bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 137676bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 137776bca880SMarcel Holtmann { 137876bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 137976bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 138076bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 138176bca880SMarcel Holtmann kfree_skb(skb); 138276bca880SMarcel Holtmann return -ENXIO; 138376bca880SMarcel Holtmann } 138476bca880SMarcel Holtmann 138576bca880SMarcel Holtmann /* Incomming skb */ 138676bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 138776bca880SMarcel Holtmann 138876bca880SMarcel Holtmann /* Time stamp */ 138976bca880SMarcel Holtmann __net_timestamp(skb); 139076bca880SMarcel Holtmann 139176bca880SMarcel Holtmann /* Queue frame for rx task */ 139276bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1393c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1394c78ae283SMarcel Holtmann 139576bca880SMarcel Holtmann return 0; 139676bca880SMarcel Holtmann } 139776bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 139876bca880SMarcel Holtmann 139933e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 14001e429f38SGustavo F. Padovan int count, __u8 index) 140133e882a5SSuraj Sumangala { 140233e882a5SSuraj Sumangala int len = 0; 140333e882a5SSuraj Sumangala int hlen = 0; 140433e882a5SSuraj Sumangala int remain = count; 140533e882a5SSuraj Sumangala struct sk_buff *skb; 140633e882a5SSuraj Sumangala struct bt_skb_cb *scb; 140733e882a5SSuraj Sumangala 140833e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 140933e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 141033e882a5SSuraj Sumangala return -EILSEQ; 141133e882a5SSuraj Sumangala 141233e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 141333e882a5SSuraj Sumangala 141433e882a5SSuraj Sumangala if (!skb) { 141533e882a5SSuraj Sumangala switch (type) { 141633e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 141733e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 141833e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 141933e882a5SSuraj Sumangala break; 142033e882a5SSuraj Sumangala case HCI_EVENT_PKT: 142133e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 142233e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 142333e882a5SSuraj Sumangala break; 142433e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 142533e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 142633e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 142733e882a5SSuraj Sumangala break; 142833e882a5SSuraj Sumangala } 142933e882a5SSuraj Sumangala 14301e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 143133e882a5SSuraj Sumangala if (!skb) 143233e882a5SSuraj Sumangala return -ENOMEM; 143333e882a5SSuraj Sumangala 143433e882a5SSuraj Sumangala scb = (void *) skb->cb; 143533e882a5SSuraj Sumangala scb->expect = hlen; 143633e882a5SSuraj Sumangala scb->pkt_type = type; 143733e882a5SSuraj Sumangala 143833e882a5SSuraj Sumangala skb->dev = (void *) hdev; 143933e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 144033e882a5SSuraj Sumangala } 144133e882a5SSuraj Sumangala 144233e882a5SSuraj Sumangala while (count) { 144333e882a5SSuraj Sumangala scb = (void *) skb->cb; 144433e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 144533e882a5SSuraj Sumangala 144633e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 144733e882a5SSuraj Sumangala 144833e882a5SSuraj Sumangala count -= len; 144933e882a5SSuraj Sumangala data += len; 145033e882a5SSuraj Sumangala scb->expect -= len; 145133e882a5SSuraj Sumangala remain = count; 145233e882a5SSuraj Sumangala 145333e882a5SSuraj Sumangala switch (type) { 145433e882a5SSuraj Sumangala case HCI_EVENT_PKT: 145533e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 145633e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 145733e882a5SSuraj Sumangala scb->expect = h->plen; 145833e882a5SSuraj Sumangala 145933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 146033e882a5SSuraj Sumangala kfree_skb(skb); 146133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 146233e882a5SSuraj Sumangala return -ENOMEM; 146333e882a5SSuraj Sumangala } 146433e882a5SSuraj Sumangala } 146533e882a5SSuraj Sumangala break; 146633e882a5SSuraj Sumangala 146733e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 146833e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 146933e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 147033e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 147133e882a5SSuraj Sumangala 147233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 147333e882a5SSuraj Sumangala kfree_skb(skb); 147433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 147533e882a5SSuraj Sumangala return -ENOMEM; 147633e882a5SSuraj Sumangala } 147733e882a5SSuraj Sumangala } 147833e882a5SSuraj Sumangala break; 147933e882a5SSuraj Sumangala 148033e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 148133e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 148233e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 148333e882a5SSuraj Sumangala scb->expect = h->dlen; 148433e882a5SSuraj Sumangala 148533e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 148633e882a5SSuraj Sumangala kfree_skb(skb); 148733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 148833e882a5SSuraj Sumangala return -ENOMEM; 148933e882a5SSuraj Sumangala } 149033e882a5SSuraj Sumangala } 149133e882a5SSuraj Sumangala break; 149233e882a5SSuraj Sumangala } 149333e882a5SSuraj Sumangala 149433e882a5SSuraj Sumangala if (scb->expect == 0) { 149533e882a5SSuraj Sumangala /* Complete frame */ 149633e882a5SSuraj Sumangala 149733e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 149833e882a5SSuraj Sumangala hci_recv_frame(skb); 149933e882a5SSuraj Sumangala 150033e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 150133e882a5SSuraj Sumangala return remain; 150233e882a5SSuraj Sumangala } 150333e882a5SSuraj Sumangala } 150433e882a5SSuraj Sumangala 150533e882a5SSuraj Sumangala return remain; 150633e882a5SSuraj Sumangala } 150733e882a5SSuraj Sumangala 1508ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1509ef222013SMarcel Holtmann { 1510f39a3c06SSuraj Sumangala int rem = 0; 1511f39a3c06SSuraj Sumangala 1512ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1513ef222013SMarcel Holtmann return -EILSEQ; 1514ef222013SMarcel Holtmann 1515da5f6c37SGustavo F. Padovan while (count) { 15161e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 1517f39a3c06SSuraj Sumangala if (rem < 0) 1518f39a3c06SSuraj Sumangala return rem; 1519ef222013SMarcel Holtmann 1520f39a3c06SSuraj Sumangala data += (count - rem); 1521f39a3c06SSuraj Sumangala count = rem; 1522f81c6224SJoe Perches } 1523ef222013SMarcel Holtmann 1524f39a3c06SSuraj Sumangala return rem; 1525ef222013SMarcel Holtmann } 1526ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1527ef222013SMarcel Holtmann 152899811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 152999811510SSuraj Sumangala 153099811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 153199811510SSuraj Sumangala { 153299811510SSuraj Sumangala int type; 153399811510SSuraj Sumangala int rem = 0; 153499811510SSuraj Sumangala 1535da5f6c37SGustavo F. Padovan while (count) { 153699811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 153799811510SSuraj Sumangala 153899811510SSuraj Sumangala if (!skb) { 153999811510SSuraj Sumangala struct { char type; } *pkt; 154099811510SSuraj Sumangala 154199811510SSuraj Sumangala /* Start of the frame */ 154299811510SSuraj Sumangala pkt = data; 154399811510SSuraj Sumangala type = pkt->type; 154499811510SSuraj Sumangala 154599811510SSuraj Sumangala data++; 154699811510SSuraj Sumangala count--; 154799811510SSuraj Sumangala } else 154899811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 154999811510SSuraj Sumangala 15501e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 15511e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 155299811510SSuraj Sumangala if (rem < 0) 155399811510SSuraj Sumangala return rem; 155499811510SSuraj Sumangala 155599811510SSuraj Sumangala data += (count - rem); 155699811510SSuraj Sumangala count = rem; 1557f81c6224SJoe Perches } 155899811510SSuraj Sumangala 155999811510SSuraj Sumangala return rem; 156099811510SSuraj Sumangala } 156199811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 156299811510SSuraj Sumangala 15631da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 15641da177e4SLinus Torvalds 15651da177e4SLinus Torvalds /* Register/Unregister protocols. 15661da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 15671da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 15681da177e4SLinus Torvalds { 15691da177e4SLinus Torvalds int err = 0; 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 15741da177e4SLinus Torvalds return -EINVAL; 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 15771da177e4SLinus Torvalds 15781da177e4SLinus Torvalds if (!hci_proto[hp->id]) 15791da177e4SLinus Torvalds hci_proto[hp->id] = hp; 15801da177e4SLinus Torvalds else 15811da177e4SLinus Torvalds err = -EEXIST; 15821da177e4SLinus Torvalds 15831da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds return err; 15861da177e4SLinus Torvalds } 15871da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 15881da177e4SLinus Torvalds 15891da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 15901da177e4SLinus Torvalds { 15911da177e4SLinus Torvalds int err = 0; 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 15961da177e4SLinus Torvalds return -EINVAL; 15971da177e4SLinus Torvalds 15981da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds if (hci_proto[hp->id]) 16011da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 16021da177e4SLinus Torvalds else 16031da177e4SLinus Torvalds err = -ENOENT; 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 16061da177e4SLinus Torvalds 16071da177e4SLinus Torvalds return err; 16081da177e4SLinus Torvalds } 16091da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 16101da177e4SLinus Torvalds 16111da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 16121da177e4SLinus Torvalds { 16131da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 16161da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 16171da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 16181da177e4SLinus Torvalds 16191da177e4SLinus Torvalds return 0; 16201da177e4SLinus Torvalds } 16211da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 16221da177e4SLinus Torvalds 16231da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 16241da177e4SLinus Torvalds { 16251da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 16261da177e4SLinus Torvalds 16271da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 16281da177e4SLinus Torvalds list_del(&cb->list); 16291da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 16301da177e4SLinus Torvalds 16311da177e4SLinus Torvalds return 0; 16321da177e4SLinus Torvalds } 16331da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 16341da177e4SLinus Torvalds 16351da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 16361da177e4SLinus Torvalds { 16371da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds if (!hdev) { 16401da177e4SLinus Torvalds kfree_skb(skb); 16411da177e4SLinus Torvalds return -ENODEV; 16421da177e4SLinus Torvalds } 16431da177e4SLinus Torvalds 16440d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 16451da177e4SLinus Torvalds 16461da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 16471da177e4SLinus Torvalds /* Time stamp */ 1648a61bbcf2SPatrick McHardy __net_timestamp(skb); 16491da177e4SLinus Torvalds 1650eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 16511da177e4SLinus Torvalds } 16521da177e4SLinus Torvalds 16531da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 16541da177e4SLinus Torvalds skb_orphan(skb); 16551da177e4SLinus Torvalds 16561da177e4SLinus Torvalds return hdev->send(skb); 16571da177e4SLinus Torvalds } 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds /* Send HCI command */ 1660a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 16611da177e4SLinus Torvalds { 16621da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 16631da177e4SLinus Torvalds struct hci_command_hdr *hdr; 16641da177e4SLinus Torvalds struct sk_buff *skb; 16651da177e4SLinus Torvalds 1666a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 16671da177e4SLinus Torvalds 16681da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 16691da177e4SLinus Torvalds if (!skb) { 1670ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 16711da177e4SLinus Torvalds return -ENOMEM; 16721da177e4SLinus Torvalds } 16731da177e4SLinus Torvalds 16741da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1675a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 16761da177e4SLinus Torvalds hdr->plen = plen; 16771da177e4SLinus Torvalds 16781da177e4SLinus Torvalds if (plen) 16791da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 16801da177e4SLinus Torvalds 16811da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 16821da177e4SLinus Torvalds 16830d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 16841da177e4SLinus Torvalds skb->dev = (void *) hdev; 1685c78ae283SMarcel Holtmann 1686a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags)) 1687a5040efaSJohan Hedberg hdev->init_last_cmd = opcode; 1688a5040efaSJohan Hedberg 16891da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1690c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 16911da177e4SLinus Torvalds 16921da177e4SLinus Torvalds return 0; 16931da177e4SLinus Torvalds } 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds /* Get data from the previously sent command */ 1696a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 16971da177e4SLinus Torvalds { 16981da177e4SLinus Torvalds struct hci_command_hdr *hdr; 16991da177e4SLinus Torvalds 17001da177e4SLinus Torvalds if (!hdev->sent_cmd) 17011da177e4SLinus Torvalds return NULL; 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 17041da177e4SLinus Torvalds 1705a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 17061da177e4SLinus Torvalds return NULL; 17071da177e4SLinus Torvalds 1708a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 17091da177e4SLinus Torvalds 17101da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 17111da177e4SLinus Torvalds } 17121da177e4SLinus Torvalds 17131da177e4SLinus Torvalds /* Send ACL data */ 17141da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 17151da177e4SLinus Torvalds { 17161da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 17171da177e4SLinus Torvalds int len = skb->len; 17181da177e4SLinus Torvalds 1719badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1720badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 17219c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1722aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1723aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 17241da177e4SLinus Torvalds } 17251da177e4SLinus Torvalds 17269a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 17271da177e4SLinus Torvalds { 17281da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 17291da177e4SLinus Torvalds struct sk_buff *list; 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 17321da177e4SLinus Torvalds 17331da177e4SLinus Torvalds skb->dev = (void *) hdev; 17340d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1735e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 17361da177e4SLinus Torvalds 173770f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 173870f23020SAndrei Emeltchenko if (!list) { 17391da177e4SLinus Torvalds /* Non fragmented */ 17401da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 17431da177e4SLinus Torvalds } else { 17441da177e4SLinus Torvalds /* Fragmented */ 17451da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 17461da177e4SLinus Torvalds 17471da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 17481da177e4SLinus Torvalds 17491da177e4SLinus Torvalds /* Queue all fragments atomically */ 17501da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 17511da177e4SLinus Torvalds 17521da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1753e702112fSAndrei Emeltchenko 1754e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1755e702112fSAndrei Emeltchenko flags |= ACL_CONT; 17561da177e4SLinus Torvalds do { 17571da177e4SLinus Torvalds skb = list; list = list->next; 17581da177e4SLinus Torvalds 17591da177e4SLinus Torvalds skb->dev = (void *) hdev; 17600d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1761e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 17641da177e4SLinus Torvalds 17651da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 17661da177e4SLinus Torvalds } while (list); 17671da177e4SLinus Torvalds 17681da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 17691da177e4SLinus Torvalds } 17701da177e4SLinus Torvalds 1771c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 17721da177e4SLinus Torvalds } 17731da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 17741da177e4SLinus Torvalds 17751da177e4SLinus Torvalds /* Send SCO data */ 17760d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 17771da177e4SLinus Torvalds { 17781da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 17791da177e4SLinus Torvalds struct hci_sco_hdr hdr; 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 17821da177e4SLinus Torvalds 1783aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 17841da177e4SLinus Torvalds hdr.dlen = skb->len; 17851da177e4SLinus Torvalds 1786badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1787badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 17889c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 17891da177e4SLinus Torvalds 17901da177e4SLinus Torvalds skb->dev = (void *) hdev; 17910d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1792c78ae283SMarcel Holtmann 17931da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1794c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 17951da177e4SLinus Torvalds } 17961da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 17991da177e4SLinus Torvalds 18001da177e4SLinus Torvalds /* HCI Connection scheduler */ 18011da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 18021da177e4SLinus Torvalds { 18031da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 18041da177e4SLinus Torvalds struct hci_conn *conn = NULL; 18051da177e4SLinus Torvalds int num = 0, min = ~0; 18061da177e4SLinus Torvalds struct list_head *p; 18071da177e4SLinus Torvalds 18081da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 18091da177e4SLinus Torvalds * added and removed with TX task disabled. */ 18101da177e4SLinus Torvalds list_for_each(p, &h->list) { 18111da177e4SLinus Torvalds struct hci_conn *c; 18121da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 18131da177e4SLinus Torvalds 1814769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 18151da177e4SLinus Torvalds continue; 1816769be974SMarcel Holtmann 1817769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1818769be974SMarcel Holtmann continue; 1819769be974SMarcel Holtmann 18201da177e4SLinus Torvalds num++; 18211da177e4SLinus Torvalds 18221da177e4SLinus Torvalds if (c->sent < min) { 18231da177e4SLinus Torvalds min = c->sent; 18241da177e4SLinus Torvalds conn = c; 18251da177e4SLinus Torvalds } 18261da177e4SLinus Torvalds } 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds if (conn) { 18296ed58ec5SVille Tervo int cnt, q; 18306ed58ec5SVille Tervo 18316ed58ec5SVille Tervo switch (conn->type) { 18326ed58ec5SVille Tervo case ACL_LINK: 18336ed58ec5SVille Tervo cnt = hdev->acl_cnt; 18346ed58ec5SVille Tervo break; 18356ed58ec5SVille Tervo case SCO_LINK: 18366ed58ec5SVille Tervo case ESCO_LINK: 18376ed58ec5SVille Tervo cnt = hdev->sco_cnt; 18386ed58ec5SVille Tervo break; 18396ed58ec5SVille Tervo case LE_LINK: 18406ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 18416ed58ec5SVille Tervo break; 18426ed58ec5SVille Tervo default: 18436ed58ec5SVille Tervo cnt = 0; 18446ed58ec5SVille Tervo BT_ERR("Unknown link type"); 18456ed58ec5SVille Tervo } 18466ed58ec5SVille Tervo 18476ed58ec5SVille Tervo q = cnt / num; 18481da177e4SLinus Torvalds *quote = q ? q : 1; 18491da177e4SLinus Torvalds } else 18501da177e4SLinus Torvalds *quote = 0; 18511da177e4SLinus Torvalds 18521da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 18531da177e4SLinus Torvalds return conn; 18541da177e4SLinus Torvalds } 18551da177e4SLinus Torvalds 1856bae1f5d9SVille Tervo static inline void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 18571da177e4SLinus Torvalds { 18581da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 18591da177e4SLinus Torvalds struct list_head *p; 18601da177e4SLinus Torvalds struct hci_conn *c; 18611da177e4SLinus Torvalds 1862bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds /* Kill stalled connections */ 18651da177e4SLinus Torvalds list_for_each(p, &h->list) { 18661da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 1867bae1f5d9SVille Tervo if (c->type == type && c->sent) { 1868bae1f5d9SVille Tervo BT_ERR("%s killing stalled connection %s", 18691da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 18701da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 18711da177e4SLinus Torvalds } 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds } 18741da177e4SLinus Torvalds 18751da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 18761da177e4SLinus Torvalds { 18771da177e4SLinus Torvalds struct hci_conn *conn; 18781da177e4SLinus Torvalds struct sk_buff *skb; 18791da177e4SLinus Torvalds int quote; 18801da177e4SLinus Torvalds 18811da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 18841da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 18851da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 188682453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 1887bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 18881da177e4SLinus Torvalds } 18891da177e4SLinus Torvalds 18901da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 18911da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 18921da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 189304837f64SMarcel Holtmann 189404837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 189504837f64SMarcel Holtmann 18961da177e4SLinus Torvalds hci_send_frame(skb); 18971da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds hdev->acl_cnt--; 19001da177e4SLinus Torvalds conn->sent++; 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds } 19031da177e4SLinus Torvalds } 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds /* Schedule SCO */ 19061da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 19071da177e4SLinus Torvalds { 19081da177e4SLinus Torvalds struct hci_conn *conn; 19091da177e4SLinus Torvalds struct sk_buff *skb; 19101da177e4SLinus Torvalds int quote; 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 19131da177e4SLinus Torvalds 19141da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 19151da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 19161da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 19171da177e4SLinus Torvalds hci_send_frame(skb); 19181da177e4SLinus Torvalds 19191da177e4SLinus Torvalds conn->sent++; 19201da177e4SLinus Torvalds if (conn->sent == ~0) 19211da177e4SLinus Torvalds conn->sent = 0; 19221da177e4SLinus Torvalds } 19231da177e4SLinus Torvalds } 19241da177e4SLinus Torvalds } 19251da177e4SLinus Torvalds 1926b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1927b6a0dc82SMarcel Holtmann { 1928b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1929b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1930b6a0dc82SMarcel Holtmann int quote; 1931b6a0dc82SMarcel Holtmann 1932b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1933b6a0dc82SMarcel Holtmann 1934b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1935b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1936b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1937b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1938b6a0dc82SMarcel Holtmann 1939b6a0dc82SMarcel Holtmann conn->sent++; 1940b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1941b6a0dc82SMarcel Holtmann conn->sent = 0; 1942b6a0dc82SMarcel Holtmann } 1943b6a0dc82SMarcel Holtmann } 1944b6a0dc82SMarcel Holtmann } 1945b6a0dc82SMarcel Holtmann 19466ed58ec5SVille Tervo static inline void hci_sched_le(struct hci_dev *hdev) 19476ed58ec5SVille Tervo { 19486ed58ec5SVille Tervo struct hci_conn *conn; 19496ed58ec5SVille Tervo struct sk_buff *skb; 19506ed58ec5SVille Tervo int quote, cnt; 19516ed58ec5SVille Tervo 19526ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 19536ed58ec5SVille Tervo 19546ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 19556ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 19566ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 1957bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 19586ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 1959bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 19606ed58ec5SVille Tervo } 19616ed58ec5SVille Tervo 19626ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 19636ed58ec5SVille Tervo while (cnt && (conn = hci_low_sent(hdev, LE_LINK, "e))) { 19646ed58ec5SVille Tervo while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 19656ed58ec5SVille Tervo BT_DBG("skb %p len %d", skb, skb->len); 19666ed58ec5SVille Tervo 19676ed58ec5SVille Tervo hci_send_frame(skb); 19686ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 19696ed58ec5SVille Tervo 19706ed58ec5SVille Tervo cnt--; 19716ed58ec5SVille Tervo conn->sent++; 19726ed58ec5SVille Tervo } 19736ed58ec5SVille Tervo } 19746ed58ec5SVille Tervo if (hdev->le_pkts) 19756ed58ec5SVille Tervo hdev->le_cnt = cnt; 19766ed58ec5SVille Tervo else 19776ed58ec5SVille Tervo hdev->acl_cnt = cnt; 19786ed58ec5SVille Tervo } 19796ed58ec5SVille Tervo 19801da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 19811da177e4SLinus Torvalds { 19821da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 19831da177e4SLinus Torvalds struct sk_buff *skb; 19841da177e4SLinus Torvalds 19851da177e4SLinus Torvalds read_lock(&hci_task_lock); 19861da177e4SLinus Torvalds 19876ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 19886ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 19911da177e4SLinus Torvalds 19921da177e4SLinus Torvalds hci_sched_acl(hdev); 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds hci_sched_sco(hdev); 19951da177e4SLinus Torvalds 1996b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1997b6a0dc82SMarcel Holtmann 19986ed58ec5SVille Tervo hci_sched_le(hdev); 19996ed58ec5SVille Tervo 20001da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 20011da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 20021da177e4SLinus Torvalds hci_send_frame(skb); 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds read_unlock(&hci_task_lock); 20051da177e4SLinus Torvalds } 20061da177e4SLinus Torvalds 200725985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 20081da177e4SLinus Torvalds 20091da177e4SLinus Torvalds /* ACL data packet */ 20101da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 20111da177e4SLinus Torvalds { 20121da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 20131da177e4SLinus Torvalds struct hci_conn *conn; 20141da177e4SLinus Torvalds __u16 handle, flags; 20151da177e4SLinus Torvalds 20161da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 20171da177e4SLinus Torvalds 20181da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 20191da177e4SLinus Torvalds flags = hci_flags(handle); 20201da177e4SLinus Torvalds handle = hci_handle(handle); 20211da177e4SLinus Torvalds 20221da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds hdev->stat.acl_rx++; 20251da177e4SLinus Torvalds 20261da177e4SLinus Torvalds hci_dev_lock(hdev); 20271da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 20281da177e4SLinus Torvalds hci_dev_unlock(hdev); 20291da177e4SLinus Torvalds 20301da177e4SLinus Torvalds if (conn) { 20311da177e4SLinus Torvalds register struct hci_proto *hp; 20321da177e4SLinus Torvalds 203304837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 203404837f64SMarcel Holtmann 20351da177e4SLinus Torvalds /* Send to upper protocol */ 203670f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 203770f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 20381da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 20391da177e4SLinus Torvalds return; 20401da177e4SLinus Torvalds } 20411da177e4SLinus Torvalds } else { 20421da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 20431da177e4SLinus Torvalds hdev->name, handle); 20441da177e4SLinus Torvalds } 20451da177e4SLinus Torvalds 20461da177e4SLinus Torvalds kfree_skb(skb); 20471da177e4SLinus Torvalds } 20481da177e4SLinus Torvalds 20491da177e4SLinus Torvalds /* SCO data packet */ 20501da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 20511da177e4SLinus Torvalds { 20521da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 20531da177e4SLinus Torvalds struct hci_conn *conn; 20541da177e4SLinus Torvalds __u16 handle; 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds hdev->stat.sco_rx++; 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds hci_dev_lock(hdev); 20651da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 20661da177e4SLinus Torvalds hci_dev_unlock(hdev); 20671da177e4SLinus Torvalds 20681da177e4SLinus Torvalds if (conn) { 20691da177e4SLinus Torvalds register struct hci_proto *hp; 20701da177e4SLinus Torvalds 20711da177e4SLinus Torvalds /* Send to upper protocol */ 207270f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 207370f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 20741da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 20751da177e4SLinus Torvalds return; 20761da177e4SLinus Torvalds } 20771da177e4SLinus Torvalds } else { 20781da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 20791da177e4SLinus Torvalds hdev->name, handle); 20801da177e4SLinus Torvalds } 20811da177e4SLinus Torvalds 20821da177e4SLinus Torvalds kfree_skb(skb); 20831da177e4SLinus Torvalds } 20841da177e4SLinus Torvalds 20856516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 20861da177e4SLinus Torvalds { 20871da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 20881da177e4SLinus Torvalds struct sk_buff *skb; 20891da177e4SLinus Torvalds 20901da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 20911da177e4SLinus Torvalds 20921da177e4SLinus Torvalds read_lock(&hci_task_lock); 20931da177e4SLinus Torvalds 20941da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 20951da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 20961da177e4SLinus Torvalds /* Send copy to the sockets */ 2097eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 20981da177e4SLinus Torvalds } 20991da177e4SLinus Torvalds 21001da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 21011da177e4SLinus Torvalds kfree_skb(skb); 21021da177e4SLinus Torvalds continue; 21031da177e4SLinus Torvalds } 21041da177e4SLinus Torvalds 21051da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 21061da177e4SLinus Torvalds /* Don't process data packets in this states. */ 21070d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 21081da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 21091da177e4SLinus Torvalds case HCI_SCODATA_PKT: 21101da177e4SLinus Torvalds kfree_skb(skb); 21111da177e4SLinus Torvalds continue; 21123ff50b79SStephen Hemminger } 21131da177e4SLinus Torvalds } 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds /* Process frame */ 21160d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 21171da177e4SLinus Torvalds case HCI_EVENT_PKT: 21181da177e4SLinus Torvalds hci_event_packet(hdev, skb); 21191da177e4SLinus Torvalds break; 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 21221da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 21231da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 21241da177e4SLinus Torvalds break; 21251da177e4SLinus Torvalds 21261da177e4SLinus Torvalds case HCI_SCODATA_PKT: 21271da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 21281da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 21291da177e4SLinus Torvalds break; 21301da177e4SLinus Torvalds 21311da177e4SLinus Torvalds default: 21321da177e4SLinus Torvalds kfree_skb(skb); 21331da177e4SLinus Torvalds break; 21341da177e4SLinus Torvalds } 21351da177e4SLinus Torvalds } 21361da177e4SLinus Torvalds 21371da177e4SLinus Torvalds read_unlock(&hci_task_lock); 21381da177e4SLinus Torvalds } 21391da177e4SLinus Torvalds 21401da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 21411da177e4SLinus Torvalds { 21421da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 21431da177e4SLinus Torvalds struct sk_buff *skb; 21441da177e4SLinus Torvalds 21451da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 21461da177e4SLinus Torvalds 21471da177e4SLinus Torvalds /* Send queued commands */ 21485a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 21495a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 21505a08ecceSAndrei Emeltchenko if (!skb) 21515a08ecceSAndrei Emeltchenko return; 21525a08ecceSAndrei Emeltchenko 21531da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 21541da177e4SLinus Torvalds 215570f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 215670f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 21571da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 21581da177e4SLinus Torvalds hci_send_frame(skb); 21596bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 21606bd32326SVille Tervo jiffies + msecs_to_jiffies(HCI_CMD_TIMEOUT)); 21611da177e4SLinus Torvalds } else { 21621da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 2163c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 21641da177e4SLinus Torvalds } 21651da177e4SLinus Torvalds } 21661da177e4SLinus Torvalds } 2167