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 static void hci_notify(struct hci_dev *hdev, int event); 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds static DEFINE_RWLOCK(hci_task_lock); 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* HCI device list */ 641da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 651da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds /* HCI callback list */ 681da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 691da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds /* HCI protocols */ 721da177e4SLinus Torvalds #define HCI_MAX_PROTO 2 731da177e4SLinus Torvalds struct hci_proto *hci_proto[HCI_MAX_PROTO]; 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /* HCI notifiers list */ 76e041c683SAlan Stern static ATOMIC_NOTIFIER_HEAD(hci_notifier); 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds int hci_register_notifier(struct notifier_block *nb) 811da177e4SLinus Torvalds { 82e041c683SAlan Stern return atomic_notifier_chain_register(&hci_notifier, nb); 831da177e4SLinus Torvalds } 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds int hci_unregister_notifier(struct notifier_block *nb) 861da177e4SLinus Torvalds { 87e041c683SAlan Stern return atomic_notifier_chain_unregister(&hci_notifier, nb); 881da177e4SLinus Torvalds } 891da177e4SLinus Torvalds 906516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 911da177e4SLinus Torvalds { 92e041c683SAlan Stern atomic_notifier_call_chain(&hci_notifier, event, hdev); 931da177e4SLinus Torvalds } 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds /* ---- HCI requests ---- */ 961da177e4SLinus Torvalds 9723bb5763SJohan Hedberg void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result) 981da177e4SLinus Torvalds { 9923bb5763SJohan Hedberg BT_DBG("%s command 0x%04x result 0x%2.2x", hdev->name, cmd, result); 10023bb5763SJohan Hedberg 101a5040efaSJohan Hedberg /* If this is the init phase check if the completed command matches 102a5040efaSJohan Hedberg * the last init command, and if not just return. 103a5040efaSJohan Hedberg */ 104a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && hdev->init_last_cmd != cmd) 10523bb5763SJohan Hedberg return; 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1081da177e4SLinus Torvalds hdev->req_result = result; 1091da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1101da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds } 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1151da177e4SLinus Torvalds { 1161da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1191da177e4SLinus Torvalds hdev->req_result = err; 1201da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1211da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds } 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds /* Execute request and wait for completion. */ 1261da177e4SLinus Torvalds static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1271da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1281da177e4SLinus Torvalds { 1291da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1301da177e4SLinus Torvalds int err = 0; 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 1331da177e4SLinus Torvalds 1341da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds add_wait_queue(&hdev->req_wait_q, &wait); 1371da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds req(hdev, opt); 1401da177e4SLinus Torvalds schedule_timeout(timeout); 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds if (signal_pending(current)) 1451da177e4SLinus Torvalds return -EINTR; 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds switch (hdev->req_status) { 1481da177e4SLinus Torvalds case HCI_REQ_DONE: 1491da177e4SLinus Torvalds err = -bt_err(hdev->req_result); 1501da177e4SLinus Torvalds break; 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds case HCI_REQ_CANCELED: 1531da177e4SLinus Torvalds err = -hdev->req_result; 1541da177e4SLinus Torvalds break; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds default: 1571da177e4SLinus Torvalds err = -ETIMEDOUT; 1581da177e4SLinus Torvalds break; 1593ff50b79SStephen Hemminger } 1601da177e4SLinus Torvalds 161a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 1621da177e4SLinus Torvalds 1631da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds return err; 1661da177e4SLinus Torvalds } 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1691da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1701da177e4SLinus Torvalds { 1711da177e4SLinus Torvalds int ret; 1721da177e4SLinus Torvalds 1737c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 1747c6a329eSMarcel Holtmann return -ENETDOWN; 1757c6a329eSMarcel Holtmann 1761da177e4SLinus Torvalds /* Serialize all requests */ 1771da177e4SLinus Torvalds hci_req_lock(hdev); 1781da177e4SLinus Torvalds ret = __hci_request(hdev, req, opt, timeout); 1791da177e4SLinus Torvalds hci_req_unlock(hdev); 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds return ret; 1821da177e4SLinus Torvalds } 1831da177e4SLinus Torvalds 1841da177e4SLinus Torvalds static void hci_reset_req(struct hci_dev *hdev, unsigned long opt) 1851da177e4SLinus Torvalds { 1861da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds /* Reset device */ 18910572132SGustavo F. Padovan set_bit(HCI_RESET, &hdev->flags); 190a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 1911da177e4SLinus Torvalds } 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1941da177e4SLinus Torvalds { 195b0916ea0SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 1961da177e4SLinus Torvalds struct sk_buff *skb; 1971ebb9252SMarcel Holtmann __le16 param; 19889f2783dSMarcel Holtmann __u8 flt_type; 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds /* Driver initialization */ 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds /* Special commands */ 2051da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 2060d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2071da177e4SLinus Torvalds skb->dev = (void *) hdev; 208c78ae283SMarcel Holtmann 2091da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 210c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 2111da177e4SLinus Torvalds } 2121da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* Mandatory initialization */ 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds /* Reset */ 21710572132SGustavo F. Padovan if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) { 21810572132SGustavo F. Padovan set_bit(HCI_RESET, &hdev->flags); 219a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 22010572132SGustavo F. Padovan } 2211da177e4SLinus Torvalds 2221da177e4SLinus Torvalds /* Read Local Supported Features */ 223a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2241da177e4SLinus Torvalds 2251143e5a6SMarcel Holtmann /* Read Local Version */ 226a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2271143e5a6SMarcel Holtmann 2281da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 229a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds #if 0 2321da177e4SLinus Torvalds /* Host buffer size */ 2331da177e4SLinus Torvalds { 2341da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 235aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2361da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 237aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 238aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 239a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2401da177e4SLinus Torvalds } 2411da177e4SLinus Torvalds #endif 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds /* Read BD Address */ 244a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 245a9de9248SMarcel Holtmann 246a9de9248SMarcel Holtmann /* Read Class of Device */ 247a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 248a9de9248SMarcel Holtmann 249a9de9248SMarcel Holtmann /* Read Local Name */ 250a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds /* Read Voice Setting */ 253a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds /* Optional initialization */ 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds /* Clear Event Filters */ 25889f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 259a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 262aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 263a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 264b0916ea0SJohan Hedberg 265b0916ea0SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 266b0916ea0SJohan Hedberg cp.delete_all = 1; 267b0916ea0SJohan Hedberg hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp); 2681da177e4SLinus Torvalds } 2691da177e4SLinus Torvalds 2706ed58ec5SVille Tervo static void hci_le_init_req(struct hci_dev *hdev, unsigned long opt) 2716ed58ec5SVille Tervo { 2726ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 2736ed58ec5SVille Tervo 2746ed58ec5SVille Tervo /* Read LE buffer size */ 2756ed58ec5SVille Tervo hci_send_cmd(hdev, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 2766ed58ec5SVille Tervo } 2776ed58ec5SVille Tervo 2781da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2791da177e4SLinus Torvalds { 2801da177e4SLinus Torvalds __u8 scan = opt; 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds /* Inquiry and Page scans */ 285a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2891da177e4SLinus Torvalds { 2901da177e4SLinus Torvalds __u8 auth = opt; 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds /* Authentication */ 295a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2991da177e4SLinus Torvalds { 3001da177e4SLinus Torvalds __u8 encrypt = opt; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 3031da177e4SLinus Torvalds 304e4e8e37cSMarcel Holtmann /* Encryption */ 305a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds 308e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 309e4e8e37cSMarcel Holtmann { 310e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 311e4e8e37cSMarcel Holtmann 312a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 313e4e8e37cSMarcel Holtmann 314e4e8e37cSMarcel Holtmann /* Default link policy */ 315e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 316e4e8e37cSMarcel Holtmann } 317e4e8e37cSMarcel Holtmann 3181da177e4SLinus Torvalds /* Get HCI device by index. 3191da177e4SLinus Torvalds * Device is held on return. */ 3201da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3211da177e4SLinus Torvalds { 3221da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3231da177e4SLinus Torvalds struct list_head *p; 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds BT_DBG("%d", index); 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds if (index < 0) 3281da177e4SLinus Torvalds return NULL; 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3311da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3321da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3331da177e4SLinus Torvalds if (d->id == index) { 3341da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3351da177e4SLinus Torvalds break; 3361da177e4SLinus Torvalds } 3371da177e4SLinus Torvalds } 3381da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3391da177e4SLinus Torvalds return hdev; 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3431da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3441da177e4SLinus Torvalds { 3451da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3461da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds cache->list = NULL; 3511da177e4SLinus Torvalds while ((e = next)) { 3521da177e4SLinus Torvalds next = e->next; 3531da177e4SLinus Torvalds kfree(e); 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds } 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3581da177e4SLinus Torvalds { 3591da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3601da177e4SLinus Torvalds struct inquiry_entry *e; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3651da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3661da177e4SLinus Torvalds break; 3671da177e4SLinus Torvalds return e; 3681da177e4SLinus Torvalds } 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3711da177e4SLinus Torvalds { 3721da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 37370f23020SAndrei Emeltchenko struct inquiry_entry *ie; 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3761da177e4SLinus Torvalds 37770f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 37870f23020SAndrei Emeltchenko if (!ie) { 3791da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 38070f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 38170f23020SAndrei Emeltchenko if (!ie) 3821da177e4SLinus Torvalds return; 38370f23020SAndrei Emeltchenko 38470f23020SAndrei Emeltchenko ie->next = cache->list; 38570f23020SAndrei Emeltchenko cache->list = ie; 3861da177e4SLinus Torvalds } 3871da177e4SLinus Torvalds 38870f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 38970f23020SAndrei Emeltchenko ie->timestamp = jiffies; 3901da177e4SLinus Torvalds cache->timestamp = jiffies; 3911da177e4SLinus Torvalds } 3921da177e4SLinus Torvalds 3931da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3941da177e4SLinus Torvalds { 3951da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3961da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3971da177e4SLinus Torvalds struct inquiry_entry *e; 3981da177e4SLinus Torvalds int copied = 0; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 4011da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 4021da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 4031da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 4041da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 4051da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 4061da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 4071da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 4081da177e4SLinus Torvalds info++; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 4121da177e4SLinus Torvalds return copied; 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 4161da177e4SLinus Torvalds { 4171da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 4181da177e4SLinus Torvalds struct hci_cp_inquiry cp; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 4231da177e4SLinus Torvalds return; 4241da177e4SLinus Torvalds 4251da177e4SLinus Torvalds /* Start Inquiry */ 4261da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4271da177e4SLinus Torvalds cp.length = ir->length; 4281da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 429a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4331da177e4SLinus Torvalds { 4341da177e4SLinus Torvalds __u8 __user *ptr = arg; 4351da177e4SLinus Torvalds struct hci_inquiry_req ir; 4361da177e4SLinus Torvalds struct hci_dev *hdev; 4371da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4381da177e4SLinus Torvalds long timeo; 4391da177e4SLinus Torvalds __u8 *buf; 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4421da177e4SLinus Torvalds return -EFAULT; 4431da177e4SLinus Torvalds 4445a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 4455a08ecceSAndrei Emeltchenko if (!hdev) 4461da177e4SLinus Torvalds return -ENODEV; 4471da177e4SLinus Torvalds 4481da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4491da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4501da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4511da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4521da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4531da177e4SLinus Torvalds do_inquiry = 1; 4541da177e4SLinus Torvalds } 4551da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4561da177e4SLinus Torvalds 45704837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 45870f23020SAndrei Emeltchenko 45970f23020SAndrei Emeltchenko if (do_inquiry) { 46070f23020SAndrei Emeltchenko err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo); 46170f23020SAndrei Emeltchenko if (err < 0) 4621da177e4SLinus Torvalds goto done; 46370f23020SAndrei Emeltchenko } 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4661da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4691da177e4SLinus Torvalds * copy it to the user space. 4701da177e4SLinus Torvalds */ 47170f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 47270f23020SAndrei Emeltchenko if (!buf) { 4731da177e4SLinus Torvalds err = -ENOMEM; 4741da177e4SLinus Torvalds goto done; 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4781da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4791da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4841da177e4SLinus Torvalds ptr += sizeof(ir); 4851da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4861da177e4SLinus Torvalds ir.num_rsp)) 4871da177e4SLinus Torvalds err = -EFAULT; 4881da177e4SLinus Torvalds } else 4891da177e4SLinus Torvalds err = -EFAULT; 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds kfree(buf); 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds done: 4941da177e4SLinus Torvalds hci_dev_put(hdev); 4951da177e4SLinus Torvalds return err; 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 5011da177e4SLinus Torvalds { 5021da177e4SLinus Torvalds struct hci_dev *hdev; 5031da177e4SLinus Torvalds int ret = 0; 5041da177e4SLinus Torvalds 5055a08ecceSAndrei Emeltchenko hdev = hci_dev_get(dev); 5065a08ecceSAndrei Emeltchenko if (!hdev) 5071da177e4SLinus Torvalds return -ENODEV; 5081da177e4SLinus Torvalds 5091da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds hci_req_lock(hdev); 5121da177e4SLinus Torvalds 513611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 514611b30f7SMarcel Holtmann ret = -ERFKILL; 515611b30f7SMarcel Holtmann goto done; 516611b30f7SMarcel Holtmann } 517611b30f7SMarcel Holtmann 5181da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 5191da177e4SLinus Torvalds ret = -EALREADY; 5201da177e4SLinus Torvalds goto done; 5211da177e4SLinus Torvalds } 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 5241da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 5251da177e4SLinus Torvalds 526943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 527943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 528943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 529943da25dSMarcel Holtmann 5301da177e4SLinus Torvalds if (hdev->open(hdev)) { 5311da177e4SLinus Torvalds ret = -EIO; 5321da177e4SLinus Torvalds goto done; 5331da177e4SLinus Torvalds } 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5361da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5371da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 538a5040efaSJohan Hedberg hdev->init_last_cmd = 0; 5391da177e4SLinus Torvalds 54004837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 54104837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5421da177e4SLinus Torvalds 5436ed58ec5SVille Tervo if (lmp_le_capable(hdev)) 5446ed58ec5SVille Tervo ret = __hci_request(hdev, hci_le_init_req, 0, 5456ed58ec5SVille Tervo msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5466ed58ec5SVille Tervo 5471da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5481da177e4SLinus Torvalds } 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds if (!ret) { 5511da177e4SLinus Torvalds hci_dev_hold(hdev); 5521da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5531da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5545add6af8SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->flags)) 5555add6af8SJohan Hedberg mgmt_powered(hdev->id, 1); 5561da177e4SLinus Torvalds } else { 5571da177e4SLinus Torvalds /* Init failed, cleanup */ 5581da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5591da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5601da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5631da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds if (hdev->flush) 5661da177e4SLinus Torvalds hdev->flush(hdev); 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds if (hdev->sent_cmd) { 5691da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5701da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5711da177e4SLinus Torvalds } 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds hdev->close(hdev); 5741da177e4SLinus Torvalds hdev->flags = 0; 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds done: 5781da177e4SLinus Torvalds hci_req_unlock(hdev); 5791da177e4SLinus Torvalds hci_dev_put(hdev); 5801da177e4SLinus Torvalds return ret; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5841da177e4SLinus Torvalds { 5851da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5881da177e4SLinus Torvalds hci_req_lock(hdev); 5891da177e4SLinus Torvalds 590*6f5ef998SThomas Gleixner /* Stop timer, it might be running */ 591*6f5ef998SThomas Gleixner del_timer_sync(&hdev->cmd_timer); 592*6f5ef998SThomas Gleixner 5931da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 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 102555ed8ca1SJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, int new_key, bdaddr_t *bdaddr, 102655ed8ca1SJohan Hedberg u8 *val, u8 type, u8 pin_len) 102755ed8ca1SJohan Hedberg { 102855ed8ca1SJohan Hedberg struct link_key *key, *old_key; 102955ed8ca1SJohan Hedberg u8 old_key_type; 103055ed8ca1SJohan Hedberg 103155ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 103255ed8ca1SJohan Hedberg if (old_key) { 103355ed8ca1SJohan Hedberg old_key_type = old_key->type; 103455ed8ca1SJohan Hedberg key = old_key; 103555ed8ca1SJohan Hedberg } else { 103655ed8ca1SJohan Hedberg old_key_type = 0xff; 103755ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 103855ed8ca1SJohan Hedberg if (!key) 103955ed8ca1SJohan Hedberg return -ENOMEM; 104055ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 104155ed8ca1SJohan Hedberg } 104255ed8ca1SJohan Hedberg 104355ed8ca1SJohan Hedberg BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type); 104455ed8ca1SJohan Hedberg 104555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 104655ed8ca1SJohan Hedberg memcpy(key->val, val, 16); 104755ed8ca1SJohan Hedberg key->type = type; 104855ed8ca1SJohan Hedberg key->pin_len = pin_len; 104955ed8ca1SJohan Hedberg 105055ed8ca1SJohan Hedberg if (new_key) 105155ed8ca1SJohan Hedberg mgmt_new_key(hdev->id, key, old_key_type); 105255ed8ca1SJohan Hedberg 105355ed8ca1SJohan Hedberg if (type == 0x06) 105455ed8ca1SJohan Hedberg key->type = old_key_type; 105555ed8ca1SJohan Hedberg 105655ed8ca1SJohan Hedberg return 0; 105755ed8ca1SJohan Hedberg } 105855ed8ca1SJohan Hedberg 105955ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 106055ed8ca1SJohan Hedberg { 106155ed8ca1SJohan Hedberg struct link_key *key; 106255ed8ca1SJohan Hedberg 106355ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 106455ed8ca1SJohan Hedberg if (!key) 106555ed8ca1SJohan Hedberg return -ENOENT; 106655ed8ca1SJohan Hedberg 106755ed8ca1SJohan Hedberg BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 106855ed8ca1SJohan Hedberg 106955ed8ca1SJohan Hedberg list_del(&key->list); 107055ed8ca1SJohan Hedberg kfree(key); 107155ed8ca1SJohan Hedberg 107255ed8ca1SJohan Hedberg return 0; 107355ed8ca1SJohan Hedberg } 107455ed8ca1SJohan Hedberg 10756bd32326SVille Tervo /* HCI command timer function */ 10766bd32326SVille Tervo static void hci_cmd_timer(unsigned long arg) 10776bd32326SVille Tervo { 10786bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 10796bd32326SVille Tervo 10806bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 10816bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 108210572132SGustavo F. Padovan clear_bit(HCI_RESET, &hdev->flags); 10836bd32326SVille Tervo tasklet_schedule(&hdev->cmd_task); 10846bd32326SVille Tervo } 10856bd32326SVille Tervo 10861da177e4SLinus Torvalds /* Register HCI device */ 10871da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 10881da177e4SLinus Torvalds { 10891da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 1090ef222013SMarcel Holtmann int i, id = 0; 10911da177e4SLinus Torvalds 1092c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 1093c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 10961da177e4SLinus Torvalds return -EINVAL; 10971da177e4SLinus Torvalds 10981da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 10991da177e4SLinus Torvalds 11001da177e4SLinus Torvalds /* Find first available device id */ 11011da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 11021da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 11031da177e4SLinus Torvalds break; 11041da177e4SLinus Torvalds head = p; id++; 11051da177e4SLinus Torvalds } 11061da177e4SLinus Torvalds 11071da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 11081da177e4SLinus Torvalds hdev->id = id; 11091da177e4SLinus Torvalds list_add(&hdev->list, head); 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 11121da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 11131da177e4SLinus Torvalds 11141da177e4SLinus Torvalds hdev->flags = 0; 11151da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 11165b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 11171da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 111817fa4b9dSJohan Hedberg hdev->io_capability = 0x03; /* No Input No Output */ 11191da177e4SLinus Torvalds 112004837f64SMarcel Holtmann hdev->idle_timeout = 0; 112104837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 112204837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 112304837f64SMarcel Holtmann 11241da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 11251da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 11261da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 11291da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 11301da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 11311da177e4SLinus Torvalds 11326bd32326SVille Tervo setup_timer(&hdev->cmd_timer, hci_cmd_timer, (unsigned long) hdev); 11336bd32326SVille Tervo 1134cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1135ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 1136ef222013SMarcel Holtmann 11371da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 1138a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 11391da177e4SLinus Torvalds 11401da177e4SLinus Torvalds inquiry_cache_init(hdev); 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds hci_conn_hash_init(hdev); 11431da177e4SLinus Torvalds 1144ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1145f0358568SJohan Hedberg 11462aeb9a1aSJohan Hedberg INIT_LIST_HEAD(&hdev->uuids); 11472aeb9a1aSJohan Hedberg 114855ed8ca1SJohan Hedberg INIT_LIST_HEAD(&hdev->link_keys); 114955ed8ca1SJohan Hedberg 1150ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1151ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1152ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1153ab81cbf9SJohan Hedberg 11541da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 11551da177e4SLinus Torvalds 11561da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 11571da177e4SLinus Torvalds 11581da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 11591da177e4SLinus Torvalds 1160f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1161f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1162f48fd9c8SMarcel Holtmann goto nomem; 1163f48fd9c8SMarcel Holtmann 11641da177e4SLinus Torvalds hci_register_sysfs(hdev); 11651da177e4SLinus Torvalds 1166611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1167611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1168611b30f7SMarcel Holtmann if (hdev->rfkill) { 1169611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1170611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1171611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1172611b30f7SMarcel Holtmann } 1173611b30f7SMarcel Holtmann } 1174611b30f7SMarcel Holtmann 1175ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1176ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1177ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1178ab81cbf9SJohan Hedberg 11791da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds return id; 1182f48fd9c8SMarcel Holtmann 1183f48fd9c8SMarcel Holtmann nomem: 1184f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1185f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1186f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1187f48fd9c8SMarcel Holtmann 1188f48fd9c8SMarcel Holtmann return -ENOMEM; 11891da177e4SLinus Torvalds } 11901da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds /* Unregister HCI device */ 11931da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 11941da177e4SLinus Torvalds { 1195ef222013SMarcel Holtmann int i; 1196ef222013SMarcel Holtmann 1197c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 11981da177e4SLinus Torvalds 11991da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 12001da177e4SLinus Torvalds list_del(&hdev->list); 12011da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds hci_dev_do_close(hdev); 12041da177e4SLinus Torvalds 1205cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1206ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1207ef222013SMarcel Holtmann 1208ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1209ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1210c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1211ab81cbf9SJohan Hedberg 12121da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 12131da177e4SLinus Torvalds 1214611b30f7SMarcel Holtmann if (hdev->rfkill) { 1215611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1216611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1217611b30f7SMarcel Holtmann } 1218611b30f7SMarcel Holtmann 1219147e2d59SDave Young hci_unregister_sysfs(hdev); 1220147e2d59SDave Young 1221c6f3c5f7SGustavo F. Padovan hci_del_off_timer(hdev); 1222c6f3c5f7SGustavo F. Padovan 1223f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1224f48fd9c8SMarcel Holtmann 1225e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1226e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 12272aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 122855ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 1229e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1230e2e0cacbSJohan Hedberg 12311da177e4SLinus Torvalds __hci_dev_put(hdev); 1232ef222013SMarcel Holtmann 12331da177e4SLinus Torvalds return 0; 12341da177e4SLinus Torvalds } 12351da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 12361da177e4SLinus Torvalds 12371da177e4SLinus Torvalds /* Suspend HCI device */ 12381da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 12391da177e4SLinus Torvalds { 12401da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 12411da177e4SLinus Torvalds return 0; 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 12441da177e4SLinus Torvalds 12451da177e4SLinus Torvalds /* Resume HCI device */ 12461da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 12471da177e4SLinus Torvalds { 12481da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 12491da177e4SLinus Torvalds return 0; 12501da177e4SLinus Torvalds } 12511da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 12521da177e4SLinus Torvalds 125376bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 125476bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 125576bca880SMarcel Holtmann { 125676bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 125776bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 125876bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 125976bca880SMarcel Holtmann kfree_skb(skb); 126076bca880SMarcel Holtmann return -ENXIO; 126176bca880SMarcel Holtmann } 126276bca880SMarcel Holtmann 126376bca880SMarcel Holtmann /* Incomming skb */ 126476bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 126576bca880SMarcel Holtmann 126676bca880SMarcel Holtmann /* Time stamp */ 126776bca880SMarcel Holtmann __net_timestamp(skb); 126876bca880SMarcel Holtmann 126976bca880SMarcel Holtmann /* Queue frame for rx task */ 127076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1271c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1272c78ae283SMarcel Holtmann 127376bca880SMarcel Holtmann return 0; 127476bca880SMarcel Holtmann } 127576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 127676bca880SMarcel Holtmann 127733e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 127833e882a5SSuraj Sumangala int count, __u8 index, gfp_t gfp_mask) 127933e882a5SSuraj Sumangala { 128033e882a5SSuraj Sumangala int len = 0; 128133e882a5SSuraj Sumangala int hlen = 0; 128233e882a5SSuraj Sumangala int remain = count; 128333e882a5SSuraj Sumangala struct sk_buff *skb; 128433e882a5SSuraj Sumangala struct bt_skb_cb *scb; 128533e882a5SSuraj Sumangala 128633e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 128733e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 128833e882a5SSuraj Sumangala return -EILSEQ; 128933e882a5SSuraj Sumangala 129033e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 129133e882a5SSuraj Sumangala 129233e882a5SSuraj Sumangala if (!skb) { 129333e882a5SSuraj Sumangala switch (type) { 129433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 129533e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 129633e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 129733e882a5SSuraj Sumangala break; 129833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 129933e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 130033e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 130133e882a5SSuraj Sumangala break; 130233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 130333e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 130433e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 130533e882a5SSuraj Sumangala break; 130633e882a5SSuraj Sumangala } 130733e882a5SSuraj Sumangala 130833e882a5SSuraj Sumangala skb = bt_skb_alloc(len, gfp_mask); 130933e882a5SSuraj Sumangala if (!skb) 131033e882a5SSuraj Sumangala return -ENOMEM; 131133e882a5SSuraj Sumangala 131233e882a5SSuraj Sumangala scb = (void *) skb->cb; 131333e882a5SSuraj Sumangala scb->expect = hlen; 131433e882a5SSuraj Sumangala scb->pkt_type = type; 131533e882a5SSuraj Sumangala 131633e882a5SSuraj Sumangala skb->dev = (void *) hdev; 131733e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 131833e882a5SSuraj Sumangala } 131933e882a5SSuraj Sumangala 132033e882a5SSuraj Sumangala while (count) { 132133e882a5SSuraj Sumangala scb = (void *) skb->cb; 132233e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 132333e882a5SSuraj Sumangala 132433e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 132533e882a5SSuraj Sumangala 132633e882a5SSuraj Sumangala count -= len; 132733e882a5SSuraj Sumangala data += len; 132833e882a5SSuraj Sumangala scb->expect -= len; 132933e882a5SSuraj Sumangala remain = count; 133033e882a5SSuraj Sumangala 133133e882a5SSuraj Sumangala switch (type) { 133233e882a5SSuraj Sumangala case HCI_EVENT_PKT: 133333e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 133433e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 133533e882a5SSuraj Sumangala scb->expect = h->plen; 133633e882a5SSuraj Sumangala 133733e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 133833e882a5SSuraj Sumangala kfree_skb(skb); 133933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 134033e882a5SSuraj Sumangala return -ENOMEM; 134133e882a5SSuraj Sumangala } 134233e882a5SSuraj Sumangala } 134333e882a5SSuraj Sumangala break; 134433e882a5SSuraj Sumangala 134533e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 134633e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 134733e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 134833e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 134933e882a5SSuraj Sumangala 135033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 135133e882a5SSuraj Sumangala kfree_skb(skb); 135233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 135333e882a5SSuraj Sumangala return -ENOMEM; 135433e882a5SSuraj Sumangala } 135533e882a5SSuraj Sumangala } 135633e882a5SSuraj Sumangala break; 135733e882a5SSuraj Sumangala 135833e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 135933e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 136033e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 136133e882a5SSuraj Sumangala scb->expect = h->dlen; 136233e882a5SSuraj Sumangala 136333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 136433e882a5SSuraj Sumangala kfree_skb(skb); 136533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 136633e882a5SSuraj Sumangala return -ENOMEM; 136733e882a5SSuraj Sumangala } 136833e882a5SSuraj Sumangala } 136933e882a5SSuraj Sumangala break; 137033e882a5SSuraj Sumangala } 137133e882a5SSuraj Sumangala 137233e882a5SSuraj Sumangala if (scb->expect == 0) { 137333e882a5SSuraj Sumangala /* Complete frame */ 137433e882a5SSuraj Sumangala 137533e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 137633e882a5SSuraj Sumangala hci_recv_frame(skb); 137733e882a5SSuraj Sumangala 137833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 137933e882a5SSuraj Sumangala return remain; 138033e882a5SSuraj Sumangala } 138133e882a5SSuraj Sumangala } 138233e882a5SSuraj Sumangala 138333e882a5SSuraj Sumangala return remain; 138433e882a5SSuraj Sumangala } 138533e882a5SSuraj Sumangala 1386ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1387ef222013SMarcel Holtmann { 1388f39a3c06SSuraj Sumangala int rem = 0; 1389f39a3c06SSuraj Sumangala 1390ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1391ef222013SMarcel Holtmann return -EILSEQ; 1392ef222013SMarcel Holtmann 1393da5f6c37SGustavo F. Padovan while (count) { 1394f39a3c06SSuraj Sumangala rem = hci_reassembly(hdev, type, data, count, 1395f39a3c06SSuraj Sumangala type - 1, GFP_ATOMIC); 1396f39a3c06SSuraj Sumangala if (rem < 0) 1397f39a3c06SSuraj Sumangala return rem; 1398ef222013SMarcel Holtmann 1399f39a3c06SSuraj Sumangala data += (count - rem); 1400f39a3c06SSuraj Sumangala count = rem; 1401da5f6c37SGustavo F. Padovan }; 1402ef222013SMarcel Holtmann 1403f39a3c06SSuraj Sumangala return rem; 1404ef222013SMarcel Holtmann } 1405ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1406ef222013SMarcel Holtmann 140799811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 140899811510SSuraj Sumangala 140999811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 141099811510SSuraj Sumangala { 141199811510SSuraj Sumangala int type; 141299811510SSuraj Sumangala int rem = 0; 141399811510SSuraj Sumangala 1414da5f6c37SGustavo F. Padovan while (count) { 141599811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 141699811510SSuraj Sumangala 141799811510SSuraj Sumangala if (!skb) { 141899811510SSuraj Sumangala struct { char type; } *pkt; 141999811510SSuraj Sumangala 142099811510SSuraj Sumangala /* Start of the frame */ 142199811510SSuraj Sumangala pkt = data; 142299811510SSuraj Sumangala type = pkt->type; 142399811510SSuraj Sumangala 142499811510SSuraj Sumangala data++; 142599811510SSuraj Sumangala count--; 142699811510SSuraj Sumangala } else 142799811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 142899811510SSuraj Sumangala 142999811510SSuraj Sumangala rem = hci_reassembly(hdev, type, data, 143099811510SSuraj Sumangala count, STREAM_REASSEMBLY, GFP_ATOMIC); 143199811510SSuraj Sumangala if (rem < 0) 143299811510SSuraj Sumangala return rem; 143399811510SSuraj Sumangala 143499811510SSuraj Sumangala data += (count - rem); 143599811510SSuraj Sumangala count = rem; 1436da5f6c37SGustavo F. Padovan }; 143799811510SSuraj Sumangala 143899811510SSuraj Sumangala return rem; 143999811510SSuraj Sumangala } 144099811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 144199811510SSuraj Sumangala 14421da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds /* Register/Unregister protocols. 14451da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 14461da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 14471da177e4SLinus Torvalds { 14481da177e4SLinus Torvalds int err = 0; 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 14531da177e4SLinus Torvalds return -EINVAL; 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds if (!hci_proto[hp->id]) 14581da177e4SLinus Torvalds hci_proto[hp->id] = hp; 14591da177e4SLinus Torvalds else 14601da177e4SLinus Torvalds err = -EEXIST; 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds return err; 14651da177e4SLinus Torvalds } 14661da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 14671da177e4SLinus Torvalds 14681da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 14691da177e4SLinus Torvalds { 14701da177e4SLinus Torvalds int err = 0; 14711da177e4SLinus Torvalds 14721da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 14751da177e4SLinus Torvalds return -EINVAL; 14761da177e4SLinus Torvalds 14771da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds if (hci_proto[hp->id]) 14801da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 14811da177e4SLinus Torvalds else 14821da177e4SLinus Torvalds err = -ENOENT; 14831da177e4SLinus Torvalds 14841da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds return err; 14871da177e4SLinus Torvalds } 14881da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 14911da177e4SLinus Torvalds { 14921da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 14931da177e4SLinus Torvalds 14941da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 14951da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 14961da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds return 0; 14991da177e4SLinus Torvalds } 15001da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 15031da177e4SLinus Torvalds { 15041da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 15071da177e4SLinus Torvalds list_del(&cb->list); 15081da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds return 0; 15111da177e4SLinus Torvalds } 15121da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 15131da177e4SLinus Torvalds 15141da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 15151da177e4SLinus Torvalds { 15161da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 15171da177e4SLinus Torvalds 15181da177e4SLinus Torvalds if (!hdev) { 15191da177e4SLinus Torvalds kfree_skb(skb); 15201da177e4SLinus Torvalds return -ENODEV; 15211da177e4SLinus Torvalds } 15221da177e4SLinus Torvalds 15230d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 15241da177e4SLinus Torvalds 15251da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 15261da177e4SLinus Torvalds /* Time stamp */ 1527a61bbcf2SPatrick McHardy __net_timestamp(skb); 15281da177e4SLinus Torvalds 1529eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 15301da177e4SLinus Torvalds } 15311da177e4SLinus Torvalds 15321da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 15331da177e4SLinus Torvalds skb_orphan(skb); 15341da177e4SLinus Torvalds 15351da177e4SLinus Torvalds return hdev->send(skb); 15361da177e4SLinus Torvalds } 15371da177e4SLinus Torvalds 15381da177e4SLinus Torvalds /* Send HCI command */ 1539a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 15401da177e4SLinus Torvalds { 15411da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 15421da177e4SLinus Torvalds struct hci_command_hdr *hdr; 15431da177e4SLinus Torvalds struct sk_buff *skb; 15441da177e4SLinus Torvalds 1545a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 15461da177e4SLinus Torvalds 15471da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 15481da177e4SLinus Torvalds if (!skb) { 1549ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 15501da177e4SLinus Torvalds return -ENOMEM; 15511da177e4SLinus Torvalds } 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1554a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 15551da177e4SLinus Torvalds hdr->plen = plen; 15561da177e4SLinus Torvalds 15571da177e4SLinus Torvalds if (plen) 15581da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 15591da177e4SLinus Torvalds 15601da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 15611da177e4SLinus Torvalds 15620d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 15631da177e4SLinus Torvalds skb->dev = (void *) hdev; 1564c78ae283SMarcel Holtmann 1565a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags)) 1566a5040efaSJohan Hedberg hdev->init_last_cmd = opcode; 1567a5040efaSJohan Hedberg 15681da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1569c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds return 0; 15721da177e4SLinus Torvalds } 15731da177e4SLinus Torvalds 15741da177e4SLinus Torvalds /* Get data from the previously sent command */ 1575a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 15761da177e4SLinus Torvalds { 15771da177e4SLinus Torvalds struct hci_command_hdr *hdr; 15781da177e4SLinus Torvalds 15791da177e4SLinus Torvalds if (!hdev->sent_cmd) 15801da177e4SLinus Torvalds return NULL; 15811da177e4SLinus Torvalds 15821da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 15831da177e4SLinus Torvalds 1584a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 15851da177e4SLinus Torvalds return NULL; 15861da177e4SLinus Torvalds 1587a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 15881da177e4SLinus Torvalds 15891da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 15901da177e4SLinus Torvalds } 15911da177e4SLinus Torvalds 15921da177e4SLinus Torvalds /* Send ACL data */ 15931da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 15941da177e4SLinus Torvalds { 15951da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 15961da177e4SLinus Torvalds int len = skb->len; 15971da177e4SLinus Torvalds 1598badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1599badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 16009c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1601aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1602aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds 16059a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 16061da177e4SLinus Torvalds { 16071da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 16081da177e4SLinus Torvalds struct sk_buff *list; 16091da177e4SLinus Torvalds 16101da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 16111da177e4SLinus Torvalds 16121da177e4SLinus Torvalds skb->dev = (void *) hdev; 16130d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1614e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 16151da177e4SLinus Torvalds 161670f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 161770f23020SAndrei Emeltchenko if (!list) { 16181da177e4SLinus Torvalds /* Non fragmented */ 16191da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 16221da177e4SLinus Torvalds } else { 16231da177e4SLinus Torvalds /* Fragmented */ 16241da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 16251da177e4SLinus Torvalds 16261da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 16271da177e4SLinus Torvalds 16281da177e4SLinus Torvalds /* Queue all fragments atomically */ 16291da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 16301da177e4SLinus Torvalds 16311da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1632e702112fSAndrei Emeltchenko 1633e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1634e702112fSAndrei Emeltchenko flags |= ACL_CONT; 16351da177e4SLinus Torvalds do { 16361da177e4SLinus Torvalds skb = list; list = list->next; 16371da177e4SLinus Torvalds 16381da177e4SLinus Torvalds skb->dev = (void *) hdev; 16390d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1640e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 16431da177e4SLinus Torvalds 16441da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 16451da177e4SLinus Torvalds } while (list); 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 16481da177e4SLinus Torvalds } 16491da177e4SLinus Torvalds 1650c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 16511da177e4SLinus Torvalds } 16521da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds /* Send SCO data */ 16550d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 16561da177e4SLinus Torvalds { 16571da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 16581da177e4SLinus Torvalds struct hci_sco_hdr hdr; 16591da177e4SLinus Torvalds 16601da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 16611da177e4SLinus Torvalds 1662aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 16631da177e4SLinus Torvalds hdr.dlen = skb->len; 16641da177e4SLinus Torvalds 1665badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1666badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 16679c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 16681da177e4SLinus Torvalds 16691da177e4SLinus Torvalds skb->dev = (void *) hdev; 16700d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1671c78ae283SMarcel Holtmann 16721da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1673c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 16741da177e4SLinus Torvalds } 16751da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds /* HCI Connection scheduler */ 16801da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 16811da177e4SLinus Torvalds { 16821da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 16831da177e4SLinus Torvalds struct hci_conn *conn = NULL; 16841da177e4SLinus Torvalds int num = 0, min = ~0; 16851da177e4SLinus Torvalds struct list_head *p; 16861da177e4SLinus Torvalds 16871da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 16881da177e4SLinus Torvalds * added and removed with TX task disabled. */ 16891da177e4SLinus Torvalds list_for_each(p, &h->list) { 16901da177e4SLinus Torvalds struct hci_conn *c; 16911da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 16921da177e4SLinus Torvalds 1693769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 16941da177e4SLinus Torvalds continue; 1695769be974SMarcel Holtmann 1696769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1697769be974SMarcel Holtmann continue; 1698769be974SMarcel Holtmann 16991da177e4SLinus Torvalds num++; 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds if (c->sent < min) { 17021da177e4SLinus Torvalds min = c->sent; 17031da177e4SLinus Torvalds conn = c; 17041da177e4SLinus Torvalds } 17051da177e4SLinus Torvalds } 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds if (conn) { 17086ed58ec5SVille Tervo int cnt, q; 17096ed58ec5SVille Tervo 17106ed58ec5SVille Tervo switch (conn->type) { 17116ed58ec5SVille Tervo case ACL_LINK: 17126ed58ec5SVille Tervo cnt = hdev->acl_cnt; 17136ed58ec5SVille Tervo break; 17146ed58ec5SVille Tervo case SCO_LINK: 17156ed58ec5SVille Tervo case ESCO_LINK: 17166ed58ec5SVille Tervo cnt = hdev->sco_cnt; 17176ed58ec5SVille Tervo break; 17186ed58ec5SVille Tervo case LE_LINK: 17196ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 17206ed58ec5SVille Tervo break; 17216ed58ec5SVille Tervo default: 17226ed58ec5SVille Tervo cnt = 0; 17236ed58ec5SVille Tervo BT_ERR("Unknown link type"); 17246ed58ec5SVille Tervo } 17256ed58ec5SVille Tervo 17266ed58ec5SVille Tervo q = cnt / num; 17271da177e4SLinus Torvalds *quote = q ? q : 1; 17281da177e4SLinus Torvalds } else 17291da177e4SLinus Torvalds *quote = 0; 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 17321da177e4SLinus Torvalds return conn; 17331da177e4SLinus Torvalds } 17341da177e4SLinus Torvalds 1735bae1f5d9SVille Tervo static inline void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 17361da177e4SLinus Torvalds { 17371da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 17381da177e4SLinus Torvalds struct list_head *p; 17391da177e4SLinus Torvalds struct hci_conn *c; 17401da177e4SLinus Torvalds 1741bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 17421da177e4SLinus Torvalds 17431da177e4SLinus Torvalds /* Kill stalled connections */ 17441da177e4SLinus Torvalds list_for_each(p, &h->list) { 17451da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 1746bae1f5d9SVille Tervo if (c->type == type && c->sent) { 1747bae1f5d9SVille Tervo BT_ERR("%s killing stalled connection %s", 17481da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 17491da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 17501da177e4SLinus Torvalds } 17511da177e4SLinus Torvalds } 17521da177e4SLinus Torvalds } 17531da177e4SLinus Torvalds 17541da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 17551da177e4SLinus Torvalds { 17561da177e4SLinus Torvalds struct hci_conn *conn; 17571da177e4SLinus Torvalds struct sk_buff *skb; 17581da177e4SLinus Torvalds int quote; 17591da177e4SLinus Torvalds 17601da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17611da177e4SLinus Torvalds 17621da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 17631da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 17641da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 176582453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 1766bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 17671da177e4SLinus Torvalds } 17681da177e4SLinus Torvalds 17691da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 17701da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 17711da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 177204837f64SMarcel Holtmann 177304837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 177404837f64SMarcel Holtmann 17751da177e4SLinus Torvalds hci_send_frame(skb); 17761da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 17771da177e4SLinus Torvalds 17781da177e4SLinus Torvalds hdev->acl_cnt--; 17791da177e4SLinus Torvalds conn->sent++; 17801da177e4SLinus Torvalds } 17811da177e4SLinus Torvalds } 17821da177e4SLinus Torvalds } 17831da177e4SLinus Torvalds 17841da177e4SLinus Torvalds /* Schedule SCO */ 17851da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 17861da177e4SLinus Torvalds { 17871da177e4SLinus Torvalds struct hci_conn *conn; 17881da177e4SLinus Torvalds struct sk_buff *skb; 17891da177e4SLinus Torvalds int quote; 17901da177e4SLinus Torvalds 17911da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17921da177e4SLinus Torvalds 17931da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 17941da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 17951da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 17961da177e4SLinus Torvalds hci_send_frame(skb); 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds conn->sent++; 17991da177e4SLinus Torvalds if (conn->sent == ~0) 18001da177e4SLinus Torvalds conn->sent = 0; 18011da177e4SLinus Torvalds } 18021da177e4SLinus Torvalds } 18031da177e4SLinus Torvalds } 18041da177e4SLinus Torvalds 1805b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1806b6a0dc82SMarcel Holtmann { 1807b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1808b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1809b6a0dc82SMarcel Holtmann int quote; 1810b6a0dc82SMarcel Holtmann 1811b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1812b6a0dc82SMarcel Holtmann 1813b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1814b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1815b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1816b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1817b6a0dc82SMarcel Holtmann 1818b6a0dc82SMarcel Holtmann conn->sent++; 1819b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1820b6a0dc82SMarcel Holtmann conn->sent = 0; 1821b6a0dc82SMarcel Holtmann } 1822b6a0dc82SMarcel Holtmann } 1823b6a0dc82SMarcel Holtmann } 1824b6a0dc82SMarcel Holtmann 18256ed58ec5SVille Tervo static inline void hci_sched_le(struct hci_dev *hdev) 18266ed58ec5SVille Tervo { 18276ed58ec5SVille Tervo struct hci_conn *conn; 18286ed58ec5SVille Tervo struct sk_buff *skb; 18296ed58ec5SVille Tervo int quote, cnt; 18306ed58ec5SVille Tervo 18316ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 18326ed58ec5SVille Tervo 18336ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 18346ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 18356ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 1836bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 18376ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 1838bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 18396ed58ec5SVille Tervo } 18406ed58ec5SVille Tervo 18416ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 18426ed58ec5SVille Tervo while (cnt && (conn = hci_low_sent(hdev, LE_LINK, "e))) { 18436ed58ec5SVille Tervo while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 18446ed58ec5SVille Tervo BT_DBG("skb %p len %d", skb, skb->len); 18456ed58ec5SVille Tervo 18466ed58ec5SVille Tervo hci_send_frame(skb); 18476ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 18486ed58ec5SVille Tervo 18496ed58ec5SVille Tervo cnt--; 18506ed58ec5SVille Tervo conn->sent++; 18516ed58ec5SVille Tervo } 18526ed58ec5SVille Tervo } 18536ed58ec5SVille Tervo if (hdev->le_pkts) 18546ed58ec5SVille Tervo hdev->le_cnt = cnt; 18556ed58ec5SVille Tervo else 18566ed58ec5SVille Tervo hdev->acl_cnt = cnt; 18576ed58ec5SVille Tervo } 18586ed58ec5SVille Tervo 18591da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 18601da177e4SLinus Torvalds { 18611da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 18621da177e4SLinus Torvalds struct sk_buff *skb; 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds read_lock(&hci_task_lock); 18651da177e4SLinus Torvalds 18666ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 18676ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 18681da177e4SLinus Torvalds 18691da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 18701da177e4SLinus Torvalds 18711da177e4SLinus Torvalds hci_sched_acl(hdev); 18721da177e4SLinus Torvalds 18731da177e4SLinus Torvalds hci_sched_sco(hdev); 18741da177e4SLinus Torvalds 1875b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1876b6a0dc82SMarcel Holtmann 18776ed58ec5SVille Tervo hci_sched_le(hdev); 18786ed58ec5SVille Tervo 18791da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 18801da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 18811da177e4SLinus Torvalds hci_send_frame(skb); 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds read_unlock(&hci_task_lock); 18841da177e4SLinus Torvalds } 18851da177e4SLinus Torvalds 18861da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 18871da177e4SLinus Torvalds 18881da177e4SLinus Torvalds /* ACL data packet */ 18891da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 18901da177e4SLinus Torvalds { 18911da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 18921da177e4SLinus Torvalds struct hci_conn *conn; 18931da177e4SLinus Torvalds __u16 handle, flags; 18941da177e4SLinus Torvalds 18951da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 18981da177e4SLinus Torvalds flags = hci_flags(handle); 18991da177e4SLinus Torvalds handle = hci_handle(handle); 19001da177e4SLinus Torvalds 19011da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds hdev->stat.acl_rx++; 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds hci_dev_lock(hdev); 19061da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 19071da177e4SLinus Torvalds hci_dev_unlock(hdev); 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds if (conn) { 19101da177e4SLinus Torvalds register struct hci_proto *hp; 19111da177e4SLinus Torvalds 191204837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 191304837f64SMarcel Holtmann 19141da177e4SLinus Torvalds /* Send to upper protocol */ 191570f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 191670f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 19171da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 19181da177e4SLinus Torvalds return; 19191da177e4SLinus Torvalds } 19201da177e4SLinus Torvalds } else { 19211da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 19221da177e4SLinus Torvalds hdev->name, handle); 19231da177e4SLinus Torvalds } 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds kfree_skb(skb); 19261da177e4SLinus Torvalds } 19271da177e4SLinus Torvalds 19281da177e4SLinus Torvalds /* SCO data packet */ 19291da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 19301da177e4SLinus Torvalds { 19311da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 19321da177e4SLinus Torvalds struct hci_conn *conn; 19331da177e4SLinus Torvalds __u16 handle; 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 19361da177e4SLinus Torvalds 19371da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 19401da177e4SLinus Torvalds 19411da177e4SLinus Torvalds hdev->stat.sco_rx++; 19421da177e4SLinus Torvalds 19431da177e4SLinus Torvalds hci_dev_lock(hdev); 19441da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 19451da177e4SLinus Torvalds hci_dev_unlock(hdev); 19461da177e4SLinus Torvalds 19471da177e4SLinus Torvalds if (conn) { 19481da177e4SLinus Torvalds register struct hci_proto *hp; 19491da177e4SLinus Torvalds 19501da177e4SLinus Torvalds /* Send to upper protocol */ 195170f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 195270f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 19531da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 19541da177e4SLinus Torvalds return; 19551da177e4SLinus Torvalds } 19561da177e4SLinus Torvalds } else { 19571da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 19581da177e4SLinus Torvalds hdev->name, handle); 19591da177e4SLinus Torvalds } 19601da177e4SLinus Torvalds 19611da177e4SLinus Torvalds kfree_skb(skb); 19621da177e4SLinus Torvalds } 19631da177e4SLinus Torvalds 19646516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 19651da177e4SLinus Torvalds { 19661da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 19671da177e4SLinus Torvalds struct sk_buff *skb; 19681da177e4SLinus Torvalds 19691da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 19701da177e4SLinus Torvalds 19711da177e4SLinus Torvalds read_lock(&hci_task_lock); 19721da177e4SLinus Torvalds 19731da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 19741da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 19751da177e4SLinus Torvalds /* Send copy to the sockets */ 1976eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 19771da177e4SLinus Torvalds } 19781da177e4SLinus Torvalds 19791da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 19801da177e4SLinus Torvalds kfree_skb(skb); 19811da177e4SLinus Torvalds continue; 19821da177e4SLinus Torvalds } 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 19851da177e4SLinus Torvalds /* Don't process data packets in this states. */ 19860d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 19871da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 19881da177e4SLinus Torvalds case HCI_SCODATA_PKT: 19891da177e4SLinus Torvalds kfree_skb(skb); 19901da177e4SLinus Torvalds continue; 19913ff50b79SStephen Hemminger } 19921da177e4SLinus Torvalds } 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds /* Process frame */ 19950d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 19961da177e4SLinus Torvalds case HCI_EVENT_PKT: 19971da177e4SLinus Torvalds hci_event_packet(hdev, skb); 19981da177e4SLinus Torvalds break; 19991da177e4SLinus Torvalds 20001da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 20011da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 20021da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 20031da177e4SLinus Torvalds break; 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds case HCI_SCODATA_PKT: 20061da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 20071da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 20081da177e4SLinus Torvalds break; 20091da177e4SLinus Torvalds 20101da177e4SLinus Torvalds default: 20111da177e4SLinus Torvalds kfree_skb(skb); 20121da177e4SLinus Torvalds break; 20131da177e4SLinus Torvalds } 20141da177e4SLinus Torvalds } 20151da177e4SLinus Torvalds 20161da177e4SLinus Torvalds read_unlock(&hci_task_lock); 20171da177e4SLinus Torvalds } 20181da177e4SLinus Torvalds 20191da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 20201da177e4SLinus Torvalds { 20211da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 20221da177e4SLinus Torvalds struct sk_buff *skb; 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 20251da177e4SLinus Torvalds 20261da177e4SLinus Torvalds /* Send queued commands */ 20275a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 20285a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 20295a08ecceSAndrei Emeltchenko if (!skb) 20305a08ecceSAndrei Emeltchenko return; 20315a08ecceSAndrei Emeltchenko 20321da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 20331da177e4SLinus Torvalds 203470f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 203570f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 20361da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 20371da177e4SLinus Torvalds hci_send_frame(skb); 20386bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 20396bd32326SVille Tervo jiffies + msecs_to_jiffies(HCI_CMD_TIMEOUT)); 20401da177e4SLinus Torvalds } else { 20411da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 2042c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 20431da177e4SLinus Torvalds } 20441da177e4SLinus Torvalds } 20451da177e4SLinus Torvalds } 2046