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> 471da177e4SLinus Torvalds #include <asm/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 531da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg); 541da177e4SLinus Torvalds static void hci_rx_task(unsigned long arg); 551da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg); 561da177e4SLinus Torvalds static void hci_notify(struct hci_dev *hdev, int event); 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds static DEFINE_RWLOCK(hci_task_lock); 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds /* HCI device list */ 611da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 621da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds /* HCI callback list */ 651da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 661da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds /* HCI protocols */ 691da177e4SLinus Torvalds #define HCI_MAX_PROTO 2 701da177e4SLinus Torvalds struct hci_proto *hci_proto[HCI_MAX_PROTO]; 711da177e4SLinus Torvalds 721da177e4SLinus Torvalds /* HCI notifiers list */ 73e041c683SAlan Stern static ATOMIC_NOTIFIER_HEAD(hci_notifier); 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds int hci_register_notifier(struct notifier_block *nb) 781da177e4SLinus Torvalds { 79e041c683SAlan Stern return atomic_notifier_chain_register(&hci_notifier, nb); 801da177e4SLinus Torvalds } 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds int hci_unregister_notifier(struct notifier_block *nb) 831da177e4SLinus Torvalds { 84e041c683SAlan Stern return atomic_notifier_chain_unregister(&hci_notifier, nb); 851da177e4SLinus Torvalds } 861da177e4SLinus Torvalds 876516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 881da177e4SLinus Torvalds { 89e041c683SAlan Stern atomic_notifier_call_chain(&hci_notifier, event, hdev); 901da177e4SLinus Torvalds } 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds /* ---- HCI requests ---- */ 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds void hci_req_complete(struct hci_dev *hdev, int result) 951da177e4SLinus Torvalds { 961da177e4SLinus Torvalds BT_DBG("%s result 0x%2.2x", hdev->name, result); 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 991da177e4SLinus Torvalds hdev->req_result = result; 1001da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1011da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1021da177e4SLinus Torvalds } 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1061da177e4SLinus Torvalds { 1071da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1101da177e4SLinus Torvalds hdev->req_result = err; 1111da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1121da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1131da177e4SLinus Torvalds } 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds /* Execute request and wait for completion. */ 1171da177e4SLinus Torvalds static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1181da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1191da177e4SLinus Torvalds { 1201da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1211da177e4SLinus Torvalds int err = 0; 1221da177e4SLinus Torvalds 1231da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds add_wait_queue(&hdev->req_wait_q, &wait); 1281da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds req(hdev, opt); 1311da177e4SLinus Torvalds schedule_timeout(timeout); 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds if (signal_pending(current)) 1361da177e4SLinus Torvalds return -EINTR; 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds switch (hdev->req_status) { 1391da177e4SLinus Torvalds case HCI_REQ_DONE: 1401da177e4SLinus Torvalds err = -bt_err(hdev->req_result); 1411da177e4SLinus Torvalds break; 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds case HCI_REQ_CANCELED: 1441da177e4SLinus Torvalds err = -hdev->req_result; 1451da177e4SLinus Torvalds break; 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds default: 1481da177e4SLinus Torvalds err = -ETIMEDOUT; 1491da177e4SLinus Torvalds break; 1503ff50b79SStephen Hemminger } 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds hdev->req_status = hdev->req_result = 0; 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds return err; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1601da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1611da177e4SLinus Torvalds { 1621da177e4SLinus Torvalds int ret; 1631da177e4SLinus Torvalds 1647c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 1657c6a329eSMarcel Holtmann return -ENETDOWN; 1667c6a329eSMarcel Holtmann 1671da177e4SLinus Torvalds /* Serialize all requests */ 1681da177e4SLinus Torvalds hci_req_lock(hdev); 1691da177e4SLinus Torvalds ret = __hci_request(hdev, req, opt, timeout); 1701da177e4SLinus Torvalds hci_req_unlock(hdev); 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds return ret; 1731da177e4SLinus Torvalds } 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds static void hci_reset_req(struct hci_dev *hdev, unsigned long opt) 1761da177e4SLinus Torvalds { 1771da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds /* Reset device */ 180a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds struct sk_buff *skb; 1861ebb9252SMarcel Holtmann __le16 param; 18789f2783dSMarcel Holtmann __u8 flt_type; 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds /* Driver initialization */ 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds /* Special commands */ 1941da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 1950d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 1961da177e4SLinus Torvalds skb->dev = (void *) hdev; 197c78ae283SMarcel Holtmann 1981da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 199c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /* Mandatory initialization */ 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds /* Reset */ 2067a9d4020SMarcel Holtmann if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) 207a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds /* Read Local Supported Features */ 210a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2111da177e4SLinus Torvalds 2121143e5a6SMarcel Holtmann /* Read Local Version */ 213a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2141143e5a6SMarcel Holtmann 2151da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 216a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds #if 0 2191da177e4SLinus Torvalds /* Host buffer size */ 2201da177e4SLinus Torvalds { 2211da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 222aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2231da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 224aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 225aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 226a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2271da177e4SLinus Torvalds } 2281da177e4SLinus Torvalds #endif 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds /* Read BD Address */ 231a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 232a9de9248SMarcel Holtmann 233a9de9248SMarcel Holtmann /* Read Class of Device */ 234a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 235a9de9248SMarcel Holtmann 236a9de9248SMarcel Holtmann /* Read Local Name */ 237a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds /* Read Voice Setting */ 240a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds /* Optional initialization */ 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds /* Clear Event Filters */ 24589f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 246a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds /* Page timeout ~20 secs */ 249aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x8000); 250a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_PG_TIMEOUT, 2, ¶m); 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 253aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 254a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 2551da177e4SLinus Torvalds } 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2581da177e4SLinus Torvalds { 2591da177e4SLinus Torvalds __u8 scan = opt; 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2621da177e4SLinus Torvalds 2631da177e4SLinus Torvalds /* Inquiry and Page scans */ 264a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2681da177e4SLinus Torvalds { 2691da177e4SLinus Torvalds __u8 auth = opt; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds /* Authentication */ 274a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2751da177e4SLinus Torvalds } 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2781da177e4SLinus Torvalds { 2791da177e4SLinus Torvalds __u8 encrypt = opt; 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 2821da177e4SLinus Torvalds 283e4e8e37cSMarcel Holtmann /* Encryption */ 284a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds 287e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 288e4e8e37cSMarcel Holtmann { 289e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 290e4e8e37cSMarcel Holtmann 291a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 292e4e8e37cSMarcel Holtmann 293e4e8e37cSMarcel Holtmann /* Default link policy */ 294e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 295e4e8e37cSMarcel Holtmann } 296e4e8e37cSMarcel Holtmann 2971da177e4SLinus Torvalds /* Get HCI device by index. 2981da177e4SLinus Torvalds * Device is held on return. */ 2991da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3001da177e4SLinus Torvalds { 3011da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3021da177e4SLinus Torvalds struct list_head *p; 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds BT_DBG("%d", index); 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds if (index < 0) 3071da177e4SLinus Torvalds return NULL; 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3101da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3111da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3121da177e4SLinus Torvalds if (d->id == index) { 3131da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3141da177e4SLinus Torvalds break; 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3181da177e4SLinus Torvalds return hdev; 3191da177e4SLinus Torvalds } 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3221da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3231da177e4SLinus Torvalds { 3241da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3251da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds cache->list = NULL; 3301da177e4SLinus Torvalds while ((e = next)) { 3311da177e4SLinus Torvalds next = e->next; 3321da177e4SLinus Torvalds kfree(e); 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds } 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3371da177e4SLinus Torvalds { 3381da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3391da177e4SLinus Torvalds struct inquiry_entry *e; 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3441da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3451da177e4SLinus Torvalds break; 3461da177e4SLinus Torvalds return e; 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3501da177e4SLinus Torvalds { 3511da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3521da177e4SLinus Torvalds struct inquiry_entry *e; 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds if (!(e = hci_inquiry_cache_lookup(hdev, &data->bdaddr))) { 3571da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 35825ea6db0SMarcel Holtmann if (!(e = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC))) 3591da177e4SLinus Torvalds return; 3601da177e4SLinus Torvalds e->next = cache->list; 3611da177e4SLinus Torvalds cache->list = e; 3621da177e4SLinus Torvalds } 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds memcpy(&e->data, data, sizeof(*data)); 3651da177e4SLinus Torvalds e->timestamp = jiffies; 3661da177e4SLinus Torvalds cache->timestamp = jiffies; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3701da177e4SLinus Torvalds { 3711da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3721da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3731da177e4SLinus Torvalds struct inquiry_entry *e; 3741da177e4SLinus Torvalds int copied = 0; 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 3771da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 3781da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 3791da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 3801da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 3811da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 3821da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 3831da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 3841da177e4SLinus Torvalds info++; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 3881da177e4SLinus Torvalds return copied; 3891da177e4SLinus Torvalds } 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 3921da177e4SLinus Torvalds { 3931da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 3941da177e4SLinus Torvalds struct hci_cp_inquiry cp; 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 3991da177e4SLinus Torvalds return; 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds /* Start Inquiry */ 4021da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4031da177e4SLinus Torvalds cp.length = ir->length; 4041da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 405a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4061da177e4SLinus Torvalds } 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4091da177e4SLinus Torvalds { 4101da177e4SLinus Torvalds __u8 __user *ptr = arg; 4111da177e4SLinus Torvalds struct hci_inquiry_req ir; 4121da177e4SLinus Torvalds struct hci_dev *hdev; 4131da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4141da177e4SLinus Torvalds long timeo; 4151da177e4SLinus Torvalds __u8 *buf; 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4181da177e4SLinus Torvalds return -EFAULT; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds if (!(hdev = hci_dev_get(ir.dev_id))) 4211da177e4SLinus Torvalds return -ENODEV; 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4241da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4251da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4261da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4271da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4281da177e4SLinus Torvalds do_inquiry = 1; 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4311da177e4SLinus Torvalds 43204837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 4331da177e4SLinus Torvalds if (do_inquiry && (err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo)) < 0) 4341da177e4SLinus Torvalds goto done; 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4371da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4401da177e4SLinus Torvalds * copy it to the user space. 4411da177e4SLinus Torvalds */ 4421da177e4SLinus Torvalds if (!(buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL))) { 4431da177e4SLinus Torvalds err = -ENOMEM; 4441da177e4SLinus Torvalds goto done; 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4481da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4491da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4521da177e4SLinus Torvalds 4531da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4541da177e4SLinus Torvalds ptr += sizeof(ir); 4551da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4561da177e4SLinus Torvalds ir.num_rsp)) 4571da177e4SLinus Torvalds err = -EFAULT; 4581da177e4SLinus Torvalds } else 4591da177e4SLinus Torvalds err = -EFAULT; 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds kfree(buf); 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds done: 4641da177e4SLinus Torvalds hci_dev_put(hdev); 4651da177e4SLinus Torvalds return err; 4661da177e4SLinus Torvalds } 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 4711da177e4SLinus Torvalds { 4721da177e4SLinus Torvalds struct hci_dev *hdev; 4731da177e4SLinus Torvalds int ret = 0; 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 4761da177e4SLinus Torvalds return -ENODEV; 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds hci_req_lock(hdev); 4811da177e4SLinus Torvalds 482611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 483611b30f7SMarcel Holtmann ret = -ERFKILL; 484611b30f7SMarcel Holtmann goto done; 485611b30f7SMarcel Holtmann } 486611b30f7SMarcel Holtmann 4871da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 4881da177e4SLinus Torvalds ret = -EALREADY; 4891da177e4SLinus Torvalds goto done; 4901da177e4SLinus Torvalds } 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 4931da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 4941da177e4SLinus Torvalds 495943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 496943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 497943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 498943da25dSMarcel Holtmann 4991da177e4SLinus Torvalds if (hdev->open(hdev)) { 5001da177e4SLinus Torvalds ret = -EIO; 5011da177e4SLinus Torvalds goto done; 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5051da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5061da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds //__hci_request(hdev, hci_reset_req, 0, HZ); 50904837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 51004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds if (!ret) { 5161da177e4SLinus Torvalds hci_dev_hold(hdev); 5171da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5181da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5191da177e4SLinus Torvalds } else { 5201da177e4SLinus Torvalds /* Init failed, cleanup */ 5211da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5221da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5231da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5261da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds if (hdev->flush) 5291da177e4SLinus Torvalds hdev->flush(hdev); 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds if (hdev->sent_cmd) { 5321da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5331da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds hdev->close(hdev); 5371da177e4SLinus Torvalds hdev->flags = 0; 5381da177e4SLinus Torvalds } 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds done: 5411da177e4SLinus Torvalds hci_req_unlock(hdev); 5421da177e4SLinus Torvalds hci_dev_put(hdev); 5431da177e4SLinus Torvalds return ret; 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5471da177e4SLinus Torvalds { 5481da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5511da177e4SLinus Torvalds hci_req_lock(hdev); 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 5541da177e4SLinus Torvalds hci_req_unlock(hdev); 5551da177e4SLinus Torvalds return 0; 5561da177e4SLinus Torvalds } 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5591da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5601da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 5631da177e4SLinus Torvalds inquiry_cache_flush(hdev); 5641da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 565f0358568SJohan Hedberg hci_blacklist_clear(hdev); 5661da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 5671da177e4SLinus Torvalds 5681da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds if (hdev->flush) 5711da177e4SLinus Torvalds hdev->flush(hdev); 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds /* Reset device */ 5741da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5751da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5761da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5771da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 57804837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 57904837f64SMarcel Holtmann msecs_to_jiffies(250)); 5801da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds /* Kill cmd task */ 5841da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds /* Drop queues */ 5871da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5881da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5891da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds /* Drop last sent command */ 5921da177e4SLinus Torvalds if (hdev->sent_cmd) { 5931da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5941da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds /* After this point our queues are empty 5981da177e4SLinus Torvalds * and no tasks are scheduled. */ 5991da177e4SLinus Torvalds hdev->close(hdev); 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds /* Clear flags */ 6021da177e4SLinus Torvalds hdev->flags = 0; 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds hci_req_unlock(hdev); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds hci_dev_put(hdev); 6071da177e4SLinus Torvalds return 0; 6081da177e4SLinus Torvalds } 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6111da177e4SLinus Torvalds { 6121da177e4SLinus Torvalds struct hci_dev *hdev; 6131da177e4SLinus Torvalds int err; 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6161da177e4SLinus Torvalds return -ENODEV; 6171da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6181da177e4SLinus Torvalds hci_dev_put(hdev); 6191da177e4SLinus Torvalds return err; 6201da177e4SLinus Torvalds } 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6231da177e4SLinus Torvalds { 6241da177e4SLinus Torvalds struct hci_dev *hdev; 6251da177e4SLinus Torvalds int ret = 0; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6281da177e4SLinus Torvalds return -ENODEV; 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds hci_req_lock(hdev); 6311da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6321da177e4SLinus Torvalds 6331da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6341da177e4SLinus Torvalds goto done; 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds /* Drop queues */ 6371da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6381da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6411da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6421da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6431da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds if (hdev->flush) 6461da177e4SLinus Torvalds hdev->flush(hdev); 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6491da177e4SLinus Torvalds hdev->acl_cnt = 0; hdev->sco_cnt = 0; 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 65204837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 65304837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds done: 6561da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6571da177e4SLinus Torvalds hci_req_unlock(hdev); 6581da177e4SLinus Torvalds hci_dev_put(hdev); 6591da177e4SLinus Torvalds return ret; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 6631da177e4SLinus Torvalds { 6641da177e4SLinus Torvalds struct hci_dev *hdev; 6651da177e4SLinus Torvalds int ret = 0; 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6681da177e4SLinus Torvalds return -ENODEV; 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds hci_dev_put(hdev); 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds return ret; 6751da177e4SLinus Torvalds } 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 6781da177e4SLinus Torvalds { 6791da177e4SLinus Torvalds struct hci_dev *hdev; 6801da177e4SLinus Torvalds struct hci_dev_req dr; 6811da177e4SLinus Torvalds int err = 0; 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 6841da177e4SLinus Torvalds return -EFAULT; 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dr.dev_id))) 6871da177e4SLinus Torvalds return -ENODEV; 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds switch (cmd) { 6901da177e4SLinus Torvalds case HCISETAUTH: 69104837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 69204837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6931da177e4SLinus Torvalds break; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds case HCISETENCRYPT: 6961da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 6971da177e4SLinus Torvalds err = -EOPNOTSUPP; 6981da177e4SLinus Torvalds break; 6991da177e4SLinus Torvalds } 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7021da177e4SLinus Torvalds /* Auth must be enabled first */ 70304837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 70404837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7051da177e4SLinus Torvalds if (err) 7061da177e4SLinus Torvalds break; 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 70904837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 71004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7111da177e4SLinus Torvalds break; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds case HCISETSCAN: 71404837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 71504837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7161da177e4SLinus Torvalds break; 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds case HCISETLINKPOL: 719e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 720e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7211da177e4SLinus Torvalds break; 7221da177e4SLinus Torvalds 7231da177e4SLinus Torvalds case HCISETLINKMODE: 724e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 725e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 726e4e8e37cSMarcel Holtmann break; 727e4e8e37cSMarcel Holtmann 728e4e8e37cSMarcel Holtmann case HCISETPTYPE: 729e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7301da177e4SLinus Torvalds break; 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds case HCISETACLMTU: 7331da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7341da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7351da177e4SLinus Torvalds break; 7361da177e4SLinus Torvalds 7371da177e4SLinus Torvalds case HCISETSCOMTU: 7381da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7391da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7401da177e4SLinus Torvalds break; 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds default: 7431da177e4SLinus Torvalds err = -EINVAL; 7441da177e4SLinus Torvalds break; 7451da177e4SLinus Torvalds } 746e4e8e37cSMarcel Holtmann 7471da177e4SLinus Torvalds hci_dev_put(hdev); 7481da177e4SLinus Torvalds return err; 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7521da177e4SLinus Torvalds { 7531da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7541da177e4SLinus Torvalds struct hci_dev_req *dr; 7551da177e4SLinus Torvalds struct list_head *p; 7561da177e4SLinus Torvalds int n = 0, size, err; 7571da177e4SLinus Torvalds __u16 dev_num; 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 7601da177e4SLinus Torvalds return -EFAULT; 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 7631da177e4SLinus Torvalds return -EINVAL; 7641da177e4SLinus Torvalds 7651da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 7661da177e4SLinus Torvalds 767c6bf514cSVegard Nossum if (!(dl = kzalloc(size, GFP_KERNEL))) 7681da177e4SLinus Torvalds return -ENOMEM; 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds dr = dl->dev_req; 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 7731da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 7741da177e4SLinus Torvalds struct hci_dev *hdev; 7751da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 7761da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 7771da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 7781da177e4SLinus Torvalds if (++n >= dev_num) 7791da177e4SLinus Torvalds break; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds dl->dev_num = n; 7841da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 7871da177e4SLinus Torvalds kfree(dl); 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds return err ? -EFAULT : 0; 7901da177e4SLinus Torvalds } 7911da177e4SLinus Torvalds 7921da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 7931da177e4SLinus Torvalds { 7941da177e4SLinus Torvalds struct hci_dev *hdev; 7951da177e4SLinus Torvalds struct hci_dev_info di; 7961da177e4SLinus Torvalds int err = 0; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 7991da177e4SLinus Torvalds return -EFAULT; 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds if (!(hdev = hci_dev_get(di.dev_id))) 8021da177e4SLinus Torvalds return -ENODEV; 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8051da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 806943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8071da177e4SLinus Torvalds di.flags = hdev->flags; 8081da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8091da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8101da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8111da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8121da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8131da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8141da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8171da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8201da177e4SLinus Torvalds err = -EFAULT; 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds hci_dev_put(hdev); 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds return err; 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8281da177e4SLinus Torvalds 829611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 830611b30f7SMarcel Holtmann { 831611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 832611b30f7SMarcel Holtmann 833611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 834611b30f7SMarcel Holtmann 835611b30f7SMarcel Holtmann if (!blocked) 836611b30f7SMarcel Holtmann return 0; 837611b30f7SMarcel Holtmann 838611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 839611b30f7SMarcel Holtmann 840611b30f7SMarcel Holtmann return 0; 841611b30f7SMarcel Holtmann } 842611b30f7SMarcel Holtmann 843611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 844611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 845611b30f7SMarcel Holtmann }; 846611b30f7SMarcel Holtmann 8471da177e4SLinus Torvalds /* Alloc HCI device */ 8481da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 8491da177e4SLinus Torvalds { 8501da177e4SLinus Torvalds struct hci_dev *hdev; 8511da177e4SLinus Torvalds 85225ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 8531da177e4SLinus Torvalds if (!hdev) 8541da177e4SLinus Torvalds return NULL; 8551da177e4SLinus Torvalds 8561da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 8571da177e4SLinus Torvalds 8581da177e4SLinus Torvalds return hdev; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds /* Free HCI device */ 8631da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 8641da177e4SLinus Torvalds { 8651da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 8661da177e4SLinus Torvalds 867a91f2e39SMarcel Holtmann /* will free via device release */ 868a91f2e39SMarcel Holtmann put_device(&hdev->dev); 8691da177e4SLinus Torvalds } 8701da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 8711da177e4SLinus Torvalds 8721da177e4SLinus Torvalds /* Register HCI device */ 8731da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 8741da177e4SLinus Torvalds { 8751da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 876ef222013SMarcel Holtmann int i, id = 0; 8771da177e4SLinus Torvalds 878c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 879c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 8821da177e4SLinus Torvalds return -EINVAL; 8831da177e4SLinus Torvalds 8841da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 8851da177e4SLinus Torvalds 8861da177e4SLinus Torvalds /* Find first available device id */ 8871da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8881da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 8891da177e4SLinus Torvalds break; 8901da177e4SLinus Torvalds head = p; id++; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 8941da177e4SLinus Torvalds hdev->id = id; 8951da177e4SLinus Torvalds list_add(&hdev->list, head); 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 8981da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds hdev->flags = 0; 9011da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 9025b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 9031da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 9041da177e4SLinus Torvalds 90504837f64SMarcel Holtmann hdev->idle_timeout = 0; 90604837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 90704837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 90804837f64SMarcel Holtmann 9091da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task,(unsigned long) hdev); 9101da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 9111da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 9121da177e4SLinus Torvalds 9131da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 9141da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 9151da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 9161da177e4SLinus Torvalds 917ef222013SMarcel Holtmann for (i = 0; i < 3; i++) 918ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 919ef222013SMarcel Holtmann 9201da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 921a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 9221da177e4SLinus Torvalds 9231da177e4SLinus Torvalds inquiry_cache_init(hdev); 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds hci_conn_hash_init(hdev); 9261da177e4SLinus Torvalds 927f0358568SJohan Hedberg INIT_LIST_HEAD(&hdev->blacklist.list); 928f0358568SJohan Hedberg 9291da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 9301da177e4SLinus Torvalds 9311da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 9341da177e4SLinus Torvalds 935f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 936f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 937f48fd9c8SMarcel Holtmann goto nomem; 938f48fd9c8SMarcel Holtmann 9391da177e4SLinus Torvalds hci_register_sysfs(hdev); 9401da177e4SLinus Torvalds 941611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 942611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 943611b30f7SMarcel Holtmann if (hdev->rfkill) { 944611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 945611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 946611b30f7SMarcel Holtmann hdev->rfkill = NULL; 947611b30f7SMarcel Holtmann } 948611b30f7SMarcel Holtmann } 949611b30f7SMarcel Holtmann 9501da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 9511da177e4SLinus Torvalds 9521da177e4SLinus Torvalds return id; 953f48fd9c8SMarcel Holtmann 954f48fd9c8SMarcel Holtmann nomem: 955f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 956f48fd9c8SMarcel Holtmann list_del(&hdev->list); 957f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 958f48fd9c8SMarcel Holtmann 959f48fd9c8SMarcel Holtmann return -ENOMEM; 9601da177e4SLinus Torvalds } 9611da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 9621da177e4SLinus Torvalds 9631da177e4SLinus Torvalds /* Unregister HCI device */ 9641da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 9651da177e4SLinus Torvalds { 966ef222013SMarcel Holtmann int i; 967ef222013SMarcel Holtmann 968c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 9711da177e4SLinus Torvalds list_del(&hdev->list); 9721da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds hci_dev_do_close(hdev); 9751da177e4SLinus Torvalds 976ef222013SMarcel Holtmann for (i = 0; i < 3; i++) 977ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 978ef222013SMarcel Holtmann 9791da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 9801da177e4SLinus Torvalds 981611b30f7SMarcel Holtmann if (hdev->rfkill) { 982611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 983611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 984611b30f7SMarcel Holtmann } 985611b30f7SMarcel Holtmann 986147e2d59SDave Young hci_unregister_sysfs(hdev); 987147e2d59SDave Young 988f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 989f48fd9c8SMarcel Holtmann 9901da177e4SLinus Torvalds __hci_dev_put(hdev); 991ef222013SMarcel Holtmann 9921da177e4SLinus Torvalds return 0; 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds /* Suspend HCI device */ 9971da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 9981da177e4SLinus Torvalds { 9991da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 10001da177e4SLinus Torvalds return 0; 10011da177e4SLinus Torvalds } 10021da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds /* Resume HCI device */ 10051da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 10061da177e4SLinus Torvalds { 10071da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 10081da177e4SLinus Torvalds return 0; 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 10111da177e4SLinus Torvalds 101276bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 101376bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 101476bca880SMarcel Holtmann { 101576bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 101676bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 101776bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 101876bca880SMarcel Holtmann kfree_skb(skb); 101976bca880SMarcel Holtmann return -ENXIO; 102076bca880SMarcel Holtmann } 102176bca880SMarcel Holtmann 102276bca880SMarcel Holtmann /* Incomming skb */ 102376bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 102476bca880SMarcel Holtmann 102576bca880SMarcel Holtmann /* Time stamp */ 102676bca880SMarcel Holtmann __net_timestamp(skb); 102776bca880SMarcel Holtmann 102876bca880SMarcel Holtmann /* Queue frame for rx task */ 102976bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1030c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1031c78ae283SMarcel Holtmann 103276bca880SMarcel Holtmann return 0; 103376bca880SMarcel Holtmann } 103476bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 103576bca880SMarcel Holtmann 1036ef222013SMarcel Holtmann /* Receive packet type fragment */ 1037ef222013SMarcel Holtmann #define __reassembly(hdev, type) ((hdev)->reassembly[(type) - 2]) 1038ef222013SMarcel Holtmann 1039ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1040ef222013SMarcel Holtmann { 1041ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1042ef222013SMarcel Holtmann return -EILSEQ; 1043ef222013SMarcel Holtmann 1044ef222013SMarcel Holtmann while (count) { 1045ef222013SMarcel Holtmann struct sk_buff *skb = __reassembly(hdev, type); 1046ef222013SMarcel Holtmann struct { int expect; } *scb; 1047ef222013SMarcel Holtmann int len = 0; 1048ef222013SMarcel Holtmann 1049ef222013SMarcel Holtmann if (!skb) { 1050ef222013SMarcel Holtmann /* Start of the frame */ 1051ef222013SMarcel Holtmann 1052ef222013SMarcel Holtmann switch (type) { 1053ef222013SMarcel Holtmann case HCI_EVENT_PKT: 1054ef222013SMarcel Holtmann if (count >= HCI_EVENT_HDR_SIZE) { 1055ef222013SMarcel Holtmann struct hci_event_hdr *h = data; 1056ef222013SMarcel Holtmann len = HCI_EVENT_HDR_SIZE + h->plen; 1057ef222013SMarcel Holtmann } else 1058ef222013SMarcel Holtmann return -EILSEQ; 1059ef222013SMarcel Holtmann break; 1060ef222013SMarcel Holtmann 1061ef222013SMarcel Holtmann case HCI_ACLDATA_PKT: 1062ef222013SMarcel Holtmann if (count >= HCI_ACL_HDR_SIZE) { 1063ef222013SMarcel Holtmann struct hci_acl_hdr *h = data; 1064ef222013SMarcel Holtmann len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen); 1065ef222013SMarcel Holtmann } else 1066ef222013SMarcel Holtmann return -EILSEQ; 1067ef222013SMarcel Holtmann break; 1068ef222013SMarcel Holtmann 1069ef222013SMarcel Holtmann case HCI_SCODATA_PKT: 1070ef222013SMarcel Holtmann if (count >= HCI_SCO_HDR_SIZE) { 1071ef222013SMarcel Holtmann struct hci_sco_hdr *h = data; 1072ef222013SMarcel Holtmann len = HCI_SCO_HDR_SIZE + h->dlen; 1073ef222013SMarcel Holtmann } else 1074ef222013SMarcel Holtmann return -EILSEQ; 1075ef222013SMarcel Holtmann break; 1076ef222013SMarcel Holtmann } 1077ef222013SMarcel Holtmann 1078ef222013SMarcel Holtmann skb = bt_skb_alloc(len, GFP_ATOMIC); 1079ef222013SMarcel Holtmann if (!skb) { 1080ef222013SMarcel Holtmann BT_ERR("%s no memory for packet", hdev->name); 1081ef222013SMarcel Holtmann return -ENOMEM; 1082ef222013SMarcel Holtmann } 1083ef222013SMarcel Holtmann 1084ef222013SMarcel Holtmann skb->dev = (void *) hdev; 1085ef222013SMarcel Holtmann bt_cb(skb)->pkt_type = type; 1086ef222013SMarcel Holtmann 1087ef222013SMarcel Holtmann __reassembly(hdev, type) = skb; 1088ef222013SMarcel Holtmann 1089ef222013SMarcel Holtmann scb = (void *) skb->cb; 1090ef222013SMarcel Holtmann scb->expect = len; 1091ef222013SMarcel Holtmann } else { 1092ef222013SMarcel Holtmann /* Continuation */ 1093ef222013SMarcel Holtmann 1094ef222013SMarcel Holtmann scb = (void *) skb->cb; 1095ef222013SMarcel Holtmann len = scb->expect; 1096ef222013SMarcel Holtmann } 1097ef222013SMarcel Holtmann 1098ef222013SMarcel Holtmann len = min(len, count); 1099ef222013SMarcel Holtmann 1100ef222013SMarcel Holtmann memcpy(skb_put(skb, len), data, len); 1101ef222013SMarcel Holtmann 1102ef222013SMarcel Holtmann scb->expect -= len; 1103ef222013SMarcel Holtmann 1104ef222013SMarcel Holtmann if (scb->expect == 0) { 1105ef222013SMarcel Holtmann /* Complete frame */ 1106ef222013SMarcel Holtmann 1107ef222013SMarcel Holtmann __reassembly(hdev, type) = NULL; 1108ef222013SMarcel Holtmann 1109ef222013SMarcel Holtmann bt_cb(skb)->pkt_type = type; 1110ef222013SMarcel Holtmann hci_recv_frame(skb); 1111ef222013SMarcel Holtmann } 1112ef222013SMarcel Holtmann 1113ef222013SMarcel Holtmann count -= len; data += len; 1114ef222013SMarcel Holtmann } 1115ef222013SMarcel Holtmann 1116ef222013SMarcel Holtmann return 0; 1117ef222013SMarcel Holtmann } 1118ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1119ef222013SMarcel Holtmann 11201da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds /* Register/Unregister protocols. 11231da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 11241da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 11251da177e4SLinus Torvalds { 11261da177e4SLinus Torvalds int err = 0; 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 11311da177e4SLinus Torvalds return -EINVAL; 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds if (!hci_proto[hp->id]) 11361da177e4SLinus Torvalds hci_proto[hp->id] = hp; 11371da177e4SLinus Torvalds else 11381da177e4SLinus Torvalds err = -EEXIST; 11391da177e4SLinus Torvalds 11401da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds return err; 11431da177e4SLinus Torvalds } 11441da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 11471da177e4SLinus Torvalds { 11481da177e4SLinus Torvalds int err = 0; 11491da177e4SLinus Torvalds 11501da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 11531da177e4SLinus Torvalds return -EINVAL; 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 11561da177e4SLinus Torvalds 11571da177e4SLinus Torvalds if (hci_proto[hp->id]) 11581da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 11591da177e4SLinus Torvalds else 11601da177e4SLinus Torvalds err = -ENOENT; 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds return err; 11651da177e4SLinus Torvalds } 11661da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 11671da177e4SLinus Torvalds 11681da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 11691da177e4SLinus Torvalds { 11701da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 11711da177e4SLinus Torvalds 11721da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 11731da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 11741da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 11751da177e4SLinus Torvalds 11761da177e4SLinus Torvalds return 0; 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 11811da177e4SLinus Torvalds { 11821da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 11851da177e4SLinus Torvalds list_del(&cb->list); 11861da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds return 0; 11891da177e4SLinus Torvalds } 11901da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 11931da177e4SLinus Torvalds { 11941da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 11951da177e4SLinus Torvalds 11961da177e4SLinus Torvalds if (!hdev) { 11971da177e4SLinus Torvalds kfree_skb(skb); 11981da177e4SLinus Torvalds return -ENODEV; 11991da177e4SLinus Torvalds } 12001da177e4SLinus Torvalds 12010d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 12041da177e4SLinus Torvalds /* Time stamp */ 1205a61bbcf2SPatrick McHardy __net_timestamp(skb); 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 12081da177e4SLinus Torvalds } 12091da177e4SLinus Torvalds 12101da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 12111da177e4SLinus Torvalds skb_orphan(skb); 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds return hdev->send(skb); 12141da177e4SLinus Torvalds } 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds /* Send HCI command */ 1217a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 12181da177e4SLinus Torvalds { 12191da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 12201da177e4SLinus Torvalds struct hci_command_hdr *hdr; 12211da177e4SLinus Torvalds struct sk_buff *skb; 12221da177e4SLinus Torvalds 1223a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 12241da177e4SLinus Torvalds 12251da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 12261da177e4SLinus Torvalds if (!skb) { 1227ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 12281da177e4SLinus Torvalds return -ENOMEM; 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1232a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 12331da177e4SLinus Torvalds hdr->plen = plen; 12341da177e4SLinus Torvalds 12351da177e4SLinus Torvalds if (plen) 12361da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 12391da177e4SLinus Torvalds 12400d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 12411da177e4SLinus Torvalds skb->dev = (void *) hdev; 1242c78ae283SMarcel Holtmann 12431da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1244c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds return 0; 12471da177e4SLinus Torvalds } 12481da177e4SLinus Torvalds 12491da177e4SLinus Torvalds /* Get data from the previously sent command */ 1250a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 12511da177e4SLinus Torvalds { 12521da177e4SLinus Torvalds struct hci_command_hdr *hdr; 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds if (!hdev->sent_cmd) 12551da177e4SLinus Torvalds return NULL; 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 12581da177e4SLinus Torvalds 1259a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 12601da177e4SLinus Torvalds return NULL; 12611da177e4SLinus Torvalds 1262a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 12651da177e4SLinus Torvalds } 12661da177e4SLinus Torvalds 12671da177e4SLinus Torvalds /* Send ACL data */ 12681da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 12691da177e4SLinus Torvalds { 12701da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 12711da177e4SLinus Torvalds int len = skb->len; 12721da177e4SLinus Torvalds 1273badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1274badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 12759c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1276aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1277aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 12781da177e4SLinus Torvalds } 12791da177e4SLinus Torvalds 12809a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 12811da177e4SLinus Torvalds { 12821da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 12831da177e4SLinus Torvalds struct sk_buff *list; 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds skb->dev = (void *) hdev; 12880d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 12891da177e4SLinus Torvalds hci_add_acl_hdr(skb, conn->handle, flags | ACL_START); 12901da177e4SLinus Torvalds 12911da177e4SLinus Torvalds if (!(list = skb_shinfo(skb)->frag_list)) { 12921da177e4SLinus Torvalds /* Non fragmented */ 12931da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 12941da177e4SLinus Torvalds 12951da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 12961da177e4SLinus Torvalds } else { 12971da177e4SLinus Torvalds /* Fragmented */ 12981da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 13011da177e4SLinus Torvalds 13021da177e4SLinus Torvalds /* Queue all fragments atomically */ 13031da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 13061da177e4SLinus Torvalds do { 13071da177e4SLinus Torvalds skb = list; list = list->next; 13081da177e4SLinus Torvalds 13091da177e4SLinus Torvalds skb->dev = (void *) hdev; 13100d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 13111da177e4SLinus Torvalds hci_add_acl_hdr(skb, conn->handle, flags | ACL_CONT); 13121da177e4SLinus Torvalds 13131da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 13141da177e4SLinus Torvalds 13151da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 13161da177e4SLinus Torvalds } while (list); 13171da177e4SLinus Torvalds 13181da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 13191da177e4SLinus Torvalds } 13201da177e4SLinus Torvalds 1321c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 13221da177e4SLinus Torvalds } 13231da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds /* Send SCO data */ 13260d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 13271da177e4SLinus Torvalds { 13281da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 13291da177e4SLinus Torvalds struct hci_sco_hdr hdr; 13301da177e4SLinus Torvalds 13311da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 13321da177e4SLinus Torvalds 1333aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 13341da177e4SLinus Torvalds hdr.dlen = skb->len; 13351da177e4SLinus Torvalds 1336badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1337badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 13389c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds skb->dev = (void *) hdev; 13410d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1342c78ae283SMarcel Holtmann 13431da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1344c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 13451da177e4SLinus Torvalds } 13461da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 13471da177e4SLinus Torvalds 13481da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 13491da177e4SLinus Torvalds 13501da177e4SLinus Torvalds /* HCI Connection scheduler */ 13511da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 13521da177e4SLinus Torvalds { 13531da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 13541da177e4SLinus Torvalds struct hci_conn *conn = NULL; 13551da177e4SLinus Torvalds int num = 0, min = ~0; 13561da177e4SLinus Torvalds struct list_head *p; 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 13591da177e4SLinus Torvalds * added and removed with TX task disabled. */ 13601da177e4SLinus Torvalds list_for_each(p, &h->list) { 13611da177e4SLinus Torvalds struct hci_conn *c; 13621da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 13631da177e4SLinus Torvalds 1364769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 13651da177e4SLinus Torvalds continue; 1366769be974SMarcel Holtmann 1367769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1368769be974SMarcel Holtmann continue; 1369769be974SMarcel Holtmann 13701da177e4SLinus Torvalds num++; 13711da177e4SLinus Torvalds 13721da177e4SLinus Torvalds if (c->sent < min) { 13731da177e4SLinus Torvalds min = c->sent; 13741da177e4SLinus Torvalds conn = c; 13751da177e4SLinus Torvalds } 13761da177e4SLinus Torvalds } 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds if (conn) { 13791da177e4SLinus Torvalds int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt); 13801da177e4SLinus Torvalds int q = cnt / num; 13811da177e4SLinus Torvalds *quote = q ? q : 1; 13821da177e4SLinus Torvalds } else 13831da177e4SLinus Torvalds *quote = 0; 13841da177e4SLinus Torvalds 13851da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 13861da177e4SLinus Torvalds return conn; 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds static inline void hci_acl_tx_to(struct hci_dev *hdev) 13901da177e4SLinus Torvalds { 13911da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 13921da177e4SLinus Torvalds struct list_head *p; 13931da177e4SLinus Torvalds struct hci_conn *c; 13941da177e4SLinus Torvalds 13951da177e4SLinus Torvalds BT_ERR("%s ACL tx timeout", hdev->name); 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds /* Kill stalled connections */ 13981da177e4SLinus Torvalds list_for_each(p, &h->list) { 13991da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 14001da177e4SLinus Torvalds if (c->type == ACL_LINK && c->sent) { 14011da177e4SLinus Torvalds BT_ERR("%s killing stalled ACL connection %s", 14021da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 14031da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 14041da177e4SLinus Torvalds } 14051da177e4SLinus Torvalds } 14061da177e4SLinus Torvalds } 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 14091da177e4SLinus Torvalds { 14101da177e4SLinus Torvalds struct hci_conn *conn; 14111da177e4SLinus Torvalds struct sk_buff *skb; 14121da177e4SLinus Torvalds int quote; 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 14171da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 14181da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 141982453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 14201da177e4SLinus Torvalds hci_acl_tx_to(hdev); 14211da177e4SLinus Torvalds } 14221da177e4SLinus Torvalds 14231da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 14241da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 14251da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 142604837f64SMarcel Holtmann 142704837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 142804837f64SMarcel Holtmann 14291da177e4SLinus Torvalds hci_send_frame(skb); 14301da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 14311da177e4SLinus Torvalds 14321da177e4SLinus Torvalds hdev->acl_cnt--; 14331da177e4SLinus Torvalds conn->sent++; 14341da177e4SLinus Torvalds } 14351da177e4SLinus Torvalds } 14361da177e4SLinus Torvalds } 14371da177e4SLinus Torvalds 14381da177e4SLinus Torvalds /* Schedule SCO */ 14391da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 14401da177e4SLinus Torvalds { 14411da177e4SLinus Torvalds struct hci_conn *conn; 14421da177e4SLinus Torvalds struct sk_buff *skb; 14431da177e4SLinus Torvalds int quote; 14441da177e4SLinus Torvalds 14451da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 14461da177e4SLinus Torvalds 14471da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 14481da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 14491da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 14501da177e4SLinus Torvalds hci_send_frame(skb); 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds conn->sent++; 14531da177e4SLinus Torvalds if (conn->sent == ~0) 14541da177e4SLinus Torvalds conn->sent = 0; 14551da177e4SLinus Torvalds } 14561da177e4SLinus Torvalds } 14571da177e4SLinus Torvalds } 14581da177e4SLinus Torvalds 1459b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1460b6a0dc82SMarcel Holtmann { 1461b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1462b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1463b6a0dc82SMarcel Holtmann int quote; 1464b6a0dc82SMarcel Holtmann 1465b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1466b6a0dc82SMarcel Holtmann 1467b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1468b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1469b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1470b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1471b6a0dc82SMarcel Holtmann 1472b6a0dc82SMarcel Holtmann conn->sent++; 1473b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1474b6a0dc82SMarcel Holtmann conn->sent = 0; 1475b6a0dc82SMarcel Holtmann } 1476b6a0dc82SMarcel Holtmann } 1477b6a0dc82SMarcel Holtmann } 1478b6a0dc82SMarcel Holtmann 14791da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 14801da177e4SLinus Torvalds { 14811da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 14821da177e4SLinus Torvalds struct sk_buff *skb; 14831da177e4SLinus Torvalds 14841da177e4SLinus Torvalds read_lock(&hci_task_lock); 14851da177e4SLinus Torvalds 14861da177e4SLinus Torvalds BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt); 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds hci_sched_acl(hdev); 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds hci_sched_sco(hdev); 14931da177e4SLinus Torvalds 1494b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1495b6a0dc82SMarcel Holtmann 14961da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 14971da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 14981da177e4SLinus Torvalds hci_send_frame(skb); 14991da177e4SLinus Torvalds 15001da177e4SLinus Torvalds read_unlock(&hci_task_lock); 15011da177e4SLinus Torvalds } 15021da177e4SLinus Torvalds 15031da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 15041da177e4SLinus Torvalds 15051da177e4SLinus Torvalds /* ACL data packet */ 15061da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 15071da177e4SLinus Torvalds { 15081da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 15091da177e4SLinus Torvalds struct hci_conn *conn; 15101da177e4SLinus Torvalds __u16 handle, flags; 15111da177e4SLinus Torvalds 15121da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 15131da177e4SLinus Torvalds 15141da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 15151da177e4SLinus Torvalds flags = hci_flags(handle); 15161da177e4SLinus Torvalds handle = hci_handle(handle); 15171da177e4SLinus Torvalds 15181da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 15191da177e4SLinus Torvalds 15201da177e4SLinus Torvalds hdev->stat.acl_rx++; 15211da177e4SLinus Torvalds 15221da177e4SLinus Torvalds hci_dev_lock(hdev); 15231da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 15241da177e4SLinus Torvalds hci_dev_unlock(hdev); 15251da177e4SLinus Torvalds 15261da177e4SLinus Torvalds if (conn) { 15271da177e4SLinus Torvalds register struct hci_proto *hp; 15281da177e4SLinus Torvalds 152904837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 153004837f64SMarcel Holtmann 15311da177e4SLinus Torvalds /* Send to upper protocol */ 15321da177e4SLinus Torvalds if ((hp = hci_proto[HCI_PROTO_L2CAP]) && hp->recv_acldata) { 15331da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 15341da177e4SLinus Torvalds return; 15351da177e4SLinus Torvalds } 15361da177e4SLinus Torvalds } else { 15371da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 15381da177e4SLinus Torvalds hdev->name, handle); 15391da177e4SLinus Torvalds } 15401da177e4SLinus Torvalds 15411da177e4SLinus Torvalds kfree_skb(skb); 15421da177e4SLinus Torvalds } 15431da177e4SLinus Torvalds 15441da177e4SLinus Torvalds /* SCO data packet */ 15451da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 15461da177e4SLinus Torvalds { 15471da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 15481da177e4SLinus Torvalds struct hci_conn *conn; 15491da177e4SLinus Torvalds __u16 handle; 15501da177e4SLinus Torvalds 15511da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 15541da177e4SLinus Torvalds 15551da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 15561da177e4SLinus Torvalds 15571da177e4SLinus Torvalds hdev->stat.sco_rx++; 15581da177e4SLinus Torvalds 15591da177e4SLinus Torvalds hci_dev_lock(hdev); 15601da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 15611da177e4SLinus Torvalds hci_dev_unlock(hdev); 15621da177e4SLinus Torvalds 15631da177e4SLinus Torvalds if (conn) { 15641da177e4SLinus Torvalds register struct hci_proto *hp; 15651da177e4SLinus Torvalds 15661da177e4SLinus Torvalds /* Send to upper protocol */ 15671da177e4SLinus Torvalds if ((hp = hci_proto[HCI_PROTO_SCO]) && hp->recv_scodata) { 15681da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 15691da177e4SLinus Torvalds return; 15701da177e4SLinus Torvalds } 15711da177e4SLinus Torvalds } else { 15721da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 15731da177e4SLinus Torvalds hdev->name, handle); 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds kfree_skb(skb); 15771da177e4SLinus Torvalds } 15781da177e4SLinus Torvalds 15796516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 15801da177e4SLinus Torvalds { 15811da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 15821da177e4SLinus Torvalds struct sk_buff *skb; 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 15851da177e4SLinus Torvalds 15861da177e4SLinus Torvalds read_lock(&hci_task_lock); 15871da177e4SLinus Torvalds 15881da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 15891da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 15901da177e4SLinus Torvalds /* Send copy to the sockets */ 15911da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 15921da177e4SLinus Torvalds } 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 15951da177e4SLinus Torvalds kfree_skb(skb); 15961da177e4SLinus Torvalds continue; 15971da177e4SLinus Torvalds } 15981da177e4SLinus Torvalds 15991da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 16001da177e4SLinus Torvalds /* Don't process data packets in this states. */ 16010d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 16021da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 16031da177e4SLinus Torvalds case HCI_SCODATA_PKT: 16041da177e4SLinus Torvalds kfree_skb(skb); 16051da177e4SLinus Torvalds continue; 16063ff50b79SStephen Hemminger } 16071da177e4SLinus Torvalds } 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds /* Process frame */ 16100d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 16111da177e4SLinus Torvalds case HCI_EVENT_PKT: 16121da177e4SLinus Torvalds hci_event_packet(hdev, skb); 16131da177e4SLinus Torvalds break; 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 16161da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 16171da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 16181da177e4SLinus Torvalds break; 16191da177e4SLinus Torvalds 16201da177e4SLinus Torvalds case HCI_SCODATA_PKT: 16211da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 16221da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 16231da177e4SLinus Torvalds break; 16241da177e4SLinus Torvalds 16251da177e4SLinus Torvalds default: 16261da177e4SLinus Torvalds kfree_skb(skb); 16271da177e4SLinus Torvalds break; 16281da177e4SLinus Torvalds } 16291da177e4SLinus Torvalds } 16301da177e4SLinus Torvalds 16311da177e4SLinus Torvalds read_unlock(&hci_task_lock); 16321da177e4SLinus Torvalds } 16331da177e4SLinus Torvalds 16341da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 16351da177e4SLinus Torvalds { 16361da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 16371da177e4SLinus Torvalds struct sk_buff *skb; 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 16401da177e4SLinus Torvalds 164182453021SS.Çağlar Onur if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) { 16421da177e4SLinus Torvalds BT_ERR("%s command tx timeout", hdev->name); 16431da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 16441da177e4SLinus Torvalds } 16451da177e4SLinus Torvalds 16461da177e4SLinus Torvalds /* Send queued commands */ 16471da177e4SLinus Torvalds if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) { 16481da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16491da177e4SLinus Torvalds 16501da177e4SLinus Torvalds if ((hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC))) { 16511da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 16521da177e4SLinus Torvalds hci_send_frame(skb); 16531da177e4SLinus Torvalds hdev->cmd_last_tx = jiffies; 16541da177e4SLinus Torvalds } else { 16551da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 1656c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 16571da177e4SLinus Torvalds } 16581da177e4SLinus Torvalds } 16591da177e4SLinus Torvalds } 1660