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 271da177e4SLinus Torvalds #include <linux/module.h> 281da177e4SLinus Torvalds #include <linux/kmod.h> 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds #include <linux/types.h> 311da177e4SLinus Torvalds #include <linux/errno.h> 321da177e4SLinus Torvalds #include <linux/kernel.h> 331da177e4SLinus Torvalds #include <linux/sched.h> 341da177e4SLinus Torvalds #include <linux/slab.h> 351da177e4SLinus Torvalds #include <linux/poll.h> 361da177e4SLinus Torvalds #include <linux/fcntl.h> 371da177e4SLinus Torvalds #include <linux/init.h> 381da177e4SLinus Torvalds #include <linux/skbuff.h> 391da177e4SLinus Torvalds #include <linux/interrupt.h> 401da177e4SLinus Torvalds #include <linux/notifier.h> 411da177e4SLinus Torvalds #include <net/sock.h> 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds #include <asm/system.h> 441da177e4SLinus Torvalds #include <asm/uaccess.h> 451da177e4SLinus Torvalds #include <asm/unaligned.h> 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 481da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #ifndef CONFIG_BT_HCI_CORE_DEBUG 511da177e4SLinus Torvalds #undef BT_DBG 521da177e4SLinus Torvalds #define BT_DBG(D...) 531da177e4SLinus Torvalds #endif 541da177e4SLinus Torvalds 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 961da177e4SLinus Torvalds void hci_req_complete(struct hci_dev *hdev, int result) 971da177e4SLinus Torvalds { 981da177e4SLinus Torvalds BT_DBG("%s result 0x%2.2x", hdev->name, result); 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1011da177e4SLinus Torvalds hdev->req_result = result; 1021da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1031da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1041da177e4SLinus Torvalds } 1051da177e4SLinus Torvalds } 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1081da177e4SLinus Torvalds { 1091da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1121da177e4SLinus Torvalds hdev->req_result = err; 1131da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1141da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1151da177e4SLinus Torvalds } 1161da177e4SLinus Torvalds } 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds /* Execute request and wait for completion. */ 1191da177e4SLinus Torvalds static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1201da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1211da177e4SLinus Torvalds { 1221da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1231da177e4SLinus Torvalds int err = 0; 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds add_wait_queue(&hdev->req_wait_q, &wait); 1301da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds req(hdev, opt); 1331da177e4SLinus Torvalds schedule_timeout(timeout); 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds if (signal_pending(current)) 1381da177e4SLinus Torvalds return -EINTR; 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds switch (hdev->req_status) { 1411da177e4SLinus Torvalds case HCI_REQ_DONE: 1421da177e4SLinus Torvalds err = -bt_err(hdev->req_result); 1431da177e4SLinus Torvalds break; 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds case HCI_REQ_CANCELED: 1461da177e4SLinus Torvalds err = -hdev->req_result; 1471da177e4SLinus Torvalds break; 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds default: 1501da177e4SLinus Torvalds err = -ETIMEDOUT; 1511da177e4SLinus Torvalds break; 1521da177e4SLinus Torvalds }; 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds hdev->req_status = hdev->req_result = 0; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds return err; 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt), 1621da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 1631da177e4SLinus Torvalds { 1641da177e4SLinus Torvalds int ret; 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /* Serialize all requests */ 1671da177e4SLinus Torvalds hci_req_lock(hdev); 1681da177e4SLinus Torvalds ret = __hci_request(hdev, req, opt, timeout); 1691da177e4SLinus Torvalds hci_req_unlock(hdev); 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds return ret; 1721da177e4SLinus Torvalds } 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds static void hci_reset_req(struct hci_dev *hdev, unsigned long opt) 1751da177e4SLinus Torvalds { 1761da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1771da177e4SLinus Torvalds 1781da177e4SLinus Torvalds /* Reset device */ 1791da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_RESET, 0, NULL); 1801da177e4SLinus Torvalds } 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds static void hci_init_req(struct hci_dev *hdev, unsigned long opt) 1831da177e4SLinus Torvalds { 1841da177e4SLinus Torvalds struct sk_buff *skb; 1851ebb9252SMarcel Holtmann __le16 param; 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds BT_DBG("%s %ld", hdev->name, opt); 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds /* Driver initialization */ 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds /* Special commands */ 1921da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->driver_init))) { 1930d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 1941da177e4SLinus Torvalds skb->dev = (void *) hdev; 1951da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 1961da177e4SLinus Torvalds hci_sched_cmd(hdev); 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds /* Mandatory initialization */ 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds /* Reset */ 2031da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks)) 2041da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_RESET, 0, NULL); 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds /* Read Local Supported Features */ 2071da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_INFO_PARAM, OCF_READ_LOCAL_FEATURES, 0, NULL); 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 2101da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_INFO_PARAM, OCF_READ_BUFFER_SIZE, 0, NULL); 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds #if 0 2131da177e4SLinus Torvalds /* Host buffer size */ 2141da177e4SLinus Torvalds { 2151da177e4SLinus Torvalds struct hci_cp_host_buffer_size cp; 2161da177e4SLinus Torvalds cp.acl_mtu = __cpu_to_le16(HCI_MAX_ACL_SIZE); 2171da177e4SLinus Torvalds cp.sco_mtu = HCI_MAX_SCO_SIZE; 2181da177e4SLinus Torvalds cp.acl_max_pkt = __cpu_to_le16(0xffff); 2191da177e4SLinus Torvalds cp.sco_max_pkt = __cpu_to_le16(0xffff); 2201da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_HOST_BUFFER_SIZE, sizeof(cp), &cp); 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds #endif 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds /* Read BD Address */ 2251da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_INFO_PARAM, OCF_READ_BD_ADDR, 0, NULL); 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds /* Read Voice Setting */ 2281da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_READ_VOICE_SETTING, 0, NULL); 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds /* Optional initialization */ 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds /* Clear Event Filters */ 2331da177e4SLinus Torvalds { 2341da177e4SLinus Torvalds struct hci_cp_set_event_flt cp; 2351da177e4SLinus Torvalds cp.flt_type = HCI_FLT_CLEAR_ALL; 2361da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_SET_EVENT_FLT, sizeof(cp), &cp); 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds /* Page timeout ~20 secs */ 2401da177e4SLinus Torvalds param = __cpu_to_le16(0x8000); 2411da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_WRITE_PG_TIMEOUT, 2, ¶m); 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds /* Connection accept timeout ~20 secs */ 2441da177e4SLinus Torvalds param = __cpu_to_le16(0x7d00); 2451da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_WRITE_CA_TIMEOUT, 2, ¶m); 2461da177e4SLinus Torvalds } 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds static void hci_scan_req(struct hci_dev *hdev, unsigned long opt) 2491da177e4SLinus Torvalds { 2501da177e4SLinus Torvalds __u8 scan = opt; 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, scan); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds /* Inquiry and Page scans */ 2551da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE, 1, &scan); 2561da177e4SLinus Torvalds } 2571da177e4SLinus Torvalds 2581da177e4SLinus Torvalds static void hci_auth_req(struct hci_dev *hdev, unsigned long opt) 2591da177e4SLinus Torvalds { 2601da177e4SLinus Torvalds __u8 auth = opt; 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, auth); 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds /* Authentication */ 2651da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_WRITE_AUTH_ENABLE, 1, &auth); 2661da177e4SLinus Torvalds } 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt) 2691da177e4SLinus Torvalds { 2701da177e4SLinus Torvalds __u8 encrypt = opt; 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds BT_DBG("%s %x", hdev->name, encrypt); 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds /* Authentication */ 2751da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_HOST_CTL, OCF_WRITE_ENCRYPT_MODE, 1, &encrypt); 2761da177e4SLinus Torvalds } 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds /* Get HCI device by index. 2791da177e4SLinus Torvalds * Device is held on return. */ 2801da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 2811da177e4SLinus Torvalds { 2821da177e4SLinus Torvalds struct hci_dev *hdev = NULL; 2831da177e4SLinus Torvalds struct list_head *p; 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds BT_DBG("%d", index); 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds if (index < 0) 2881da177e4SLinus Torvalds return NULL; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 2911da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 2921da177e4SLinus Torvalds struct hci_dev *d = list_entry(p, struct hci_dev, list); 2931da177e4SLinus Torvalds if (d->id == index) { 2941da177e4SLinus Torvalds hdev = hci_dev_hold(d); 2951da177e4SLinus Torvalds break; 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds } 2981da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 2991da177e4SLinus Torvalds return hdev; 3001da177e4SLinus Torvalds } 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 3031da177e4SLinus Torvalds static void inquiry_cache_flush(struct hci_dev *hdev) 3041da177e4SLinus Torvalds { 3051da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3061da177e4SLinus Torvalds struct inquiry_entry *next = cache->list, *e; 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds BT_DBG("cache %p", cache); 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds cache->list = NULL; 3111da177e4SLinus Torvalds while ((e = next)) { 3121da177e4SLinus Torvalds next = e->next; 3131da177e4SLinus Torvalds kfree(e); 3141da177e4SLinus Torvalds } 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr) 3181da177e4SLinus Torvalds { 3191da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3201da177e4SLinus Torvalds struct inquiry_entry *e; 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(bdaddr)); 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds for (e = cache->list; e; e = e->next) 3251da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 3261da177e4SLinus Torvalds break; 3271da177e4SLinus Torvalds return e; 3281da177e4SLinus Torvalds } 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data) 3311da177e4SLinus Torvalds { 3321da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3331da177e4SLinus Torvalds struct inquiry_entry *e; 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr)); 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds if (!(e = hci_inquiry_cache_lookup(hdev, &data->bdaddr))) { 3381da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 3391da177e4SLinus Torvalds if (!(e = kmalloc(sizeof(struct inquiry_entry), GFP_ATOMIC))) 3401da177e4SLinus Torvalds return; 3411da177e4SLinus Torvalds memset(e, 0, sizeof(struct inquiry_entry)); 3421da177e4SLinus Torvalds e->next = cache->list; 3431da177e4SLinus Torvalds cache->list = e; 3441da177e4SLinus Torvalds } 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds memcpy(&e->data, data, sizeof(*data)); 3471da177e4SLinus Torvalds e->timestamp = jiffies; 3481da177e4SLinus Torvalds cache->timestamp = jiffies; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 3521da177e4SLinus Torvalds { 3531da177e4SLinus Torvalds struct inquiry_cache *cache = &hdev->inq_cache; 3541da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 3551da177e4SLinus Torvalds struct inquiry_entry *e; 3561da177e4SLinus Torvalds int copied = 0; 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds for (e = cache->list; e && copied < num; e = e->next, copied++) { 3591da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 3601da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 3611da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 3621da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 3631da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 3641da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 3651da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 3661da177e4SLinus Torvalds info++; 3671da177e4SLinus Torvalds } 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 3701da177e4SLinus Torvalds return copied; 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds 3731da177e4SLinus Torvalds static void hci_inq_req(struct hci_dev *hdev, unsigned long opt) 3741da177e4SLinus Torvalds { 3751da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 3761da177e4SLinus Torvalds struct hci_cp_inquiry cp; 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 3811da177e4SLinus Torvalds return; 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds /* Start Inquiry */ 3841da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 3851da177e4SLinus Torvalds cp.length = ir->length; 3861da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 3871da177e4SLinus Torvalds hci_send_cmd(hdev, OGF_LINK_CTL, OCF_INQUIRY, sizeof(cp), &cp); 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 3911da177e4SLinus Torvalds { 3921da177e4SLinus Torvalds __u8 __user *ptr = arg; 3931da177e4SLinus Torvalds struct hci_inquiry_req ir; 3941da177e4SLinus Torvalds struct hci_dev *hdev; 3951da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 3961da177e4SLinus Torvalds long timeo; 3971da177e4SLinus Torvalds __u8 *buf; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 4001da177e4SLinus Torvalds return -EFAULT; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds if (!(hdev = hci_dev_get(ir.dev_id))) 4031da177e4SLinus Torvalds return -ENODEV; 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4061da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 4071da177e4SLinus Torvalds inquiry_cache_empty(hdev) || 4081da177e4SLinus Torvalds ir.flags & IREQ_CACHE_FLUSH) { 4091da177e4SLinus Torvalds inquiry_cache_flush(hdev); 4101da177e4SLinus Torvalds do_inquiry = 1; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4131da177e4SLinus Torvalds 414*04837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 4151da177e4SLinus Torvalds if (do_inquiry && (err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo)) < 0) 4161da177e4SLinus Torvalds goto done; 4171da177e4SLinus Torvalds 4181da177e4SLinus Torvalds /* for unlimited number of responses we will use buffer with 255 entries */ 4191da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 4201da177e4SLinus Torvalds 4211da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 4221da177e4SLinus Torvalds * copy it to the user space. 4231da177e4SLinus Torvalds */ 4241da177e4SLinus Torvalds if (!(buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL))) { 4251da177e4SLinus Torvalds err = -ENOMEM; 4261da177e4SLinus Torvalds goto done; 4271da177e4SLinus Torvalds } 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 4301da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 4311da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 4361da177e4SLinus Torvalds ptr += sizeof(ir); 4371da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 4381da177e4SLinus Torvalds ir.num_rsp)) 4391da177e4SLinus Torvalds err = -EFAULT; 4401da177e4SLinus Torvalds } else 4411da177e4SLinus Torvalds err = -EFAULT; 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds kfree(buf); 4441da177e4SLinus Torvalds 4451da177e4SLinus Torvalds done: 4461da177e4SLinus Torvalds hci_dev_put(hdev); 4471da177e4SLinus Torvalds return err; 4481da177e4SLinus Torvalds } 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds /* ---- HCI ioctl helpers ---- */ 4511da177e4SLinus Torvalds 4521da177e4SLinus Torvalds int hci_dev_open(__u16 dev) 4531da177e4SLinus Torvalds { 4541da177e4SLinus Torvalds struct hci_dev *hdev; 4551da177e4SLinus Torvalds int ret = 0; 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 4581da177e4SLinus Torvalds return -ENODEV; 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 4611da177e4SLinus Torvalds 4621da177e4SLinus Torvalds hci_req_lock(hdev); 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 4651da177e4SLinus Torvalds ret = -EALREADY; 4661da177e4SLinus Torvalds goto done; 4671da177e4SLinus Torvalds } 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 4701da177e4SLinus Torvalds set_bit(HCI_RAW, &hdev->flags); 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds if (hdev->open(hdev)) { 4731da177e4SLinus Torvalds ret = -EIO; 4741da177e4SLinus Torvalds goto done; 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 4781da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 4791da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds //__hci_request(hdev, hci_reset_req, 0, HZ); 482*04837f64SMarcel Holtmann ret = __hci_request(hdev, hci_init_req, 0, 483*04837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds if (!ret) { 4891da177e4SLinus Torvalds hci_dev_hold(hdev); 4901da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 4911da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 4921da177e4SLinus Torvalds } else { 4931da177e4SLinus Torvalds /* Init failed, cleanup */ 4941da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 4951da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 4961da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 4991da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds if (hdev->flush) 5021da177e4SLinus Torvalds hdev->flush(hdev); 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds if (hdev->sent_cmd) { 5051da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5061da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds 5091da177e4SLinus Torvalds hdev->close(hdev); 5101da177e4SLinus Torvalds hdev->flags = 0; 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds done: 5141da177e4SLinus Torvalds hci_req_unlock(hdev); 5151da177e4SLinus Torvalds hci_dev_put(hdev); 5161da177e4SLinus Torvalds return ret; 5171da177e4SLinus Torvalds } 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 5201da177e4SLinus Torvalds { 5211da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 5241da177e4SLinus Torvalds hci_req_lock(hdev); 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 5271da177e4SLinus Torvalds hci_req_unlock(hdev); 5281da177e4SLinus Torvalds return 0; 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds /* Kill RX and TX tasks */ 5321da177e4SLinus Torvalds tasklet_kill(&hdev->rx_task); 5331da177e4SLinus Torvalds tasklet_kill(&hdev->tx_task); 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 5361da177e4SLinus Torvalds inquiry_cache_flush(hdev); 5371da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 5381da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds if (hdev->flush) 5431da177e4SLinus Torvalds hdev->flush(hdev); 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds /* Reset device */ 5461da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5471da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 5481da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 5491da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 550*04837f64SMarcel Holtmann __hci_request(hdev, hci_reset_req, 0, 551*04837f64SMarcel Holtmann msecs_to_jiffies(250)); 5521da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 5531da177e4SLinus Torvalds } 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds /* Kill cmd task */ 5561da177e4SLinus Torvalds tasklet_kill(&hdev->cmd_task); 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds /* Drop queues */ 5591da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 5601da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 5611da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds /* Drop last sent command */ 5641da177e4SLinus Torvalds if (hdev->sent_cmd) { 5651da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 5661da177e4SLinus Torvalds hdev->sent_cmd = NULL; 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* After this point our queues are empty 5701da177e4SLinus Torvalds * and no tasks are scheduled. */ 5711da177e4SLinus Torvalds hdev->close(hdev); 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds /* Clear flags */ 5741da177e4SLinus Torvalds hdev->flags = 0; 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds hci_req_unlock(hdev); 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds hci_dev_put(hdev); 5791da177e4SLinus Torvalds return 0; 5801da177e4SLinus Torvalds } 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 5831da177e4SLinus Torvalds { 5841da177e4SLinus Torvalds struct hci_dev *hdev; 5851da177e4SLinus Torvalds int err; 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 5881da177e4SLinus Torvalds return -ENODEV; 5891da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 5901da177e4SLinus Torvalds hci_dev_put(hdev); 5911da177e4SLinus Torvalds return err; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 5951da177e4SLinus Torvalds { 5961da177e4SLinus Torvalds struct hci_dev *hdev; 5971da177e4SLinus Torvalds int ret = 0; 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6001da177e4SLinus Torvalds return -ENODEV; 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds hci_req_lock(hdev); 6031da177e4SLinus Torvalds tasklet_disable(&hdev->tx_task); 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds if (!test_bit(HCI_UP, &hdev->flags)) 6061da177e4SLinus Torvalds goto done; 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds /* Drop queues */ 6091da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 6101da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds hci_dev_lock_bh(hdev); 6131da177e4SLinus Torvalds inquiry_cache_flush(hdev); 6141da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 6151da177e4SLinus Torvalds hci_dev_unlock_bh(hdev); 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds if (hdev->flush) 6181da177e4SLinus Torvalds hdev->flush(hdev); 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 6211da177e4SLinus Torvalds hdev->acl_cnt = 0; hdev->sco_cnt = 0; 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 624*04837f64SMarcel Holtmann ret = __hci_request(hdev, hci_reset_req, 0, 625*04837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds done: 6281da177e4SLinus Torvalds tasklet_enable(&hdev->tx_task); 6291da177e4SLinus Torvalds hci_req_unlock(hdev); 6301da177e4SLinus Torvalds hci_dev_put(hdev); 6311da177e4SLinus Torvalds return ret; 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 6351da177e4SLinus Torvalds { 6361da177e4SLinus Torvalds struct hci_dev *hdev; 6371da177e4SLinus Torvalds int ret = 0; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dev))) 6401da177e4SLinus Torvalds return -ENODEV; 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds hci_dev_put(hdev); 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds return ret; 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 6501da177e4SLinus Torvalds { 6511da177e4SLinus Torvalds struct hci_dev *hdev; 6521da177e4SLinus Torvalds struct hci_dev_req dr; 6531da177e4SLinus Torvalds int err = 0; 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 6561da177e4SLinus Torvalds return -EFAULT; 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds if (!(hdev = hci_dev_get(dr.dev_id))) 6591da177e4SLinus Torvalds return -ENODEV; 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds switch (cmd) { 6621da177e4SLinus Torvalds case HCISETAUTH: 663*04837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 664*04837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6651da177e4SLinus Torvalds break; 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds case HCISETENCRYPT: 6681da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 6691da177e4SLinus Torvalds err = -EOPNOTSUPP; 6701da177e4SLinus Torvalds break; 6711da177e4SLinus Torvalds } 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 6741da177e4SLinus Torvalds /* Auth must be enabled first */ 675*04837f64SMarcel Holtmann err = hci_request(hdev, hci_auth_req, dr.dev_opt, 676*04837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6771da177e4SLinus Torvalds if (err) 6781da177e4SLinus Torvalds break; 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds 681*04837f64SMarcel Holtmann err = hci_request(hdev, hci_encrypt_req, dr.dev_opt, 682*04837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6831da177e4SLinus Torvalds break; 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds case HCISETSCAN: 686*04837f64SMarcel Holtmann err = hci_request(hdev, hci_scan_req, dr.dev_opt, 687*04837f64SMarcel Holtmann msecs_to_jiffies(HCI_INIT_TIMEOUT)); 6881da177e4SLinus Torvalds break; 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds case HCISETPTYPE: 6911da177e4SLinus Torvalds hdev->pkt_type = (__u16) dr.dev_opt; 6921da177e4SLinus Torvalds break; 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds case HCISETLINKPOL: 6951da177e4SLinus Torvalds hdev->link_policy = (__u16) dr.dev_opt; 6961da177e4SLinus Torvalds break; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds case HCISETLINKMODE: 6991da177e4SLinus Torvalds hdev->link_mode = ((__u16) dr.dev_opt) & (HCI_LM_MASTER | HCI_LM_ACCEPT); 7001da177e4SLinus Torvalds break; 7011da177e4SLinus Torvalds 7021da177e4SLinus Torvalds case HCISETACLMTU: 7031da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *)&dr.dev_opt + 1); 7041da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *)&dr.dev_opt + 0); 7051da177e4SLinus Torvalds break; 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds case HCISETSCOMTU: 7081da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *)&dr.dev_opt + 1); 7091da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *)&dr.dev_opt + 0); 7101da177e4SLinus Torvalds break; 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds default: 7131da177e4SLinus Torvalds err = -EINVAL; 7141da177e4SLinus Torvalds break; 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds hci_dev_put(hdev); 7171da177e4SLinus Torvalds return err; 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 7211da177e4SLinus Torvalds { 7221da177e4SLinus Torvalds struct hci_dev_list_req *dl; 7231da177e4SLinus Torvalds struct hci_dev_req *dr; 7241da177e4SLinus Torvalds struct list_head *p; 7251da177e4SLinus Torvalds int n = 0, size, err; 7261da177e4SLinus Torvalds __u16 dev_num; 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 7291da177e4SLinus Torvalds return -EFAULT; 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 7321da177e4SLinus Torvalds return -EINVAL; 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds if (!(dl = kmalloc(size, GFP_KERNEL))) 7371da177e4SLinus Torvalds return -ENOMEM; 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds dr = dl->dev_req; 7401da177e4SLinus Torvalds 7411da177e4SLinus Torvalds read_lock_bh(&hci_dev_list_lock); 7421da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 7431da177e4SLinus Torvalds struct hci_dev *hdev; 7441da177e4SLinus Torvalds hdev = list_entry(p, struct hci_dev, list); 7451da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 7461da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 7471da177e4SLinus Torvalds if (++n >= dev_num) 7481da177e4SLinus Torvalds break; 7491da177e4SLinus Torvalds } 7501da177e4SLinus Torvalds read_unlock_bh(&hci_dev_list_lock); 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds dl->dev_num = n; 7531da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 7561da177e4SLinus Torvalds kfree(dl); 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds return err ? -EFAULT : 0; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds 7611da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 7621da177e4SLinus Torvalds { 7631da177e4SLinus Torvalds struct hci_dev *hdev; 7641da177e4SLinus Torvalds struct hci_dev_info di; 7651da177e4SLinus Torvalds int err = 0; 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 7681da177e4SLinus Torvalds return -EFAULT; 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds if (!(hdev = hci_dev_get(di.dev_id))) 7711da177e4SLinus Torvalds return -ENODEV; 7721da177e4SLinus Torvalds 7731da177e4SLinus Torvalds strcpy(di.name, hdev->name); 7741da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 7751da177e4SLinus Torvalds di.type = hdev->type; 7761da177e4SLinus Torvalds di.flags = hdev->flags; 7771da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 7781da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 7791da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 7801da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 7811da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 7821da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 7831da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 7861da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 7891da177e4SLinus Torvalds err = -EFAULT; 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds hci_dev_put(hdev); 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds return err; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds /* Alloc HCI device */ 7991da177e4SLinus Torvalds struct hci_dev *hci_alloc_dev(void) 8001da177e4SLinus Torvalds { 8011da177e4SLinus Torvalds struct hci_dev *hdev; 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds hdev = kmalloc(sizeof(struct hci_dev), GFP_KERNEL); 8041da177e4SLinus Torvalds if (!hdev) 8051da177e4SLinus Torvalds return NULL; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds memset(hdev, 0, sizeof(struct hci_dev)); 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds skb_queue_head_init(&hdev->driver_init); 8101da177e4SLinus Torvalds 8111da177e4SLinus Torvalds return hdev; 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds EXPORT_SYMBOL(hci_alloc_dev); 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds /* Free HCI device */ 8161da177e4SLinus Torvalds void hci_free_dev(struct hci_dev *hdev) 8171da177e4SLinus Torvalds { 8181da177e4SLinus Torvalds skb_queue_purge(&hdev->driver_init); 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds /* will free via class release */ 8211da177e4SLinus Torvalds class_device_put(&hdev->class_dev); 8221da177e4SLinus Torvalds } 8231da177e4SLinus Torvalds EXPORT_SYMBOL(hci_free_dev); 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds /* Register HCI device */ 8261da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 8271da177e4SLinus Torvalds { 8281da177e4SLinus Torvalds struct list_head *head = &hci_dev_list, *p; 8291da177e4SLinus Torvalds int id = 0; 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds BT_DBG("%p name %s type %d owner %p", hdev, hdev->name, hdev->type, hdev->owner); 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds if (!hdev->open || !hdev->close || !hdev->destruct) 8341da177e4SLinus Torvalds return -EINVAL; 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds /* Find first available device id */ 8391da177e4SLinus Torvalds list_for_each(p, &hci_dev_list) { 8401da177e4SLinus Torvalds if (list_entry(p, struct hci_dev, list)->id != id) 8411da177e4SLinus Torvalds break; 8421da177e4SLinus Torvalds head = p; id++; 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 8461da177e4SLinus Torvalds hdev->id = id; 8471da177e4SLinus Torvalds list_add(&hdev->list, head); 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds atomic_set(&hdev->refcnt, 1); 8501da177e4SLinus Torvalds spin_lock_init(&hdev->lock); 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds hdev->flags = 0; 8531da177e4SLinus Torvalds hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 8541da177e4SLinus Torvalds hdev->link_mode = (HCI_LM_ACCEPT); 8551da177e4SLinus Torvalds 856*04837f64SMarcel Holtmann hdev->idle_timeout = 0; 857*04837f64SMarcel Holtmann hdev->sniff_max_interval = 800; 858*04837f64SMarcel Holtmann hdev->sniff_min_interval = 80; 859*04837f64SMarcel Holtmann 8601da177e4SLinus Torvalds tasklet_init(&hdev->cmd_task, hci_cmd_task,(unsigned long) hdev); 8611da177e4SLinus Torvalds tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev); 8621da177e4SLinus Torvalds tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev); 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds skb_queue_head_init(&hdev->rx_q); 8651da177e4SLinus Torvalds skb_queue_head_init(&hdev->cmd_q); 8661da177e4SLinus Torvalds skb_queue_head_init(&hdev->raw_q); 8671da177e4SLinus Torvalds 8681da177e4SLinus Torvalds init_waitqueue_head(&hdev->req_wait_q); 8691da177e4SLinus Torvalds init_MUTEX(&hdev->req_lock); 8701da177e4SLinus Torvalds 8711da177e4SLinus Torvalds inquiry_cache_init(hdev); 8721da177e4SLinus Torvalds 8731da177e4SLinus Torvalds hci_conn_hash_init(hdev); 8741da177e4SLinus Torvalds 8751da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 8761da177e4SLinus Torvalds 8771da177e4SLinus Torvalds atomic_set(&hdev->promisc, 0); 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds hci_register_sysfs(hdev); 8821da177e4SLinus Torvalds 8831da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds return id; 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds /* Unregister HCI device */ 8901da177e4SLinus Torvalds int hci_unregister_dev(struct hci_dev *hdev) 8911da177e4SLinus Torvalds { 8921da177e4SLinus Torvalds BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds hci_unregister_sysfs(hdev); 8951da177e4SLinus Torvalds 8961da177e4SLinus Torvalds write_lock_bh(&hci_dev_list_lock); 8971da177e4SLinus Torvalds list_del(&hdev->list); 8981da177e4SLinus Torvalds write_unlock_bh(&hci_dev_list_lock); 8991da177e4SLinus Torvalds 9001da177e4SLinus Torvalds hci_dev_do_close(hdev); 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 9031da177e4SLinus Torvalds 9041da177e4SLinus Torvalds __hci_dev_put(hdev); 9051da177e4SLinus Torvalds return 0; 9061da177e4SLinus Torvalds } 9071da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds /* Suspend HCI device */ 9101da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 9111da177e4SLinus Torvalds { 9121da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 9131da177e4SLinus Torvalds return 0; 9141da177e4SLinus Torvalds } 9151da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 9161da177e4SLinus Torvalds 9171da177e4SLinus Torvalds /* Resume HCI device */ 9181da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 9191da177e4SLinus Torvalds { 9201da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 9211da177e4SLinus Torvalds return 0; 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds /* Register/Unregister protocols. 9281da177e4SLinus Torvalds * hci_task_lock is used to ensure that no tasks are running. */ 9291da177e4SLinus Torvalds int hci_register_proto(struct hci_proto *hp) 9301da177e4SLinus Torvalds { 9311da177e4SLinus Torvalds int err = 0; 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 9361da177e4SLinus Torvalds return -EINVAL; 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds if (!hci_proto[hp->id]) 9411da177e4SLinus Torvalds hci_proto[hp->id] = hp; 9421da177e4SLinus Torvalds else 9431da177e4SLinus Torvalds err = -EEXIST; 9441da177e4SLinus Torvalds 9451da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 9461da177e4SLinus Torvalds 9471da177e4SLinus Torvalds return err; 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_proto); 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds int hci_unregister_proto(struct hci_proto *hp) 9521da177e4SLinus Torvalds { 9531da177e4SLinus Torvalds int err = 0; 9541da177e4SLinus Torvalds 9551da177e4SLinus Torvalds BT_DBG("%p name %s id %d", hp, hp->name, hp->id); 9561da177e4SLinus Torvalds 9571da177e4SLinus Torvalds if (hp->id >= HCI_MAX_PROTO) 9581da177e4SLinus Torvalds return -EINVAL; 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds write_lock_bh(&hci_task_lock); 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds if (hci_proto[hp->id]) 9631da177e4SLinus Torvalds hci_proto[hp->id] = NULL; 9641da177e4SLinus Torvalds else 9651da177e4SLinus Torvalds err = -ENOENT; 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds write_unlock_bh(&hci_task_lock); 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds return err; 9701da177e4SLinus Torvalds } 9711da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_proto); 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 9741da177e4SLinus Torvalds { 9751da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 9761da177e4SLinus Torvalds 9771da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 9781da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 9791da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds return 0; 9821da177e4SLinus Torvalds } 9831da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 9841da177e4SLinus Torvalds 9851da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 9861da177e4SLinus Torvalds { 9871da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds write_lock_bh(&hci_cb_list_lock); 9901da177e4SLinus Torvalds list_del(&cb->list); 9911da177e4SLinus Torvalds write_unlock_bh(&hci_cb_list_lock); 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds return 0; 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds static int hci_send_frame(struct sk_buff *skb) 9981da177e4SLinus Torvalds { 9991da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) skb->dev; 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds if (!hdev) { 10021da177e4SLinus Torvalds kfree_skb(skb); 10031da177e4SLinus Torvalds return -ENODEV; 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 10060d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 10091da177e4SLinus Torvalds /* Time stamp */ 1010a61bbcf2SPatrick McHardy __net_timestamp(skb); 10111da177e4SLinus Torvalds 10121da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 10131da177e4SLinus Torvalds } 10141da177e4SLinus Torvalds 10151da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 10161da177e4SLinus Torvalds skb_orphan(skb); 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds return hdev->send(skb); 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds 10211da177e4SLinus Torvalds /* Send HCI command */ 10221da177e4SLinus Torvalds int hci_send_cmd(struct hci_dev *hdev, __u16 ogf, __u16 ocf, __u32 plen, void *param) 10231da177e4SLinus Torvalds { 10241da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 10251da177e4SLinus Torvalds struct hci_command_hdr *hdr; 10261da177e4SLinus Torvalds struct sk_buff *skb; 10271da177e4SLinus Torvalds 10281da177e4SLinus Torvalds BT_DBG("%s ogf 0x%x ocf 0x%x plen %d", hdev->name, ogf, ocf, plen); 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 10311da177e4SLinus Torvalds if (!skb) { 10321da177e4SLinus Torvalds BT_ERR("%s Can't allocate memory for HCI command", hdev->name); 10331da177e4SLinus Torvalds return -ENOMEM; 10341da177e4SLinus Torvalds } 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 10371da177e4SLinus Torvalds hdr->opcode = __cpu_to_le16(hci_opcode_pack(ogf, ocf)); 10381da177e4SLinus Torvalds hdr->plen = plen; 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds if (plen) 10411da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 10441da177e4SLinus Torvalds 10450d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 10461da177e4SLinus Torvalds skb->dev = (void *) hdev; 10471da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 10481da177e4SLinus Torvalds hci_sched_cmd(hdev); 10491da177e4SLinus Torvalds 10501da177e4SLinus Torvalds return 0; 10511da177e4SLinus Torvalds } 10521da177e4SLinus Torvalds 10531da177e4SLinus Torvalds /* Get data from the previously sent command */ 10541da177e4SLinus Torvalds void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 ogf, __u16 ocf) 10551da177e4SLinus Torvalds { 10561da177e4SLinus Torvalds struct hci_command_hdr *hdr; 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds if (!hdev->sent_cmd) 10591da177e4SLinus Torvalds return NULL; 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds if (hdr->opcode != __cpu_to_le16(hci_opcode_pack(ogf, ocf))) 10641da177e4SLinus Torvalds return NULL; 10651da177e4SLinus Torvalds 10661da177e4SLinus Torvalds BT_DBG("%s ogf 0x%x ocf 0x%x", hdev->name, ogf, ocf); 10671da177e4SLinus Torvalds 10681da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 10691da177e4SLinus Torvalds } 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds /* Send ACL data */ 10721da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 10731da177e4SLinus Torvalds { 10741da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 10751da177e4SLinus Torvalds int len = skb->len; 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds hdr = (struct hci_acl_hdr *) skb_push(skb, HCI_ACL_HDR_SIZE); 10781da177e4SLinus Torvalds hdr->handle = __cpu_to_le16(hci_handle_pack(handle, flags)); 10791da177e4SLinus Torvalds hdr->dlen = __cpu_to_le16(len); 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds skb->h.raw = (void *) hdr; 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds 10841da177e4SLinus Torvalds int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags) 10851da177e4SLinus Torvalds { 10861da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 10871da177e4SLinus Torvalds struct sk_buff *list; 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags); 10901da177e4SLinus Torvalds 10911da177e4SLinus Torvalds skb->dev = (void *) hdev; 10920d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 10931da177e4SLinus Torvalds hci_add_acl_hdr(skb, conn->handle, flags | ACL_START); 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds if (!(list = skb_shinfo(skb)->frag_list)) { 10961da177e4SLinus Torvalds /* Non fragmented */ 10971da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 10981da177e4SLinus Torvalds 10991da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 11001da177e4SLinus Torvalds } else { 11011da177e4SLinus Torvalds /* Fragmented */ 11021da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds /* Queue all fragments atomically */ 11071da177e4SLinus Torvalds spin_lock_bh(&conn->data_q.lock); 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 11101da177e4SLinus Torvalds do { 11111da177e4SLinus Torvalds skb = list; list = list->next; 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds skb->dev = (void *) hdev; 11140d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 11151da177e4SLinus Torvalds hci_add_acl_hdr(skb, conn->handle, flags | ACL_CONT); 11161da177e4SLinus Torvalds 11171da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 11181da177e4SLinus Torvalds 11191da177e4SLinus Torvalds __skb_queue_tail(&conn->data_q, skb); 11201da177e4SLinus Torvalds } while (list); 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds spin_unlock_bh(&conn->data_q.lock); 11231da177e4SLinus Torvalds } 11241da177e4SLinus Torvalds 11251da177e4SLinus Torvalds hci_sched_tx(hdev); 11261da177e4SLinus Torvalds return 0; 11271da177e4SLinus Torvalds } 11281da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_acl); 11291da177e4SLinus Torvalds 11301da177e4SLinus Torvalds /* Send SCO data */ 11311da177e4SLinus Torvalds int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 11321da177e4SLinus Torvalds { 11331da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 11341da177e4SLinus Torvalds struct hci_sco_hdr hdr; 11351da177e4SLinus Torvalds 11361da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 11371da177e4SLinus Torvalds 11381da177e4SLinus Torvalds if (skb->len > hdev->sco_mtu) { 11391da177e4SLinus Torvalds kfree_skb(skb); 11401da177e4SLinus Torvalds return -EINVAL; 11411da177e4SLinus Torvalds } 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds hdr.handle = __cpu_to_le16(conn->handle); 11441da177e4SLinus Torvalds hdr.dlen = skb->len; 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds skb->h.raw = skb_push(skb, HCI_SCO_HDR_SIZE); 11471da177e4SLinus Torvalds memcpy(skb->h.raw, &hdr, HCI_SCO_HDR_SIZE); 11481da177e4SLinus Torvalds 11491da177e4SLinus Torvalds skb->dev = (void *) hdev; 11500d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 11511da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 11521da177e4SLinus Torvalds hci_sched_tx(hdev); 11531da177e4SLinus Torvalds return 0; 11541da177e4SLinus Torvalds } 11551da177e4SLinus Torvalds EXPORT_SYMBOL(hci_send_sco); 11561da177e4SLinus Torvalds 11571da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 11581da177e4SLinus Torvalds 11591da177e4SLinus Torvalds /* HCI Connection scheduler */ 11601da177e4SLinus Torvalds static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote) 11611da177e4SLinus Torvalds { 11621da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 11631da177e4SLinus Torvalds struct hci_conn *conn = NULL; 11641da177e4SLinus Torvalds int num = 0, min = ~0; 11651da177e4SLinus Torvalds struct list_head *p; 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 11681da177e4SLinus Torvalds * added and removed with TX task disabled. */ 11691da177e4SLinus Torvalds list_for_each(p, &h->list) { 11701da177e4SLinus Torvalds struct hci_conn *c; 11711da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 11721da177e4SLinus Torvalds 11731da177e4SLinus Torvalds if (c->type != type || c->state != BT_CONNECTED 11741da177e4SLinus Torvalds || skb_queue_empty(&c->data_q)) 11751da177e4SLinus Torvalds continue; 11761da177e4SLinus Torvalds num++; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds if (c->sent < min) { 11791da177e4SLinus Torvalds min = c->sent; 11801da177e4SLinus Torvalds conn = c; 11811da177e4SLinus Torvalds } 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds if (conn) { 11851da177e4SLinus Torvalds int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt); 11861da177e4SLinus Torvalds int q = cnt / num; 11871da177e4SLinus Torvalds *quote = q ? q : 1; 11881da177e4SLinus Torvalds } else 11891da177e4SLinus Torvalds *quote = 0; 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 11921da177e4SLinus Torvalds return conn; 11931da177e4SLinus Torvalds } 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds static inline void hci_acl_tx_to(struct hci_dev *hdev) 11961da177e4SLinus Torvalds { 11971da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 11981da177e4SLinus Torvalds struct list_head *p; 11991da177e4SLinus Torvalds struct hci_conn *c; 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds BT_ERR("%s ACL tx timeout", hdev->name); 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds /* Kill stalled connections */ 12041da177e4SLinus Torvalds list_for_each(p, &h->list) { 12051da177e4SLinus Torvalds c = list_entry(p, struct hci_conn, list); 12061da177e4SLinus Torvalds if (c->type == ACL_LINK && c->sent) { 12071da177e4SLinus Torvalds BT_ERR("%s killing stalled ACL connection %s", 12081da177e4SLinus Torvalds hdev->name, batostr(&c->dst)); 12091da177e4SLinus Torvalds hci_acl_disconn(c, 0x13); 12101da177e4SLinus Torvalds } 12111da177e4SLinus Torvalds } 12121da177e4SLinus Torvalds } 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds static inline void hci_sched_acl(struct hci_dev *hdev) 12151da177e4SLinus Torvalds { 12161da177e4SLinus Torvalds struct hci_conn *conn; 12171da177e4SLinus Torvalds struct sk_buff *skb; 12181da177e4SLinus Torvalds int quote; 12191da177e4SLinus Torvalds 12201da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 12231da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 12241da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 12251da177e4SLinus Torvalds if (!hdev->acl_cnt && (jiffies - hdev->acl_last_tx) > (HZ * 45)) 12261da177e4SLinus Torvalds hci_acl_tx_to(hdev); 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, "e))) { 12301da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 12311da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 1232*04837f64SMarcel Holtmann 1233*04837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 1234*04837f64SMarcel Holtmann 12351da177e4SLinus Torvalds hci_send_frame(skb); 12361da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds hdev->acl_cnt--; 12391da177e4SLinus Torvalds conn->sent++; 12401da177e4SLinus Torvalds } 12411da177e4SLinus Torvalds } 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds 12441da177e4SLinus Torvalds /* Schedule SCO */ 12451da177e4SLinus Torvalds static inline void hci_sched_sco(struct hci_dev *hdev) 12461da177e4SLinus Torvalds { 12471da177e4SLinus Torvalds struct hci_conn *conn; 12481da177e4SLinus Torvalds struct sk_buff *skb; 12491da177e4SLinus Torvalds int quote; 12501da177e4SLinus Torvalds 12511da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 12541da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 12551da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 12561da177e4SLinus Torvalds hci_send_frame(skb); 12571da177e4SLinus Torvalds 12581da177e4SLinus Torvalds conn->sent++; 12591da177e4SLinus Torvalds if (conn->sent == ~0) 12601da177e4SLinus Torvalds conn->sent = 0; 12611da177e4SLinus Torvalds } 12621da177e4SLinus Torvalds } 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds static void hci_tx_task(unsigned long arg) 12661da177e4SLinus Torvalds { 12671da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 12681da177e4SLinus Torvalds struct sk_buff *skb; 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds read_lock(&hci_task_lock); 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt); 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds hci_sched_acl(hdev); 12771da177e4SLinus Torvalds 12781da177e4SLinus Torvalds hci_sched_sco(hdev); 12791da177e4SLinus Torvalds 12801da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 12811da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 12821da177e4SLinus Torvalds hci_send_frame(skb); 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds read_unlock(&hci_task_lock); 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds /* ----- HCI RX task (incoming data proccessing) ----- */ 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds /* ACL data packet */ 12901da177e4SLinus Torvalds static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 12911da177e4SLinus Torvalds { 12921da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 12931da177e4SLinus Torvalds struct hci_conn *conn; 12941da177e4SLinus Torvalds __u16 handle, flags; 12951da177e4SLinus Torvalds 12961da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 12971da177e4SLinus Torvalds 12981da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 12991da177e4SLinus Torvalds flags = hci_flags(handle); 13001da177e4SLinus Torvalds handle = hci_handle(handle); 13011da177e4SLinus Torvalds 13021da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags); 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds hdev->stat.acl_rx++; 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds hci_dev_lock(hdev); 13071da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 13081da177e4SLinus Torvalds hci_dev_unlock(hdev); 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds if (conn) { 13111da177e4SLinus Torvalds register struct hci_proto *hp; 13121da177e4SLinus Torvalds 1313*04837f64SMarcel Holtmann hci_conn_enter_active_mode(conn); 1314*04837f64SMarcel Holtmann 13151da177e4SLinus Torvalds /* Send to upper protocol */ 13161da177e4SLinus Torvalds if ((hp = hci_proto[HCI_PROTO_L2CAP]) && hp->recv_acldata) { 13171da177e4SLinus Torvalds hp->recv_acldata(conn, skb, flags); 13181da177e4SLinus Torvalds return; 13191da177e4SLinus Torvalds } 13201da177e4SLinus Torvalds } else { 13211da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 13221da177e4SLinus Torvalds hdev->name, handle); 13231da177e4SLinus Torvalds } 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds kfree_skb(skb); 13261da177e4SLinus Torvalds } 13271da177e4SLinus Torvalds 13281da177e4SLinus Torvalds /* SCO data packet */ 13291da177e4SLinus Torvalds static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 13301da177e4SLinus Torvalds { 13311da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 13321da177e4SLinus Torvalds struct hci_conn *conn; 13331da177e4SLinus Torvalds __u16 handle; 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 13361da177e4SLinus Torvalds 13371da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 13381da177e4SLinus Torvalds 13391da177e4SLinus Torvalds BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle); 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds hdev->stat.sco_rx++; 13421da177e4SLinus Torvalds 13431da177e4SLinus Torvalds hci_dev_lock(hdev); 13441da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 13451da177e4SLinus Torvalds hci_dev_unlock(hdev); 13461da177e4SLinus Torvalds 13471da177e4SLinus Torvalds if (conn) { 13481da177e4SLinus Torvalds register struct hci_proto *hp; 13491da177e4SLinus Torvalds 13501da177e4SLinus Torvalds /* Send to upper protocol */ 13511da177e4SLinus Torvalds if ((hp = hci_proto[HCI_PROTO_SCO]) && hp->recv_scodata) { 13521da177e4SLinus Torvalds hp->recv_scodata(conn, skb); 13531da177e4SLinus Torvalds return; 13541da177e4SLinus Torvalds } 13551da177e4SLinus Torvalds } else { 13561da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 13571da177e4SLinus Torvalds hdev->name, handle); 13581da177e4SLinus Torvalds } 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds kfree_skb(skb); 13611da177e4SLinus Torvalds } 13621da177e4SLinus Torvalds 13636516455dSMarcel Holtmann static void hci_rx_task(unsigned long arg) 13641da177e4SLinus Torvalds { 13651da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 13661da177e4SLinus Torvalds struct sk_buff *skb; 13671da177e4SLinus Torvalds 13681da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 13691da177e4SLinus Torvalds 13701da177e4SLinus Torvalds read_lock(&hci_task_lock); 13711da177e4SLinus Torvalds 13721da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 13731da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 13741da177e4SLinus Torvalds /* Send copy to the sockets */ 13751da177e4SLinus Torvalds hci_send_to_sock(hdev, skb); 13761da177e4SLinus Torvalds } 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds if (test_bit(HCI_RAW, &hdev->flags)) { 13791da177e4SLinus Torvalds kfree_skb(skb); 13801da177e4SLinus Torvalds continue; 13811da177e4SLinus Torvalds } 13821da177e4SLinus Torvalds 13831da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 13841da177e4SLinus Torvalds /* Don't process data packets in this states. */ 13850d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 13861da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 13871da177e4SLinus Torvalds case HCI_SCODATA_PKT: 13881da177e4SLinus Torvalds kfree_skb(skb); 13891da177e4SLinus Torvalds continue; 13901da177e4SLinus Torvalds }; 13911da177e4SLinus Torvalds } 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds /* Process frame */ 13940d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 13951da177e4SLinus Torvalds case HCI_EVENT_PKT: 13961da177e4SLinus Torvalds hci_event_packet(hdev, skb); 13971da177e4SLinus Torvalds break; 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 14001da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 14011da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 14021da177e4SLinus Torvalds break; 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds case HCI_SCODATA_PKT: 14051da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 14061da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 14071da177e4SLinus Torvalds break; 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds default: 14101da177e4SLinus Torvalds kfree_skb(skb); 14111da177e4SLinus Torvalds break; 14121da177e4SLinus Torvalds } 14131da177e4SLinus Torvalds } 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds read_unlock(&hci_task_lock); 14161da177e4SLinus Torvalds } 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds static void hci_cmd_task(unsigned long arg) 14191da177e4SLinus Torvalds { 14201da177e4SLinus Torvalds struct hci_dev *hdev = (struct hci_dev *) arg; 14211da177e4SLinus Torvalds struct sk_buff *skb; 14221da177e4SLinus Torvalds 14231da177e4SLinus Torvalds BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt)); 14241da177e4SLinus Torvalds 14251da177e4SLinus Torvalds if (!atomic_read(&hdev->cmd_cnt) && (jiffies - hdev->cmd_last_tx) > HZ) { 14261da177e4SLinus Torvalds BT_ERR("%s command tx timeout", hdev->name); 14271da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14281da177e4SLinus Torvalds } 14291da177e4SLinus Torvalds 14301da177e4SLinus Torvalds /* Send queued commands */ 14311da177e4SLinus Torvalds if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) { 14321da177e4SLinus Torvalds if (hdev->sent_cmd) 14331da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 14341da177e4SLinus Torvalds 14351da177e4SLinus Torvalds if ((hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC))) { 14361da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 14371da177e4SLinus Torvalds hci_send_frame(skb); 14381da177e4SLinus Torvalds hdev->cmd_last_tx = jiffies; 14391da177e4SLinus Torvalds } else { 14401da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 14411da177e4SLinus Torvalds hci_sched_cmd(hdev); 14421da177e4SLinus Torvalds } 14431da177e4SLinus Torvalds } 14441da177e4SLinus Torvalds } 1445