11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 41da177e4SLinus Torvalds 51da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 61da177e4SLinus Torvalds 71da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 81da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 91da177e4SLinus Torvalds published by the Free Software Foundation; 101da177e4SLinus Torvalds 111da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 121da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 131da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 141da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 151da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 161da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 171da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 181da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 211da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 221da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 231da177e4SLinus Torvalds */ 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds /* Bluetooth HCI core. */ 261da177e4SLinus Torvalds 2782453021SS.Çağlar Onur #include <linux/jiffies.h> 281da177e4SLinus Torvalds #include <linux/module.h> 291da177e4SLinus Torvalds #include <linux/kmod.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <linux/types.h> 321da177e4SLinus Torvalds #include <linux/errno.h> 331da177e4SLinus Torvalds #include <linux/kernel.h> 341da177e4SLinus Torvalds #include <linux/sched.h> 351da177e4SLinus Torvalds #include <linux/slab.h> 361da177e4SLinus Torvalds #include <linux/poll.h> 371da177e4SLinus Torvalds #include <linux/fcntl.h> 381da177e4SLinus Torvalds #include <linux/init.h> 391da177e4SLinus Torvalds #include <linux/skbuff.h> 40f48fd9c8SMarcel Holtmann #include <linux/workqueue.h> 411da177e4SLinus Torvalds #include <linux/interrupt.h> 421da177e4SLinus Torvalds #include <linux/notifier.h> 43611b30f7SMarcel Holtmann #include <linux/rfkill.h> 446bd32326SVille Tervo #include <linux/timer.h> 451da177e4SLinus Torvalds #include <net/sock.h> 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds #include <asm/system.h> 4870f23020SAndrei Emeltchenko #include <linux/uaccess.h> 491da177e4SLinus Torvalds #include <asm/unaligned.h> 501da177e4SLinus Torvalds 511da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 521da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 531da177e4SLinus Torvalds 54ab81cbf9SJohan Hedberg #define AUTO_OFF_TIMEOUT 2000 55ab81cbf9SJohan Hedberg 561da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg); 571da177e4SLinus Torvalds static void hci_rx_task(unsigned long arg); 581da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg); 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds static DEFINE_RWLOCK(hci_task_lock); 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds /* HCI device list */ 631da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 641da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /* HCI callback list */ 671da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 681da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds /* HCI protocols */ 711da177e4SLinus Torvalds #define HCI_MAX_PROTO 2 721da177e4SLinus Torvalds struct hci_proto *hci_proto[HCI_MAX_PROTO]; 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* HCI notifiers list */ 75e041c683SAlan Stern static ATOMIC_NOTIFIER_HEAD(hci_notifier); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds int hci_register_notifier(struct notifier_block *nb) 801da177e4SLinus Torvalds { 81e041c683SAlan Stern return atomic_notifier_chain_register(&hci_notifier, nb); 821da177e4SLinus Torvalds } 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds int hci_unregister_notifier(struct notifier_block *nb) 851da177e4SLinus Torvalds { 86e041c683SAlan Stern return atomic_notifier_chain_unregister(&hci_notifier, nb); 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 896516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 901da177e4SLinus Torvalds { 91e041c683SAlan Stern atomic_notifier_call_chain(&hci_notifier, event, hdev); 921da177e4SLinus Torvalds } 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* ---- HCI requests ---- */ 951da177e4SLinus Torvalds 9623bb5763SJohan Hedberg void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result) 971da177e4SLinus Torvalds { 9823bb5763SJohan Hedberg BT_DBG("%s command 0x%04x result 0x%2.2x", hdev->name, cmd, result); 9923bb5763SJohan Hedberg 100a5040efaSJohan Hedberg /* If this is the init phase check if the completed command matches 101a5040efaSJohan Hedberg * the last init command, and if not just return. 102a5040efaSJohan Hedberg */ 103a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && hdev->init_last_cmd != cmd) 10423bb5763SJohan Hedberg return; 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1071da177e4SLinus Torvalds hdev->req_result = result; 1081da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1091da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1141da177e4SLinus Torvalds { 1151da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1181da177e4SLinus Torvalds hdev->req_result = err; 1191da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1201da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1211da177e4SLinus Torvalds } 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds /* Execute request and wait for completion. */ 1251da177e4SLinus Torvalds static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1261da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1291da177e4SLinus Torvalds int err = 0; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds add_wait_queue(&hdev->req_wait_q, &wait); 1361da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds req(hdev, opt); 1391da177e4SLinus Torvalds schedule_timeout(timeout); 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds if (signal_pending(current)) 1441da177e4SLinus Torvalds return -EINTR; 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds switch (hdev->req_status) { 1471da177e4SLinus Torvalds case HCI_REQ_DONE: 1481da177e4SLinus Torvalds err = -bt_err(hdev->req_result); 1491da177e4SLinus Torvalds break; 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds case HCI_REQ_CANCELED: 1521da177e4SLinus Torvalds err = -hdev->req_result; 1531da177e4SLinus Torvalds break; 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds default: 1561da177e4SLinus Torvalds err = -ETIMEDOUT; 1571da177e4SLinus Torvalds break; 1583ff50b79SStephen Hemminger } 1591da177e4SLinus Torvalds 160a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds return err; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1681da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1691da177e4SLinus Torvalds { 1701da177e4SLinus Torvalds int ret; 1711da177e4SLinus Torvalds 1727c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 1737c6a329eSMarcel Holtmann return -ENETDOWN; 1747c6a329eSMarcel Holtmann 1751da177e4SLinus Torvalds /* Serialize all requests */ 1761da177e4SLinus Torvalds hci_req_lock(hdev); 1771da177e4SLinus Torvalds ret = __hci_request(hdev, req, opt, timeout); 1781da177e4SLinus Torvalds hci_req_unlock(hdev); 1791da177e4SLinus Torvalds 1801da177e4SLinus Torvalds return ret; 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds static void hci_reset_req(struct hci_dev *hdev, unsigned long opt) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds /* Reset device */ 18810572132SGustavo F. Padovan set_bit(HCI_RESET, &hdev->flags); 189a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1931da177e4SLinus Torvalds { 194b0916ea0SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 1951da177e4SLinus Torvalds struct sk_buff *skb; 1961ebb9252SMarcel Holtmann __le16 param; 19789f2783dSMarcel Holtmann __u8 flt_type; 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds /* Driver initialization */ 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /* Special commands */ 2041da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 2050d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2061da177e4SLinus Torvalds skb->dev = (void *) hdev; 207c78ae283SMarcel Holtmann 2081da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 209c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2121da177e4SLinus Torvalds 2131da177e4SLinus Torvalds /* Mandatory initialization */ 2141da177e4SLinus Torvalds 2151da177e4SLinus Torvalds /* Reset */ 21610572132SGustavo F. Padovan if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) { 21710572132SGustavo F. Padovan set_bit(HCI_RESET, &hdev->flags); 218a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 21910572132SGustavo F. Padovan } 2201da177e4SLinus Torvalds 2211da177e4SLinus Torvalds /* Read Local Supported Features */ 222a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2231da177e4SLinus Torvalds 2241143e5a6SMarcel Holtmann /* Read Local Version */ 225a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2261143e5a6SMarcel Holtmann 2271da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 228a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds #if 0 2311da177e4SLinus Torvalds /* Host buffer size */ 2321da177e4SLinus Torvalds { 2331da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 234aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2351da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 236aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 237aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 238a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds #endif 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds /* Read BD Address */ 243a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 244a9de9248SMarcel Holtmann 245a9de9248SMarcel Holtmann /* Read Class of Device */ 246a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 247a9de9248SMarcel Holtmann 248a9de9248SMarcel Holtmann /* Read Local Name */ 249a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* Read Voice Setting */ 252a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds /* Optional initialization */ 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds /* Clear Event Filters */ 25789f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 258a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 261aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 262a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 263b0916ea0SJohan Hedberg 264b0916ea0SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 265b0916ea0SJohan Hedberg cp.delete_all = 1; 266b0916ea0SJohan Hedberg hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp); 2671da177e4SLinus Torvalds } 2681da177e4SLinus Torvalds 2696ed58ec5SVille Tervo static void hci_le_init_req(struct hci_dev *hdev, unsigned long opt) 2706ed58ec5SVille Tervo { 2716ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 2726ed58ec5SVille Tervo 2736ed58ec5SVille Tervo /* Read LE buffer size */ 2746ed58ec5SVille Tervo hci_send_cmd(hdev, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 2756ed58ec5SVille Tervo } 2766ed58ec5SVille Tervo 2771da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2781da177e4SLinus Torvalds { 2791da177e4SLinus Torvalds __u8 scan = opt; 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds /* Inquiry and Page scans */ 284a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2881da177e4SLinus Torvalds { 2891da177e4SLinus Torvalds __u8 auth = opt; 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds /* Authentication */ 294a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2981da177e4SLinus Torvalds { 2991da177e4SLinus Torvalds __u8 encrypt = opt; 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 3021da177e4SLinus Torvalds 303e4e8e37cSMarcel Holtmann /* Encryption */ 304a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 307e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 308e4e8e37cSMarcel Holtmann { 309e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 310e4e8e37cSMarcel Holtmann 311a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 312e4e8e37cSMarcel Holtmann 313e4e8e37cSMarcel Holtmann /* Default link policy */ 314e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 315e4e8e37cSMarcel Holtmann } 316e4e8e37cSMarcel Holtmann 3171da177e4SLinus Torvalds /* Get HCI device by index. 3181da177e4SLinus Torvalds * Device is held on return. */ 3191da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3201da177e4SLinus Torvalds { 3211da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3221da177e4SLinus Torvalds struct list_head *p; 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds BT_DBG("%d", index); 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds if (index < 0) 3271da177e4SLinus Torvalds return NULL; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3301da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3311da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3321da177e4SLinus Torvalds if (d->id == index) { 3331da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3341da177e4SLinus Torvalds break; 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds } 3371da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3381da177e4SLinus Torvalds return hdev; 3391da177e4SLinus Torvalds } 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3421da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3431da177e4SLinus Torvalds { 3441da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3451da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds cache->list = NULL; 3501da177e4SLinus Torvalds while ((e = next)) { 3511da177e4SLinus Torvalds next = e->next; 3521da177e4SLinus Torvalds kfree(e); 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3571da177e4SLinus Torvalds { 3581da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3591da177e4SLinus Torvalds struct inquiry_entry *e; 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3641da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3651da177e4SLinus Torvalds break; 3661da177e4SLinus Torvalds return e; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3701da177e4SLinus Torvalds { 3711da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 37270f23020SAndrei Emeltchenko struct inquiry_entry *ie; 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3751da177e4SLinus Torvalds 37670f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 37770f23020SAndrei Emeltchenko if (!ie) { 3781da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 37970f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 38070f23020SAndrei Emeltchenko if (!ie) 3811da177e4SLinus Torvalds return; 38270f23020SAndrei Emeltchenko 38370f23020SAndrei Emeltchenko ie->next = cache->list; 38470f23020SAndrei Emeltchenko cache->list = ie; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 38770f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 38870f23020SAndrei Emeltchenko ie->timestamp = jiffies; 3891da177e4SLinus Torvalds cache->timestamp = jiffies; 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds 3921da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3931da177e4SLinus Torvalds { 3941da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3951da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3961da177e4SLinus Torvalds struct inquiry_entry *e; 3971da177e4SLinus Torvalds int copied = 0; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 4001da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 4011da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 4021da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 4031da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 4041da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 4051da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 4061da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 4071da177e4SLinus Torvalds info++; 4081da177e4SLinus Torvalds } 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 4111da177e4SLinus Torvalds return copied; 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 4151da177e4SLinus Torvalds { 4161da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 4171da177e4SLinus Torvalds struct hci_cp_inquiry cp; 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 4221da177e4SLinus Torvalds return; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds /* Start Inquiry */ 4251da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4261da177e4SLinus Torvalds cp.length = ir->length; 4271da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 428a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4321da177e4SLinus Torvalds { 4331da177e4SLinus Torvalds __u8 __user *ptr = arg; 4341da177e4SLinus Torvalds struct hci_inquiry_req ir; 4351da177e4SLinus Torvalds struct hci_dev *hdev; 4361da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4371da177e4SLinus Torvalds long timeo; 4381da177e4SLinus Torvalds __u8 *buf; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4411da177e4SLinus Torvalds return -EFAULT; 4421da177e4SLinus Torvalds 4435a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 4445a08ecceSAndrei Emeltchenko if (!hdev) 4451da177e4SLinus Torvalds return -ENODEV; 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4481da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4491da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4501da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4511da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4521da177e4SLinus Torvalds do_inquiry = 1; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4551da177e4SLinus Torvalds 45604837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 45770f23020SAndrei Emeltchenko 45870f23020SAndrei Emeltchenko if (do_inquiry) { 45970f23020SAndrei Emeltchenko err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo); 46070f23020SAndrei Emeltchenko if (err < 0) 4611da177e4SLinus Torvalds goto done; 46270f23020SAndrei Emeltchenko } 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4651da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4681da177e4SLinus Torvalds * copy it to the user space. 4691da177e4SLinus Torvalds */ 47070f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 47170f23020SAndrei Emeltchenko if (!buf) { 4721da177e4SLinus Torvalds err = -ENOMEM; 4731da177e4SLinus Torvalds goto done; 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4771da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4781da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4831da177e4SLinus Torvalds ptr += sizeof(ir); 4841da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4851da177e4SLinus Torvalds ir.num_rsp)) 4861da177e4SLinus Torvalds err = -EFAULT; 4871da177e4SLinus Torvalds } else 4881da177e4SLinus Torvalds err = -EFAULT; 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds kfree(buf); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds done: 4931da177e4SLinus Torvalds hci_dev_put(hdev); 4941da177e4SLinus Torvalds return err; 4951da177e4SLinus Torvalds } 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 5001da177e4SLinus Torvalds { 5011da177e4SLinus Torvalds struct hci_dev *hdev; 5021da177e4SLinus Torvalds int ret = 0; 5031da177e4SLinus Torvalds 5045a08ecceSAndrei Emeltchenko hdev = hci_dev_get(dev); 5055a08ecceSAndrei Emeltchenko if (!hdev) 5061da177e4SLinus Torvalds return -ENODEV; 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds hci_req_lock(hdev); 5111da177e4SLinus Torvalds 512611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 513611b30f7SMarcel Holtmann ret = -ERFKILL; 514611b30f7SMarcel Holtmann goto done; 515611b30f7SMarcel Holtmann } 516611b30f7SMarcel Holtmann 5171da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 5181da177e4SLinus Torvalds ret = -EALREADY; 5191da177e4SLinus Torvalds goto done; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 5231da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 5241da177e4SLinus Torvalds 525943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 526943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 527943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 528943da25dSMarcel Holtmann 5291da177e4SLinus Torvalds if (hdev->open(hdev)) { 5301da177e4SLinus Torvalds ret = -EIO; 5311da177e4SLinus Torvalds goto done; 5321da177e4SLinus Torvalds } 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5351da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5361da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 537a5040efaSJohan Hedberg hdev->init_last_cmd = 0; 5381da177e4SLinus Torvalds 53904837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 54004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5411da177e4SLinus Torvalds 5426ed58ec5SVille Tervo if (lmp_le_capable(hdev)) 5436ed58ec5SVille Tervo ret = __hci_request(hdev, hci_le_init_req, 0, 5446ed58ec5SVille Tervo msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5456ed58ec5SVille Tervo 5461da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds if (!ret) { 5501da177e4SLinus Torvalds hci_dev_hold(hdev); 5511da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5521da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5535add6af8SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->flags)) 5545add6af8SJohan Hedberg mgmt_powered(hdev->id, 1); 5551da177e4SLinus Torvalds } else { 5561da177e4SLinus Torvalds /* Init failed, cleanup */ 5571da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5581da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5591da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5621da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds if (hdev->flush) 5651da177e4SLinus Torvalds hdev->flush(hdev); 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds if (hdev->sent_cmd) { 5681da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5691da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds hdev->close(hdev); 5731da177e4SLinus Torvalds hdev->flags = 0; 5741da177e4SLinus Torvalds } 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds done: 5771da177e4SLinus Torvalds hci_req_unlock(hdev); 5781da177e4SLinus Torvalds hci_dev_put(hdev); 5791da177e4SLinus Torvalds return ret; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5831da177e4SLinus Torvalds { 5841da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5871da177e4SLinus Torvalds hci_req_lock(hdev); 5881da177e4SLinus Torvalds 5896f5ef998SThomas Gleixner /* Stop timer, it might be running */ 5906f5ef998SThomas Gleixner del_timer_sync(&hdev->cmd_timer); 5916f5ef998SThomas Gleixner 5921da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 593b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 5941da177e4SLinus Torvalds hci_req_unlock(hdev); 5951da177e4SLinus Torvalds return 0; 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5991da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 6001da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6031da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6041da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6051da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds if (hdev->flush) 6101da177e4SLinus Torvalds hdev->flush(hdev); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds /* Reset device */ 6131da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6141da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6151da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 6161da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 61704837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 61804837f64SMarcel Holtmann msecs_to_jiffies(250)); 6191da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 6201da177e4SLinus Torvalds } 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds /* Kill cmd task */ 6231da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds /* Drop queues */ 6261da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6271da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6281da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds /* Drop last sent command */ 6311da177e4SLinus Torvalds if (hdev->sent_cmd) { 6321da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 6331da177e4SLinus Torvalds hdev->sent_cmd = NULL; 6341da177e4SLinus Torvalds } 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds /* After this point our queues are empty 6371da177e4SLinus Torvalds * and no tasks are scheduled. */ 6381da177e4SLinus Torvalds hdev->close(hdev); 6391da177e4SLinus Torvalds 6405add6af8SJohan Hedberg mgmt_powered(hdev->id, 0); 6415add6af8SJohan Hedberg 6421da177e4SLinus Torvalds /* Clear flags */ 6431da177e4SLinus Torvalds hdev->flags = 0; 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds hci_req_unlock(hdev); 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds hci_dev_put(hdev); 6481da177e4SLinus Torvalds return 0; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6521da177e4SLinus Torvalds { 6531da177e4SLinus Torvalds struct hci_dev *hdev; 6541da177e4SLinus Torvalds int err; 6551da177e4SLinus Torvalds 65670f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 65770f23020SAndrei Emeltchenko if (!hdev) 6581da177e4SLinus Torvalds return -ENODEV; 6591da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6601da177e4SLinus Torvalds hci_dev_put(hdev); 6611da177e4SLinus Torvalds return err; 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6651da177e4SLinus Torvalds { 6661da177e4SLinus Torvalds struct hci_dev *hdev; 6671da177e4SLinus Torvalds int ret = 0; 6681da177e4SLinus Torvalds 66970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 67070f23020SAndrei Emeltchenko if (!hdev) 6711da177e4SLinus Torvalds return -ENODEV; 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds hci_req_lock(hdev); 6741da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6771da177e4SLinus Torvalds goto done; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds /* Drop queues */ 6801da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6811da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6841da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6851da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6861da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds if (hdev->flush) 6891da177e4SLinus Torvalds hdev->flush(hdev); 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6926ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 69504837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 69604837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds done: 6991da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 7001da177e4SLinus Torvalds hci_req_unlock(hdev); 7011da177e4SLinus Torvalds hci_dev_put(hdev); 7021da177e4SLinus Torvalds return ret; 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 7061da177e4SLinus Torvalds { 7071da177e4SLinus Torvalds struct hci_dev *hdev; 7081da177e4SLinus Torvalds int ret = 0; 7091da177e4SLinus Torvalds 71070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 71170f23020SAndrei Emeltchenko if (!hdev) 7121da177e4SLinus Torvalds return -ENODEV; 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds hci_dev_put(hdev); 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds return ret; 7191da177e4SLinus Torvalds } 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 7221da177e4SLinus Torvalds { 7231da177e4SLinus Torvalds struct hci_dev *hdev; 7241da177e4SLinus Torvalds struct hci_dev_req dr; 7251da177e4SLinus Torvalds int err = 0; 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 7281da177e4SLinus Torvalds return -EFAULT; 7291da177e4SLinus Torvalds 73070f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 73170f23020SAndrei Emeltchenko if (!hdev) 7321da177e4SLinus Torvalds return -ENODEV; 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds switch (cmd) { 7351da177e4SLinus Torvalds case HCISETAUTH: 73604837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 73704837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7381da177e4SLinus Torvalds break; 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds case HCISETENCRYPT: 7411da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 7421da177e4SLinus Torvalds err = -EOPNOTSUPP; 7431da177e4SLinus Torvalds break; 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7471da177e4SLinus Torvalds /* Auth must be enabled first */ 74804837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 74904837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7501da177e4SLinus Torvalds if (err) 7511da177e4SLinus Torvalds break; 7521da177e4SLinus Torvalds } 7531da177e4SLinus Torvalds 75404837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 75504837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7561da177e4SLinus Torvalds break; 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds case HCISETSCAN: 75904837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 76004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7611da177e4SLinus Torvalds break; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds case HCISETLINKPOL: 764e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 765e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7661da177e4SLinus Torvalds break; 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds case HCISETLINKMODE: 769e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 770e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 771e4e8e37cSMarcel Holtmann break; 772e4e8e37cSMarcel Holtmann 773e4e8e37cSMarcel Holtmann case HCISETPTYPE: 774e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7751da177e4SLinus Torvalds break; 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds case HCISETACLMTU: 7781da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7791da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7801da177e4SLinus Torvalds break; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds case HCISETSCOMTU: 7831da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7841da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7851da177e4SLinus Torvalds break; 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds default: 7881da177e4SLinus Torvalds err = -EINVAL; 7891da177e4SLinus Torvalds break; 7901da177e4SLinus Torvalds } 791e4e8e37cSMarcel Holtmann 7921da177e4SLinus Torvalds hci_dev_put(hdev); 7931da177e4SLinus Torvalds return err; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7971da177e4SLinus Torvalds { 7981da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7991da177e4SLinus Torvalds struct hci_dev_req *dr; 8001da177e4SLinus Torvalds struct list_head *p; 8011da177e4SLinus Torvalds int n = 0, size, err; 8021da177e4SLinus Torvalds __u16 dev_num; 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 8051da177e4SLinus Torvalds return -EFAULT; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 8081da177e4SLinus Torvalds return -EINVAL; 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 8111da177e4SLinus Torvalds 81270f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 81370f23020SAndrei Emeltchenko if (!dl) 8141da177e4SLinus Torvalds return -ENOMEM; 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds dr = dl->dev_req; 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 8191da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8201da177e4SLinus Torvalds struct hci_dev *hdev; 821c542a06cSJohan Hedberg 8221da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 823c542a06cSJohan Hedberg 824ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 825c542a06cSJohan Hedberg 826c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 827c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 828c542a06cSJohan Hedberg 8291da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 8301da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 831c542a06cSJohan Hedberg 8321da177e4SLinus Torvalds if (++n >= dev_num) 8331da177e4SLinus Torvalds break; 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds dl->dev_num = n; 8381da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 8411da177e4SLinus Torvalds kfree(dl); 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds return err ? -EFAULT : 0; 8441da177e4SLinus Torvalds } 8451da177e4SLinus Torvalds 8461da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 8471da177e4SLinus Torvalds { 8481da177e4SLinus Torvalds struct hci_dev *hdev; 8491da177e4SLinus Torvalds struct hci_dev_info di; 8501da177e4SLinus Torvalds int err = 0; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 8531da177e4SLinus Torvalds return -EFAULT; 8541da177e4SLinus Torvalds 85570f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 85670f23020SAndrei Emeltchenko if (!hdev) 8571da177e4SLinus Torvalds return -ENODEV; 8581da177e4SLinus Torvalds 859ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 860ab81cbf9SJohan Hedberg 861c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 862c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 863c542a06cSJohan Hedberg 8641da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8651da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 866943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8671da177e4SLinus Torvalds di.flags = hdev->flags; 8681da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8691da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8701da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8711da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8721da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8731da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8741da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8751da177e4SLinus Torvalds 8761da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8771da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8801da177e4SLinus Torvalds err = -EFAULT; 8811da177e4SLinus Torvalds 8821da177e4SLinus Torvalds hci_dev_put(hdev); 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds return err; 8851da177e4SLinus Torvalds } 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8881da177e4SLinus Torvalds 889611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 890611b30f7SMarcel Holtmann { 891611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 892611b30f7SMarcel Holtmann 893611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 894611b30f7SMarcel Holtmann 895611b30f7SMarcel Holtmann if (!blocked) 896611b30f7SMarcel Holtmann return 0; 897611b30f7SMarcel Holtmann 898611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 899611b30f7SMarcel Holtmann 900611b30f7SMarcel Holtmann return 0; 901611b30f7SMarcel Holtmann } 902611b30f7SMarcel Holtmann 903611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 904611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 905611b30f7SMarcel Holtmann }; 906611b30f7SMarcel Holtmann 9071da177e4SLinus Torvalds /* Alloc HCI device */ 9081da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 9091da177e4SLinus Torvalds { 9101da177e4SLinus Torvalds struct hci_dev *hdev; 9111da177e4SLinus Torvalds 91225ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 9131da177e4SLinus Torvalds if (!hdev) 9141da177e4SLinus Torvalds return NULL; 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 9171da177e4SLinus Torvalds 9181da177e4SLinus Torvalds return hdev; 9191da177e4SLinus Torvalds } 9201da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds /* Free HCI device */ 9231da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 9241da177e4SLinus Torvalds { 9251da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 9261da177e4SLinus Torvalds 927a91f2e39SMarcel Holtmann /* will free via device release */ 928a91f2e39SMarcel Holtmann put_device(&hdev->dev); 9291da177e4SLinus Torvalds } 9301da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 9311da177e4SLinus Torvalds 932ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 933ab81cbf9SJohan Hedberg { 934ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 935ab81cbf9SJohan Hedberg 936ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 937ab81cbf9SJohan Hedberg 938ab81cbf9SJohan Hedberg if (hci_dev_open(hdev->id) < 0) 939ab81cbf9SJohan Hedberg return; 940ab81cbf9SJohan Hedberg 941ab81cbf9SJohan Hedberg if (test_bit(HCI_AUTO_OFF, &hdev->flags)) 942ab81cbf9SJohan Hedberg mod_timer(&hdev->off_timer, 943ab81cbf9SJohan Hedberg jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT)); 944ab81cbf9SJohan Hedberg 945ab81cbf9SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->flags)) 946ab81cbf9SJohan Hedberg mgmt_index_added(hdev->id); 947ab81cbf9SJohan Hedberg } 948ab81cbf9SJohan Hedberg 949ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 950ab81cbf9SJohan Hedberg { 951ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_off); 952ab81cbf9SJohan Hedberg 953ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 954ab81cbf9SJohan Hedberg 955ab81cbf9SJohan Hedberg hci_dev_close(hdev->id); 956ab81cbf9SJohan Hedberg } 957ab81cbf9SJohan Hedberg 958ab81cbf9SJohan Hedberg static void hci_auto_off(unsigned long data) 959ab81cbf9SJohan Hedberg { 960ab81cbf9SJohan Hedberg struct hci_dev *hdev = (struct hci_dev *) data; 961ab81cbf9SJohan Hedberg 962ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 963ab81cbf9SJohan Hedberg 964ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 965ab81cbf9SJohan Hedberg 966ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_off); 967ab81cbf9SJohan Hedberg } 968ab81cbf9SJohan Hedberg 969ab81cbf9SJohan Hedberg void hci_del_off_timer(struct hci_dev *hdev) 970ab81cbf9SJohan Hedberg { 971ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 972ab81cbf9SJohan Hedberg 973ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 974ab81cbf9SJohan Hedberg del_timer(&hdev->off_timer); 975ab81cbf9SJohan Hedberg } 976ab81cbf9SJohan Hedberg 9772aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 9782aeb9a1aSJohan Hedberg { 9792aeb9a1aSJohan Hedberg struct list_head *p, *n; 9802aeb9a1aSJohan Hedberg 9812aeb9a1aSJohan Hedberg list_for_each_safe(p, n, &hdev->uuids) { 9822aeb9a1aSJohan Hedberg struct bt_uuid *uuid; 9832aeb9a1aSJohan Hedberg 9842aeb9a1aSJohan Hedberg uuid = list_entry(p, struct bt_uuid, list); 9852aeb9a1aSJohan Hedberg 9862aeb9a1aSJohan Hedberg list_del(p); 9872aeb9a1aSJohan Hedberg kfree(uuid); 9882aeb9a1aSJohan Hedberg } 9892aeb9a1aSJohan Hedberg 9902aeb9a1aSJohan Hedberg return 0; 9912aeb9a1aSJohan Hedberg } 9922aeb9a1aSJohan Hedberg 99355ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 99455ed8ca1SJohan Hedberg { 99555ed8ca1SJohan Hedberg struct list_head *p, *n; 99655ed8ca1SJohan Hedberg 99755ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 99855ed8ca1SJohan Hedberg struct link_key *key; 99955ed8ca1SJohan Hedberg 100055ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 100155ed8ca1SJohan Hedberg 100255ed8ca1SJohan Hedberg list_del(p); 100355ed8ca1SJohan Hedberg kfree(key); 100455ed8ca1SJohan Hedberg } 100555ed8ca1SJohan Hedberg 100655ed8ca1SJohan Hedberg return 0; 100755ed8ca1SJohan Hedberg } 100855ed8ca1SJohan Hedberg 100955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 101055ed8ca1SJohan Hedberg { 101155ed8ca1SJohan Hedberg struct list_head *p; 101255ed8ca1SJohan Hedberg 101355ed8ca1SJohan Hedberg list_for_each(p, &hdev->link_keys) { 101455ed8ca1SJohan Hedberg struct link_key *k; 101555ed8ca1SJohan Hedberg 101655ed8ca1SJohan Hedberg k = list_entry(p, struct link_key, list); 101755ed8ca1SJohan Hedberg 101855ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 101955ed8ca1SJohan Hedberg return k; 102055ed8ca1SJohan Hedberg } 102155ed8ca1SJohan Hedberg 102255ed8ca1SJohan Hedberg return NULL; 102355ed8ca1SJohan Hedberg } 102455ed8ca1SJohan Hedberg 1025d25e28abSJohan Hedberg static int hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 1026d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 1027d25e28abSJohan Hedberg { 1028d25e28abSJohan Hedberg /* Legacy key */ 1029d25e28abSJohan Hedberg if (key_type < 0x03) 1030d25e28abSJohan Hedberg return 1; 1031d25e28abSJohan Hedberg 1032d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 1033d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 1034d25e28abSJohan Hedberg return 0; 1035d25e28abSJohan Hedberg 1036d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 1037d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 1038d25e28abSJohan Hedberg return 0; 1039d25e28abSJohan Hedberg 1040d25e28abSJohan Hedberg /* Security mode 3 case */ 1041d25e28abSJohan Hedberg if (!conn) 1042d25e28abSJohan Hedberg return 1; 1043d25e28abSJohan Hedberg 1044d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 1045d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 1046d25e28abSJohan Hedberg return 1; 1047d25e28abSJohan Hedberg 1048d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 1049d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 1050d25e28abSJohan Hedberg return 1; 1051d25e28abSJohan Hedberg 1052d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 1053d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 1054d25e28abSJohan Hedberg return 1; 1055d25e28abSJohan Hedberg 1056d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 1057d25e28abSJohan Hedberg * persistently */ 1058d25e28abSJohan Hedberg return 0; 1059d25e28abSJohan Hedberg } 1060d25e28abSJohan Hedberg 1061d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 1062d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 106355ed8ca1SJohan Hedberg { 106455ed8ca1SJohan Hedberg struct link_key *key, *old_key; 106555ed8ca1SJohan Hedberg u8 old_key_type; 106655ed8ca1SJohan Hedberg 106755ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 106855ed8ca1SJohan Hedberg if (old_key) { 106955ed8ca1SJohan Hedberg old_key_type = old_key->type; 107055ed8ca1SJohan Hedberg key = old_key; 107155ed8ca1SJohan Hedberg } else { 107212adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 107355ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 107455ed8ca1SJohan Hedberg if (!key) 107555ed8ca1SJohan Hedberg return -ENOMEM; 107655ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 107755ed8ca1SJohan Hedberg } 107855ed8ca1SJohan Hedberg 107955ed8ca1SJohan Hedberg BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type); 108055ed8ca1SJohan Hedberg 1081d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 1082d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 1083d25e28abSJohan Hedberg * previous key */ 1084d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 1085d25e28abSJohan Hedberg (!conn || conn->remote_auth == 0xff) && 1086655fe6ecSJohan Hedberg old_key_type == 0xff) { 1087d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 1088655fe6ecSJohan Hedberg if (conn) 1089655fe6ecSJohan Hedberg conn->key_type = type; 1090655fe6ecSJohan Hedberg } 1091d25e28abSJohan Hedberg 1092d25e28abSJohan Hedberg if (new_key && !hci_persistent_key(hdev, conn, type, old_key_type)) { 1093d25e28abSJohan Hedberg list_del(&key->list); 1094d25e28abSJohan Hedberg kfree(key); 1095d25e28abSJohan Hedberg return 0; 1096d25e28abSJohan Hedberg } 1097d25e28abSJohan Hedberg 109855ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 109955ed8ca1SJohan Hedberg memcpy(key->val, val, 16); 110055ed8ca1SJohan Hedberg key->type = type; 110155ed8ca1SJohan Hedberg key->pin_len = pin_len; 110255ed8ca1SJohan Hedberg 110355ed8ca1SJohan Hedberg if (new_key) 110455ed8ca1SJohan Hedberg mgmt_new_key(hdev->id, key, old_key_type); 110555ed8ca1SJohan Hedberg 1106b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 110755ed8ca1SJohan Hedberg key->type = old_key_type; 110855ed8ca1SJohan Hedberg 110955ed8ca1SJohan Hedberg return 0; 111055ed8ca1SJohan Hedberg } 111155ed8ca1SJohan Hedberg 111255ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 111355ed8ca1SJohan Hedberg { 111455ed8ca1SJohan Hedberg struct link_key *key; 111555ed8ca1SJohan Hedberg 111655ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 111755ed8ca1SJohan Hedberg if (!key) 111855ed8ca1SJohan Hedberg return -ENOENT; 111955ed8ca1SJohan Hedberg 112055ed8ca1SJohan Hedberg BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 112155ed8ca1SJohan Hedberg 112255ed8ca1SJohan Hedberg list_del(&key->list); 112355ed8ca1SJohan Hedberg kfree(key); 112455ed8ca1SJohan Hedberg 112555ed8ca1SJohan Hedberg return 0; 112655ed8ca1SJohan Hedberg } 112755ed8ca1SJohan Hedberg 11286bd32326SVille Tervo /* HCI command timer function */ 11296bd32326SVille Tervo static void hci_cmd_timer(unsigned long arg) 11306bd32326SVille Tervo { 11316bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 11326bd32326SVille Tervo 11336bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 11346bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 113510572132SGustavo F. Padovan clear_bit(HCI_RESET, &hdev->flags); 11366bd32326SVille Tervo tasklet_schedule(&hdev->cmd_task); 11376bd32326SVille Tervo } 11386bd32326SVille Tervo 11392763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 11402763eda6SSzymon Janc bdaddr_t *bdaddr) 11412763eda6SSzymon Janc { 11422763eda6SSzymon Janc struct oob_data *data; 11432763eda6SSzymon Janc 11442763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 11452763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 11462763eda6SSzymon Janc return data; 11472763eda6SSzymon Janc 11482763eda6SSzymon Janc return NULL; 11492763eda6SSzymon Janc } 11502763eda6SSzymon Janc 11512763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 11522763eda6SSzymon Janc { 11532763eda6SSzymon Janc struct oob_data *data; 11542763eda6SSzymon Janc 11552763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 11562763eda6SSzymon Janc if (!data) 11572763eda6SSzymon Janc return -ENOENT; 11582763eda6SSzymon Janc 11592763eda6SSzymon Janc BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 11602763eda6SSzymon Janc 11612763eda6SSzymon Janc list_del(&data->list); 11622763eda6SSzymon Janc kfree(data); 11632763eda6SSzymon Janc 11642763eda6SSzymon Janc return 0; 11652763eda6SSzymon Janc } 11662763eda6SSzymon Janc 11672763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 11682763eda6SSzymon Janc { 11692763eda6SSzymon Janc struct oob_data *data, *n; 11702763eda6SSzymon Janc 11712763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 11722763eda6SSzymon Janc list_del(&data->list); 11732763eda6SSzymon Janc kfree(data); 11742763eda6SSzymon Janc } 11752763eda6SSzymon Janc 11762763eda6SSzymon Janc return 0; 11772763eda6SSzymon Janc } 11782763eda6SSzymon Janc 11792763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 11802763eda6SSzymon Janc u8 *randomizer) 11812763eda6SSzymon Janc { 11822763eda6SSzymon Janc struct oob_data *data; 11832763eda6SSzymon Janc 11842763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 11852763eda6SSzymon Janc 11862763eda6SSzymon Janc if (!data) { 11872763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 11882763eda6SSzymon Janc if (!data) 11892763eda6SSzymon Janc return -ENOMEM; 11902763eda6SSzymon Janc 11912763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 11922763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 11932763eda6SSzymon Janc } 11942763eda6SSzymon Janc 11952763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 11962763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 11972763eda6SSzymon Janc 11982763eda6SSzymon Janc BT_DBG("%s for %s", hdev->name, batostr(bdaddr)); 11992763eda6SSzymon Janc 12002763eda6SSzymon Janc return 0; 12012763eda6SSzymon Janc } 12022763eda6SSzymon Janc 12031da177e4SLinus Torvalds /* Register HCI device */ 12041da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 12051da177e4SLinus Torvalds { 12061da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 1207ef222013SMarcel Holtmann int i, id = 0; 12081da177e4SLinus Torvalds 1209c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 1210c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 12131da177e4SLinus Torvalds return -EINVAL; 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds /* Find first available device id */ 12181da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 12191da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 12201da177e4SLinus Torvalds break; 12211da177e4SLinus Torvalds head = p; id++; 12221da177e4SLinus Torvalds } 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 12251da177e4SLinus Torvalds hdev->id = id; 12261da177e4SLinus Torvalds list_add(&hdev->list, head); 12271da177e4SLinus Torvalds 12281da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 12291da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds hdev->flags = 0; 12321da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 12335b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 12341da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 123517fa4b9dSJohan Hedberg hdev->io_capability = 0x03; /* No Input No Output */ 12361da177e4SLinus Torvalds 123704837f64SMarcel Holtmann hdev->idle_timeout = 0; 123804837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 123904837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 124004837f64SMarcel Holtmann 12411da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 12421da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 12431da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 12441da177e4SLinus Torvalds 12451da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 12461da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 12471da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 12481da177e4SLinus Torvalds 12496bd32326SVille Tervo setup_timer(&hdev->cmd_timer, hci_cmd_timer, (unsigned long) hdev); 12506bd32326SVille Tervo 1251cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1252ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 1253ef222013SMarcel Holtmann 12541da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 1255a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds inquiry_cache_init(hdev); 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds hci_conn_hash_init(hdev); 12601da177e4SLinus Torvalds 1261ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1262f0358568SJohan Hedberg 12632aeb9a1aSJohan Hedberg INIT_LIST_HEAD(&hdev->uuids); 12642aeb9a1aSJohan Hedberg 126555ed8ca1SJohan Hedberg INIT_LIST_HEAD(&hdev->link_keys); 126655ed8ca1SJohan Hedberg 12672763eda6SSzymon Janc INIT_LIST_HEAD(&hdev->remote_oob_data); 12682763eda6SSzymon Janc 1269ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1270ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1271ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1272ab81cbf9SJohan Hedberg 12731da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 12741da177e4SLinus Torvalds 12751da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 12781da177e4SLinus Torvalds 1279f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1280f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1281f48fd9c8SMarcel Holtmann goto nomem; 1282f48fd9c8SMarcel Holtmann 12831da177e4SLinus Torvalds hci_register_sysfs(hdev); 12841da177e4SLinus Torvalds 1285611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1286611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1287611b30f7SMarcel Holtmann if (hdev->rfkill) { 1288611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1289611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1290611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1291611b30f7SMarcel Holtmann } 1292611b30f7SMarcel Holtmann } 1293611b30f7SMarcel Holtmann 1294ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1295ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1296ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1297ab81cbf9SJohan Hedberg 12981da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds return id; 1301f48fd9c8SMarcel Holtmann 1302f48fd9c8SMarcel Holtmann nomem: 1303f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1304f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1305f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1306f48fd9c8SMarcel Holtmann 1307f48fd9c8SMarcel Holtmann return -ENOMEM; 13081da177e4SLinus Torvalds } 13091da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 13101da177e4SLinus Torvalds 13111da177e4SLinus Torvalds /* Unregister HCI device */ 13121da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 13131da177e4SLinus Torvalds { 1314ef222013SMarcel Holtmann int i; 1315ef222013SMarcel Holtmann 1316c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 13171da177e4SLinus Torvalds 13181da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 13191da177e4SLinus Torvalds list_del(&hdev->list); 13201da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 13211da177e4SLinus Torvalds 13221da177e4SLinus Torvalds hci_dev_do_close(hdev); 13231da177e4SLinus Torvalds 1324cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1325ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1326ef222013SMarcel Holtmann 1327ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1328ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1329c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1330ab81cbf9SJohan Hedberg 13311da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 13321da177e4SLinus Torvalds 1333611b30f7SMarcel Holtmann if (hdev->rfkill) { 1334611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1335611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1336611b30f7SMarcel Holtmann } 1337611b30f7SMarcel Holtmann 1338147e2d59SDave Young hci_unregister_sysfs(hdev); 1339147e2d59SDave Young 1340c6f3c5f7SGustavo F. Padovan hci_del_off_timer(hdev); 1341c6f3c5f7SGustavo F. Padovan 1342f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1343f48fd9c8SMarcel Holtmann 1344e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1345e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 13462aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 134755ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 13482763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 1349e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1350e2e0cacbSJohan Hedberg 13511da177e4SLinus Torvalds __hci_dev_put(hdev); 1352ef222013SMarcel Holtmann 13531da177e4SLinus Torvalds return 0; 13541da177e4SLinus Torvalds } 13551da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds /* Suspend HCI device */ 13581da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 13591da177e4SLinus Torvalds { 13601da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 13611da177e4SLinus Torvalds return 0; 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds /* Resume HCI device */ 13661da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 13671da177e4SLinus Torvalds { 13681da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 13691da177e4SLinus Torvalds return 0; 13701da177e4SLinus Torvalds } 13711da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 13721da177e4SLinus Torvalds 137376bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 137476bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 137576bca880SMarcel Holtmann { 137676bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 137776bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 137876bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 137976bca880SMarcel Holtmann kfree_skb(skb); 138076bca880SMarcel Holtmann return -ENXIO; 138176bca880SMarcel Holtmann } 138276bca880SMarcel Holtmann 138376bca880SMarcel Holtmann /* Incomming skb */ 138476bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 138576bca880SMarcel Holtmann 138676bca880SMarcel Holtmann /* Time stamp */ 138776bca880SMarcel Holtmann __net_timestamp(skb); 138876bca880SMarcel Holtmann 138976bca880SMarcel Holtmann /* Queue frame for rx task */ 139076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1391c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1392c78ae283SMarcel Holtmann 139376bca880SMarcel Holtmann return 0; 139476bca880SMarcel Holtmann } 139576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 139676bca880SMarcel Holtmann 139733e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 13981e429f38SGustavo F. Padovan int count, __u8 index) 139933e882a5SSuraj Sumangala { 140033e882a5SSuraj Sumangala int len = 0; 140133e882a5SSuraj Sumangala int hlen = 0; 140233e882a5SSuraj Sumangala int remain = count; 140333e882a5SSuraj Sumangala struct sk_buff *skb; 140433e882a5SSuraj Sumangala struct bt_skb_cb *scb; 140533e882a5SSuraj Sumangala 140633e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 140733e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 140833e882a5SSuraj Sumangala return -EILSEQ; 140933e882a5SSuraj Sumangala 141033e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 141133e882a5SSuraj Sumangala 141233e882a5SSuraj Sumangala if (!skb) { 141333e882a5SSuraj Sumangala switch (type) { 141433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 141533e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 141633e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 141733e882a5SSuraj Sumangala break; 141833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 141933e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 142033e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 142133e882a5SSuraj Sumangala break; 142233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 142333e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 142433e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 142533e882a5SSuraj Sumangala break; 142633e882a5SSuraj Sumangala } 142733e882a5SSuraj Sumangala 14281e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 142933e882a5SSuraj Sumangala if (!skb) 143033e882a5SSuraj Sumangala return -ENOMEM; 143133e882a5SSuraj Sumangala 143233e882a5SSuraj Sumangala scb = (void *) skb->cb; 143333e882a5SSuraj Sumangala scb->expect = hlen; 143433e882a5SSuraj Sumangala scb->pkt_type = type; 143533e882a5SSuraj Sumangala 143633e882a5SSuraj Sumangala skb->dev = (void *) hdev; 143733e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 143833e882a5SSuraj Sumangala } 143933e882a5SSuraj Sumangala 144033e882a5SSuraj Sumangala while (count) { 144133e882a5SSuraj Sumangala scb = (void *) skb->cb; 144233e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 144333e882a5SSuraj Sumangala 144433e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 144533e882a5SSuraj Sumangala 144633e882a5SSuraj Sumangala count -= len; 144733e882a5SSuraj Sumangala data += len; 144833e882a5SSuraj Sumangala scb->expect -= len; 144933e882a5SSuraj Sumangala remain = count; 145033e882a5SSuraj Sumangala 145133e882a5SSuraj Sumangala switch (type) { 145233e882a5SSuraj Sumangala case HCI_EVENT_PKT: 145333e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 145433e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 145533e882a5SSuraj Sumangala scb->expect = h->plen; 145633e882a5SSuraj Sumangala 145733e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 145833e882a5SSuraj Sumangala kfree_skb(skb); 145933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 146033e882a5SSuraj Sumangala return -ENOMEM; 146133e882a5SSuraj Sumangala } 146233e882a5SSuraj Sumangala } 146333e882a5SSuraj Sumangala break; 146433e882a5SSuraj Sumangala 146533e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 146633e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 146733e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 146833e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 146933e882a5SSuraj Sumangala 147033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 147133e882a5SSuraj Sumangala kfree_skb(skb); 147233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 147333e882a5SSuraj Sumangala return -ENOMEM; 147433e882a5SSuraj Sumangala } 147533e882a5SSuraj Sumangala } 147633e882a5SSuraj Sumangala break; 147733e882a5SSuraj Sumangala 147833e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 147933e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 148033e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 148133e882a5SSuraj Sumangala scb->expect = h->dlen; 148233e882a5SSuraj Sumangala 148333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 148433e882a5SSuraj Sumangala kfree_skb(skb); 148533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 148633e882a5SSuraj Sumangala return -ENOMEM; 148733e882a5SSuraj Sumangala } 148833e882a5SSuraj Sumangala } 148933e882a5SSuraj Sumangala break; 149033e882a5SSuraj Sumangala } 149133e882a5SSuraj Sumangala 149233e882a5SSuraj Sumangala if (scb->expect == 0) { 149333e882a5SSuraj Sumangala /* Complete frame */ 149433e882a5SSuraj Sumangala 149533e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 149633e882a5SSuraj Sumangala hci_recv_frame(skb); 149733e882a5SSuraj Sumangala 149833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 149933e882a5SSuraj Sumangala return remain; 150033e882a5SSuraj Sumangala } 150133e882a5SSuraj Sumangala } 150233e882a5SSuraj Sumangala 150333e882a5SSuraj Sumangala return remain; 150433e882a5SSuraj Sumangala } 150533e882a5SSuraj Sumangala 1506ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1507ef222013SMarcel Holtmann { 1508f39a3c06SSuraj Sumangala int rem = 0; 1509f39a3c06SSuraj Sumangala 1510ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1511ef222013SMarcel Holtmann return -EILSEQ; 1512ef222013SMarcel Holtmann 1513da5f6c37SGustavo F. Padovan while (count) { 15141e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 1515f39a3c06SSuraj Sumangala if (rem < 0) 1516f39a3c06SSuraj Sumangala return rem; 1517ef222013SMarcel Holtmann 1518f39a3c06SSuraj Sumangala data += (count - rem); 1519f39a3c06SSuraj Sumangala count = rem; 1520da5f6c37SGustavo F. Padovan }; 1521ef222013SMarcel Holtmann 1522f39a3c06SSuraj Sumangala return rem; 1523ef222013SMarcel Holtmann } 1524ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1525ef222013SMarcel Holtmann 152699811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 152799811510SSuraj Sumangala 152899811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 152999811510SSuraj Sumangala { 153099811510SSuraj Sumangala int type; 153199811510SSuraj Sumangala int rem = 0; 153299811510SSuraj Sumangala 1533da5f6c37SGustavo F. Padovan while (count) { 153499811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 153599811510SSuraj Sumangala 153699811510SSuraj Sumangala if (!skb) { 153799811510SSuraj Sumangala struct { char type; } *pkt; 153899811510SSuraj Sumangala 153999811510SSuraj Sumangala /* Start of the frame */ 154099811510SSuraj Sumangala pkt = data; 154199811510SSuraj Sumangala type = pkt->type; 154299811510SSuraj Sumangala 154399811510SSuraj Sumangala data++; 154499811510SSuraj Sumangala count--; 154599811510SSuraj Sumangala } else 154699811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 154799811510SSuraj Sumangala 15481e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 15491e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 155099811510SSuraj Sumangala if (rem < 0) 155199811510SSuraj Sumangala return rem; 155299811510SSuraj Sumangala 155399811510SSuraj Sumangala data += (count - rem); 155499811510SSuraj Sumangala count = rem; 1555da5f6c37SGustavo F. Padovan }; 155699811510SSuraj Sumangala 155799811510SSuraj Sumangala return rem; 155899811510SSuraj Sumangala } 155999811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 156099811510SSuraj Sumangala 15611da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 15621da177e4SLinus Torvalds 15631da177e4SLinus Torvalds /* Register/Unregister protocols. 15641da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 15651da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 15661da177e4SLinus Torvalds { 15671da177e4SLinus Torvalds int err = 0; 15681da177e4SLinus Torvalds 15691da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 15721da177e4SLinus Torvalds return -EINVAL; 15731da177e4SLinus Torvalds 15741da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds if (!hci_proto[hp->id]) 15771da177e4SLinus Torvalds hci_proto[hp->id] = hp; 15781da177e4SLinus Torvalds else 15791da177e4SLinus Torvalds err = -EEXIST; 15801da177e4SLinus Torvalds 15811da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 15821da177e4SLinus Torvalds 15831da177e4SLinus Torvalds return err; 15841da177e4SLinus Torvalds } 15851da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 15861da177e4SLinus Torvalds 15871da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 15881da177e4SLinus Torvalds { 15891da177e4SLinus Torvalds int err = 0; 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 15941da177e4SLinus Torvalds return -EINVAL; 15951da177e4SLinus Torvalds 15961da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 15971da177e4SLinus Torvalds 15981da177e4SLinus Torvalds if (hci_proto[hp->id]) 15991da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 16001da177e4SLinus Torvalds else 16011da177e4SLinus Torvalds err = -ENOENT; 16021da177e4SLinus Torvalds 16031da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds return err; 16061da177e4SLinus Torvalds } 16071da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 16101da177e4SLinus Torvalds { 16111da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 16121da177e4SLinus Torvalds 16131da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 16141da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 16151da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 16161da177e4SLinus Torvalds 16171da177e4SLinus Torvalds return 0; 16181da177e4SLinus Torvalds } 16191da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 16221da177e4SLinus Torvalds { 16231da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 16241da177e4SLinus Torvalds 16251da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 16261da177e4SLinus Torvalds list_del(&cb->list); 16271da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 16281da177e4SLinus Torvalds 16291da177e4SLinus Torvalds return 0; 16301da177e4SLinus Torvalds } 16311da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 16341da177e4SLinus Torvalds { 16351da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 16361da177e4SLinus Torvalds 16371da177e4SLinus Torvalds if (!hdev) { 16381da177e4SLinus Torvalds kfree_skb(skb); 16391da177e4SLinus Torvalds return -ENODEV; 16401da177e4SLinus Torvalds } 16411da177e4SLinus Torvalds 16420d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 16431da177e4SLinus Torvalds 16441da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 16451da177e4SLinus Torvalds /* Time stamp */ 1646a61bbcf2SPatrick McHardy __net_timestamp(skb); 16471da177e4SLinus Torvalds 1648eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 16491da177e4SLinus Torvalds } 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 16521da177e4SLinus Torvalds skb_orphan(skb); 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds return hdev->send(skb); 16551da177e4SLinus Torvalds } 16561da177e4SLinus Torvalds 16571da177e4SLinus Torvalds /* Send HCI command */ 1658a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 16591da177e4SLinus Torvalds { 16601da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 16611da177e4SLinus Torvalds struct hci_command_hdr *hdr; 16621da177e4SLinus Torvalds struct sk_buff *skb; 16631da177e4SLinus Torvalds 1664a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 16671da177e4SLinus Torvalds if (!skb) { 1668ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 16691da177e4SLinus Torvalds return -ENOMEM; 16701da177e4SLinus Torvalds } 16711da177e4SLinus Torvalds 16721da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1673a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 16741da177e4SLinus Torvalds hdr->plen = plen; 16751da177e4SLinus Torvalds 16761da177e4SLinus Torvalds if (plen) 16771da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 16801da177e4SLinus Torvalds 16810d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 16821da177e4SLinus Torvalds skb->dev = (void *) hdev; 1683c78ae283SMarcel Holtmann 1684a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags)) 1685a5040efaSJohan Hedberg hdev->init_last_cmd = opcode; 1686a5040efaSJohan Hedberg 16871da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1688c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 16891da177e4SLinus Torvalds 16901da177e4SLinus Torvalds return 0; 16911da177e4SLinus Torvalds } 16921da177e4SLinus Torvalds 16931da177e4SLinus Torvalds /* Get data from the previously sent command */ 1694a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 16951da177e4SLinus Torvalds { 16961da177e4SLinus Torvalds struct hci_command_hdr *hdr; 16971da177e4SLinus Torvalds 16981da177e4SLinus Torvalds if (!hdev->sent_cmd) 16991da177e4SLinus Torvalds return NULL; 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 17021da177e4SLinus Torvalds 1703a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 17041da177e4SLinus Torvalds return NULL; 17051da177e4SLinus Torvalds 1706a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 17071da177e4SLinus Torvalds 17081da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 17091da177e4SLinus Torvalds } 17101da177e4SLinus Torvalds 17111da177e4SLinus Torvalds /* Send ACL data */ 17121da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 17131da177e4SLinus Torvalds { 17141da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 17151da177e4SLinus Torvalds int len = skb->len; 17161da177e4SLinus Torvalds 1717badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1718badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 17199c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1720aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1721aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 17221da177e4SLinus Torvalds } 17231da177e4SLinus Torvalds 17249a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 17251da177e4SLinus Torvalds { 17261da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 17271da177e4SLinus Torvalds struct sk_buff *list; 17281da177e4SLinus Torvalds 17291da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds skb->dev = (void *) hdev; 17320d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1733e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 17341da177e4SLinus Torvalds 173570f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 173670f23020SAndrei Emeltchenko if (!list) { 17371da177e4SLinus Torvalds /* Non fragmented */ 17381da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 17411da177e4SLinus Torvalds } else { 17421da177e4SLinus Torvalds /* Fragmented */ 17431da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 17441da177e4SLinus Torvalds 17451da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 17461da177e4SLinus Torvalds 17471da177e4SLinus Torvalds /* Queue all fragments atomically */ 17481da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 17491da177e4SLinus Torvalds 17501da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1751e702112fSAndrei Emeltchenko 1752e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1753e702112fSAndrei Emeltchenko flags |= ACL_CONT; 17541da177e4SLinus Torvalds do { 17551da177e4SLinus Torvalds skb = list; list = list->next; 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds skb->dev = (void *) hdev; 17580d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1759e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 17601da177e4SLinus Torvalds 17611da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 17641da177e4SLinus Torvalds } while (list); 17651da177e4SLinus Torvalds 17661da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 17671da177e4SLinus Torvalds } 17681da177e4SLinus Torvalds 1769c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 17701da177e4SLinus Torvalds } 17711da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds /* Send SCO data */ 17740d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 17751da177e4SLinus Torvalds { 17761da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 17771da177e4SLinus Torvalds struct hci_sco_hdr hdr; 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 17801da177e4SLinus Torvalds 1781aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 17821da177e4SLinus Torvalds hdr.dlen = skb->len; 17831da177e4SLinus Torvalds 1784badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1785badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 17869c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 17871da177e4SLinus Torvalds 17881da177e4SLinus Torvalds skb->dev = (void *) hdev; 17890d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1790c78ae283SMarcel Holtmann 17911da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1792c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 17931da177e4SLinus Torvalds } 17941da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 17951da177e4SLinus Torvalds 17961da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds /* HCI Connection scheduler */ 17991da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 18001da177e4SLinus Torvalds { 18011da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 18021da177e4SLinus Torvalds struct hci_conn *conn = NULL; 18031da177e4SLinus Torvalds int num = 0, min = ~0; 18041da177e4SLinus Torvalds struct list_head *p; 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 18071da177e4SLinus Torvalds * added and removed with TX task disabled. */ 18081da177e4SLinus Torvalds list_for_each(p, &h->list) { 18091da177e4SLinus Torvalds struct hci_conn *c; 18101da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 18111da177e4SLinus Torvalds 1812769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 18131da177e4SLinus Torvalds continue; 1814769be974SMarcel Holtmann 1815769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1816769be974SMarcel Holtmann continue; 1817769be974SMarcel Holtmann 18181da177e4SLinus Torvalds num++; 18191da177e4SLinus Torvalds 18201da177e4SLinus Torvalds if (c->sent < min) { 18211da177e4SLinus Torvalds min = c->sent; 18221da177e4SLinus Torvalds conn = c; 18231da177e4SLinus Torvalds } 18241da177e4SLinus Torvalds } 18251da177e4SLinus Torvalds 18261da177e4SLinus Torvalds if (conn) { 18276ed58ec5SVille Tervo int cnt, q; 18286ed58ec5SVille Tervo 18296ed58ec5SVille Tervo switch (conn->type) { 18306ed58ec5SVille Tervo case ACL_LINK: 18316ed58ec5SVille Tervo cnt = hdev->acl_cnt; 18326ed58ec5SVille Tervo break; 18336ed58ec5SVille Tervo case SCO_LINK: 18346ed58ec5SVille Tervo case ESCO_LINK: 18356ed58ec5SVille Tervo cnt = hdev->sco_cnt; 18366ed58ec5SVille Tervo break; 18376ed58ec5SVille Tervo case LE_LINK: 18386ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 18396ed58ec5SVille Tervo break; 18406ed58ec5SVille Tervo default: 18416ed58ec5SVille Tervo cnt = 0; 18426ed58ec5SVille Tervo BT_ERR("Unknown link type"); 18436ed58ec5SVille Tervo } 18446ed58ec5SVille Tervo 18456ed58ec5SVille Tervo q = cnt / num; 18461da177e4SLinus Torvalds *quote = q ? q : 1; 18471da177e4SLinus Torvalds } else 18481da177e4SLinus Torvalds *quote = 0; 18491da177e4SLinus Torvalds 18501da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 18511da177e4SLinus Torvalds return conn; 18521da177e4SLinus Torvalds } 18531da177e4SLinus Torvalds 1854bae1f5d9SVille Tervo static inline void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 18551da177e4SLinus Torvalds { 18561da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 18571da177e4SLinus Torvalds struct list_head *p; 18581da177e4SLinus Torvalds struct hci_conn *c; 18591da177e4SLinus Torvalds 1860bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 18611da177e4SLinus Torvalds 18621da177e4SLinus Torvalds /* Kill stalled connections */ 18631da177e4SLinus Torvalds list_for_each(p, &h->list) { 18641da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 1865bae1f5d9SVille Tervo if (c->type == type && c->sent) { 1866bae1f5d9SVille Tervo BT_ERR("%s killing stalled connection %s", 18671da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 18681da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 18691da177e4SLinus Torvalds } 18701da177e4SLinus Torvalds } 18711da177e4SLinus Torvalds } 18721da177e4SLinus Torvalds 18731da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 18741da177e4SLinus Torvalds { 18751da177e4SLinus Torvalds struct hci_conn *conn; 18761da177e4SLinus Torvalds struct sk_buff *skb; 18771da177e4SLinus Torvalds int quote; 18781da177e4SLinus Torvalds 18791da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 18801da177e4SLinus Torvalds 18811da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 18821da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 18831da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 188482453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 1885bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 18861da177e4SLinus Torvalds } 18871da177e4SLinus Torvalds 18881da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 18891da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 18901da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 189104837f64SMarcel Holtmann 189204837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 189304837f64SMarcel Holtmann 18941da177e4SLinus Torvalds hci_send_frame(skb); 18951da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds hdev->acl_cnt--; 18981da177e4SLinus Torvalds conn->sent++; 18991da177e4SLinus Torvalds } 19001da177e4SLinus Torvalds } 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds /* Schedule SCO */ 19041da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 19051da177e4SLinus Torvalds { 19061da177e4SLinus Torvalds struct hci_conn *conn; 19071da177e4SLinus Torvalds struct sk_buff *skb; 19081da177e4SLinus Torvalds int quote; 19091da177e4SLinus Torvalds 19101da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 19131da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 19141da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 19151da177e4SLinus Torvalds hci_send_frame(skb); 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds conn->sent++; 19181da177e4SLinus Torvalds if (conn->sent == ~0) 19191da177e4SLinus Torvalds conn->sent = 0; 19201da177e4SLinus Torvalds } 19211da177e4SLinus Torvalds } 19221da177e4SLinus Torvalds } 19231da177e4SLinus Torvalds 1924b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1925b6a0dc82SMarcel Holtmann { 1926b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1927b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1928b6a0dc82SMarcel Holtmann int quote; 1929b6a0dc82SMarcel Holtmann 1930b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1931b6a0dc82SMarcel Holtmann 1932b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1933b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1934b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1935b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1936b6a0dc82SMarcel Holtmann 1937b6a0dc82SMarcel Holtmann conn->sent++; 1938b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1939b6a0dc82SMarcel Holtmann conn->sent = 0; 1940b6a0dc82SMarcel Holtmann } 1941b6a0dc82SMarcel Holtmann } 1942b6a0dc82SMarcel Holtmann } 1943b6a0dc82SMarcel Holtmann 19446ed58ec5SVille Tervo static inline void hci_sched_le(struct hci_dev *hdev) 19456ed58ec5SVille Tervo { 19466ed58ec5SVille Tervo struct hci_conn *conn; 19476ed58ec5SVille Tervo struct sk_buff *skb; 19486ed58ec5SVille Tervo int quote, cnt; 19496ed58ec5SVille Tervo 19506ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 19516ed58ec5SVille Tervo 19526ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 19536ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 19546ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 1955bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 19566ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 1957bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 19586ed58ec5SVille Tervo } 19596ed58ec5SVille Tervo 19606ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 19616ed58ec5SVille Tervo while (cnt && (conn = hci_low_sent(hdev, LE_LINK, "e))) { 19626ed58ec5SVille Tervo while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 19636ed58ec5SVille Tervo BT_DBG("skb %p len %d", skb, skb->len); 19646ed58ec5SVille Tervo 19656ed58ec5SVille Tervo hci_send_frame(skb); 19666ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 19676ed58ec5SVille Tervo 19686ed58ec5SVille Tervo cnt--; 19696ed58ec5SVille Tervo conn->sent++; 19706ed58ec5SVille Tervo } 19716ed58ec5SVille Tervo } 19726ed58ec5SVille Tervo if (hdev->le_pkts) 19736ed58ec5SVille Tervo hdev->le_cnt = cnt; 19746ed58ec5SVille Tervo else 19756ed58ec5SVille Tervo hdev->acl_cnt = cnt; 19766ed58ec5SVille Tervo } 19776ed58ec5SVille Tervo 19781da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 19791da177e4SLinus Torvalds { 19801da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 19811da177e4SLinus Torvalds struct sk_buff *skb; 19821da177e4SLinus Torvalds 19831da177e4SLinus Torvalds read_lock(&hci_task_lock); 19841da177e4SLinus Torvalds 19856ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 19866ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 19871da177e4SLinus Torvalds 19881da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds hci_sched_acl(hdev); 19911da177e4SLinus Torvalds 19921da177e4SLinus Torvalds hci_sched_sco(hdev); 19931da177e4SLinus Torvalds 1994b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1995b6a0dc82SMarcel Holtmann 19966ed58ec5SVille Tervo hci_sched_le(hdev); 19976ed58ec5SVille Tervo 19981da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 19991da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 20001da177e4SLinus Torvalds hci_send_frame(skb); 20011da177e4SLinus Torvalds 20021da177e4SLinus Torvalds read_unlock(&hci_task_lock); 20031da177e4SLinus Torvalds } 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 20061da177e4SLinus Torvalds 20071da177e4SLinus Torvalds /* ACL data packet */ 20081da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 20091da177e4SLinus Torvalds { 20101da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 20111da177e4SLinus Torvalds struct hci_conn *conn; 20121da177e4SLinus Torvalds __u16 handle, flags; 20131da177e4SLinus Torvalds 20141da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 20151da177e4SLinus Torvalds 20161da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 20171da177e4SLinus Torvalds flags = hci_flags(handle); 20181da177e4SLinus Torvalds handle = hci_handle(handle); 20191da177e4SLinus Torvalds 20201da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 20211da177e4SLinus Torvalds 20221da177e4SLinus Torvalds hdev->stat.acl_rx++; 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds hci_dev_lock(hdev); 20251da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 20261da177e4SLinus Torvalds hci_dev_unlock(hdev); 20271da177e4SLinus Torvalds 20281da177e4SLinus Torvalds if (conn) { 20291da177e4SLinus Torvalds register struct hci_proto *hp; 20301da177e4SLinus Torvalds 203104837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 203204837f64SMarcel Holtmann 20331da177e4SLinus Torvalds /* Send to upper protocol */ 203470f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 203570f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 20361da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 20371da177e4SLinus Torvalds return; 20381da177e4SLinus Torvalds } 20391da177e4SLinus Torvalds } else { 20401da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 20411da177e4SLinus Torvalds hdev->name, handle); 20421da177e4SLinus Torvalds } 20431da177e4SLinus Torvalds 20441da177e4SLinus Torvalds kfree_skb(skb); 20451da177e4SLinus Torvalds } 20461da177e4SLinus Torvalds 20471da177e4SLinus Torvalds /* SCO data packet */ 20481da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 20491da177e4SLinus Torvalds { 20501da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 20511da177e4SLinus Torvalds struct hci_conn *conn; 20521da177e4SLinus Torvalds __u16 handle; 20531da177e4SLinus Torvalds 20541da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds hdev->stat.sco_rx++; 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds hci_dev_lock(hdev); 20631da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 20641da177e4SLinus Torvalds hci_dev_unlock(hdev); 20651da177e4SLinus Torvalds 20661da177e4SLinus Torvalds if (conn) { 20671da177e4SLinus Torvalds register struct hci_proto *hp; 20681da177e4SLinus Torvalds 20691da177e4SLinus Torvalds /* Send to upper protocol */ 207070f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 207170f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 20721da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 20731da177e4SLinus Torvalds return; 20741da177e4SLinus Torvalds } 20751da177e4SLinus Torvalds } else { 20761da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 20771da177e4SLinus Torvalds hdev->name, handle); 20781da177e4SLinus Torvalds } 20791da177e4SLinus Torvalds 20801da177e4SLinus Torvalds kfree_skb(skb); 20811da177e4SLinus Torvalds } 20821da177e4SLinus Torvalds 20836516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 20841da177e4SLinus Torvalds { 20851da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 20861da177e4SLinus Torvalds struct sk_buff *skb; 20871da177e4SLinus Torvalds 20881da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 20891da177e4SLinus Torvalds 20901da177e4SLinus Torvalds read_lock(&hci_task_lock); 20911da177e4SLinus Torvalds 20921da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 20931da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 20941da177e4SLinus Torvalds /* Send copy to the sockets */ 2095eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 20961da177e4SLinus Torvalds } 20971da177e4SLinus Torvalds 20981da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 20991da177e4SLinus Torvalds kfree_skb(skb); 21001da177e4SLinus Torvalds continue; 21011da177e4SLinus Torvalds } 21021da177e4SLinus Torvalds 21031da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 21041da177e4SLinus Torvalds /* Don't process data packets in this states. */ 21050d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 21061da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 21071da177e4SLinus Torvalds case HCI_SCODATA_PKT: 21081da177e4SLinus Torvalds kfree_skb(skb); 21091da177e4SLinus Torvalds continue; 21103ff50b79SStephen Hemminger } 21111da177e4SLinus Torvalds } 21121da177e4SLinus Torvalds 21131da177e4SLinus Torvalds /* Process frame */ 21140d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 21151da177e4SLinus Torvalds case HCI_EVENT_PKT: 21161da177e4SLinus Torvalds hci_event_packet(hdev, skb); 21171da177e4SLinus Torvalds break; 21181da177e4SLinus Torvalds 21191da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 21201da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 21211da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 21221da177e4SLinus Torvalds break; 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds case HCI_SCODATA_PKT: 21251da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 21261da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 21271da177e4SLinus Torvalds break; 21281da177e4SLinus Torvalds 21291da177e4SLinus Torvalds default: 21301da177e4SLinus Torvalds kfree_skb(skb); 21311da177e4SLinus Torvalds break; 21321da177e4SLinus Torvalds } 21331da177e4SLinus Torvalds } 21341da177e4SLinus Torvalds 21351da177e4SLinus Torvalds read_unlock(&hci_task_lock); 21361da177e4SLinus Torvalds } 21371da177e4SLinus Torvalds 21381da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 21391da177e4SLinus Torvalds { 21401da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 21411da177e4SLinus Torvalds struct sk_buff *skb; 21421da177e4SLinus Torvalds 21431da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 21441da177e4SLinus Torvalds 21451da177e4SLinus Torvalds /* Send queued commands */ 21465a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 21475a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 21485a08ecceSAndrei Emeltchenko if (!skb) 21495a08ecceSAndrei Emeltchenko return; 21505a08ecceSAndrei Emeltchenko 21511da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 21521da177e4SLinus Torvalds 215370f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 215470f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 21551da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 21561da177e4SLinus Torvalds hci_send_frame(skb); 21576bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 21586bd32326SVille Tervo jiffies + msecs_to_jiffies(HCI_CMD_TIMEOUT)); 21591da177e4SLinus Torvalds } else { 21601da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 2161c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 21621da177e4SLinus Torvalds } 21631da177e4SLinus Torvalds } 21641da177e4SLinus Torvalds } 2165