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> 401da177e4SLinus Torvalds #include <linux/interrupt.h> 411da177e4SLinus Torvalds #include <linux/notifier.h> 421da177e4SLinus Torvalds #include <net/sock.h> 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds #include <asm/system.h> 451da177e4SLinus Torvalds #include <asm/uaccess.h> 461da177e4SLinus Torvalds #include <asm/unaligned.h> 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 491da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 501da177e4SLinus Torvalds 511da177e4SLinus Torvalds #ifndef CONFIG_BT_HCI_CORE_DEBUG 521da177e4SLinus Torvalds #undef BT_DBG 531da177e4SLinus Torvalds #define BT_DBG(D...) 541da177e4SLinus Torvalds #endif 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg); 571da177e4SLinus Torvalds static void hci_rx_task(unsigned long arg); 581da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg); 591da177e4SLinus Torvalds static void hci_notify(struct hci_dev *hdev, int event); 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds static DEFINE_RWLOCK(hci_task_lock); 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* HCI device list */ 641da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 651da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds /* HCI callback list */ 681da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 691da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds /* HCI protocols */ 721da177e4SLinus Torvalds #define HCI_MAX_PROTO 2 731da177e4SLinus Torvalds struct hci_proto *hci_proto[HCI_MAX_PROTO]; 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds /* HCI notifiers list */ 76e041c683SAlan Stern static ATOMIC_NOTIFIER_HEAD(hci_notifier); 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds int hci_register_notifier(struct notifier_block *nb) 811da177e4SLinus Torvalds { 82e041c683SAlan Stern return atomic_notifier_chain_register(&hci_notifier, nb); 831da177e4SLinus Torvalds } 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds int hci_unregister_notifier(struct notifier_block *nb) 861da177e4SLinus Torvalds { 87e041c683SAlan Stern return atomic_notifier_chain_unregister(&hci_notifier, nb); 881da177e4SLinus Torvalds } 891da177e4SLinus Torvalds 906516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 911da177e4SLinus Torvalds { 92e041c683SAlan Stern atomic_notifier_call_chain(&hci_notifier, event, hdev); 931da177e4SLinus Torvalds } 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds /* ---- HCI requests ---- */ 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds void hci_req_complete(struct hci_dev *hdev, int result) 981da177e4SLinus Torvalds { 991da177e4SLinus Torvalds BT_DBG("%s result 0x%2.2x", hdev->name, result); 1001da177e4SLinus Torvalds 1011da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1021da177e4SLinus Torvalds hdev->req_result = result; 1031da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1041da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1051da177e4SLinus Torvalds } 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1091da177e4SLinus Torvalds { 1101da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1131da177e4SLinus Torvalds hdev->req_result = err; 1141da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1151da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1161da177e4SLinus Torvalds } 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds /* Execute request and wait for completion. */ 1201da177e4SLinus Torvalds static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1211da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1221da177e4SLinus Torvalds { 1231da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1241da177e4SLinus Torvalds int err = 0; 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 1271da177e4SLinus Torvalds 1281da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds add_wait_queue(&hdev->req_wait_q, &wait); 1311da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds req(hdev, opt); 1341da177e4SLinus Torvalds schedule_timeout(timeout); 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds if (signal_pending(current)) 1391da177e4SLinus Torvalds return -EINTR; 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds switch (hdev->req_status) { 1421da177e4SLinus Torvalds case HCI_REQ_DONE: 1431da177e4SLinus Torvalds err = -bt_err(hdev->req_result); 1441da177e4SLinus Torvalds break; 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds case HCI_REQ_CANCELED: 1471da177e4SLinus Torvalds err = -hdev->req_result; 1481da177e4SLinus Torvalds break; 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds default: 1511da177e4SLinus Torvalds err = -ETIMEDOUT; 1521da177e4SLinus Torvalds break; 1533ff50b79SStephen Hemminger } 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds hdev->req_status = hdev->req_result = 0; 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds return err; 1601da177e4SLinus Torvalds } 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1631da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1641da177e4SLinus Torvalds { 1651da177e4SLinus Torvalds int ret; 1661da177e4SLinus Torvalds 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; 1971da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1981da177e4SLinus Torvalds hci_sched_cmd(hdev); 1991da177e4SLinus Torvalds } 2001da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds /* Mandatory initialization */ 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds /* Reset */ 2051da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks)) 206a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 2071da177e4SLinus Torvalds 2081da177e4SLinus Torvalds /* Read Local Supported Features */ 209a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2101da177e4SLinus Torvalds 2111143e5a6SMarcel Holtmann /* Read Local Version */ 212a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2131143e5a6SMarcel Holtmann 2141da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 215a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds #if 0 2181da177e4SLinus Torvalds /* Host buffer size */ 2191da177e4SLinus Torvalds { 2201da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 221aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2221da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 223aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 224aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 225a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds #endif 2281da177e4SLinus Torvalds 2291da177e4SLinus Torvalds /* Read BD Address */ 230a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 231a9de9248SMarcel Holtmann 232a9de9248SMarcel Holtmann /* Read Class of Device */ 233a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 234a9de9248SMarcel Holtmann 235a9de9248SMarcel Holtmann /* Read Local Name */ 236a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds /* Read Voice Setting */ 239a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds /* Optional initialization */ 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds /* Clear Event Filters */ 24489f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 245a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds /* Page timeout ~20 secs */ 248aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x8000); 249a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_PG_TIMEOUT, 2, ¶m); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 252aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 253a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 2541da177e4SLinus Torvalds } 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2571da177e4SLinus Torvalds { 2581da177e4SLinus Torvalds __u8 scan = opt; 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds /* Inquiry and Page scans */ 263a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2671da177e4SLinus Torvalds { 2681da177e4SLinus Torvalds __u8 auth = opt; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds /* Authentication */ 273a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2771da177e4SLinus Torvalds { 2781da177e4SLinus Torvalds __u8 encrypt = opt; 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 2811da177e4SLinus Torvalds 282e4e8e37cSMarcel Holtmann /* Encryption */ 283a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 286e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 287e4e8e37cSMarcel Holtmann { 288e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 289e4e8e37cSMarcel Holtmann 290e4e8e37cSMarcel Holtmann BT_DBG("%s %x", hdev->name, opt); 291e4e8e37cSMarcel Holtmann 292e4e8e37cSMarcel Holtmann /* Default link policy */ 293e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 294e4e8e37cSMarcel Holtmann } 295e4e8e37cSMarcel Holtmann 2961da177e4SLinus Torvalds /* Get HCI device by index. 2971da177e4SLinus Torvalds * Device is held on return. */ 2981da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 2991da177e4SLinus Torvalds { 3001da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3011da177e4SLinus Torvalds struct list_head *p; 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds BT_DBG("%d", index); 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds if (index < 0) 3061da177e4SLinus Torvalds return NULL; 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3091da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3101da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3111da177e4SLinus Torvalds if (d->id == index) { 3121da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3131da177e4SLinus Torvalds break; 3141da177e4SLinus Torvalds } 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3171da177e4SLinus Torvalds return hdev; 3181da177e4SLinus Torvalds } 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3211da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3221da177e4SLinus Torvalds { 3231da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3241da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds cache->list = NULL; 3291da177e4SLinus Torvalds while ((e = next)) { 3301da177e4SLinus Torvalds next = e->next; 3311da177e4SLinus Torvalds kfree(e); 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds } 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3361da177e4SLinus Torvalds { 3371da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3381da177e4SLinus Torvalds struct inquiry_entry *e; 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3431da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3441da177e4SLinus Torvalds break; 3451da177e4SLinus Torvalds return e; 3461da177e4SLinus Torvalds } 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3491da177e4SLinus Torvalds { 3501da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3511da177e4SLinus Torvalds struct inquiry_entry *e; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds if (!(e = hci_inquiry_cache_lookup(hdev, &data->bdaddr))) { 3561da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 35725ea6db0SMarcel Holtmann if (!(e = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC))) 3581da177e4SLinus Torvalds return; 3591da177e4SLinus Torvalds e->next = cache->list; 3601da177e4SLinus Torvalds cache->list = e; 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds memcpy(&e->data, data, sizeof(*data)); 3641da177e4SLinus Torvalds e->timestamp = jiffies; 3651da177e4SLinus Torvalds cache->timestamp = jiffies; 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3691da177e4SLinus Torvalds { 3701da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3711da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3721da177e4SLinus Torvalds struct inquiry_entry *e; 3731da177e4SLinus Torvalds int copied = 0; 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 3761da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 3771da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 3781da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 3791da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 3801da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 3811da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 3821da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 3831da177e4SLinus Torvalds info++; 3841da177e4SLinus Torvalds } 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 3871da177e4SLinus Torvalds return copied; 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 3911da177e4SLinus Torvalds { 3921da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 3931da177e4SLinus Torvalds struct hci_cp_inquiry cp; 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 3961da177e4SLinus Torvalds 3971da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 3981da177e4SLinus Torvalds return; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds /* Start Inquiry */ 4011da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4021da177e4SLinus Torvalds cp.length = ir->length; 4031da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 404a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4081da177e4SLinus Torvalds { 4091da177e4SLinus Torvalds __u8 __user *ptr = arg; 4101da177e4SLinus Torvalds struct hci_inquiry_req ir; 4111da177e4SLinus Torvalds struct hci_dev *hdev; 4121da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4131da177e4SLinus Torvalds long timeo; 4141da177e4SLinus Torvalds __u8 *buf; 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4171da177e4SLinus Torvalds return -EFAULT; 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds if (!(hdev = hci_dev_get(ir.dev_id))) 4201da177e4SLinus Torvalds return -ENODEV; 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4231da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4241da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4251da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4261da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4271da177e4SLinus Torvalds do_inquiry = 1; 4281da177e4SLinus Torvalds } 4291da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4301da177e4SLinus Torvalds 43104837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 4321da177e4SLinus Torvalds if (do_inquiry && (err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo)) < 0) 4331da177e4SLinus Torvalds goto done; 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4361da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4391da177e4SLinus Torvalds * copy it to the user space. 4401da177e4SLinus Torvalds */ 4411da177e4SLinus Torvalds if (!(buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL))) { 4421da177e4SLinus Torvalds err = -ENOMEM; 4431da177e4SLinus Torvalds goto done; 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4471da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4481da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4531da177e4SLinus Torvalds ptr += sizeof(ir); 4541da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4551da177e4SLinus Torvalds ir.num_rsp)) 4561da177e4SLinus Torvalds err = -EFAULT; 4571da177e4SLinus Torvalds } else 4581da177e4SLinus Torvalds err = -EFAULT; 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds kfree(buf); 4611da177e4SLinus Torvalds 4621da177e4SLinus Torvalds done: 4631da177e4SLinus Torvalds hci_dev_put(hdev); 4641da177e4SLinus Torvalds return err; 4651da177e4SLinus Torvalds } 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 4701da177e4SLinus Torvalds { 4711da177e4SLinus Torvalds struct hci_dev *hdev; 4721da177e4SLinus Torvalds int ret = 0; 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 4751da177e4SLinus Torvalds return -ENODEV; 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds hci_req_lock(hdev); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 4821da177e4SLinus Torvalds ret = -EALREADY; 4831da177e4SLinus Torvalds goto done; 4841da177e4SLinus Torvalds } 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 4871da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds if (hdev->open(hdev)) { 4901da177e4SLinus Torvalds ret = -EIO; 4911da177e4SLinus Torvalds goto done; 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 4951da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 4961da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds //__hci_request(hdev, hci_reset_req, 0, HZ); 49904837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 50004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds if (!ret) { 5061da177e4SLinus Torvalds hci_dev_hold(hdev); 5071da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5081da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5091da177e4SLinus Torvalds } else { 5101da177e4SLinus Torvalds /* Init failed, cleanup */ 5111da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5121da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5131da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5161da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds if (hdev->flush) 5191da177e4SLinus Torvalds hdev->flush(hdev); 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds if (hdev->sent_cmd) { 5221da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5231da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds hdev->close(hdev); 5271da177e4SLinus Torvalds hdev->flags = 0; 5281da177e4SLinus Torvalds } 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds done: 5311da177e4SLinus Torvalds hci_req_unlock(hdev); 5321da177e4SLinus Torvalds hci_dev_put(hdev); 5331da177e4SLinus Torvalds return ret; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5371da177e4SLinus Torvalds { 5381da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5411da177e4SLinus Torvalds hci_req_lock(hdev); 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 5441da177e4SLinus Torvalds hci_req_unlock(hdev); 5451da177e4SLinus Torvalds return 0; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5491da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5501da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 5531da177e4SLinus Torvalds inquiry_cache_flush(hdev); 5541da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 5551da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds if (hdev->flush) 5601da177e4SLinus Torvalds hdev->flush(hdev); 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds /* Reset device */ 5631da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5641da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5651da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5661da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 56704837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 56804837f64SMarcel Holtmann msecs_to_jiffies(250)); 5691da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds /* Kill cmd task */ 5731da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds /* Drop queues */ 5761da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5771da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5781da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds /* Drop last sent command */ 5811da177e4SLinus Torvalds if (hdev->sent_cmd) { 5821da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5831da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5841da177e4SLinus Torvalds } 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds /* After this point our queues are empty 5871da177e4SLinus Torvalds * and no tasks are scheduled. */ 5881da177e4SLinus Torvalds hdev->close(hdev); 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds /* Clear flags */ 5911da177e4SLinus Torvalds hdev->flags = 0; 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds hci_req_unlock(hdev); 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds hci_dev_put(hdev); 5961da177e4SLinus Torvalds return 0; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6001da177e4SLinus Torvalds { 6011da177e4SLinus Torvalds struct hci_dev *hdev; 6021da177e4SLinus Torvalds int err; 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6051da177e4SLinus Torvalds return -ENODEV; 6061da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6071da177e4SLinus Torvalds hci_dev_put(hdev); 6081da177e4SLinus Torvalds return err; 6091da177e4SLinus Torvalds } 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6121da177e4SLinus Torvalds { 6131da177e4SLinus Torvalds struct hci_dev *hdev; 6141da177e4SLinus Torvalds int ret = 0; 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6171da177e4SLinus Torvalds return -ENODEV; 6181da177e4SLinus Torvalds 6191da177e4SLinus Torvalds hci_req_lock(hdev); 6201da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6231da177e4SLinus Torvalds goto done; 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds /* Drop queues */ 6261da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6271da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6301da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6311da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6321da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds if (hdev->flush) 6351da177e4SLinus Torvalds hdev->flush(hdev); 6361da177e4SLinus Torvalds 6371da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6381da177e4SLinus Torvalds hdev->acl_cnt = 0; hdev->sco_cnt = 0; 6391da177e4SLinus Torvalds 6401da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 64104837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 64204837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds done: 6451da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6461da177e4SLinus Torvalds hci_req_unlock(hdev); 6471da177e4SLinus Torvalds hci_dev_put(hdev); 6481da177e4SLinus Torvalds return ret; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 6521da177e4SLinus Torvalds { 6531da177e4SLinus Torvalds struct hci_dev *hdev; 6541da177e4SLinus Torvalds int ret = 0; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6571da177e4SLinus Torvalds return -ENODEV; 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds hci_dev_put(hdev); 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds return ret; 6641da177e4SLinus Torvalds } 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 6671da177e4SLinus Torvalds { 6681da177e4SLinus Torvalds struct hci_dev *hdev; 6691da177e4SLinus Torvalds struct hci_dev_req dr; 6701da177e4SLinus Torvalds int err = 0; 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 6731da177e4SLinus Torvalds return -EFAULT; 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dr.dev_id))) 6761da177e4SLinus Torvalds return -ENODEV; 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds switch (cmd) { 6791da177e4SLinus Torvalds case HCISETAUTH: 68004837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 68104837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6821da177e4SLinus Torvalds break; 6831da177e4SLinus Torvalds 6841da177e4SLinus Torvalds case HCISETENCRYPT: 6851da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 6861da177e4SLinus Torvalds err = -EOPNOTSUPP; 6871da177e4SLinus Torvalds break; 6881da177e4SLinus Torvalds } 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 6911da177e4SLinus Torvalds /* Auth must be enabled first */ 69204837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 69304837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6941da177e4SLinus Torvalds if (err) 6951da177e4SLinus Torvalds break; 6961da177e4SLinus Torvalds } 6971da177e4SLinus Torvalds 69804837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 69904837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7001da177e4SLinus Torvalds break; 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds case HCISETSCAN: 70304837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 70404837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7051da177e4SLinus Torvalds break; 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds case HCISETLINKPOL: 708e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 709e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7101da177e4SLinus Torvalds break; 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds case HCISETLINKMODE: 713e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 714e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 715e4e8e37cSMarcel Holtmann break; 716e4e8e37cSMarcel Holtmann 717e4e8e37cSMarcel Holtmann case HCISETPTYPE: 718e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7191da177e4SLinus Torvalds break; 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds case HCISETACLMTU: 7221da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7231da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7241da177e4SLinus Torvalds break; 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds case HCISETSCOMTU: 7271da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7281da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7291da177e4SLinus Torvalds break; 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds default: 7321da177e4SLinus Torvalds err = -EINVAL; 7331da177e4SLinus Torvalds break; 7341da177e4SLinus Torvalds } 735e4e8e37cSMarcel Holtmann 7361da177e4SLinus Torvalds hci_dev_put(hdev); 7371da177e4SLinus Torvalds return err; 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7411da177e4SLinus Torvalds { 7421da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7431da177e4SLinus Torvalds struct hci_dev_req *dr; 7441da177e4SLinus Torvalds struct list_head *p; 7451da177e4SLinus Torvalds int n = 0, size, err; 7461da177e4SLinus Torvalds __u16 dev_num; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 7491da177e4SLinus Torvalds return -EFAULT; 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 7521da177e4SLinus Torvalds return -EINVAL; 7531da177e4SLinus Torvalds 7541da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 7551da177e4SLinus Torvalds 7561da177e4SLinus Torvalds if (!(dl = kmalloc(size, GFP_KERNEL))) 7571da177e4SLinus Torvalds return -ENOMEM; 7581da177e4SLinus Torvalds 7591da177e4SLinus Torvalds dr = dl->dev_req; 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 7621da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 7631da177e4SLinus Torvalds struct hci_dev *hdev; 7641da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 7651da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 7661da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 7671da177e4SLinus Torvalds if (++n >= dev_num) 7681da177e4SLinus Torvalds break; 7691da177e4SLinus Torvalds } 7701da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds dl->dev_num = n; 7731da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 7741da177e4SLinus Torvalds 7751da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 7761da177e4SLinus Torvalds kfree(dl); 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds return err ? -EFAULT : 0; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds 7811da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 7821da177e4SLinus Torvalds { 7831da177e4SLinus Torvalds struct hci_dev *hdev; 7841da177e4SLinus Torvalds struct hci_dev_info di; 7851da177e4SLinus Torvalds int err = 0; 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 7881da177e4SLinus Torvalds return -EFAULT; 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds if (!(hdev = hci_dev_get(di.dev_id))) 7911da177e4SLinus Torvalds return -ENODEV; 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds strcpy(di.name, hdev->name); 7941da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 7951da177e4SLinus Torvalds di.type = hdev->type; 7961da177e4SLinus Torvalds di.flags = hdev->flags; 7971da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 7981da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 7991da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8001da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8011da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8021da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8031da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8061da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8091da177e4SLinus Torvalds err = -EFAULT; 8101da177e4SLinus Torvalds 8111da177e4SLinus Torvalds hci_dev_put(hdev); 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds return err; 8141da177e4SLinus Torvalds } 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds /* Alloc HCI device */ 8191da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 8201da177e4SLinus Torvalds { 8211da177e4SLinus Torvalds struct hci_dev *hdev; 8221da177e4SLinus Torvalds 82325ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 8241da177e4SLinus Torvalds if (!hdev) 8251da177e4SLinus Torvalds return NULL; 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 8281da177e4SLinus Torvalds 8291da177e4SLinus Torvalds return hdev; 8301da177e4SLinus Torvalds } 8311da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds /* Free HCI device */ 8341da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 8351da177e4SLinus Torvalds { 8361da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 8371da177e4SLinus Torvalds 838a91f2e39SMarcel Holtmann /* will free via device release */ 839a91f2e39SMarcel Holtmann put_device(&hdev->dev); 8401da177e4SLinus Torvalds } 8411da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds /* Register HCI device */ 8441da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 8451da177e4SLinus Torvalds { 8461da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 847ef222013SMarcel Holtmann int i, id = 0; 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds BT_DBG("%p name %s type %d owner %p", hdev, hdev->name, hdev->type, hdev->owner); 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 8521da177e4SLinus Torvalds return -EINVAL; 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 8551da177e4SLinus Torvalds 8561da177e4SLinus Torvalds /* Find first available device id */ 8571da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8581da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 8591da177e4SLinus Torvalds break; 8601da177e4SLinus Torvalds head = p; id++; 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds 8631da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 8641da177e4SLinus Torvalds hdev->id = id; 8651da177e4SLinus Torvalds list_add(&hdev->list, head); 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 8681da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds hdev->flags = 0; 8711da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 8725b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 8731da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 8741da177e4SLinus Torvalds 87504837f64SMarcel Holtmann hdev->idle_timeout = 0; 87604837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 87704837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 87804837f64SMarcel Holtmann 8791da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task,(unsigned long) hdev); 8801da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 8811da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 8821da177e4SLinus Torvalds 8831da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 8841da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 8851da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 8861da177e4SLinus Torvalds 887ef222013SMarcel Holtmann for (i = 0; i < 3; i++) 888ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 889ef222013SMarcel Holtmann 8901da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 8911da177e4SLinus Torvalds init_MUTEX(&hdev->req_lock); 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds inquiry_cache_init(hdev); 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds hci_conn_hash_init(hdev); 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 9001da177e4SLinus Torvalds 9011da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds hci_register_sysfs(hdev); 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds return id; 9081da177e4SLinus Torvalds } 9091da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 9101da177e4SLinus Torvalds 9111da177e4SLinus Torvalds /* Unregister HCI device */ 9121da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 9131da177e4SLinus Torvalds { 914ef222013SMarcel Holtmann int i; 915ef222013SMarcel Holtmann 9161da177e4SLinus Torvalds BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); 9171da177e4SLinus Torvalds 9181da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 9191da177e4SLinus Torvalds list_del(&hdev->list); 9201da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds hci_dev_do_close(hdev); 9231da177e4SLinus Torvalds 924ef222013SMarcel Holtmann for (i = 0; i < 3; i++) 925ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 926ef222013SMarcel Holtmann 9271da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 9281da177e4SLinus Torvalds 929147e2d59SDave Young hci_unregister_sysfs(hdev); 930147e2d59SDave Young 9311da177e4SLinus Torvalds __hci_dev_put(hdev); 932ef222013SMarcel Holtmann 9331da177e4SLinus Torvalds return 0; 9341da177e4SLinus Torvalds } 9351da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 9361da177e4SLinus Torvalds 9371da177e4SLinus Torvalds /* Suspend HCI device */ 9381da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 9391da177e4SLinus Torvalds { 9401da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 9411da177e4SLinus Torvalds return 0; 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 9441da177e4SLinus Torvalds 9451da177e4SLinus Torvalds /* Resume HCI device */ 9461da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 9471da177e4SLinus Torvalds { 9481da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 9491da177e4SLinus Torvalds return 0; 9501da177e4SLinus Torvalds } 9511da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 9521da177e4SLinus Torvalds 953ef222013SMarcel Holtmann /* Receive packet type fragment */ 954ef222013SMarcel Holtmann #define __reassembly(hdev, type) ((hdev)->reassembly[(type) - 2]) 955ef222013SMarcel Holtmann 956ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 957ef222013SMarcel Holtmann { 958ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 959ef222013SMarcel Holtmann return -EILSEQ; 960ef222013SMarcel Holtmann 961ef222013SMarcel Holtmann while (count) { 962ef222013SMarcel Holtmann struct sk_buff *skb = __reassembly(hdev, type); 963ef222013SMarcel Holtmann struct { int expect; } *scb; 964ef222013SMarcel Holtmann int len = 0; 965ef222013SMarcel Holtmann 966ef222013SMarcel Holtmann if (!skb) { 967ef222013SMarcel Holtmann /* Start of the frame */ 968ef222013SMarcel Holtmann 969ef222013SMarcel Holtmann switch (type) { 970ef222013SMarcel Holtmann case HCI_EVENT_PKT: 971ef222013SMarcel Holtmann if (count >= HCI_EVENT_HDR_SIZE) { 972ef222013SMarcel Holtmann struct hci_event_hdr *h = data; 973ef222013SMarcel Holtmann len = HCI_EVENT_HDR_SIZE + h->plen; 974ef222013SMarcel Holtmann } else 975ef222013SMarcel Holtmann return -EILSEQ; 976ef222013SMarcel Holtmann break; 977ef222013SMarcel Holtmann 978ef222013SMarcel Holtmann case HCI_ACLDATA_PKT: 979ef222013SMarcel Holtmann if (count >= HCI_ACL_HDR_SIZE) { 980ef222013SMarcel Holtmann struct hci_acl_hdr *h = data; 981ef222013SMarcel Holtmann len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen); 982ef222013SMarcel Holtmann } else 983ef222013SMarcel Holtmann return -EILSEQ; 984ef222013SMarcel Holtmann break; 985ef222013SMarcel Holtmann 986ef222013SMarcel Holtmann case HCI_SCODATA_PKT: 987ef222013SMarcel Holtmann if (count >= HCI_SCO_HDR_SIZE) { 988ef222013SMarcel Holtmann struct hci_sco_hdr *h = data; 989ef222013SMarcel Holtmann len = HCI_SCO_HDR_SIZE + h->dlen; 990ef222013SMarcel Holtmann } else 991ef222013SMarcel Holtmann return -EILSEQ; 992ef222013SMarcel Holtmann break; 993ef222013SMarcel Holtmann } 994ef222013SMarcel Holtmann 995ef222013SMarcel Holtmann skb = bt_skb_alloc(len, GFP_ATOMIC); 996ef222013SMarcel Holtmann if (!skb) { 997ef222013SMarcel Holtmann BT_ERR("%s no memory for packet", hdev->name); 998ef222013SMarcel Holtmann return -ENOMEM; 999ef222013SMarcel Holtmann } 1000ef222013SMarcel Holtmann 1001ef222013SMarcel Holtmann skb->dev = (void *) hdev; 1002ef222013SMarcel Holtmann bt_cb(skb)->pkt_type = type; 1003ef222013SMarcel Holtmann 1004ef222013SMarcel Holtmann __reassembly(hdev, type) = skb; 1005ef222013SMarcel Holtmann 1006ef222013SMarcel Holtmann scb = (void *) skb->cb; 1007ef222013SMarcel Holtmann scb->expect = len; 1008ef222013SMarcel Holtmann } else { 1009ef222013SMarcel Holtmann /* Continuation */ 1010ef222013SMarcel Holtmann 1011ef222013SMarcel Holtmann scb = (void *) skb->cb; 1012ef222013SMarcel Holtmann len = scb->expect; 1013ef222013SMarcel Holtmann } 1014ef222013SMarcel Holtmann 1015ef222013SMarcel Holtmann len = min(len, count); 1016ef222013SMarcel Holtmann 1017ef222013SMarcel Holtmann memcpy(skb_put(skb, len), data, len); 1018ef222013SMarcel Holtmann 1019ef222013SMarcel Holtmann scb->expect -= len; 1020ef222013SMarcel Holtmann 1021ef222013SMarcel Holtmann if (scb->expect == 0) { 1022ef222013SMarcel Holtmann /* Complete frame */ 1023ef222013SMarcel Holtmann 1024ef222013SMarcel Holtmann __reassembly(hdev, type) = NULL; 1025ef222013SMarcel Holtmann 1026ef222013SMarcel Holtmann bt_cb(skb)->pkt_type = type; 1027ef222013SMarcel Holtmann hci_recv_frame(skb); 1028ef222013SMarcel Holtmann } 1029ef222013SMarcel Holtmann 1030ef222013SMarcel Holtmann count -= len; data += len; 1031ef222013SMarcel Holtmann } 1032ef222013SMarcel Holtmann 1033ef222013SMarcel Holtmann return 0; 1034ef222013SMarcel Holtmann } 1035ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1036ef222013SMarcel Holtmann 10371da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds /* Register/Unregister protocols. 10401da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 10411da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 10421da177e4SLinus Torvalds { 10431da177e4SLinus Torvalds int err = 0; 10441da177e4SLinus Torvalds 10451da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 10481da177e4SLinus Torvalds return -EINVAL; 10491da177e4SLinus Torvalds 10501da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds if (!hci_proto[hp->id]) 10531da177e4SLinus Torvalds hci_proto[hp->id] = hp; 10541da177e4SLinus Torvalds else 10551da177e4SLinus Torvalds err = -EEXIST; 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds return err; 10601da177e4SLinus Torvalds } 10611da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 10641da177e4SLinus Torvalds { 10651da177e4SLinus Torvalds int err = 0; 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 10701da177e4SLinus Torvalds return -EINVAL; 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds if (hci_proto[hp->id]) 10751da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 10761da177e4SLinus Torvalds else 10771da177e4SLinus Torvalds err = -ENOENT; 10781da177e4SLinus Torvalds 10791da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds return err; 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 10861da177e4SLinus Torvalds { 10871da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 10901da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 10911da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 10921da177e4SLinus Torvalds 10931da177e4SLinus Torvalds return 0; 10941da177e4SLinus Torvalds } 10951da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 10961da177e4SLinus Torvalds 10971da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 10981da177e4SLinus Torvalds { 10991da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 11001da177e4SLinus Torvalds 11011da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 11021da177e4SLinus Torvalds list_del(&cb->list); 11031da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 11041da177e4SLinus Torvalds 11051da177e4SLinus Torvalds return 0; 11061da177e4SLinus Torvalds } 11071da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 11101da177e4SLinus Torvalds { 11111da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds if (!hdev) { 11141da177e4SLinus Torvalds kfree_skb(skb); 11151da177e4SLinus Torvalds return -ENODEV; 11161da177e4SLinus Torvalds } 11171da177e4SLinus Torvalds 11180d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 11191da177e4SLinus Torvalds 11201da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 11211da177e4SLinus Torvalds /* Time stamp */ 1122a61bbcf2SPatrick McHardy __net_timestamp(skb); 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 11271da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 11281da177e4SLinus Torvalds skb_orphan(skb); 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds return hdev->send(skb); 11311da177e4SLinus Torvalds } 11321da177e4SLinus Torvalds 11331da177e4SLinus Torvalds /* Send HCI command */ 1134a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 11351da177e4SLinus Torvalds { 11361da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 11371da177e4SLinus Torvalds struct hci_command_hdr *hdr; 11381da177e4SLinus Torvalds struct sk_buff *skb; 11391da177e4SLinus Torvalds 1140a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 11431da177e4SLinus Torvalds if (!skb) { 1144ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 11451da177e4SLinus Torvalds return -ENOMEM; 11461da177e4SLinus Torvalds } 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1149a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 11501da177e4SLinus Torvalds hdr->plen = plen; 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds if (plen) 11531da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 11561da177e4SLinus Torvalds 11570d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 11581da177e4SLinus Torvalds skb->dev = (void *) hdev; 11591da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 11601da177e4SLinus Torvalds hci_sched_cmd(hdev); 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds return 0; 11631da177e4SLinus Torvalds } 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds /* Get data from the previously sent command */ 1166a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 11671da177e4SLinus Torvalds { 11681da177e4SLinus Torvalds struct hci_command_hdr *hdr; 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds if (!hdev->sent_cmd) 11711da177e4SLinus Torvalds return NULL; 11721da177e4SLinus Torvalds 11731da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 11741da177e4SLinus Torvalds 1175a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 11761da177e4SLinus Torvalds return NULL; 11771da177e4SLinus Torvalds 1178a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 11811da177e4SLinus Torvalds } 11821da177e4SLinus Torvalds 11831da177e4SLinus Torvalds /* Send ACL data */ 11841da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 11851da177e4SLinus Torvalds { 11861da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 11871da177e4SLinus Torvalds int len = skb->len; 11881da177e4SLinus Torvalds 1189badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1190badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 11919c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1192aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1193aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 11941da177e4SLinus Torvalds } 11951da177e4SLinus Torvalds 11961da177e4SLinus Torvalds int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 11971da177e4SLinus Torvalds { 11981da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 11991da177e4SLinus Torvalds struct sk_buff *list; 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds skb->dev = (void *) hdev; 12040d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 12051da177e4SLinus Torvalds hci_add_acl_hdr(skb, conn->handle, flags | ACL_START); 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds if (!(list = skb_shinfo(skb)->frag_list)) { 12081da177e4SLinus Torvalds /* Non fragmented */ 12091da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 12121da177e4SLinus Torvalds } else { 12131da177e4SLinus Torvalds /* Fragmented */ 12141da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 12171da177e4SLinus Torvalds 12181da177e4SLinus Torvalds /* Queue all fragments atomically */ 12191da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 12221da177e4SLinus Torvalds do { 12231da177e4SLinus Torvalds skb = list; list = list->next; 12241da177e4SLinus Torvalds 12251da177e4SLinus Torvalds skb->dev = (void *) hdev; 12260d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 12271da177e4SLinus Torvalds hci_add_acl_hdr(skb, conn->handle, flags | ACL_CONT); 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 12321da177e4SLinus Torvalds } while (list); 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 12351da177e4SLinus Torvalds } 12361da177e4SLinus Torvalds 12371da177e4SLinus Torvalds hci_sched_tx(hdev); 12381da177e4SLinus Torvalds return 0; 12391da177e4SLinus Torvalds } 12401da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 12411da177e4SLinus Torvalds 12421da177e4SLinus Torvalds /* Send SCO data */ 12431da177e4SLinus Torvalds int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 12441da177e4SLinus Torvalds { 12451da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 12461da177e4SLinus Torvalds struct hci_sco_hdr hdr; 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 12491da177e4SLinus Torvalds 12501da177e4SLinus Torvalds if (skb->len > hdev->sco_mtu) { 12511da177e4SLinus Torvalds kfree_skb(skb); 12521da177e4SLinus Torvalds return -EINVAL; 12531da177e4SLinus Torvalds } 12541da177e4SLinus Torvalds 1255aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 12561da177e4SLinus Torvalds hdr.dlen = skb->len; 12571da177e4SLinus Torvalds 1258badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1259badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 12609c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 12611da177e4SLinus Torvalds 12621da177e4SLinus Torvalds skb->dev = (void *) hdev; 12630d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 12641da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 12651da177e4SLinus Torvalds hci_sched_tx(hdev); 12661da177e4SLinus Torvalds return 0; 12671da177e4SLinus Torvalds } 12681da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds /* HCI Connection scheduler */ 12731da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 12741da177e4SLinus Torvalds { 12751da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 12761da177e4SLinus Torvalds struct hci_conn *conn = NULL; 12771da177e4SLinus Torvalds int num = 0, min = ~0; 12781da177e4SLinus Torvalds struct list_head *p; 12791da177e4SLinus Torvalds 12801da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 12811da177e4SLinus Torvalds * added and removed with TX task disabled. */ 12821da177e4SLinus Torvalds list_for_each(p, &h->list) { 12831da177e4SLinus Torvalds struct hci_conn *c; 12841da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 12851da177e4SLinus Torvalds 1286769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 12871da177e4SLinus Torvalds continue; 1288769be974SMarcel Holtmann 1289769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1290769be974SMarcel Holtmann continue; 1291769be974SMarcel Holtmann 12921da177e4SLinus Torvalds num++; 12931da177e4SLinus Torvalds 12941da177e4SLinus Torvalds if (c->sent < min) { 12951da177e4SLinus Torvalds min = c->sent; 12961da177e4SLinus Torvalds conn = c; 12971da177e4SLinus Torvalds } 12981da177e4SLinus Torvalds } 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds if (conn) { 13011da177e4SLinus Torvalds int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt); 13021da177e4SLinus Torvalds int q = cnt / num; 13031da177e4SLinus Torvalds *quote = q ? q : 1; 13041da177e4SLinus Torvalds } else 13051da177e4SLinus Torvalds *quote = 0; 13061da177e4SLinus Torvalds 13071da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 13081da177e4SLinus Torvalds return conn; 13091da177e4SLinus Torvalds } 13101da177e4SLinus Torvalds 13111da177e4SLinus Torvalds static inline void hci_acl_tx_to(struct hci_dev *hdev) 13121da177e4SLinus Torvalds { 13131da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 13141da177e4SLinus Torvalds struct list_head *p; 13151da177e4SLinus Torvalds struct hci_conn *c; 13161da177e4SLinus Torvalds 13171da177e4SLinus Torvalds BT_ERR("%s ACL tx timeout", hdev->name); 13181da177e4SLinus Torvalds 13191da177e4SLinus Torvalds /* Kill stalled connections */ 13201da177e4SLinus Torvalds list_for_each(p, &h->list) { 13211da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 13221da177e4SLinus Torvalds if (c->type == ACL_LINK && c->sent) { 13231da177e4SLinus Torvalds BT_ERR("%s killing stalled ACL connection %s", 13241da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 13251da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 13261da177e4SLinus Torvalds } 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds } 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 13311da177e4SLinus Torvalds { 13321da177e4SLinus Torvalds struct hci_conn *conn; 13331da177e4SLinus Torvalds struct sk_buff *skb; 13341da177e4SLinus Torvalds int quote; 13351da177e4SLinus Torvalds 13361da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 13371da177e4SLinus Torvalds 13381da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 13391da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 13401da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 134182453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 13421da177e4SLinus Torvalds hci_acl_tx_to(hdev); 13431da177e4SLinus Torvalds } 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 13461da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 13471da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 134804837f64SMarcel Holtmann 134904837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 135004837f64SMarcel Holtmann 13511da177e4SLinus Torvalds hci_send_frame(skb); 13521da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds hdev->acl_cnt--; 13551da177e4SLinus Torvalds conn->sent++; 13561da177e4SLinus Torvalds } 13571da177e4SLinus Torvalds } 13581da177e4SLinus Torvalds } 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds /* Schedule SCO */ 13611da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 13621da177e4SLinus Torvalds { 13631da177e4SLinus Torvalds struct hci_conn *conn; 13641da177e4SLinus Torvalds struct sk_buff *skb; 13651da177e4SLinus Torvalds int quote; 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 13701da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 13711da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 13721da177e4SLinus Torvalds hci_send_frame(skb); 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds conn->sent++; 13751da177e4SLinus Torvalds if (conn->sent == ~0) 13761da177e4SLinus Torvalds conn->sent = 0; 13771da177e4SLinus Torvalds } 13781da177e4SLinus Torvalds } 13791da177e4SLinus Torvalds } 13801da177e4SLinus Torvalds 1381b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1382b6a0dc82SMarcel Holtmann { 1383b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1384b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1385b6a0dc82SMarcel Holtmann int quote; 1386b6a0dc82SMarcel Holtmann 1387b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1388b6a0dc82SMarcel Holtmann 1389b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1390b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1391b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1392b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1393b6a0dc82SMarcel Holtmann 1394b6a0dc82SMarcel Holtmann conn->sent++; 1395b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1396b6a0dc82SMarcel Holtmann conn->sent = 0; 1397b6a0dc82SMarcel Holtmann } 1398b6a0dc82SMarcel Holtmann } 1399b6a0dc82SMarcel Holtmann } 1400b6a0dc82SMarcel Holtmann 14011da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 14021da177e4SLinus Torvalds { 14031da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 14041da177e4SLinus Torvalds struct sk_buff *skb; 14051da177e4SLinus Torvalds 14061da177e4SLinus Torvalds read_lock(&hci_task_lock); 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt); 14091da177e4SLinus Torvalds 14101da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 14111da177e4SLinus Torvalds 14121da177e4SLinus Torvalds hci_sched_acl(hdev); 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds hci_sched_sco(hdev); 14151da177e4SLinus Torvalds 1416b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1417b6a0dc82SMarcel Holtmann 14181da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 14191da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 14201da177e4SLinus Torvalds hci_send_frame(skb); 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds read_unlock(&hci_task_lock); 14231da177e4SLinus Torvalds } 14241da177e4SLinus Torvalds 14251da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 14261da177e4SLinus Torvalds 14271da177e4SLinus Torvalds /* ACL data packet */ 14281da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 14291da177e4SLinus Torvalds { 14301da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 14311da177e4SLinus Torvalds struct hci_conn *conn; 14321da177e4SLinus Torvalds __u16 handle, flags; 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 14371da177e4SLinus Torvalds flags = hci_flags(handle); 14381da177e4SLinus Torvalds handle = hci_handle(handle); 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds hdev->stat.acl_rx++; 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds hci_dev_lock(hdev); 14451da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 14461da177e4SLinus Torvalds hci_dev_unlock(hdev); 14471da177e4SLinus Torvalds 14481da177e4SLinus Torvalds if (conn) { 14491da177e4SLinus Torvalds register struct hci_proto *hp; 14501da177e4SLinus Torvalds 145104837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 145204837f64SMarcel Holtmann 14531da177e4SLinus Torvalds /* Send to upper protocol */ 14541da177e4SLinus Torvalds if ((hp = hci_proto[HCI_PROTO_L2CAP]) && hp->recv_acldata) { 14551da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 14561da177e4SLinus Torvalds return; 14571da177e4SLinus Torvalds } 14581da177e4SLinus Torvalds } else { 14591da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 14601da177e4SLinus Torvalds hdev->name, handle); 14611da177e4SLinus Torvalds } 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds kfree_skb(skb); 14641da177e4SLinus Torvalds } 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds /* SCO data packet */ 14671da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 14681da177e4SLinus Torvalds { 14691da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 14701da177e4SLinus Torvalds struct hci_conn *conn; 14711da177e4SLinus Torvalds __u16 handle; 14721da177e4SLinus Torvalds 14731da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 14761da177e4SLinus Torvalds 14771da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds hdev->stat.sco_rx++; 14801da177e4SLinus Torvalds 14811da177e4SLinus Torvalds hci_dev_lock(hdev); 14821da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 14831da177e4SLinus Torvalds hci_dev_unlock(hdev); 14841da177e4SLinus Torvalds 14851da177e4SLinus Torvalds if (conn) { 14861da177e4SLinus Torvalds register struct hci_proto *hp; 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds /* Send to upper protocol */ 14891da177e4SLinus Torvalds if ((hp = hci_proto[HCI_PROTO_SCO]) && hp->recv_scodata) { 14901da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 14911da177e4SLinus Torvalds return; 14921da177e4SLinus Torvalds } 14931da177e4SLinus Torvalds } else { 14941da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 14951da177e4SLinus Torvalds hdev->name, handle); 14961da177e4SLinus Torvalds } 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds kfree_skb(skb); 14991da177e4SLinus Torvalds } 15001da177e4SLinus Torvalds 15016516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 15021da177e4SLinus Torvalds { 15031da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 15041da177e4SLinus Torvalds struct sk_buff *skb; 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 15071da177e4SLinus Torvalds 15081da177e4SLinus Torvalds read_lock(&hci_task_lock); 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 15111da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 15121da177e4SLinus Torvalds /* Send copy to the sockets */ 15131da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 15141da177e4SLinus Torvalds } 15151da177e4SLinus Torvalds 15161da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 15171da177e4SLinus Torvalds kfree_skb(skb); 15181da177e4SLinus Torvalds continue; 15191da177e4SLinus Torvalds } 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 15221da177e4SLinus Torvalds /* Don't process data packets in this states. */ 15230d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 15241da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 15251da177e4SLinus Torvalds case HCI_SCODATA_PKT: 15261da177e4SLinus Torvalds kfree_skb(skb); 15271da177e4SLinus Torvalds continue; 15283ff50b79SStephen Hemminger } 15291da177e4SLinus Torvalds } 15301da177e4SLinus Torvalds 15311da177e4SLinus Torvalds /* Process frame */ 15320d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 15331da177e4SLinus Torvalds case HCI_EVENT_PKT: 15341da177e4SLinus Torvalds hci_event_packet(hdev, skb); 15351da177e4SLinus Torvalds break; 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 15381da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 15391da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 15401da177e4SLinus Torvalds break; 15411da177e4SLinus Torvalds 15421da177e4SLinus Torvalds case HCI_SCODATA_PKT: 15431da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 15441da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 15451da177e4SLinus Torvalds break; 15461da177e4SLinus Torvalds 15471da177e4SLinus Torvalds default: 15481da177e4SLinus Torvalds kfree_skb(skb); 15491da177e4SLinus Torvalds break; 15501da177e4SLinus Torvalds } 15511da177e4SLinus Torvalds } 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds read_unlock(&hci_task_lock); 15541da177e4SLinus Torvalds } 15551da177e4SLinus Torvalds 15561da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 15571da177e4SLinus Torvalds { 15581da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 15591da177e4SLinus Torvalds struct sk_buff *skb; 15601da177e4SLinus Torvalds 15611da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 15621da177e4SLinus Torvalds 156382453021SS.Çağlar Onur if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) { 15641da177e4SLinus Torvalds BT_ERR("%s command tx timeout", hdev->name); 15651da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 15661da177e4SLinus Torvalds } 15671da177e4SLinus Torvalds 15681da177e4SLinus Torvalds /* Send queued commands */ 15691da177e4SLinus Torvalds if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) { 15701da177e4SLinus Torvalds if (hdev->sent_cmd) 15711da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds if ((hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC))) { 15741da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 15751da177e4SLinus Torvalds hci_send_frame(skb); 15761da177e4SLinus Torvalds hdev->cmd_last_tx = jiffies; 15771da177e4SLinus Torvalds } else { 15781da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 15791da177e4SLinus Torvalds hci_sched_cmd(hdev); 15801da177e4SLinus Torvalds } 15811da177e4SLinus Torvalds } 15821da177e4SLinus Torvalds } 1583