11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 41da177e4SLinus Torvalds 51da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 61da177e4SLinus Torvalds 71da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 81da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 91da177e4SLinus Torvalds published by the Free Software Foundation; 101da177e4SLinus Torvalds 111da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 121da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 131da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 141da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 151da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 161da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 171da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 181da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 211da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 221da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 231da177e4SLinus Torvalds */ 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds /* Bluetooth HCI core. */ 261da177e4SLinus Torvalds 2782453021SS.Çağlar Onur #include <linux/jiffies.h> 281da177e4SLinus Torvalds #include <linux/module.h> 291da177e4SLinus Torvalds #include <linux/kmod.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <linux/types.h> 321da177e4SLinus Torvalds #include <linux/errno.h> 331da177e4SLinus Torvalds #include <linux/kernel.h> 341da177e4SLinus Torvalds #include <linux/sched.h> 351da177e4SLinus Torvalds #include <linux/slab.h> 361da177e4SLinus Torvalds #include <linux/poll.h> 371da177e4SLinus Torvalds #include <linux/fcntl.h> 381da177e4SLinus Torvalds #include <linux/init.h> 391da177e4SLinus Torvalds #include <linux/skbuff.h> 40f48fd9c8SMarcel Holtmann #include <linux/workqueue.h> 411da177e4SLinus Torvalds #include <linux/interrupt.h> 421da177e4SLinus Torvalds #include <linux/notifier.h> 43611b30f7SMarcel Holtmann #include <linux/rfkill.h> 441da177e4SLinus Torvalds #include <net/sock.h> 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds #include <asm/system.h> 4770f23020SAndrei Emeltchenko #include <linux/uaccess.h> 481da177e4SLinus Torvalds #include <asm/unaligned.h> 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 511da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 521da177e4SLinus Torvalds 53ab81cbf9SJohan Hedberg #define AUTO_OFF_TIMEOUT 2000 54ab81cbf9SJohan Hedberg 551da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg); 561da177e4SLinus Torvalds static void hci_rx_task(unsigned long arg); 571da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg); 581da177e4SLinus Torvalds static void hci_notify(struct hci_dev *hdev, int event); 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds static DEFINE_RWLOCK(hci_task_lock); 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds /* HCI device list */ 631da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 641da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /* HCI callback list */ 671da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 681da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds /* HCI protocols */ 711da177e4SLinus Torvalds #define HCI_MAX_PROTO 2 721da177e4SLinus Torvalds struct hci_proto *hci_proto[HCI_MAX_PROTO]; 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* HCI notifiers list */ 75e041c683SAlan Stern static ATOMIC_NOTIFIER_HEAD(hci_notifier); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds int hci_register_notifier(struct notifier_block *nb) 801da177e4SLinus Torvalds { 81e041c683SAlan Stern return atomic_notifier_chain_register(&hci_notifier, nb); 821da177e4SLinus Torvalds } 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds int hci_unregister_notifier(struct notifier_block *nb) 851da177e4SLinus Torvalds { 86e041c683SAlan Stern return atomic_notifier_chain_unregister(&hci_notifier, nb); 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 896516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 901da177e4SLinus Torvalds { 91e041c683SAlan Stern atomic_notifier_call_chain(&hci_notifier, event, hdev); 921da177e4SLinus Torvalds } 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* ---- HCI requests ---- */ 951da177e4SLinus Torvalds 9623bb5763SJohan Hedberg void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result) 971da177e4SLinus Torvalds { 9823bb5763SJohan Hedberg BT_DBG("%s command 0x%04x result 0x%2.2x", hdev->name, cmd, result); 9923bb5763SJohan Hedberg 10023bb5763SJohan Hedberg /* If the request has set req_last_cmd (typical for multi-HCI 10123bb5763SJohan Hedberg * command requests) check if the completed command matches 10223bb5763SJohan Hedberg * this, and if not just return. Single HCI command requests 10323bb5763SJohan Hedberg * typically leave req_last_cmd as 0 */ 10423bb5763SJohan Hedberg if (hdev->req_last_cmd && cmd != hdev->req_last_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 16123bb5763SJohan Hedberg hdev->req_last_cmd = 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 */ 189a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1931da177e4SLinus Torvalds { 1941da177e4SLinus Torvalds struct sk_buff *skb; 1951ebb9252SMarcel Holtmann __le16 param; 19689f2783dSMarcel Holtmann __u8 flt_type; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* Driver initialization */ 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds /* Special commands */ 2031da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 2040d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2051da177e4SLinus Torvalds skb->dev = (void *) hdev; 206c78ae283SMarcel Holtmann 2071da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 208c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds /* Mandatory initialization */ 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* Reset */ 2157a9d4020SMarcel Holtmann if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) 216a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds /* Read Local Supported Features */ 219a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2201da177e4SLinus Torvalds 2211143e5a6SMarcel Holtmann /* Read Local Version */ 222a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2231143e5a6SMarcel Holtmann 2241da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 225a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds #if 0 2281da177e4SLinus Torvalds /* Host buffer size */ 2291da177e4SLinus Torvalds { 2301da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 231aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2321da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 233aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 234aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 235a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds #endif 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds /* Read BD Address */ 240a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 241a9de9248SMarcel Holtmann 242a9de9248SMarcel Holtmann /* Read Class of Device */ 243a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 244a9de9248SMarcel Holtmann 245a9de9248SMarcel Holtmann /* Read Local Name */ 246a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds /* Read Voice Setting */ 249a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* Optional initialization */ 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* Clear Event Filters */ 25489f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 255a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds /* Page timeout ~20 secs */ 258aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x8000); 259a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_PG_TIMEOUT, 2, ¶m); 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); 26423bb5763SJohan Hedberg 26523bb5763SJohan Hedberg hdev->req_last_cmd = HCI_OP_WRITE_CA_TIMEOUT; 2661da177e4SLinus Torvalds } 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2691da177e4SLinus Torvalds { 2701da177e4SLinus Torvalds __u8 scan = opt; 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds /* Inquiry and Page scans */ 275a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2761da177e4SLinus Torvalds } 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2791da177e4SLinus Torvalds { 2801da177e4SLinus Torvalds __u8 auth = opt; 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds /* Authentication */ 285a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2891da177e4SLinus Torvalds { 2901da177e4SLinus Torvalds __u8 encrypt = opt; 2911da177e4SLinus Torvalds 2921da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 2931da177e4SLinus Torvalds 294e4e8e37cSMarcel Holtmann /* Encryption */ 295a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds 298e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 299e4e8e37cSMarcel Holtmann { 300e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 301e4e8e37cSMarcel Holtmann 302a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 303e4e8e37cSMarcel Holtmann 304e4e8e37cSMarcel Holtmann /* Default link policy */ 305e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 306e4e8e37cSMarcel Holtmann } 307e4e8e37cSMarcel Holtmann 3081da177e4SLinus Torvalds /* Get HCI device by index. 3091da177e4SLinus Torvalds * Device is held on return. */ 3101da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3111da177e4SLinus Torvalds { 3121da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3131da177e4SLinus Torvalds struct list_head *p; 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds BT_DBG("%d", index); 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds if (index < 0) 3181da177e4SLinus Torvalds return NULL; 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3211da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3221da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3231da177e4SLinus Torvalds if (d->id == index) { 3241da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3251da177e4SLinus Torvalds break; 3261da177e4SLinus Torvalds } 3271da177e4SLinus Torvalds } 3281da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3291da177e4SLinus Torvalds return hdev; 3301da177e4SLinus Torvalds } 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3331da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3341da177e4SLinus Torvalds { 3351da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3361da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds cache->list = NULL; 3411da177e4SLinus Torvalds while ((e = next)) { 3421da177e4SLinus Torvalds next = e->next; 3431da177e4SLinus Torvalds kfree(e); 3441da177e4SLinus Torvalds } 3451da177e4SLinus Torvalds } 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3481da177e4SLinus Torvalds { 3491da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3501da177e4SLinus Torvalds struct inquiry_entry *e; 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3551da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3561da177e4SLinus Torvalds break; 3571da177e4SLinus Torvalds return e; 3581da177e4SLinus Torvalds } 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3611da177e4SLinus Torvalds { 3621da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 36370f23020SAndrei Emeltchenko struct inquiry_entry *ie; 3641da177e4SLinus Torvalds 3651da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3661da177e4SLinus Torvalds 36770f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 36870f23020SAndrei Emeltchenko if (!ie) { 3691da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 37070f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 37170f23020SAndrei Emeltchenko if (!ie) 3721da177e4SLinus Torvalds return; 37370f23020SAndrei Emeltchenko 37470f23020SAndrei Emeltchenko ie->next = cache->list; 37570f23020SAndrei Emeltchenko cache->list = ie; 3761da177e4SLinus Torvalds } 3771da177e4SLinus Torvalds 37870f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 37970f23020SAndrei Emeltchenko ie->timestamp = jiffies; 3801da177e4SLinus Torvalds cache->timestamp = jiffies; 3811da177e4SLinus Torvalds } 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3841da177e4SLinus Torvalds { 3851da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3861da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3871da177e4SLinus Torvalds struct inquiry_entry *e; 3881da177e4SLinus Torvalds int copied = 0; 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 3911da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 3921da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 3931da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 3941da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 3951da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 3961da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 3971da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 3981da177e4SLinus Torvalds info++; 3991da177e4SLinus Torvalds } 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 4021da177e4SLinus Torvalds return copied; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 4061da177e4SLinus Torvalds { 4071da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 4081da177e4SLinus Torvalds struct hci_cp_inquiry cp; 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 4131da177e4SLinus Torvalds return; 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds /* Start Inquiry */ 4161da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4171da177e4SLinus Torvalds cp.length = ir->length; 4181da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 419a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4231da177e4SLinus Torvalds { 4241da177e4SLinus Torvalds __u8 __user *ptr = arg; 4251da177e4SLinus Torvalds struct hci_inquiry_req ir; 4261da177e4SLinus Torvalds struct hci_dev *hdev; 4271da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4281da177e4SLinus Torvalds long timeo; 4291da177e4SLinus Torvalds __u8 *buf; 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4321da177e4SLinus Torvalds return -EFAULT; 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds if (!(hdev = hci_dev_get(ir.dev_id))) 4351da177e4SLinus Torvalds return -ENODEV; 4361da177e4SLinus Torvalds 4371da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4381da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4391da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4401da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4411da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4421da177e4SLinus Torvalds do_inquiry = 1; 4431da177e4SLinus Torvalds } 4441da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4451da177e4SLinus Torvalds 44604837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 44770f23020SAndrei Emeltchenko 44870f23020SAndrei Emeltchenko if (do_inquiry) { 44970f23020SAndrei Emeltchenko err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo); 45070f23020SAndrei Emeltchenko if (err < 0) 4511da177e4SLinus Torvalds goto done; 45270f23020SAndrei Emeltchenko } 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4551da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4581da177e4SLinus Torvalds * copy it to the user space. 4591da177e4SLinus Torvalds */ 46070f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) *max_rsp, GFP_KERNEL); 46170f23020SAndrei Emeltchenko if (!buf) { 4621da177e4SLinus Torvalds err = -ENOMEM; 4631da177e4SLinus Torvalds goto done; 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4671da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4681da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4731da177e4SLinus Torvalds ptr += sizeof(ir); 4741da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4751da177e4SLinus Torvalds ir.num_rsp)) 4761da177e4SLinus Torvalds err = -EFAULT; 4771da177e4SLinus Torvalds } else 4781da177e4SLinus Torvalds err = -EFAULT; 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds kfree(buf); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds done: 4831da177e4SLinus Torvalds hci_dev_put(hdev); 4841da177e4SLinus Torvalds return err; 4851da177e4SLinus Torvalds } 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 4901da177e4SLinus Torvalds { 4911da177e4SLinus Torvalds struct hci_dev *hdev; 4921da177e4SLinus Torvalds int ret = 0; 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 4951da177e4SLinus Torvalds return -ENODEV; 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds hci_req_lock(hdev); 5001da177e4SLinus Torvalds 501611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 502611b30f7SMarcel Holtmann ret = -ERFKILL; 503611b30f7SMarcel Holtmann goto done; 504611b30f7SMarcel Holtmann } 505611b30f7SMarcel Holtmann 5061da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 5071da177e4SLinus Torvalds ret = -EALREADY; 5081da177e4SLinus Torvalds goto done; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 5121da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 5131da177e4SLinus Torvalds 514943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 515943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 516943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 517943da25dSMarcel Holtmann 5181da177e4SLinus Torvalds if (hdev->open(hdev)) { 5191da177e4SLinus Torvalds ret = -EIO; 5201da177e4SLinus Torvalds goto done; 5211da177e4SLinus Torvalds } 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5241da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5251da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds //__hci_request(hdev, hci_reset_req, 0, HZ); 52804837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 52904837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5321da177e4SLinus Torvalds } 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds if (!ret) { 5351da177e4SLinus Torvalds hci_dev_hold(hdev); 5361da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5371da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5385add6af8SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->flags)) 5395add6af8SJohan Hedberg mgmt_powered(hdev->id, 1); 5401da177e4SLinus Torvalds } else { 5411da177e4SLinus Torvalds /* Init failed, cleanup */ 5421da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5431da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5441da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5471da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds if (hdev->flush) 5501da177e4SLinus Torvalds hdev->flush(hdev); 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds if (hdev->sent_cmd) { 5531da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5541da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5551da177e4SLinus Torvalds } 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds hdev->close(hdev); 5581da177e4SLinus Torvalds hdev->flags = 0; 5591da177e4SLinus Torvalds } 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds done: 5621da177e4SLinus Torvalds hci_req_unlock(hdev); 5631da177e4SLinus Torvalds hci_dev_put(hdev); 5641da177e4SLinus Torvalds return ret; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5681da177e4SLinus Torvalds { 5691da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5721da177e4SLinus Torvalds hci_req_lock(hdev); 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 5751da177e4SLinus Torvalds hci_req_unlock(hdev); 5761da177e4SLinus Torvalds return 0; 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5801da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5811da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 5841da177e4SLinus Torvalds inquiry_cache_flush(hdev); 5851da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 5861da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds if (hdev->flush) 5911da177e4SLinus Torvalds hdev->flush(hdev); 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds /* Reset device */ 5941da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5951da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5961da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5971da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 59804837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 59904837f64SMarcel Holtmann msecs_to_jiffies(250)); 6001da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds /* Kill cmd task */ 6041da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds /* Drop queues */ 6071da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6081da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6091da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds /* Drop last sent command */ 6121da177e4SLinus Torvalds if (hdev->sent_cmd) { 6131da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 6141da177e4SLinus Torvalds hdev->sent_cmd = NULL; 6151da177e4SLinus Torvalds } 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds /* After this point our queues are empty 6181da177e4SLinus Torvalds * and no tasks are scheduled. */ 6191da177e4SLinus Torvalds hdev->close(hdev); 6201da177e4SLinus Torvalds 6215add6af8SJohan Hedberg mgmt_powered(hdev->id, 0); 6225add6af8SJohan Hedberg 6231da177e4SLinus Torvalds /* Clear flags */ 6241da177e4SLinus Torvalds hdev->flags = 0; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds hci_req_unlock(hdev); 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds hci_dev_put(hdev); 6291da177e4SLinus Torvalds return 0; 6301da177e4SLinus Torvalds } 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6331da177e4SLinus Torvalds { 6341da177e4SLinus Torvalds struct hci_dev *hdev; 6351da177e4SLinus Torvalds int err; 6361da177e4SLinus Torvalds 63770f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 63870f23020SAndrei Emeltchenko if (!hdev) 6391da177e4SLinus Torvalds return -ENODEV; 6401da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6411da177e4SLinus Torvalds hci_dev_put(hdev); 6421da177e4SLinus Torvalds return err; 6431da177e4SLinus Torvalds } 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6461da177e4SLinus Torvalds { 6471da177e4SLinus Torvalds struct hci_dev *hdev; 6481da177e4SLinus Torvalds int ret = 0; 6491da177e4SLinus Torvalds 65070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 65170f23020SAndrei Emeltchenko if (!hdev) 6521da177e4SLinus Torvalds return -ENODEV; 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds hci_req_lock(hdev); 6551da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6581da177e4SLinus Torvalds goto done; 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds /* Drop queues */ 6611da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6621da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6651da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6661da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6671da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds if (hdev->flush) 6701da177e4SLinus Torvalds hdev->flush(hdev); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6731da177e4SLinus Torvalds hdev->acl_cnt = 0; hdev->sco_cnt = 0; 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 67604837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 67704837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds done: 6801da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6811da177e4SLinus Torvalds hci_req_unlock(hdev); 6821da177e4SLinus Torvalds hci_dev_put(hdev); 6831da177e4SLinus Torvalds return ret; 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 6871da177e4SLinus Torvalds { 6881da177e4SLinus Torvalds struct hci_dev *hdev; 6891da177e4SLinus Torvalds int ret = 0; 6901da177e4SLinus Torvalds 69170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 69270f23020SAndrei Emeltchenko if (!hdev) 6931da177e4SLinus Torvalds return -ENODEV; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds hci_dev_put(hdev); 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds return ret; 7001da177e4SLinus Torvalds } 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 7031da177e4SLinus Torvalds { 7041da177e4SLinus Torvalds struct hci_dev *hdev; 7051da177e4SLinus Torvalds struct hci_dev_req dr; 7061da177e4SLinus Torvalds int err = 0; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 7091da177e4SLinus Torvalds return -EFAULT; 7101da177e4SLinus Torvalds 71170f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 71270f23020SAndrei Emeltchenko if (!hdev) 7131da177e4SLinus Torvalds return -ENODEV; 7141da177e4SLinus Torvalds 7151da177e4SLinus Torvalds switch (cmd) { 7161da177e4SLinus Torvalds case HCISETAUTH: 71704837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 71804837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7191da177e4SLinus Torvalds break; 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds case HCISETENCRYPT: 7221da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 7231da177e4SLinus Torvalds err = -EOPNOTSUPP; 7241da177e4SLinus Torvalds break; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7281da177e4SLinus Torvalds /* Auth must be enabled first */ 72904837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 73004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7311da177e4SLinus Torvalds if (err) 7321da177e4SLinus Torvalds break; 7331da177e4SLinus Torvalds } 7341da177e4SLinus Torvalds 73504837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 73604837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7371da177e4SLinus Torvalds break; 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds case HCISETSCAN: 74004837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 74104837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7421da177e4SLinus Torvalds break; 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds case HCISETLINKPOL: 745e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 746e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7471da177e4SLinus Torvalds break; 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds case HCISETLINKMODE: 750e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 751e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 752e4e8e37cSMarcel Holtmann break; 753e4e8e37cSMarcel Holtmann 754e4e8e37cSMarcel Holtmann case HCISETPTYPE: 755e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7561da177e4SLinus Torvalds break; 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds case HCISETACLMTU: 7591da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7601da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7611da177e4SLinus Torvalds break; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds case HCISETSCOMTU: 7641da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7651da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7661da177e4SLinus Torvalds break; 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds default: 7691da177e4SLinus Torvalds err = -EINVAL; 7701da177e4SLinus Torvalds break; 7711da177e4SLinus Torvalds } 772e4e8e37cSMarcel Holtmann 7731da177e4SLinus Torvalds hci_dev_put(hdev); 7741da177e4SLinus Torvalds return err; 7751da177e4SLinus Torvalds } 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7781da177e4SLinus Torvalds { 7791da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7801da177e4SLinus Torvalds struct hci_dev_req *dr; 7811da177e4SLinus Torvalds struct list_head *p; 7821da177e4SLinus Torvalds int n = 0, size, err; 7831da177e4SLinus Torvalds __u16 dev_num; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 7861da177e4SLinus Torvalds return -EFAULT; 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 7891da177e4SLinus Torvalds return -EINVAL; 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 7921da177e4SLinus Torvalds 79370f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 79470f23020SAndrei Emeltchenko if (!dl) 7951da177e4SLinus Torvalds return -ENOMEM; 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds dr = dl->dev_req; 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 8001da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8011da177e4SLinus Torvalds struct hci_dev *hdev; 8021da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 803ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 8041da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 8051da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 8061da177e4SLinus Torvalds if (++n >= dev_num) 8071da177e4SLinus Torvalds break; 8081da177e4SLinus Torvalds } 8091da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 8101da177e4SLinus Torvalds 8111da177e4SLinus Torvalds dl->dev_num = n; 8121da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 8151da177e4SLinus Torvalds kfree(dl); 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds return err ? -EFAULT : 0; 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 8211da177e4SLinus Torvalds { 8221da177e4SLinus Torvalds struct hci_dev *hdev; 8231da177e4SLinus Torvalds struct hci_dev_info di; 8241da177e4SLinus Torvalds int err = 0; 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 8271da177e4SLinus Torvalds return -EFAULT; 8281da177e4SLinus Torvalds 82970f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 83070f23020SAndrei Emeltchenko if (!hdev) 8311da177e4SLinus Torvalds return -ENODEV; 8321da177e4SLinus Torvalds 833ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 834ab81cbf9SJohan Hedberg 8351da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8361da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 837943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8381da177e4SLinus Torvalds di.flags = hdev->flags; 8391da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8401da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8411da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8421da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8431da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8441da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8451da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8481da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8511da177e4SLinus Torvalds err = -EFAULT; 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds hci_dev_put(hdev); 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds return err; 8561da177e4SLinus Torvalds } 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8591da177e4SLinus Torvalds 860611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 861611b30f7SMarcel Holtmann { 862611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 863611b30f7SMarcel Holtmann 864611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 865611b30f7SMarcel Holtmann 866611b30f7SMarcel Holtmann if (!blocked) 867611b30f7SMarcel Holtmann return 0; 868611b30f7SMarcel Holtmann 869611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 870611b30f7SMarcel Holtmann 871611b30f7SMarcel Holtmann return 0; 872611b30f7SMarcel Holtmann } 873611b30f7SMarcel Holtmann 874611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 875611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 876611b30f7SMarcel Holtmann }; 877611b30f7SMarcel Holtmann 8781da177e4SLinus Torvalds /* Alloc HCI device */ 8791da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 8801da177e4SLinus Torvalds { 8811da177e4SLinus Torvalds struct hci_dev *hdev; 8821da177e4SLinus Torvalds 88325ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 8841da177e4SLinus Torvalds if (!hdev) 8851da177e4SLinus Torvalds return NULL; 8861da177e4SLinus Torvalds 8871da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds return hdev; 8901da177e4SLinus Torvalds } 8911da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds /* Free HCI device */ 8941da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 8951da177e4SLinus Torvalds { 8961da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 8971da177e4SLinus Torvalds 898a91f2e39SMarcel Holtmann /* will free via device release */ 899a91f2e39SMarcel Holtmann put_device(&hdev->dev); 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 9021da177e4SLinus Torvalds 903ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 904ab81cbf9SJohan Hedberg { 905ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 906ab81cbf9SJohan Hedberg 907ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 908ab81cbf9SJohan Hedberg 909ab81cbf9SJohan Hedberg if (hci_dev_open(hdev->id) < 0) 910ab81cbf9SJohan Hedberg return; 911ab81cbf9SJohan Hedberg 912ab81cbf9SJohan Hedberg if (test_bit(HCI_AUTO_OFF, &hdev->flags)) 913ab81cbf9SJohan Hedberg mod_timer(&hdev->off_timer, 914ab81cbf9SJohan Hedberg jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT)); 915ab81cbf9SJohan Hedberg 916ab81cbf9SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->flags)) 917ab81cbf9SJohan Hedberg mgmt_index_added(hdev->id); 918ab81cbf9SJohan Hedberg } 919ab81cbf9SJohan Hedberg 920ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 921ab81cbf9SJohan Hedberg { 922ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_off); 923ab81cbf9SJohan Hedberg 924ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 925ab81cbf9SJohan Hedberg 926ab81cbf9SJohan Hedberg hci_dev_close(hdev->id); 927ab81cbf9SJohan Hedberg } 928ab81cbf9SJohan Hedberg 929ab81cbf9SJohan Hedberg static void hci_auto_off(unsigned long data) 930ab81cbf9SJohan Hedberg { 931ab81cbf9SJohan Hedberg struct hci_dev *hdev = (struct hci_dev *) data; 932ab81cbf9SJohan Hedberg 933ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 934ab81cbf9SJohan Hedberg 935ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 936ab81cbf9SJohan Hedberg 937ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_off); 938ab81cbf9SJohan Hedberg } 939ab81cbf9SJohan Hedberg 940ab81cbf9SJohan Hedberg void hci_del_off_timer(struct hci_dev *hdev) 941ab81cbf9SJohan Hedberg { 942ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 943ab81cbf9SJohan Hedberg 944ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 945ab81cbf9SJohan Hedberg del_timer(&hdev->off_timer); 946ab81cbf9SJohan Hedberg } 947ab81cbf9SJohan Hedberg 9481da177e4SLinus Torvalds /* Register HCI device */ 9491da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 9501da177e4SLinus Torvalds { 9511da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 952ef222013SMarcel Holtmann int i, id = 0; 9531da177e4SLinus Torvalds 954c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 955c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 9561da177e4SLinus Torvalds 9571da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 9581da177e4SLinus Torvalds return -EINVAL; 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds /* Find first available device id */ 9631da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 9641da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 9651da177e4SLinus Torvalds break; 9661da177e4SLinus Torvalds head = p; id++; 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 9701da177e4SLinus Torvalds hdev->id = id; 9711da177e4SLinus Torvalds list_add(&hdev->list, head); 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 9741da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds hdev->flags = 0; 9771da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 9785b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 9791da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 9801da177e4SLinus Torvalds 98104837f64SMarcel Holtmann hdev->idle_timeout = 0; 98204837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 98304837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 98404837f64SMarcel Holtmann 9851da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 9861da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 9871da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 9901da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 9911da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 9921da177e4SLinus Torvalds 993cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 994ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 995ef222013SMarcel Holtmann 9961da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 997a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds inquiry_cache_init(hdev); 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds hci_conn_hash_init(hdev); 10021da177e4SLinus Torvalds 1003ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1004f0358568SJohan Hedberg 1005ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1006ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1007ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1008ab81cbf9SJohan Hedberg 10091da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 10101da177e4SLinus Torvalds 10111da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 10141da177e4SLinus Torvalds 1015f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1016f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1017f48fd9c8SMarcel Holtmann goto nomem; 1018f48fd9c8SMarcel Holtmann 10191da177e4SLinus Torvalds hci_register_sysfs(hdev); 10201da177e4SLinus Torvalds 1021611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1022611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1023611b30f7SMarcel Holtmann if (hdev->rfkill) { 1024611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1025611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1026611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1027611b30f7SMarcel Holtmann } 1028611b30f7SMarcel Holtmann } 1029611b30f7SMarcel Holtmann 1030ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1031ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1032ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1033ab81cbf9SJohan Hedberg 10341da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds return id; 1037f48fd9c8SMarcel Holtmann 1038f48fd9c8SMarcel Holtmann nomem: 1039f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1040f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1041f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1042f48fd9c8SMarcel Holtmann 1043f48fd9c8SMarcel Holtmann return -ENOMEM; 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds /* Unregister HCI device */ 10481da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 10491da177e4SLinus Torvalds { 1050ef222013SMarcel Holtmann int i; 1051ef222013SMarcel Holtmann 1052c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 10551da177e4SLinus Torvalds list_del(&hdev->list); 10561da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds hci_dev_do_close(hdev); 10591da177e4SLinus Torvalds 1060cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1061ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1062ef222013SMarcel Holtmann 1063ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1064ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1065c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1066ab81cbf9SJohan Hedberg 10671da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 10681da177e4SLinus Torvalds 1069611b30f7SMarcel Holtmann if (hdev->rfkill) { 1070611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1071611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1072611b30f7SMarcel Holtmann } 1073611b30f7SMarcel Holtmann 1074147e2d59SDave Young hci_unregister_sysfs(hdev); 1075147e2d59SDave Young 1076f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1077f48fd9c8SMarcel Holtmann 1078e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1079e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 1080e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1081e2e0cacbSJohan Hedberg 10821da177e4SLinus Torvalds __hci_dev_put(hdev); 1083ef222013SMarcel Holtmann 10841da177e4SLinus Torvalds return 0; 10851da177e4SLinus Torvalds } 10861da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 10871da177e4SLinus Torvalds 10881da177e4SLinus Torvalds /* Suspend HCI device */ 10891da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 10901da177e4SLinus Torvalds { 10911da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 10921da177e4SLinus Torvalds return 0; 10931da177e4SLinus Torvalds } 10941da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds /* Resume HCI device */ 10971da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 10981da177e4SLinus Torvalds { 10991da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 11001da177e4SLinus Torvalds return 0; 11011da177e4SLinus Torvalds } 11021da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 11031da177e4SLinus Torvalds 110476bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 110576bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 110676bca880SMarcel Holtmann { 110776bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 110876bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 110976bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 111076bca880SMarcel Holtmann kfree_skb(skb); 111176bca880SMarcel Holtmann return -ENXIO; 111276bca880SMarcel Holtmann } 111376bca880SMarcel Holtmann 111476bca880SMarcel Holtmann /* Incomming skb */ 111576bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 111676bca880SMarcel Holtmann 111776bca880SMarcel Holtmann /* Time stamp */ 111876bca880SMarcel Holtmann __net_timestamp(skb); 111976bca880SMarcel Holtmann 112076bca880SMarcel Holtmann /* Queue frame for rx task */ 112176bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1122c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1123c78ae283SMarcel Holtmann 112476bca880SMarcel Holtmann return 0; 112576bca880SMarcel Holtmann } 112676bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 112776bca880SMarcel Holtmann 112833e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 112933e882a5SSuraj Sumangala int count, __u8 index, gfp_t gfp_mask) 113033e882a5SSuraj Sumangala { 113133e882a5SSuraj Sumangala int len = 0; 113233e882a5SSuraj Sumangala int hlen = 0; 113333e882a5SSuraj Sumangala int remain = count; 113433e882a5SSuraj Sumangala struct sk_buff *skb; 113533e882a5SSuraj Sumangala struct bt_skb_cb *scb; 113633e882a5SSuraj Sumangala 113733e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 113833e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 113933e882a5SSuraj Sumangala return -EILSEQ; 114033e882a5SSuraj Sumangala 114133e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 114233e882a5SSuraj Sumangala 114333e882a5SSuraj Sumangala if (!skb) { 114433e882a5SSuraj Sumangala switch (type) { 114533e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 114633e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 114733e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 114833e882a5SSuraj Sumangala break; 114933e882a5SSuraj Sumangala case HCI_EVENT_PKT: 115033e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 115133e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 115233e882a5SSuraj Sumangala break; 115333e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 115433e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 115533e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 115633e882a5SSuraj Sumangala break; 115733e882a5SSuraj Sumangala } 115833e882a5SSuraj Sumangala 115933e882a5SSuraj Sumangala skb = bt_skb_alloc(len, gfp_mask); 116033e882a5SSuraj Sumangala if (!skb) 116133e882a5SSuraj Sumangala return -ENOMEM; 116233e882a5SSuraj Sumangala 116333e882a5SSuraj Sumangala scb = (void *) skb->cb; 116433e882a5SSuraj Sumangala scb->expect = hlen; 116533e882a5SSuraj Sumangala scb->pkt_type = type; 116633e882a5SSuraj Sumangala 116733e882a5SSuraj Sumangala skb->dev = (void *) hdev; 116833e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 116933e882a5SSuraj Sumangala } 117033e882a5SSuraj Sumangala 117133e882a5SSuraj Sumangala while (count) { 117233e882a5SSuraj Sumangala scb = (void *) skb->cb; 117333e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 117433e882a5SSuraj Sumangala 117533e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 117633e882a5SSuraj Sumangala 117733e882a5SSuraj Sumangala count -= len; 117833e882a5SSuraj Sumangala data += len; 117933e882a5SSuraj Sumangala scb->expect -= len; 118033e882a5SSuraj Sumangala remain = count; 118133e882a5SSuraj Sumangala 118233e882a5SSuraj Sumangala switch (type) { 118333e882a5SSuraj Sumangala case HCI_EVENT_PKT: 118433e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 118533e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 118633e882a5SSuraj Sumangala scb->expect = h->plen; 118733e882a5SSuraj Sumangala 118833e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 118933e882a5SSuraj Sumangala kfree_skb(skb); 119033e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 119133e882a5SSuraj Sumangala return -ENOMEM; 119233e882a5SSuraj Sumangala } 119333e882a5SSuraj Sumangala } 119433e882a5SSuraj Sumangala break; 119533e882a5SSuraj Sumangala 119633e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 119733e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 119833e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 119933e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 120033e882a5SSuraj Sumangala 120133e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 120233e882a5SSuraj Sumangala kfree_skb(skb); 120333e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 120433e882a5SSuraj Sumangala return -ENOMEM; 120533e882a5SSuraj Sumangala } 120633e882a5SSuraj Sumangala } 120733e882a5SSuraj Sumangala break; 120833e882a5SSuraj Sumangala 120933e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 121033e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 121133e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 121233e882a5SSuraj Sumangala scb->expect = h->dlen; 121333e882a5SSuraj Sumangala 121433e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 121533e882a5SSuraj Sumangala kfree_skb(skb); 121633e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 121733e882a5SSuraj Sumangala return -ENOMEM; 121833e882a5SSuraj Sumangala } 121933e882a5SSuraj Sumangala } 122033e882a5SSuraj Sumangala break; 122133e882a5SSuraj Sumangala } 122233e882a5SSuraj Sumangala 122333e882a5SSuraj Sumangala if (scb->expect == 0) { 122433e882a5SSuraj Sumangala /* Complete frame */ 122533e882a5SSuraj Sumangala 122633e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 122733e882a5SSuraj Sumangala hci_recv_frame(skb); 122833e882a5SSuraj Sumangala 122933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 123033e882a5SSuraj Sumangala return remain; 123133e882a5SSuraj Sumangala } 123233e882a5SSuraj Sumangala } 123333e882a5SSuraj Sumangala 123433e882a5SSuraj Sumangala return remain; 123533e882a5SSuraj Sumangala } 123633e882a5SSuraj Sumangala 1237ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1238ef222013SMarcel Holtmann { 1239f39a3c06SSuraj Sumangala int rem = 0; 1240f39a3c06SSuraj Sumangala 1241ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1242ef222013SMarcel Holtmann return -EILSEQ; 1243ef222013SMarcel Holtmann 1244da5f6c37SGustavo F. Padovan while (count) { 1245f39a3c06SSuraj Sumangala rem = hci_reassembly(hdev, type, data, count, 1246f39a3c06SSuraj Sumangala type - 1, GFP_ATOMIC); 1247f39a3c06SSuraj Sumangala if (rem < 0) 1248f39a3c06SSuraj Sumangala return rem; 1249ef222013SMarcel Holtmann 1250f39a3c06SSuraj Sumangala data += (count - rem); 1251f39a3c06SSuraj Sumangala count = rem; 1252da5f6c37SGustavo F. Padovan }; 1253ef222013SMarcel Holtmann 1254f39a3c06SSuraj Sumangala return rem; 1255ef222013SMarcel Holtmann } 1256ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1257ef222013SMarcel Holtmann 125899811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 125999811510SSuraj Sumangala 126099811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 126199811510SSuraj Sumangala { 126299811510SSuraj Sumangala int type; 126399811510SSuraj Sumangala int rem = 0; 126499811510SSuraj Sumangala 1265da5f6c37SGustavo F. Padovan while (count) { 126699811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 126799811510SSuraj Sumangala 126899811510SSuraj Sumangala if (!skb) { 126999811510SSuraj Sumangala struct { char type; } *pkt; 127099811510SSuraj Sumangala 127199811510SSuraj Sumangala /* Start of the frame */ 127299811510SSuraj Sumangala pkt = data; 127399811510SSuraj Sumangala type = pkt->type; 127499811510SSuraj Sumangala 127599811510SSuraj Sumangala data++; 127699811510SSuraj Sumangala count--; 127799811510SSuraj Sumangala } else 127899811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 127999811510SSuraj Sumangala 128099811510SSuraj Sumangala rem = hci_reassembly(hdev, type, data, 128199811510SSuraj Sumangala count, STREAM_REASSEMBLY, GFP_ATOMIC); 128299811510SSuraj Sumangala if (rem < 0) 128399811510SSuraj Sumangala return rem; 128499811510SSuraj Sumangala 128599811510SSuraj Sumangala data += (count - rem); 128699811510SSuraj Sumangala count = rem; 1287da5f6c37SGustavo F. Padovan }; 128899811510SSuraj Sumangala 128999811510SSuraj Sumangala return rem; 129099811510SSuraj Sumangala } 129199811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 129299811510SSuraj Sumangala 12931da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 12941da177e4SLinus Torvalds 12951da177e4SLinus Torvalds /* Register/Unregister protocols. 12961da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 12971da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 12981da177e4SLinus Torvalds { 12991da177e4SLinus Torvalds int err = 0; 13001da177e4SLinus Torvalds 13011da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 13021da177e4SLinus Torvalds 13031da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 13041da177e4SLinus Torvalds return -EINVAL; 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds if (!hci_proto[hp->id]) 13091da177e4SLinus Torvalds hci_proto[hp->id] = hp; 13101da177e4SLinus Torvalds else 13111da177e4SLinus Torvalds err = -EEXIST; 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 13141da177e4SLinus Torvalds 13151da177e4SLinus Torvalds return err; 13161da177e4SLinus Torvalds } 13171da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 13181da177e4SLinus Torvalds 13191da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 13201da177e4SLinus Torvalds { 13211da177e4SLinus Torvalds int err = 0; 13221da177e4SLinus Torvalds 13231da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 13261da177e4SLinus Torvalds return -EINVAL; 13271da177e4SLinus Torvalds 13281da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds if (hci_proto[hp->id]) 13311da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 13321da177e4SLinus Torvalds else 13331da177e4SLinus Torvalds err = -ENOENT; 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 13361da177e4SLinus Torvalds 13371da177e4SLinus Torvalds return err; 13381da177e4SLinus Torvalds } 13391da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 13421da177e4SLinus Torvalds { 13431da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 13461da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 13471da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds return 0; 13501da177e4SLinus Torvalds } 13511da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 13521da177e4SLinus Torvalds 13531da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 13541da177e4SLinus Torvalds { 13551da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 13581da177e4SLinus Torvalds list_del(&cb->list); 13591da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 13601da177e4SLinus Torvalds 13611da177e4SLinus Torvalds return 0; 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 13661da177e4SLinus Torvalds { 13671da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds if (!hdev) { 13701da177e4SLinus Torvalds kfree_skb(skb); 13711da177e4SLinus Torvalds return -ENODEV; 13721da177e4SLinus Torvalds } 13731da177e4SLinus Torvalds 13740d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 13751da177e4SLinus Torvalds 13761da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 13771da177e4SLinus Torvalds /* Time stamp */ 1378a61bbcf2SPatrick McHardy __net_timestamp(skb); 13791da177e4SLinus Torvalds 13801da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 13811da177e4SLinus Torvalds } 13821da177e4SLinus Torvalds 13831da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 13841da177e4SLinus Torvalds skb_orphan(skb); 13851da177e4SLinus Torvalds 13861da177e4SLinus Torvalds return hdev->send(skb); 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds /* Send HCI command */ 1390a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 13911da177e4SLinus Torvalds { 13921da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 13931da177e4SLinus Torvalds struct hci_command_hdr *hdr; 13941da177e4SLinus Torvalds struct sk_buff *skb; 13951da177e4SLinus Torvalds 1396a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 13991da177e4SLinus Torvalds if (!skb) { 1400ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 14011da177e4SLinus Torvalds return -ENOMEM; 14021da177e4SLinus Torvalds } 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1405a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 14061da177e4SLinus Torvalds hdr->plen = plen; 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds if (plen) 14091da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 14121da177e4SLinus Torvalds 14130d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 14141da177e4SLinus Torvalds skb->dev = (void *) hdev; 1415c78ae283SMarcel Holtmann 14161da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1417c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds return 0; 14201da177e4SLinus Torvalds } 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds /* Get data from the previously sent command */ 1423a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 14241da177e4SLinus Torvalds { 14251da177e4SLinus Torvalds struct hci_command_hdr *hdr; 14261da177e4SLinus Torvalds 14271da177e4SLinus Torvalds if (!hdev->sent_cmd) 14281da177e4SLinus Torvalds return NULL; 14291da177e4SLinus Torvalds 14301da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 14311da177e4SLinus Torvalds 1432a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 14331da177e4SLinus Torvalds return NULL; 14341da177e4SLinus Torvalds 1435a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 14381da177e4SLinus Torvalds } 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds /* Send ACL data */ 14411da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 14421da177e4SLinus Torvalds { 14431da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 14441da177e4SLinus Torvalds int len = skb->len; 14451da177e4SLinus Torvalds 1446badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1447badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 14489c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1449aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1450aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 14511da177e4SLinus Torvalds } 14521da177e4SLinus Torvalds 14539a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 14541da177e4SLinus Torvalds { 14551da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 14561da177e4SLinus Torvalds struct sk_buff *list; 14571da177e4SLinus Torvalds 14581da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds skb->dev = (void *) hdev; 14610d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1462e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 14631da177e4SLinus Torvalds 146470f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 146570f23020SAndrei Emeltchenko if (!list) { 14661da177e4SLinus Torvalds /* Non fragmented */ 14671da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 14681da177e4SLinus Torvalds 14691da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 14701da177e4SLinus Torvalds } else { 14711da177e4SLinus Torvalds /* Fragmented */ 14721da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 14751da177e4SLinus Torvalds 14761da177e4SLinus Torvalds /* Queue all fragments atomically */ 14771da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1480e702112fSAndrei Emeltchenko 1481e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1482e702112fSAndrei Emeltchenko flags |= ACL_CONT; 14831da177e4SLinus Torvalds do { 14841da177e4SLinus Torvalds skb = list; list = list->next; 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds skb->dev = (void *) hdev; 14870d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1488e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 14931da177e4SLinus Torvalds } while (list); 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 14961da177e4SLinus Torvalds } 14971da177e4SLinus Torvalds 1498c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 14991da177e4SLinus Torvalds } 15001da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds /* Send SCO data */ 15030d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 15041da177e4SLinus Torvalds { 15051da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 15061da177e4SLinus Torvalds struct hci_sco_hdr hdr; 15071da177e4SLinus Torvalds 15081da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 15091da177e4SLinus Torvalds 1510aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 15111da177e4SLinus Torvalds hdr.dlen = skb->len; 15121da177e4SLinus Torvalds 1513badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1514badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 15159c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds skb->dev = (void *) hdev; 15180d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1519c78ae283SMarcel Holtmann 15201da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1521c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 15221da177e4SLinus Torvalds } 15231da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 15241da177e4SLinus Torvalds 15251da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds /* HCI Connection scheduler */ 15281da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 15291da177e4SLinus Torvalds { 15301da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 15311da177e4SLinus Torvalds struct hci_conn *conn = NULL; 15321da177e4SLinus Torvalds int num = 0, min = ~0; 15331da177e4SLinus Torvalds struct list_head *p; 15341da177e4SLinus Torvalds 15351da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 15361da177e4SLinus Torvalds * added and removed with TX task disabled. */ 15371da177e4SLinus Torvalds list_for_each(p, &h->list) { 15381da177e4SLinus Torvalds struct hci_conn *c; 15391da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 15401da177e4SLinus Torvalds 1541769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 15421da177e4SLinus Torvalds continue; 1543769be974SMarcel Holtmann 1544769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1545769be974SMarcel Holtmann continue; 1546769be974SMarcel Holtmann 15471da177e4SLinus Torvalds num++; 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds if (c->sent < min) { 15501da177e4SLinus Torvalds min = c->sent; 15511da177e4SLinus Torvalds conn = c; 15521da177e4SLinus Torvalds } 15531da177e4SLinus Torvalds } 15541da177e4SLinus Torvalds 15551da177e4SLinus Torvalds if (conn) { 15561da177e4SLinus Torvalds int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt); 15571da177e4SLinus Torvalds int q = cnt / num; 15581da177e4SLinus Torvalds *quote = q ? q : 1; 15591da177e4SLinus Torvalds } else 15601da177e4SLinus Torvalds *quote = 0; 15611da177e4SLinus Torvalds 15621da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 15631da177e4SLinus Torvalds return conn; 15641da177e4SLinus Torvalds } 15651da177e4SLinus Torvalds 15661da177e4SLinus Torvalds static inline void hci_acl_tx_to(struct hci_dev *hdev) 15671da177e4SLinus Torvalds { 15681da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 15691da177e4SLinus Torvalds struct list_head *p; 15701da177e4SLinus Torvalds struct hci_conn *c; 15711da177e4SLinus Torvalds 15721da177e4SLinus Torvalds BT_ERR("%s ACL tx timeout", hdev->name); 15731da177e4SLinus Torvalds 15741da177e4SLinus Torvalds /* Kill stalled connections */ 15751da177e4SLinus Torvalds list_for_each(p, &h->list) { 15761da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 15771da177e4SLinus Torvalds if (c->type == ACL_LINK && c->sent) { 15781da177e4SLinus Torvalds BT_ERR("%s killing stalled ACL connection %s", 15791da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 15801da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 15811da177e4SLinus Torvalds } 15821da177e4SLinus Torvalds } 15831da177e4SLinus Torvalds } 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 15861da177e4SLinus Torvalds { 15871da177e4SLinus Torvalds struct hci_conn *conn; 15881da177e4SLinus Torvalds struct sk_buff *skb; 15891da177e4SLinus Torvalds int quote; 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 15941da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 15951da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 159682453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 15971da177e4SLinus Torvalds hci_acl_tx_to(hdev); 15981da177e4SLinus Torvalds } 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 16011da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 16021da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 160304837f64SMarcel Holtmann 160404837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 160504837f64SMarcel Holtmann 16061da177e4SLinus Torvalds hci_send_frame(skb); 16071da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds hdev->acl_cnt--; 16101da177e4SLinus Torvalds conn->sent++; 16111da177e4SLinus Torvalds } 16121da177e4SLinus Torvalds } 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds /* Schedule SCO */ 16161da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 16171da177e4SLinus Torvalds { 16181da177e4SLinus Torvalds struct hci_conn *conn; 16191da177e4SLinus Torvalds struct sk_buff *skb; 16201da177e4SLinus Torvalds int quote; 16211da177e4SLinus Torvalds 16221da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 16231da177e4SLinus Torvalds 16241da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 16251da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 16261da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 16271da177e4SLinus Torvalds hci_send_frame(skb); 16281da177e4SLinus Torvalds 16291da177e4SLinus Torvalds conn->sent++; 16301da177e4SLinus Torvalds if (conn->sent == ~0) 16311da177e4SLinus Torvalds conn->sent = 0; 16321da177e4SLinus Torvalds } 16331da177e4SLinus Torvalds } 16341da177e4SLinus Torvalds } 16351da177e4SLinus Torvalds 1636b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1637b6a0dc82SMarcel Holtmann { 1638b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1639b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1640b6a0dc82SMarcel Holtmann int quote; 1641b6a0dc82SMarcel Holtmann 1642b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1643b6a0dc82SMarcel Holtmann 1644b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1645b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1646b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1647b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1648b6a0dc82SMarcel Holtmann 1649b6a0dc82SMarcel Holtmann conn->sent++; 1650b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1651b6a0dc82SMarcel Holtmann conn->sent = 0; 1652b6a0dc82SMarcel Holtmann } 1653b6a0dc82SMarcel Holtmann } 1654b6a0dc82SMarcel Holtmann } 1655b6a0dc82SMarcel Holtmann 16561da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 16571da177e4SLinus Torvalds { 16581da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 16591da177e4SLinus Torvalds struct sk_buff *skb; 16601da177e4SLinus Torvalds 16611da177e4SLinus Torvalds read_lock(&hci_task_lock); 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt); 16641da177e4SLinus Torvalds 16651da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 16661da177e4SLinus Torvalds 16671da177e4SLinus Torvalds hci_sched_acl(hdev); 16681da177e4SLinus Torvalds 16691da177e4SLinus Torvalds hci_sched_sco(hdev); 16701da177e4SLinus Torvalds 1671b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1672b6a0dc82SMarcel Holtmann 16731da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 16741da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 16751da177e4SLinus Torvalds hci_send_frame(skb); 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds read_unlock(&hci_task_lock); 16781da177e4SLinus Torvalds } 16791da177e4SLinus Torvalds 16801da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 16811da177e4SLinus Torvalds 16821da177e4SLinus Torvalds /* ACL data packet */ 16831da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 16841da177e4SLinus Torvalds { 16851da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 16861da177e4SLinus Torvalds struct hci_conn *conn; 16871da177e4SLinus Torvalds __u16 handle, flags; 16881da177e4SLinus Torvalds 16891da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 16901da177e4SLinus Torvalds 16911da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 16921da177e4SLinus Torvalds flags = hci_flags(handle); 16931da177e4SLinus Torvalds handle = hci_handle(handle); 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds hdev->stat.acl_rx++; 16981da177e4SLinus Torvalds 16991da177e4SLinus Torvalds hci_dev_lock(hdev); 17001da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 17011da177e4SLinus Torvalds hci_dev_unlock(hdev); 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds if (conn) { 17041da177e4SLinus Torvalds register struct hci_proto *hp; 17051da177e4SLinus Torvalds 170604837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 170704837f64SMarcel Holtmann 17081da177e4SLinus Torvalds /* Send to upper protocol */ 170970f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 171070f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 17111da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 17121da177e4SLinus Torvalds return; 17131da177e4SLinus Torvalds } 17141da177e4SLinus Torvalds } else { 17151da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 17161da177e4SLinus Torvalds hdev->name, handle); 17171da177e4SLinus Torvalds } 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds kfree_skb(skb); 17201da177e4SLinus Torvalds } 17211da177e4SLinus Torvalds 17221da177e4SLinus Torvalds /* SCO data packet */ 17231da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 17241da177e4SLinus Torvalds { 17251da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 17261da177e4SLinus Torvalds struct hci_conn *conn; 17271da177e4SLinus Torvalds __u16 handle; 17281da177e4SLinus Torvalds 17291da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 17321da177e4SLinus Torvalds 17331da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 17341da177e4SLinus Torvalds 17351da177e4SLinus Torvalds hdev->stat.sco_rx++; 17361da177e4SLinus Torvalds 17371da177e4SLinus Torvalds hci_dev_lock(hdev); 17381da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 17391da177e4SLinus Torvalds hci_dev_unlock(hdev); 17401da177e4SLinus Torvalds 17411da177e4SLinus Torvalds if (conn) { 17421da177e4SLinus Torvalds register struct hci_proto *hp; 17431da177e4SLinus Torvalds 17441da177e4SLinus Torvalds /* Send to upper protocol */ 174570f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 174670f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 17471da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 17481da177e4SLinus Torvalds return; 17491da177e4SLinus Torvalds } 17501da177e4SLinus Torvalds } else { 17511da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 17521da177e4SLinus Torvalds hdev->name, handle); 17531da177e4SLinus Torvalds } 17541da177e4SLinus Torvalds 17551da177e4SLinus Torvalds kfree_skb(skb); 17561da177e4SLinus Torvalds } 17571da177e4SLinus Torvalds 17586516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 17591da177e4SLinus Torvalds { 17601da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 17611da177e4SLinus Torvalds struct sk_buff *skb; 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17641da177e4SLinus Torvalds 17651da177e4SLinus Torvalds read_lock(&hci_task_lock); 17661da177e4SLinus Torvalds 17671da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 17681da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 17691da177e4SLinus Torvalds /* Send copy to the sockets */ 17701da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 17711da177e4SLinus Torvalds } 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 17741da177e4SLinus Torvalds kfree_skb(skb); 17751da177e4SLinus Torvalds continue; 17761da177e4SLinus Torvalds } 17771da177e4SLinus Torvalds 17781da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 17791da177e4SLinus Torvalds /* Don't process data packets in this states. */ 17800d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 17811da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 17821da177e4SLinus Torvalds case HCI_SCODATA_PKT: 17831da177e4SLinus Torvalds kfree_skb(skb); 17841da177e4SLinus Torvalds continue; 17853ff50b79SStephen Hemminger } 17861da177e4SLinus Torvalds } 17871da177e4SLinus Torvalds 17881da177e4SLinus Torvalds /* Process frame */ 17890d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 17901da177e4SLinus Torvalds case HCI_EVENT_PKT: 17911da177e4SLinus Torvalds hci_event_packet(hdev, skb); 17921da177e4SLinus Torvalds break; 17931da177e4SLinus Torvalds 17941da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 17951da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 17961da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 17971da177e4SLinus Torvalds break; 17981da177e4SLinus Torvalds 17991da177e4SLinus Torvalds case HCI_SCODATA_PKT: 18001da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 18011da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 18021da177e4SLinus Torvalds break; 18031da177e4SLinus Torvalds 18041da177e4SLinus Torvalds default: 18051da177e4SLinus Torvalds kfree_skb(skb); 18061da177e4SLinus Torvalds break; 18071da177e4SLinus Torvalds } 18081da177e4SLinus Torvalds } 18091da177e4SLinus Torvalds 18101da177e4SLinus Torvalds read_unlock(&hci_task_lock); 18111da177e4SLinus Torvalds } 18121da177e4SLinus Torvalds 18131da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 18141da177e4SLinus Torvalds { 18151da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 18161da177e4SLinus Torvalds struct sk_buff *skb; 18171da177e4SLinus Torvalds 18181da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 18191da177e4SLinus Torvalds 182082453021SS.Çağlar Onur if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) { 18211da177e4SLinus Torvalds BT_ERR("%s command tx timeout", hdev->name); 18221da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18231da177e4SLinus Torvalds } 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds /* Send queued commands */ 18261da177e4SLinus Torvalds if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) { 18271da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 18281da177e4SLinus Torvalds 182970f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 183070f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 18311da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 18321da177e4SLinus Torvalds hci_send_frame(skb); 18331da177e4SLinus Torvalds hdev->cmd_last_tx = jiffies; 18341da177e4SLinus Torvalds } else { 18351da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 1836c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 18371da177e4SLinus Torvalds } 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds } 1840