11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 41da177e4SLinus Torvalds 51da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 61da177e4SLinus Torvalds 71da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 81da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 91da177e4SLinus Torvalds published by the Free Software Foundation; 101da177e4SLinus Torvalds 111da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 121da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 131da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 141da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 151da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 161da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 171da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 181da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 211da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 221da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 231da177e4SLinus Torvalds */ 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds /* Bluetooth HCI core. */ 261da177e4SLinus Torvalds 2782453021SS.Çağlar Onur #include <linux/jiffies.h> 281da177e4SLinus Torvalds #include <linux/module.h> 291da177e4SLinus Torvalds #include <linux/kmod.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <linux/types.h> 321da177e4SLinus Torvalds #include <linux/errno.h> 331da177e4SLinus Torvalds #include <linux/kernel.h> 341da177e4SLinus Torvalds #include <linux/sched.h> 351da177e4SLinus Torvalds #include <linux/slab.h> 361da177e4SLinus Torvalds #include <linux/poll.h> 371da177e4SLinus Torvalds #include <linux/fcntl.h> 381da177e4SLinus Torvalds #include <linux/init.h> 391da177e4SLinus Torvalds #include <linux/skbuff.h> 40f48fd9c8SMarcel Holtmann #include <linux/workqueue.h> 411da177e4SLinus Torvalds #include <linux/interrupt.h> 421da177e4SLinus Torvalds #include <linux/notifier.h> 43611b30f7SMarcel Holtmann #include <linux/rfkill.h> 441da177e4SLinus Torvalds #include <net/sock.h> 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds #include <asm/system.h> 4770f23020SAndrei Emeltchenko #include <linux/uaccess.h> 481da177e4SLinus Torvalds #include <asm/unaligned.h> 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 511da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 521da177e4SLinus Torvalds 53ab81cbf9SJohan Hedberg #define AUTO_OFF_TIMEOUT 2000 54ab81cbf9SJohan Hedberg 551da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg); 561da177e4SLinus Torvalds static void hci_rx_task(unsigned long arg); 571da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg); 581da177e4SLinus Torvalds static void hci_notify(struct hci_dev *hdev, int event); 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds static DEFINE_RWLOCK(hci_task_lock); 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds /* HCI device list */ 631da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 641da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /* HCI callback list */ 671da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 681da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 691da177e4SLinus Torvalds 701da177e4SLinus Torvalds /* HCI protocols */ 711da177e4SLinus Torvalds #define HCI_MAX_PROTO 2 721da177e4SLinus Torvalds struct hci_proto *hci_proto[HCI_MAX_PROTO]; 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds /* HCI notifiers list */ 75e041c683SAlan Stern static ATOMIC_NOTIFIER_HEAD(hci_notifier); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds int hci_register_notifier(struct notifier_block *nb) 801da177e4SLinus Torvalds { 81e041c683SAlan Stern return atomic_notifier_chain_register(&hci_notifier, nb); 821da177e4SLinus Torvalds } 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds int hci_unregister_notifier(struct notifier_block *nb) 851da177e4SLinus Torvalds { 86e041c683SAlan Stern return atomic_notifier_chain_unregister(&hci_notifier, nb); 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 896516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 901da177e4SLinus Torvalds { 91e041c683SAlan Stern atomic_notifier_call_chain(&hci_notifier, event, hdev); 921da177e4SLinus Torvalds } 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds /* ---- HCI requests ---- */ 951da177e4SLinus Torvalds 9623bb5763SJohan Hedberg void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result) 971da177e4SLinus Torvalds { 9823bb5763SJohan Hedberg BT_DBG("%s command 0x%04x result 0x%2.2x", hdev->name, cmd, result); 9923bb5763SJohan Hedberg 100a5040efaSJohan Hedberg /* If this is the init phase check if the completed command matches 101a5040efaSJohan Hedberg * the last init command, and if not just return. 102a5040efaSJohan Hedberg */ 103a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && hdev->init_last_cmd != cmd) 10423bb5763SJohan Hedberg return; 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1071da177e4SLinus Torvalds hdev->req_result = result; 1081da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1091da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1141da177e4SLinus Torvalds { 1151da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1181da177e4SLinus Torvalds hdev->req_result = err; 1191da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1201da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1211da177e4SLinus Torvalds } 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds /* Execute request and wait for completion. */ 1251da177e4SLinus Torvalds static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1261da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1291da177e4SLinus Torvalds int err = 0; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds add_wait_queue(&hdev->req_wait_q, &wait); 1361da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds req(hdev, opt); 1391da177e4SLinus Torvalds schedule_timeout(timeout); 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds if (signal_pending(current)) 1441da177e4SLinus Torvalds return -EINTR; 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds switch (hdev->req_status) { 1471da177e4SLinus Torvalds case HCI_REQ_DONE: 1481da177e4SLinus Torvalds err = -bt_err(hdev->req_result); 1491da177e4SLinus Torvalds break; 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds case HCI_REQ_CANCELED: 1521da177e4SLinus Torvalds err = -hdev->req_result; 1531da177e4SLinus Torvalds break; 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds default: 1561da177e4SLinus Torvalds err = -ETIMEDOUT; 1571da177e4SLinus Torvalds break; 1583ff50b79SStephen Hemminger } 1591da177e4SLinus Torvalds 160a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds return err; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1681da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1691da177e4SLinus Torvalds { 1701da177e4SLinus Torvalds int ret; 1711da177e4SLinus Torvalds 1727c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 1737c6a329eSMarcel Holtmann return -ENETDOWN; 1747c6a329eSMarcel Holtmann 1751da177e4SLinus Torvalds /* Serialize all requests */ 1761da177e4SLinus Torvalds hci_req_lock(hdev); 1771da177e4SLinus Torvalds ret = __hci_request(hdev, req, opt, timeout); 1781da177e4SLinus Torvalds hci_req_unlock(hdev); 1791da177e4SLinus Torvalds 1801da177e4SLinus Torvalds return ret; 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds static void hci_reset_req(struct hci_dev *hdev, unsigned long opt) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds /* Reset device */ 188a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1921da177e4SLinus Torvalds { 193b0916ea0SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 1941da177e4SLinus Torvalds struct sk_buff *skb; 1951ebb9252SMarcel Holtmann __le16 param; 19689f2783dSMarcel Holtmann __u8 flt_type; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* Driver initialization */ 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds /* Special commands */ 2031da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 2040d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2051da177e4SLinus Torvalds skb->dev = (void *) hdev; 206c78ae283SMarcel Holtmann 2071da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 208c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds /* Mandatory initialization */ 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds /* Reset */ 2157a9d4020SMarcel Holtmann if (!test_bit(HCI_QUIRK_NO_RESET, &hdev->quirks)) 216a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds /* Read Local Supported Features */ 219a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2201da177e4SLinus Torvalds 2211143e5a6SMarcel Holtmann /* Read Local Version */ 222a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2231143e5a6SMarcel Holtmann 2241da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 225a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds #if 0 2281da177e4SLinus Torvalds /* Host buffer size */ 2291da177e4SLinus Torvalds { 2301da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 231aca3192cSYOSHIFUJI Hideaki cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE); 2321da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 233aca3192cSYOSHIFUJI Hideaki cp.acl_max_pkt = cpu_to_le16(0xffff); 234aca3192cSYOSHIFUJI Hideaki cp.sco_max_pkt = cpu_to_le16(0xffff); 235a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds #endif 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds /* Read BD Address */ 240a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL); 241a9de9248SMarcel Holtmann 242a9de9248SMarcel Holtmann /* Read Class of Device */ 243a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 244a9de9248SMarcel Holtmann 245a9de9248SMarcel Holtmann /* Read Local Name */ 246a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds /* Read Voice Setting */ 249a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* Optional initialization */ 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* Clear Event Filters */ 25489f2783dSMarcel Holtmann flt_type = HCI_FLT_CLEAR_ALL; 255a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 258aca3192cSYOSHIFUJI Hideaki param = cpu_to_le16(0x7d00); 259a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 260b0916ea0SJohan Hedberg 261b0916ea0SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 262b0916ea0SJohan Hedberg cp.delete_all = 1; 263b0916ea0SJohan Hedberg hci_send_cmd(hdev, HCI_OP_DELETE_STORED_LINK_KEY, sizeof(cp), &cp); 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2671da177e4SLinus Torvalds { 2681da177e4SLinus Torvalds __u8 scan = opt; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds /* Inquiry and Page scans */ 273a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2771da177e4SLinus Torvalds { 2781da177e4SLinus Torvalds __u8 auth = opt; 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds /* Authentication */ 283a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2871da177e4SLinus Torvalds { 2881da177e4SLinus Torvalds __u8 encrypt = opt; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 2911da177e4SLinus Torvalds 292e4e8e37cSMarcel Holtmann /* Encryption */ 293a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds 296e4e8e37cSMarcel Holtmann static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt) 297e4e8e37cSMarcel Holtmann { 298e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 299e4e8e37cSMarcel Holtmann 300a418b893SMarcel Holtmann BT_DBG("%s %x", hdev->name, policy); 301e4e8e37cSMarcel Holtmann 302e4e8e37cSMarcel Holtmann /* Default link policy */ 303e4e8e37cSMarcel Holtmann hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 304e4e8e37cSMarcel Holtmann } 305e4e8e37cSMarcel Holtmann 3061da177e4SLinus Torvalds /* Get HCI device by index. 3071da177e4SLinus Torvalds * Device is held on return. */ 3081da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 3091da177e4SLinus Torvalds { 3101da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 3111da177e4SLinus Torvalds struct list_head *p; 3121da177e4SLinus Torvalds 3131da177e4SLinus Torvalds BT_DBG("%d", index); 3141da177e4SLinus Torvalds 3151da177e4SLinus Torvalds if (index < 0) 3161da177e4SLinus Torvalds return NULL; 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 3191da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 3201da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 3211da177e4SLinus Torvalds if (d->id == index) { 3221da177e4SLinus Torvalds hdev = hci_dev_hold(d); 3231da177e4SLinus Torvalds break; 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 3271da177e4SLinus Torvalds return hdev; 3281da177e4SLinus Torvalds } 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3311da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3321da177e4SLinus Torvalds { 3331da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3341da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds cache->list = NULL; 3391da177e4SLinus Torvalds while ((e = next)) { 3401da177e4SLinus Torvalds next = e->next; 3411da177e4SLinus Torvalds kfree(e); 3421da177e4SLinus Torvalds } 3431da177e4SLinus Torvalds } 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3461da177e4SLinus Torvalds { 3471da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3481da177e4SLinus Torvalds struct inquiry_entry *e; 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3531da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3541da177e4SLinus Torvalds break; 3551da177e4SLinus Torvalds return e; 3561da177e4SLinus Torvalds } 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3591da177e4SLinus Torvalds { 3601da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 36170f23020SAndrei Emeltchenko struct inquiry_entry *ie; 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3641da177e4SLinus Torvalds 36570f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 36670f23020SAndrei Emeltchenko if (!ie) { 3671da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 36870f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 36970f23020SAndrei Emeltchenko if (!ie) 3701da177e4SLinus Torvalds return; 37170f23020SAndrei Emeltchenko 37270f23020SAndrei Emeltchenko ie->next = cache->list; 37370f23020SAndrei Emeltchenko cache->list = ie; 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds 37670f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 37770f23020SAndrei Emeltchenko ie->timestamp = jiffies; 3781da177e4SLinus Torvalds cache->timestamp = jiffies; 3791da177e4SLinus Torvalds } 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3821da177e4SLinus Torvalds { 3831da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3841da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3851da177e4SLinus Torvalds struct inquiry_entry *e; 3861da177e4SLinus Torvalds int copied = 0; 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 3891da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 3901da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 3911da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 3921da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 3931da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 3941da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 3951da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 3961da177e4SLinus Torvalds info++; 3971da177e4SLinus Torvalds } 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 4001da177e4SLinus Torvalds return copied; 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 4041da177e4SLinus Torvalds { 4051da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 4061da177e4SLinus Torvalds struct hci_cp_inquiry cp; 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 4111da177e4SLinus Torvalds return; 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds /* Start Inquiry */ 4141da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 4151da177e4SLinus Torvalds cp.length = ir->length; 4161da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 417a9de9248SMarcel Holtmann hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp); 4181da177e4SLinus Torvalds } 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 4211da177e4SLinus Torvalds { 4221da177e4SLinus Torvalds __u8 __user *ptr = arg; 4231da177e4SLinus Torvalds struct hci_inquiry_req ir; 4241da177e4SLinus Torvalds struct hci_dev *hdev; 4251da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 4261da177e4SLinus Torvalds long timeo; 4271da177e4SLinus Torvalds __u8 *buf; 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4301da177e4SLinus Torvalds return -EFAULT; 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds if (!(hdev = hci_dev_get(ir.dev_id))) 4331da177e4SLinus Torvalds return -ENODEV; 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4361da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4371da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4381da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4391da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4401da177e4SLinus Torvalds do_inquiry = 1; 4411da177e4SLinus Torvalds } 4421da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4431da177e4SLinus Torvalds 44404837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 44570f23020SAndrei Emeltchenko 44670f23020SAndrei Emeltchenko if (do_inquiry) { 44770f23020SAndrei Emeltchenko err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo); 44870f23020SAndrei Emeltchenko if (err < 0) 4491da177e4SLinus Torvalds goto done; 45070f23020SAndrei Emeltchenko } 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4531da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4561da177e4SLinus Torvalds * copy it to the user space. 4571da177e4SLinus Torvalds */ 45870f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) *max_rsp, GFP_KERNEL); 45970f23020SAndrei Emeltchenko if (!buf) { 4601da177e4SLinus Torvalds err = -ENOMEM; 4611da177e4SLinus Torvalds goto done; 4621da177e4SLinus Torvalds } 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4651da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4661da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4711da177e4SLinus Torvalds ptr += sizeof(ir); 4721da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4731da177e4SLinus Torvalds ir.num_rsp)) 4741da177e4SLinus Torvalds err = -EFAULT; 4751da177e4SLinus Torvalds } else 4761da177e4SLinus Torvalds err = -EFAULT; 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds kfree(buf); 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds done: 4811da177e4SLinus Torvalds hci_dev_put(hdev); 4821da177e4SLinus Torvalds return err; 4831da177e4SLinus Torvalds } 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 4881da177e4SLinus Torvalds { 4891da177e4SLinus Torvalds struct hci_dev *hdev; 4901da177e4SLinus Torvalds int ret = 0; 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 4931da177e4SLinus Torvalds return -ENODEV; 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds hci_req_lock(hdev); 4981da177e4SLinus Torvalds 499611b30f7SMarcel Holtmann if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) { 500611b30f7SMarcel Holtmann ret = -ERFKILL; 501611b30f7SMarcel Holtmann goto done; 502611b30f7SMarcel Holtmann } 503611b30f7SMarcel Holtmann 5041da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 5051da177e4SLinus Torvalds ret = -EALREADY; 5061da177e4SLinus Torvalds goto done; 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds 5091da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 5101da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 5111da177e4SLinus Torvalds 512943da25dSMarcel Holtmann /* Treat all non BR/EDR controllers as raw devices for now */ 513943da25dSMarcel Holtmann if (hdev->dev_type != HCI_BREDR) 514943da25dSMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 515943da25dSMarcel Holtmann 5161da177e4SLinus Torvalds if (hdev->open(hdev)) { 5171da177e4SLinus Torvalds ret = -EIO; 5181da177e4SLinus Torvalds goto done; 5191da177e4SLinus Torvalds } 5201da177e4SLinus Torvalds 5211da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5221da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5231da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 524a5040efaSJohan Hedberg hdev->init_last_cmd = 0; 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds //__hci_request(hdev, hci_reset_req, 0, HZ); 52704837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 52804837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5311da177e4SLinus Torvalds } 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds if (!ret) { 5341da177e4SLinus Torvalds hci_dev_hold(hdev); 5351da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 5361da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 5375add6af8SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->flags)) 5385add6af8SJohan Hedberg mgmt_powered(hdev->id, 1); 5391da177e4SLinus Torvalds } else { 5401da177e4SLinus Torvalds /* Init failed, cleanup */ 5411da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5421da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5431da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5461da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds if (hdev->flush) 5491da177e4SLinus Torvalds hdev->flush(hdev); 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds if (hdev->sent_cmd) { 5521da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5531da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds hdev->close(hdev); 5571da177e4SLinus Torvalds hdev->flags = 0; 5581da177e4SLinus Torvalds } 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds done: 5611da177e4SLinus Torvalds hci_req_unlock(hdev); 5621da177e4SLinus Torvalds hci_dev_put(hdev); 5631da177e4SLinus Torvalds return ret; 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5671da177e4SLinus Torvalds { 5681da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5711da177e4SLinus Torvalds hci_req_lock(hdev); 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 5741da177e4SLinus Torvalds hci_req_unlock(hdev); 5751da177e4SLinus Torvalds return 0; 5761da177e4SLinus Torvalds } 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5791da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5801da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 5831da177e4SLinus Torvalds inquiry_cache_flush(hdev); 5841da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 5851da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds if (hdev->flush) 5901da177e4SLinus Torvalds hdev->flush(hdev); 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds /* Reset device */ 5931da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5941da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5951da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5961da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 59704837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 59804837f64SMarcel Holtmann msecs_to_jiffies(250)); 5991da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds /* Kill cmd task */ 6031da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds /* Drop queues */ 6061da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6071da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6081da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds /* Drop last sent command */ 6111da177e4SLinus Torvalds if (hdev->sent_cmd) { 6121da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 6131da177e4SLinus Torvalds hdev->sent_cmd = NULL; 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds /* After this point our queues are empty 6171da177e4SLinus Torvalds * and no tasks are scheduled. */ 6181da177e4SLinus Torvalds hdev->close(hdev); 6191da177e4SLinus Torvalds 6205add6af8SJohan Hedberg mgmt_powered(hdev->id, 0); 6215add6af8SJohan Hedberg 6221da177e4SLinus Torvalds /* Clear flags */ 6231da177e4SLinus Torvalds hdev->flags = 0; 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds hci_req_unlock(hdev); 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds hci_dev_put(hdev); 6281da177e4SLinus Torvalds return 0; 6291da177e4SLinus Torvalds } 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 6321da177e4SLinus Torvalds { 6331da177e4SLinus Torvalds struct hci_dev *hdev; 6341da177e4SLinus Torvalds int err; 6351da177e4SLinus Torvalds 63670f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 63770f23020SAndrei Emeltchenko if (!hdev) 6381da177e4SLinus Torvalds return -ENODEV; 6391da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 6401da177e4SLinus Torvalds hci_dev_put(hdev); 6411da177e4SLinus Torvalds return err; 6421da177e4SLinus Torvalds } 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 6451da177e4SLinus Torvalds { 6461da177e4SLinus Torvalds struct hci_dev *hdev; 6471da177e4SLinus Torvalds int ret = 0; 6481da177e4SLinus Torvalds 64970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 65070f23020SAndrei Emeltchenko if (!hdev) 6511da177e4SLinus Torvalds return -ENODEV; 6521da177e4SLinus Torvalds 6531da177e4SLinus Torvalds hci_req_lock(hdev); 6541da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6571da177e4SLinus Torvalds goto done; 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds /* Drop queues */ 6601da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6611da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6641da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6651da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6661da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds if (hdev->flush) 6691da177e4SLinus Torvalds hdev->flush(hdev); 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6721da177e4SLinus Torvalds hdev->acl_cnt = 0; hdev->sco_cnt = 0; 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 67504837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 67604837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds done: 6791da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6801da177e4SLinus Torvalds hci_req_unlock(hdev); 6811da177e4SLinus Torvalds hci_dev_put(hdev); 6821da177e4SLinus Torvalds return ret; 6831da177e4SLinus Torvalds } 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 6861da177e4SLinus Torvalds { 6871da177e4SLinus Torvalds struct hci_dev *hdev; 6881da177e4SLinus Torvalds int ret = 0; 6891da177e4SLinus Torvalds 69070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 69170f23020SAndrei Emeltchenko if (!hdev) 6921da177e4SLinus Torvalds return -ENODEV; 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds hci_dev_put(hdev); 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds return ret; 6991da177e4SLinus Torvalds } 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 7021da177e4SLinus Torvalds { 7031da177e4SLinus Torvalds struct hci_dev *hdev; 7041da177e4SLinus Torvalds struct hci_dev_req dr; 7051da177e4SLinus Torvalds int err = 0; 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 7081da177e4SLinus Torvalds return -EFAULT; 7091da177e4SLinus Torvalds 71070f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 71170f23020SAndrei Emeltchenko if (!hdev) 7121da177e4SLinus Torvalds return -ENODEV; 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds switch (cmd) { 7151da177e4SLinus Torvalds case HCISETAUTH: 71604837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 71704837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7181da177e4SLinus Torvalds break; 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds case HCISETENCRYPT: 7211da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 7221da177e4SLinus Torvalds err = -EOPNOTSUPP; 7231da177e4SLinus Torvalds break; 7241da177e4SLinus Torvalds } 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 7271da177e4SLinus Torvalds /* Auth must be enabled first */ 72804837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 72904837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7301da177e4SLinus Torvalds if (err) 7311da177e4SLinus Torvalds break; 7321da177e4SLinus Torvalds } 7331da177e4SLinus Torvalds 73404837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 73504837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7361da177e4SLinus Torvalds break; 7371da177e4SLinus Torvalds 7381da177e4SLinus Torvalds case HCISETSCAN: 73904837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 74004837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7411da177e4SLinus Torvalds break; 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds case HCISETLINKPOL: 744e4e8e37cSMarcel Holtmann err = hci_request(hdev, hci_linkpol_req, dr.dev_opt, 745e4e8e37cSMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 7461da177e4SLinus Torvalds break; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds case HCISETLINKMODE: 749e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 750e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 751e4e8e37cSMarcel Holtmann break; 752e4e8e37cSMarcel Holtmann 753e4e8e37cSMarcel Holtmann case HCISETPTYPE: 754e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 7551da177e4SLinus Torvalds break; 7561da177e4SLinus Torvalds 7571da177e4SLinus Torvalds case HCISETACLMTU: 7581da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 7591da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 7601da177e4SLinus Torvalds break; 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds case HCISETSCOMTU: 7631da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 7641da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 7651da177e4SLinus Torvalds break; 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds default: 7681da177e4SLinus Torvalds err = -EINVAL; 7691da177e4SLinus Torvalds break; 7701da177e4SLinus Torvalds } 771e4e8e37cSMarcel Holtmann 7721da177e4SLinus Torvalds hci_dev_put(hdev); 7731da177e4SLinus Torvalds return err; 7741da177e4SLinus Torvalds } 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7771da177e4SLinus Torvalds { 7781da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7791da177e4SLinus Torvalds struct hci_dev_req *dr; 7801da177e4SLinus Torvalds struct list_head *p; 7811da177e4SLinus Torvalds int n = 0, size, err; 7821da177e4SLinus Torvalds __u16 dev_num; 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 7851da177e4SLinus Torvalds return -EFAULT; 7861da177e4SLinus Torvalds 7871da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 7881da177e4SLinus Torvalds return -EINVAL; 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 7911da177e4SLinus Torvalds 79270f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 79370f23020SAndrei Emeltchenko if (!dl) 7941da177e4SLinus Torvalds return -ENOMEM; 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds dr = dl->dev_req; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 7991da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8001da177e4SLinus Torvalds struct hci_dev *hdev; 801c542a06cSJohan Hedberg 8021da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 803c542a06cSJohan Hedberg 804ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 805c542a06cSJohan Hedberg 806c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 807c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 808c542a06cSJohan Hedberg 8091da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 8101da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 811c542a06cSJohan Hedberg 8121da177e4SLinus Torvalds if (++n >= dev_num) 8131da177e4SLinus Torvalds break; 8141da177e4SLinus Torvalds } 8151da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds dl->dev_num = n; 8181da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 8211da177e4SLinus Torvalds kfree(dl); 8221da177e4SLinus Torvalds 8231da177e4SLinus Torvalds return err ? -EFAULT : 0; 8241da177e4SLinus Torvalds } 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 8271da177e4SLinus Torvalds { 8281da177e4SLinus Torvalds struct hci_dev *hdev; 8291da177e4SLinus Torvalds struct hci_dev_info di; 8301da177e4SLinus Torvalds int err = 0; 8311da177e4SLinus Torvalds 8321da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 8331da177e4SLinus Torvalds return -EFAULT; 8341da177e4SLinus Torvalds 83570f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 83670f23020SAndrei Emeltchenko if (!hdev) 8371da177e4SLinus Torvalds return -ENODEV; 8381da177e4SLinus Torvalds 839ab81cbf9SJohan Hedberg hci_del_off_timer(hdev); 840ab81cbf9SJohan Hedberg 841c542a06cSJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->flags)) 842c542a06cSJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->flags); 843c542a06cSJohan Hedberg 8441da177e4SLinus Torvalds strcpy(di.name, hdev->name); 8451da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 846943da25dSMarcel Holtmann di.type = (hdev->bus & 0x0f) | (hdev->dev_type << 4); 8471da177e4SLinus Torvalds di.flags = hdev->flags; 8481da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 8491da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 8501da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 8511da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 8521da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 8531da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 8541da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 8551da177e4SLinus Torvalds 8561da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 8571da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 8581da177e4SLinus Torvalds 8591da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 8601da177e4SLinus Torvalds err = -EFAULT; 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds hci_dev_put(hdev); 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds return err; 8651da177e4SLinus Torvalds } 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 8681da177e4SLinus Torvalds 869611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 870611b30f7SMarcel Holtmann { 871611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 872611b30f7SMarcel Holtmann 873611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 874611b30f7SMarcel Holtmann 875611b30f7SMarcel Holtmann if (!blocked) 876611b30f7SMarcel Holtmann return 0; 877611b30f7SMarcel Holtmann 878611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 879611b30f7SMarcel Holtmann 880611b30f7SMarcel Holtmann return 0; 881611b30f7SMarcel Holtmann } 882611b30f7SMarcel Holtmann 883611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 884611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 885611b30f7SMarcel Holtmann }; 886611b30f7SMarcel Holtmann 8871da177e4SLinus Torvalds /* Alloc HCI device */ 8881da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 8891da177e4SLinus Torvalds { 8901da177e4SLinus Torvalds struct hci_dev *hdev; 8911da177e4SLinus Torvalds 89225ea6db0SMarcel Holtmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 8931da177e4SLinus Torvalds if (!hdev) 8941da177e4SLinus Torvalds return NULL; 8951da177e4SLinus Torvalds 8961da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds return hdev; 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds /* Free HCI device */ 9031da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 9041da177e4SLinus Torvalds { 9051da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 9061da177e4SLinus Torvalds 907a91f2e39SMarcel Holtmann /* will free via device release */ 908a91f2e39SMarcel Holtmann put_device(&hdev->dev); 9091da177e4SLinus Torvalds } 9101da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 9111da177e4SLinus Torvalds 912ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 913ab81cbf9SJohan Hedberg { 914ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 915ab81cbf9SJohan Hedberg 916ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 917ab81cbf9SJohan Hedberg 918ab81cbf9SJohan Hedberg if (hci_dev_open(hdev->id) < 0) 919ab81cbf9SJohan Hedberg return; 920ab81cbf9SJohan Hedberg 921ab81cbf9SJohan Hedberg if (test_bit(HCI_AUTO_OFF, &hdev->flags)) 922ab81cbf9SJohan Hedberg mod_timer(&hdev->off_timer, 923ab81cbf9SJohan Hedberg jiffies + msecs_to_jiffies(AUTO_OFF_TIMEOUT)); 924ab81cbf9SJohan Hedberg 925ab81cbf9SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->flags)) 926ab81cbf9SJohan Hedberg mgmt_index_added(hdev->id); 927ab81cbf9SJohan Hedberg } 928ab81cbf9SJohan Hedberg 929ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 930ab81cbf9SJohan Hedberg { 931ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_off); 932ab81cbf9SJohan Hedberg 933ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 934ab81cbf9SJohan Hedberg 935ab81cbf9SJohan Hedberg hci_dev_close(hdev->id); 936ab81cbf9SJohan Hedberg } 937ab81cbf9SJohan Hedberg 938ab81cbf9SJohan Hedberg static void hci_auto_off(unsigned long data) 939ab81cbf9SJohan Hedberg { 940ab81cbf9SJohan Hedberg struct hci_dev *hdev = (struct hci_dev *) data; 941ab81cbf9SJohan Hedberg 942ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 943ab81cbf9SJohan Hedberg 944ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 945ab81cbf9SJohan Hedberg 946ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_off); 947ab81cbf9SJohan Hedberg } 948ab81cbf9SJohan Hedberg 949ab81cbf9SJohan Hedberg void hci_del_off_timer(struct hci_dev *hdev) 950ab81cbf9SJohan Hedberg { 951ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 952ab81cbf9SJohan Hedberg 953ab81cbf9SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->flags); 954ab81cbf9SJohan Hedberg del_timer(&hdev->off_timer); 955ab81cbf9SJohan Hedberg } 956ab81cbf9SJohan Hedberg 9572aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 9582aeb9a1aSJohan Hedberg { 9592aeb9a1aSJohan Hedberg struct list_head *p, *n; 9602aeb9a1aSJohan Hedberg 9612aeb9a1aSJohan Hedberg list_for_each_safe(p, n, &hdev->uuids) { 9622aeb9a1aSJohan Hedberg struct bt_uuid *uuid; 9632aeb9a1aSJohan Hedberg 9642aeb9a1aSJohan Hedberg uuid = list_entry(p, struct bt_uuid, list); 9652aeb9a1aSJohan Hedberg 9662aeb9a1aSJohan Hedberg list_del(p); 9672aeb9a1aSJohan Hedberg kfree(uuid); 9682aeb9a1aSJohan Hedberg } 9692aeb9a1aSJohan Hedberg 9702aeb9a1aSJohan Hedberg return 0; 9712aeb9a1aSJohan Hedberg } 9722aeb9a1aSJohan Hedberg 97355ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 97455ed8ca1SJohan Hedberg { 97555ed8ca1SJohan Hedberg struct list_head *p, *n; 97655ed8ca1SJohan Hedberg 97755ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 97855ed8ca1SJohan Hedberg struct link_key *key; 97955ed8ca1SJohan Hedberg 98055ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 98155ed8ca1SJohan Hedberg 98255ed8ca1SJohan Hedberg list_del(p); 98355ed8ca1SJohan Hedberg kfree(key); 98455ed8ca1SJohan Hedberg } 98555ed8ca1SJohan Hedberg 98655ed8ca1SJohan Hedberg return 0; 98755ed8ca1SJohan Hedberg } 98855ed8ca1SJohan Hedberg 98955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 99055ed8ca1SJohan Hedberg { 99155ed8ca1SJohan Hedberg struct list_head *p; 99255ed8ca1SJohan Hedberg 99355ed8ca1SJohan Hedberg list_for_each(p, &hdev->link_keys) { 99455ed8ca1SJohan Hedberg struct link_key *k; 99555ed8ca1SJohan Hedberg 99655ed8ca1SJohan Hedberg k = list_entry(p, struct link_key, list); 99755ed8ca1SJohan Hedberg 99855ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 99955ed8ca1SJohan Hedberg return k; 100055ed8ca1SJohan Hedberg } 100155ed8ca1SJohan Hedberg 100255ed8ca1SJohan Hedberg return NULL; 100355ed8ca1SJohan Hedberg } 100455ed8ca1SJohan Hedberg 100555ed8ca1SJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, int new_key, bdaddr_t *bdaddr, 100655ed8ca1SJohan Hedberg u8 *val, u8 type, u8 pin_len) 100755ed8ca1SJohan Hedberg { 100855ed8ca1SJohan Hedberg struct link_key *key, *old_key; 100955ed8ca1SJohan Hedberg u8 old_key_type; 101055ed8ca1SJohan Hedberg 101155ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 101255ed8ca1SJohan Hedberg if (old_key) { 101355ed8ca1SJohan Hedberg old_key_type = old_key->type; 101455ed8ca1SJohan Hedberg key = old_key; 101555ed8ca1SJohan Hedberg } else { 101655ed8ca1SJohan Hedberg old_key_type = 0xff; 101755ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 101855ed8ca1SJohan Hedberg if (!key) 101955ed8ca1SJohan Hedberg return -ENOMEM; 102055ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 102155ed8ca1SJohan Hedberg } 102255ed8ca1SJohan Hedberg 102355ed8ca1SJohan Hedberg BT_DBG("%s key for %s type %u", hdev->name, batostr(bdaddr), type); 102455ed8ca1SJohan Hedberg 102555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 102655ed8ca1SJohan Hedberg memcpy(key->val, val, 16); 102755ed8ca1SJohan Hedberg key->type = type; 102855ed8ca1SJohan Hedberg key->pin_len = pin_len; 102955ed8ca1SJohan Hedberg 103055ed8ca1SJohan Hedberg if (new_key) 103155ed8ca1SJohan Hedberg mgmt_new_key(hdev->id, key, old_key_type); 103255ed8ca1SJohan Hedberg 103355ed8ca1SJohan Hedberg if (type == 0x06) 103455ed8ca1SJohan Hedberg key->type = old_key_type; 103555ed8ca1SJohan Hedberg 103655ed8ca1SJohan Hedberg return 0; 103755ed8ca1SJohan Hedberg } 103855ed8ca1SJohan Hedberg 103955ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 104055ed8ca1SJohan Hedberg { 104155ed8ca1SJohan Hedberg struct link_key *key; 104255ed8ca1SJohan Hedberg 104355ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 104455ed8ca1SJohan Hedberg if (!key) 104555ed8ca1SJohan Hedberg return -ENOENT; 104655ed8ca1SJohan Hedberg 104755ed8ca1SJohan Hedberg BT_DBG("%s removing %s", hdev->name, batostr(bdaddr)); 104855ed8ca1SJohan Hedberg 104955ed8ca1SJohan Hedberg list_del(&key->list); 105055ed8ca1SJohan Hedberg kfree(key); 105155ed8ca1SJohan Hedberg 105255ed8ca1SJohan Hedberg return 0; 105355ed8ca1SJohan Hedberg } 105455ed8ca1SJohan Hedberg 10551da177e4SLinus Torvalds /* Register HCI device */ 10561da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 10571da177e4SLinus Torvalds { 10581da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 1059ef222013SMarcel Holtmann int i, id = 0; 10601da177e4SLinus Torvalds 1061c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d owner %p", hdev, hdev->name, 1062c13854ceSMarcel Holtmann hdev->bus, hdev->owner); 10631da177e4SLinus Torvalds 10641da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 10651da177e4SLinus Torvalds return -EINVAL; 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds /* Find first available device id */ 10701da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 10711da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 10721da177e4SLinus Torvalds break; 10731da177e4SLinus Torvalds head = p; id++; 10741da177e4SLinus Torvalds } 10751da177e4SLinus Torvalds 10761da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 10771da177e4SLinus Torvalds hdev->id = id; 10781da177e4SLinus Torvalds list_add(&hdev->list, head); 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 10811da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 10821da177e4SLinus Torvalds 10831da177e4SLinus Torvalds hdev->flags = 0; 10841da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 10855b7f9909SMarcel Holtmann hdev->esco_type = (ESCO_HV1); 10861da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 10871da177e4SLinus Torvalds 108804837f64SMarcel Holtmann hdev->idle_timeout = 0; 108904837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 109004837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 109104837f64SMarcel Holtmann 10921da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task, (unsigned long) hdev); 10931da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 10941da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 10971da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 10981da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 10991da177e4SLinus Torvalds 1100cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1101ef222013SMarcel Holtmann hdev->reassembly[i] = NULL; 1102ef222013SMarcel Holtmann 11031da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 1104a6a67efdSThomas Gleixner mutex_init(&hdev->req_lock); 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds inquiry_cache_init(hdev); 11071da177e4SLinus Torvalds 11081da177e4SLinus Torvalds hci_conn_hash_init(hdev); 11091da177e4SLinus Torvalds 1110ea4bd8baSDavid Miller INIT_LIST_HEAD(&hdev->blacklist); 1111f0358568SJohan Hedberg 11122aeb9a1aSJohan Hedberg INIT_LIST_HEAD(&hdev->uuids); 11132aeb9a1aSJohan Hedberg 111455ed8ca1SJohan Hedberg INIT_LIST_HEAD(&hdev->link_keys); 111555ed8ca1SJohan Hedberg 1116ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_on, hci_power_on); 1117ab81cbf9SJohan Hedberg INIT_WORK(&hdev->power_off, hci_power_off); 1118ab81cbf9SJohan Hedberg setup_timer(&hdev->off_timer, hci_auto_off, (unsigned long) hdev); 1119ab81cbf9SJohan Hedberg 11201da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 11251da177e4SLinus Torvalds 1126f48fd9c8SMarcel Holtmann hdev->workqueue = create_singlethread_workqueue(hdev->name); 1127f48fd9c8SMarcel Holtmann if (!hdev->workqueue) 1128f48fd9c8SMarcel Holtmann goto nomem; 1129f48fd9c8SMarcel Holtmann 11301da177e4SLinus Torvalds hci_register_sysfs(hdev); 11311da177e4SLinus Torvalds 1132611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 1133611b30f7SMarcel Holtmann RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, hdev); 1134611b30f7SMarcel Holtmann if (hdev->rfkill) { 1135611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 1136611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1137611b30f7SMarcel Holtmann hdev->rfkill = NULL; 1138611b30f7SMarcel Holtmann } 1139611b30f7SMarcel Holtmann } 1140611b30f7SMarcel Holtmann 1141ab81cbf9SJohan Hedberg set_bit(HCI_AUTO_OFF, &hdev->flags); 1142ab81cbf9SJohan Hedberg set_bit(HCI_SETUP, &hdev->flags); 1143ab81cbf9SJohan Hedberg queue_work(hdev->workqueue, &hdev->power_on); 1144ab81cbf9SJohan Hedberg 11451da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds return id; 1148f48fd9c8SMarcel Holtmann 1149f48fd9c8SMarcel Holtmann nomem: 1150f48fd9c8SMarcel Holtmann write_lock_bh(&hci_dev_list_lock); 1151f48fd9c8SMarcel Holtmann list_del(&hdev->list); 1152f48fd9c8SMarcel Holtmann write_unlock_bh(&hci_dev_list_lock); 1153f48fd9c8SMarcel Holtmann 1154f48fd9c8SMarcel Holtmann return -ENOMEM; 11551da177e4SLinus Torvalds } 11561da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 11571da177e4SLinus Torvalds 11581da177e4SLinus Torvalds /* Unregister HCI device */ 11591da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 11601da177e4SLinus Torvalds { 1161ef222013SMarcel Holtmann int i; 1162ef222013SMarcel Holtmann 1163c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 11661da177e4SLinus Torvalds list_del(&hdev->list); 11671da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 11681da177e4SLinus Torvalds 11691da177e4SLinus Torvalds hci_dev_do_close(hdev); 11701da177e4SLinus Torvalds 1171cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 1172ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 1173ef222013SMarcel Holtmann 1174ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 1175ab81cbf9SJohan Hedberg !test_bit(HCI_SETUP, &hdev->flags)) 1176c71e97bfSJohan Hedberg mgmt_index_removed(hdev->id); 1177ab81cbf9SJohan Hedberg 11781da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 11791da177e4SLinus Torvalds 1180611b30f7SMarcel Holtmann if (hdev->rfkill) { 1181611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 1182611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 1183611b30f7SMarcel Holtmann } 1184611b30f7SMarcel Holtmann 1185147e2d59SDave Young hci_unregister_sysfs(hdev); 1186147e2d59SDave Young 1187f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 1188f48fd9c8SMarcel Holtmann 1189e2e0cacbSJohan Hedberg hci_dev_lock_bh(hdev); 1190e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 11912aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 119255ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 1193e2e0cacbSJohan Hedberg hci_dev_unlock_bh(hdev); 1194e2e0cacbSJohan Hedberg 11951da177e4SLinus Torvalds __hci_dev_put(hdev); 1196ef222013SMarcel Holtmann 11971da177e4SLinus Torvalds return 0; 11981da177e4SLinus Torvalds } 11991da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds /* Suspend HCI device */ 12021da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 12031da177e4SLinus Torvalds { 12041da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 12051da177e4SLinus Torvalds return 0; 12061da177e4SLinus Torvalds } 12071da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 12081da177e4SLinus Torvalds 12091da177e4SLinus Torvalds /* Resume HCI device */ 12101da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 12111da177e4SLinus Torvalds { 12121da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 12131da177e4SLinus Torvalds return 0; 12141da177e4SLinus Torvalds } 12151da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 12161da177e4SLinus Torvalds 121776bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 121876bca880SMarcel Holtmann int hci_recv_frame(struct sk_buff *skb) 121976bca880SMarcel Holtmann { 122076bca880SMarcel Holtmann struct hci_dev *hdev = (struct hci_dev *) skb->dev; 122176bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 122276bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 122376bca880SMarcel Holtmann kfree_skb(skb); 122476bca880SMarcel Holtmann return -ENXIO; 122576bca880SMarcel Holtmann } 122676bca880SMarcel Holtmann 122776bca880SMarcel Holtmann /* Incomming skb */ 122876bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 122976bca880SMarcel Holtmann 123076bca880SMarcel Holtmann /* Time stamp */ 123176bca880SMarcel Holtmann __net_timestamp(skb); 123276bca880SMarcel Holtmann 123376bca880SMarcel Holtmann /* Queue frame for rx task */ 123476bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 1235c78ae283SMarcel Holtmann tasklet_schedule(&hdev->rx_task); 1236c78ae283SMarcel Holtmann 123776bca880SMarcel Holtmann return 0; 123876bca880SMarcel Holtmann } 123976bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 124076bca880SMarcel Holtmann 124133e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 124233e882a5SSuraj Sumangala int count, __u8 index, gfp_t gfp_mask) 124333e882a5SSuraj Sumangala { 124433e882a5SSuraj Sumangala int len = 0; 124533e882a5SSuraj Sumangala int hlen = 0; 124633e882a5SSuraj Sumangala int remain = count; 124733e882a5SSuraj Sumangala struct sk_buff *skb; 124833e882a5SSuraj Sumangala struct bt_skb_cb *scb; 124933e882a5SSuraj Sumangala 125033e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 125133e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 125233e882a5SSuraj Sumangala return -EILSEQ; 125333e882a5SSuraj Sumangala 125433e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 125533e882a5SSuraj Sumangala 125633e882a5SSuraj Sumangala if (!skb) { 125733e882a5SSuraj Sumangala switch (type) { 125833e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 125933e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 126033e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 126133e882a5SSuraj Sumangala break; 126233e882a5SSuraj Sumangala case HCI_EVENT_PKT: 126333e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 126433e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 126533e882a5SSuraj Sumangala break; 126633e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 126733e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 126833e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 126933e882a5SSuraj Sumangala break; 127033e882a5SSuraj Sumangala } 127133e882a5SSuraj Sumangala 127233e882a5SSuraj Sumangala skb = bt_skb_alloc(len, gfp_mask); 127333e882a5SSuraj Sumangala if (!skb) 127433e882a5SSuraj Sumangala return -ENOMEM; 127533e882a5SSuraj Sumangala 127633e882a5SSuraj Sumangala scb = (void *) skb->cb; 127733e882a5SSuraj Sumangala scb->expect = hlen; 127833e882a5SSuraj Sumangala scb->pkt_type = type; 127933e882a5SSuraj Sumangala 128033e882a5SSuraj Sumangala skb->dev = (void *) hdev; 128133e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 128233e882a5SSuraj Sumangala } 128333e882a5SSuraj Sumangala 128433e882a5SSuraj Sumangala while (count) { 128533e882a5SSuraj Sumangala scb = (void *) skb->cb; 128633e882a5SSuraj Sumangala len = min(scb->expect, (__u16)count); 128733e882a5SSuraj Sumangala 128833e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 128933e882a5SSuraj Sumangala 129033e882a5SSuraj Sumangala count -= len; 129133e882a5SSuraj Sumangala data += len; 129233e882a5SSuraj Sumangala scb->expect -= len; 129333e882a5SSuraj Sumangala remain = count; 129433e882a5SSuraj Sumangala 129533e882a5SSuraj Sumangala switch (type) { 129633e882a5SSuraj Sumangala case HCI_EVENT_PKT: 129733e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 129833e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 129933e882a5SSuraj Sumangala scb->expect = h->plen; 130033e882a5SSuraj Sumangala 130133e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 130233e882a5SSuraj Sumangala kfree_skb(skb); 130333e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 130433e882a5SSuraj Sumangala return -ENOMEM; 130533e882a5SSuraj Sumangala } 130633e882a5SSuraj Sumangala } 130733e882a5SSuraj Sumangala break; 130833e882a5SSuraj Sumangala 130933e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 131033e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 131133e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 131233e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 131333e882a5SSuraj Sumangala 131433e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 131533e882a5SSuraj Sumangala kfree_skb(skb); 131633e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 131733e882a5SSuraj Sumangala return -ENOMEM; 131833e882a5SSuraj Sumangala } 131933e882a5SSuraj Sumangala } 132033e882a5SSuraj Sumangala break; 132133e882a5SSuraj Sumangala 132233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 132333e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 132433e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 132533e882a5SSuraj Sumangala scb->expect = h->dlen; 132633e882a5SSuraj Sumangala 132733e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 132833e882a5SSuraj Sumangala kfree_skb(skb); 132933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 133033e882a5SSuraj Sumangala return -ENOMEM; 133133e882a5SSuraj Sumangala } 133233e882a5SSuraj Sumangala } 133333e882a5SSuraj Sumangala break; 133433e882a5SSuraj Sumangala } 133533e882a5SSuraj Sumangala 133633e882a5SSuraj Sumangala if (scb->expect == 0) { 133733e882a5SSuraj Sumangala /* Complete frame */ 133833e882a5SSuraj Sumangala 133933e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 134033e882a5SSuraj Sumangala hci_recv_frame(skb); 134133e882a5SSuraj Sumangala 134233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 134333e882a5SSuraj Sumangala return remain; 134433e882a5SSuraj Sumangala } 134533e882a5SSuraj Sumangala } 134633e882a5SSuraj Sumangala 134733e882a5SSuraj Sumangala return remain; 134833e882a5SSuraj Sumangala } 134933e882a5SSuraj Sumangala 1350ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 1351ef222013SMarcel Holtmann { 1352f39a3c06SSuraj Sumangala int rem = 0; 1353f39a3c06SSuraj Sumangala 1354ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 1355ef222013SMarcel Holtmann return -EILSEQ; 1356ef222013SMarcel Holtmann 1357da5f6c37SGustavo F. Padovan while (count) { 1358f39a3c06SSuraj Sumangala rem = hci_reassembly(hdev, type, data, count, 1359f39a3c06SSuraj Sumangala type - 1, GFP_ATOMIC); 1360f39a3c06SSuraj Sumangala if (rem < 0) 1361f39a3c06SSuraj Sumangala return rem; 1362ef222013SMarcel Holtmann 1363f39a3c06SSuraj Sumangala data += (count - rem); 1364f39a3c06SSuraj Sumangala count = rem; 1365da5f6c37SGustavo F. Padovan }; 1366ef222013SMarcel Holtmann 1367f39a3c06SSuraj Sumangala return rem; 1368ef222013SMarcel Holtmann } 1369ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 1370ef222013SMarcel Holtmann 137199811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 137299811510SSuraj Sumangala 137399811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 137499811510SSuraj Sumangala { 137599811510SSuraj Sumangala int type; 137699811510SSuraj Sumangala int rem = 0; 137799811510SSuraj Sumangala 1378da5f6c37SGustavo F. Padovan while (count) { 137999811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 138099811510SSuraj Sumangala 138199811510SSuraj Sumangala if (!skb) { 138299811510SSuraj Sumangala struct { char type; } *pkt; 138399811510SSuraj Sumangala 138499811510SSuraj Sumangala /* Start of the frame */ 138599811510SSuraj Sumangala pkt = data; 138699811510SSuraj Sumangala type = pkt->type; 138799811510SSuraj Sumangala 138899811510SSuraj Sumangala data++; 138999811510SSuraj Sumangala count--; 139099811510SSuraj Sumangala } else 139199811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 139299811510SSuraj Sumangala 139399811510SSuraj Sumangala rem = hci_reassembly(hdev, type, data, 139499811510SSuraj Sumangala count, STREAM_REASSEMBLY, GFP_ATOMIC); 139599811510SSuraj Sumangala if (rem < 0) 139699811510SSuraj Sumangala return rem; 139799811510SSuraj Sumangala 139899811510SSuraj Sumangala data += (count - rem); 139999811510SSuraj Sumangala count = rem; 1400da5f6c37SGustavo F. Padovan }; 140199811510SSuraj Sumangala 140299811510SSuraj Sumangala return rem; 140399811510SSuraj Sumangala } 140499811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 140599811510SSuraj Sumangala 14061da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds /* Register/Unregister protocols. 14091da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 14101da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 14111da177e4SLinus Torvalds { 14121da177e4SLinus Torvalds int err = 0; 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 14171da177e4SLinus Torvalds return -EINVAL; 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 14201da177e4SLinus Torvalds 14211da177e4SLinus Torvalds if (!hci_proto[hp->id]) 14221da177e4SLinus Torvalds hci_proto[hp->id] = hp; 14231da177e4SLinus Torvalds else 14241da177e4SLinus Torvalds err = -EEXIST; 14251da177e4SLinus Torvalds 14261da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds return err; 14291da177e4SLinus Torvalds } 14301da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 14311da177e4SLinus Torvalds 14321da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 14331da177e4SLinus Torvalds { 14341da177e4SLinus Torvalds int err = 0; 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 14371da177e4SLinus Torvalds 14381da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 14391da177e4SLinus Torvalds return -EINVAL; 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds if (hci_proto[hp->id]) 14441da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 14451da177e4SLinus Torvalds else 14461da177e4SLinus Torvalds err = -ENOENT; 14471da177e4SLinus Torvalds 14481da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds return err; 14511da177e4SLinus Torvalds } 14521da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 14551da177e4SLinus Torvalds { 14561da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 14571da177e4SLinus Torvalds 14581da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 14591da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 14601da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds return 0; 14631da177e4SLinus Torvalds } 14641da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 14671da177e4SLinus Torvalds { 14681da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 14711da177e4SLinus Torvalds list_del(&cb->list); 14721da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds return 0; 14751da177e4SLinus Torvalds } 14761da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 14771da177e4SLinus Torvalds 14781da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 14791da177e4SLinus Torvalds { 14801da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 14811da177e4SLinus Torvalds 14821da177e4SLinus Torvalds if (!hdev) { 14831da177e4SLinus Torvalds kfree_skb(skb); 14841da177e4SLinus Torvalds return -ENODEV; 14851da177e4SLinus Torvalds } 14861da177e4SLinus Torvalds 14870d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 14901da177e4SLinus Torvalds /* Time stamp */ 1491a61bbcf2SPatrick McHardy __net_timestamp(skb); 14921da177e4SLinus Torvalds 1493eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 14941da177e4SLinus Torvalds } 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 14971da177e4SLinus Torvalds skb_orphan(skb); 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds return hdev->send(skb); 15001da177e4SLinus Torvalds } 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds /* Send HCI command */ 1503a9de9248SMarcel Holtmann int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param) 15041da177e4SLinus Torvalds { 15051da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 15061da177e4SLinus Torvalds struct hci_command_hdr *hdr; 15071da177e4SLinus Torvalds struct sk_buff *skb; 15081da177e4SLinus Torvalds 1509a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen); 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 15121da177e4SLinus Torvalds if (!skb) { 1513ef222013SMarcel Holtmann BT_ERR("%s no memory for command", hdev->name); 15141da177e4SLinus Torvalds return -ENOMEM; 15151da177e4SLinus Torvalds } 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 1518a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 15191da177e4SLinus Torvalds hdr->plen = plen; 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds if (plen) 15221da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 15231da177e4SLinus Torvalds 15241da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 15251da177e4SLinus Torvalds 15260d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 15271da177e4SLinus Torvalds skb->dev = (void *) hdev; 1528c78ae283SMarcel Holtmann 1529a5040efaSJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags)) 1530a5040efaSJohan Hedberg hdev->init_last_cmd = opcode; 1531a5040efaSJohan Hedberg 15321da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1533c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 15341da177e4SLinus Torvalds 15351da177e4SLinus Torvalds return 0; 15361da177e4SLinus Torvalds } 15371da177e4SLinus Torvalds 15381da177e4SLinus Torvalds /* Get data from the previously sent command */ 1539a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 15401da177e4SLinus Torvalds { 15411da177e4SLinus Torvalds struct hci_command_hdr *hdr; 15421da177e4SLinus Torvalds 15431da177e4SLinus Torvalds if (!hdev->sent_cmd) 15441da177e4SLinus Torvalds return NULL; 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 15471da177e4SLinus Torvalds 1548a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 15491da177e4SLinus Torvalds return NULL; 15501da177e4SLinus Torvalds 1551a9de9248SMarcel Holtmann BT_DBG("%s opcode 0x%x", hdev->name, opcode); 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 15541da177e4SLinus Torvalds } 15551da177e4SLinus Torvalds 15561da177e4SLinus Torvalds /* Send ACL data */ 15571da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 15581da177e4SLinus Torvalds { 15591da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 15601da177e4SLinus Torvalds int len = skb->len; 15611da177e4SLinus Torvalds 1562badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 1563badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 15649c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 1565aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 1566aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 15671da177e4SLinus Torvalds } 15681da177e4SLinus Torvalds 15699a9c6a34SGustavo F. Padovan void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 15701da177e4SLinus Torvalds { 15711da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 15721da177e4SLinus Torvalds struct sk_buff *list; 15731da177e4SLinus Torvalds 15741da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds skb->dev = (void *) hdev; 15770d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1578e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 15791da177e4SLinus Torvalds 158070f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 158170f23020SAndrei Emeltchenko if (!list) { 15821da177e4SLinus Torvalds /* Non fragmented */ 15831da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 15861da177e4SLinus Torvalds } else { 15871da177e4SLinus Torvalds /* Fragmented */ 15881da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 15911da177e4SLinus Torvalds 15921da177e4SLinus Torvalds /* Queue all fragments atomically */ 15931da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 1596e702112fSAndrei Emeltchenko 1597e702112fSAndrei Emeltchenko flags &= ~ACL_START; 1598e702112fSAndrei Emeltchenko flags |= ACL_CONT; 15991da177e4SLinus Torvalds do { 16001da177e4SLinus Torvalds skb = list; list = list->next; 16011da177e4SLinus Torvalds 16021da177e4SLinus Torvalds skb->dev = (void *) hdev; 16030d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 1604e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 16071da177e4SLinus Torvalds 16081da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 16091da177e4SLinus Torvalds } while (list); 16101da177e4SLinus Torvalds 16111da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 16121da177e4SLinus Torvalds } 16131da177e4SLinus Torvalds 1614c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 16151da177e4SLinus Torvalds } 16161da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 16171da177e4SLinus Torvalds 16181da177e4SLinus Torvalds /* Send SCO data */ 16190d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 16201da177e4SLinus Torvalds { 16211da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 16221da177e4SLinus Torvalds struct hci_sco_hdr hdr; 16231da177e4SLinus Torvalds 16241da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 16251da177e4SLinus Torvalds 1626aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 16271da177e4SLinus Torvalds hdr.dlen = skb->len; 16281da177e4SLinus Torvalds 1629badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 1630badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 16319c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds skb->dev = (void *) hdev; 16340d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 1635c78ae283SMarcel Holtmann 16361da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 1637c78ae283SMarcel Holtmann tasklet_schedule(&hdev->tx_task); 16381da177e4SLinus Torvalds } 16391da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 16401da177e4SLinus Torvalds 16411da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 16421da177e4SLinus Torvalds 16431da177e4SLinus Torvalds /* HCI Connection scheduler */ 16441da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 16451da177e4SLinus Torvalds { 16461da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 16471da177e4SLinus Torvalds struct hci_conn *conn = NULL; 16481da177e4SLinus Torvalds int num = 0, min = ~0; 16491da177e4SLinus Torvalds struct list_head *p; 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 16521da177e4SLinus Torvalds * added and removed with TX task disabled. */ 16531da177e4SLinus Torvalds list_for_each(p, &h->list) { 16541da177e4SLinus Torvalds struct hci_conn *c; 16551da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 16561da177e4SLinus Torvalds 1657769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 16581da177e4SLinus Torvalds continue; 1659769be974SMarcel Holtmann 1660769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 1661769be974SMarcel Holtmann continue; 1662769be974SMarcel Holtmann 16631da177e4SLinus Torvalds num++; 16641da177e4SLinus Torvalds 16651da177e4SLinus Torvalds if (c->sent < min) { 16661da177e4SLinus Torvalds min = c->sent; 16671da177e4SLinus Torvalds conn = c; 16681da177e4SLinus Torvalds } 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 16711da177e4SLinus Torvalds if (conn) { 16721da177e4SLinus Torvalds int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt); 16731da177e4SLinus Torvalds int q = cnt / num; 16741da177e4SLinus Torvalds *quote = q ? q : 1; 16751da177e4SLinus Torvalds } else 16761da177e4SLinus Torvalds *quote = 0; 16771da177e4SLinus Torvalds 16781da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 16791da177e4SLinus Torvalds return conn; 16801da177e4SLinus Torvalds } 16811da177e4SLinus Torvalds 16821da177e4SLinus Torvalds static inline void hci_acl_tx_to(struct hci_dev *hdev) 16831da177e4SLinus Torvalds { 16841da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 16851da177e4SLinus Torvalds struct list_head *p; 16861da177e4SLinus Torvalds struct hci_conn *c; 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds BT_ERR("%s ACL tx timeout", hdev->name); 16891da177e4SLinus Torvalds 16901da177e4SLinus Torvalds /* Kill stalled connections */ 16911da177e4SLinus Torvalds list_for_each(p, &h->list) { 16921da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 16931da177e4SLinus Torvalds if (c->type == ACL_LINK && c->sent) { 16941da177e4SLinus Torvalds BT_ERR("%s killing stalled ACL connection %s", 16951da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 16961da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 16971da177e4SLinus Torvalds } 16981da177e4SLinus Torvalds } 16991da177e4SLinus Torvalds } 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 17021da177e4SLinus Torvalds { 17031da177e4SLinus Torvalds struct hci_conn *conn; 17041da177e4SLinus Torvalds struct sk_buff *skb; 17051da177e4SLinus Torvalds int quote; 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17081da177e4SLinus Torvalds 17091da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 17101da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 17111da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 171282453021SS.Çağlar Onur if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45)) 17131da177e4SLinus Torvalds hci_acl_tx_to(hdev); 17141da177e4SLinus Torvalds } 17151da177e4SLinus Torvalds 17161da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 17171da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 17181da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 171904837f64SMarcel Holtmann 172004837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 172104837f64SMarcel Holtmann 17221da177e4SLinus Torvalds hci_send_frame(skb); 17231da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 17241da177e4SLinus Torvalds 17251da177e4SLinus Torvalds hdev->acl_cnt--; 17261da177e4SLinus Torvalds conn->sent++; 17271da177e4SLinus Torvalds } 17281da177e4SLinus Torvalds } 17291da177e4SLinus Torvalds } 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds /* Schedule SCO */ 17321da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 17331da177e4SLinus Torvalds { 17341da177e4SLinus Torvalds struct hci_conn *conn; 17351da177e4SLinus Torvalds struct sk_buff *skb; 17361da177e4SLinus Torvalds int quote; 17371da177e4SLinus Torvalds 17381da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 17411da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 17421da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 17431da177e4SLinus Torvalds hci_send_frame(skb); 17441da177e4SLinus Torvalds 17451da177e4SLinus Torvalds conn->sent++; 17461da177e4SLinus Torvalds if (conn->sent == ~0) 17471da177e4SLinus Torvalds conn->sent = 0; 17481da177e4SLinus Torvalds } 17491da177e4SLinus Torvalds } 17501da177e4SLinus Torvalds } 17511da177e4SLinus Torvalds 1752b6a0dc82SMarcel Holtmann static inline void hci_sched_esco(struct hci_dev *hdev) 1753b6a0dc82SMarcel Holtmann { 1754b6a0dc82SMarcel Holtmann struct hci_conn *conn; 1755b6a0dc82SMarcel Holtmann struct sk_buff *skb; 1756b6a0dc82SMarcel Holtmann int quote; 1757b6a0dc82SMarcel Holtmann 1758b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 1759b6a0dc82SMarcel Holtmann 1760b6a0dc82SMarcel Holtmann while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, "e))) { 1761b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 1762b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 1763b6a0dc82SMarcel Holtmann hci_send_frame(skb); 1764b6a0dc82SMarcel Holtmann 1765b6a0dc82SMarcel Holtmann conn->sent++; 1766b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 1767b6a0dc82SMarcel Holtmann conn->sent = 0; 1768b6a0dc82SMarcel Holtmann } 1769b6a0dc82SMarcel Holtmann } 1770b6a0dc82SMarcel Holtmann } 1771b6a0dc82SMarcel Holtmann 17721da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 17731da177e4SLinus Torvalds { 17741da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 17751da177e4SLinus Torvalds struct sk_buff *skb; 17761da177e4SLinus Torvalds 17771da177e4SLinus Torvalds read_lock(&hci_task_lock); 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt); 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 17821da177e4SLinus Torvalds 17831da177e4SLinus Torvalds hci_sched_acl(hdev); 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds hci_sched_sco(hdev); 17861da177e4SLinus Torvalds 1787b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 1788b6a0dc82SMarcel Holtmann 17891da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 17901da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 17911da177e4SLinus Torvalds hci_send_frame(skb); 17921da177e4SLinus Torvalds 17931da177e4SLinus Torvalds read_unlock(&hci_task_lock); 17941da177e4SLinus Torvalds } 17951da177e4SLinus Torvalds 17961da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds /* ACL data packet */ 17991da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 18001da177e4SLinus Torvalds { 18011da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 18021da177e4SLinus Torvalds struct hci_conn *conn; 18031da177e4SLinus Torvalds __u16 handle, flags; 18041da177e4SLinus Torvalds 18051da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 18061da177e4SLinus Torvalds 18071da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 18081da177e4SLinus Torvalds flags = hci_flags(handle); 18091da177e4SLinus Torvalds handle = hci_handle(handle); 18101da177e4SLinus Torvalds 18111da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 18121da177e4SLinus Torvalds 18131da177e4SLinus Torvalds hdev->stat.acl_rx++; 18141da177e4SLinus Torvalds 18151da177e4SLinus Torvalds hci_dev_lock(hdev); 18161da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 18171da177e4SLinus Torvalds hci_dev_unlock(hdev); 18181da177e4SLinus Torvalds 18191da177e4SLinus Torvalds if (conn) { 18201da177e4SLinus Torvalds register struct hci_proto *hp; 18211da177e4SLinus Torvalds 182204837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 182304837f64SMarcel Holtmann 18241da177e4SLinus Torvalds /* Send to upper protocol */ 182570f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_L2CAP]; 182670f23020SAndrei Emeltchenko if (hp && hp->recv_acldata) { 18271da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 18281da177e4SLinus Torvalds return; 18291da177e4SLinus Torvalds } 18301da177e4SLinus Torvalds } else { 18311da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 18321da177e4SLinus Torvalds hdev->name, handle); 18331da177e4SLinus Torvalds } 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds kfree_skb(skb); 18361da177e4SLinus Torvalds } 18371da177e4SLinus Torvalds 18381da177e4SLinus Torvalds /* SCO data packet */ 18391da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 18401da177e4SLinus Torvalds { 18411da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 18421da177e4SLinus Torvalds struct hci_conn *conn; 18431da177e4SLinus Torvalds __u16 handle; 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 18461da177e4SLinus Torvalds 18471da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 18481da177e4SLinus Torvalds 18491da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds hdev->stat.sco_rx++; 18521da177e4SLinus Torvalds 18531da177e4SLinus Torvalds hci_dev_lock(hdev); 18541da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 18551da177e4SLinus Torvalds hci_dev_unlock(hdev); 18561da177e4SLinus Torvalds 18571da177e4SLinus Torvalds if (conn) { 18581da177e4SLinus Torvalds register struct hci_proto *hp; 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds /* Send to upper protocol */ 186170f23020SAndrei Emeltchenko hp = hci_proto[HCI_PROTO_SCO]; 186270f23020SAndrei Emeltchenko if (hp && hp->recv_scodata) { 18631da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 18641da177e4SLinus Torvalds return; 18651da177e4SLinus Torvalds } 18661da177e4SLinus Torvalds } else { 18671da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 18681da177e4SLinus Torvalds hdev->name, handle); 18691da177e4SLinus Torvalds } 18701da177e4SLinus Torvalds 18711da177e4SLinus Torvalds kfree_skb(skb); 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds 18746516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 18751da177e4SLinus Torvalds { 18761da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 18771da177e4SLinus Torvalds struct sk_buff *skb; 18781da177e4SLinus Torvalds 18791da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 18801da177e4SLinus Torvalds 18811da177e4SLinus Torvalds read_lock(&hci_task_lock); 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 18841da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 18851da177e4SLinus Torvalds /* Send copy to the sockets */ 1886eec8d2bcSJohan Hedberg hci_send_to_sock(hdev, skb, NULL); 18871da177e4SLinus Torvalds } 18881da177e4SLinus Torvalds 18891da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 18901da177e4SLinus Torvalds kfree_skb(skb); 18911da177e4SLinus Torvalds continue; 18921da177e4SLinus Torvalds } 18931da177e4SLinus Torvalds 18941da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 18951da177e4SLinus Torvalds /* Don't process data packets in this states. */ 18960d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 18971da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 18981da177e4SLinus Torvalds case HCI_SCODATA_PKT: 18991da177e4SLinus Torvalds kfree_skb(skb); 19001da177e4SLinus Torvalds continue; 19013ff50b79SStephen Hemminger } 19021da177e4SLinus Torvalds } 19031da177e4SLinus Torvalds 19041da177e4SLinus Torvalds /* Process frame */ 19050d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 19061da177e4SLinus Torvalds case HCI_EVENT_PKT: 19071da177e4SLinus Torvalds hci_event_packet(hdev, skb); 19081da177e4SLinus Torvalds break; 19091da177e4SLinus Torvalds 19101da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 19111da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 19121da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 19131da177e4SLinus Torvalds break; 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds case HCI_SCODATA_PKT: 19161da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 19171da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 19181da177e4SLinus Torvalds break; 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds default: 19211da177e4SLinus Torvalds kfree_skb(skb); 19221da177e4SLinus Torvalds break; 19231da177e4SLinus Torvalds } 19241da177e4SLinus Torvalds } 19251da177e4SLinus Torvalds 19261da177e4SLinus Torvalds read_unlock(&hci_task_lock); 19271da177e4SLinus Torvalds } 19281da177e4SLinus Torvalds 19291da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 19301da177e4SLinus Torvalds { 19311da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 19321da177e4SLinus Torvalds struct sk_buff *skb; 19331da177e4SLinus Torvalds 19341da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 19351da177e4SLinus Torvalds 193682453021SS.Çağlar Onur if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) { 19371da177e4SLinus Torvalds BT_ERR("%s command tx timeout", hdev->name); 19381da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 19391da177e4SLinus Torvalds } 19401da177e4SLinus Torvalds 19411da177e4SLinus Torvalds /* Send queued commands */ 19421da177e4SLinus Torvalds if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) { 19431da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 19441da177e4SLinus Torvalds 194570f23020SAndrei Emeltchenko hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC); 194670f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 19471da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 19481da177e4SLinus Torvalds hci_send_frame(skb); 19491da177e4SLinus Torvalds hdev->cmd_last_tx = jiffies; 19501da177e4SLinus Torvalds } else { 19511da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 1952c78ae283SMarcel Holtmann tasklet_schedule(&hdev->cmd_task); 19531da177e4SLinus Torvalds } 19541da177e4SLinus Torvalds } 19551da177e4SLinus Torvalds } 1956