11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 4590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 51da177e4SLinus Torvalds 61da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 101da177e4SLinus Torvalds published by the Free Software Foundation; 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 131da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 141da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 151da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 161da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 171da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 181da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 191da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 221da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 231da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds /* Bluetooth HCI core. */ 271da177e4SLinus Torvalds 288c520a59SGustavo Padovan #include <linux/export.h> 293df92b31SSasha Levin #include <linux/idr.h> 30611b30f7SMarcel Holtmann #include <linux/rfkill.h> 31baf27f6eSMarcel Holtmann #include <linux/debugfs.h> 3299780a7bSJohan Hedberg #include <linux/crypto.h> 3347219839SMarcel Holtmann #include <asm/unaligned.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 361da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 374bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 38af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 391da177e4SLinus Torvalds 400857dd3bSJohan Hedberg #include "hci_request.h" 4160c5f5fbSMarcel Holtmann #include "hci_debugfs.h" 42970c4e46SJohan Hedberg #include "smp.h" 43970c4e46SJohan Hedberg 44b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 45c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 463eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds /* HCI device list */ 491da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 501da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds /* HCI callback list */ 531da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 54fba7ecf0SJohan Hedberg DEFINE_MUTEX(hci_cb_list_lock); 551da177e4SLinus Torvalds 563df92b31SSasha Levin /* HCI ID Numbering */ 573df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 583df92b31SSasha Levin 59899de765SMarcel Holtmann /* ----- HCI requests ----- */ 60899de765SMarcel Holtmann 61899de765SMarcel Holtmann #define HCI_REQ_DONE 0 62899de765SMarcel Holtmann #define HCI_REQ_PEND 1 63899de765SMarcel Holtmann #define HCI_REQ_CANCELED 2 64899de765SMarcel Holtmann 65899de765SMarcel Holtmann #define hci_req_lock(d) mutex_lock(&d->req_lock) 66899de765SMarcel Holtmann #define hci_req_unlock(d) mutex_unlock(&d->req_lock) 67899de765SMarcel Holtmann 681da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 691da177e4SLinus Torvalds 706516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 711da177e4SLinus Torvalds { 72040030efSMarcel Holtmann hci_sock_dev_event(hdev, event); 731da177e4SLinus Torvalds } 741da177e4SLinus Torvalds 75baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 76baf27f6eSMarcel Holtmann 774b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 784b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 794b4148e9SMarcel Holtmann { 804b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 814b4148e9SMarcel Holtmann char buf[3]; 824b4148e9SMarcel Holtmann 83b7cb93e5SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y': 'N'; 844b4148e9SMarcel Holtmann buf[1] = '\n'; 854b4148e9SMarcel Holtmann buf[2] = '\0'; 864b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 874b4148e9SMarcel Holtmann } 884b4148e9SMarcel Holtmann 894b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 904b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 914b4148e9SMarcel Holtmann { 924b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 934b4148e9SMarcel Holtmann struct sk_buff *skb; 944b4148e9SMarcel Holtmann char buf[32]; 954b4148e9SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 964b4148e9SMarcel Holtmann bool enable; 974b4148e9SMarcel Holtmann 984b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 994b4148e9SMarcel Holtmann return -ENETDOWN; 1004b4148e9SMarcel Holtmann 1014b4148e9SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 1024b4148e9SMarcel Holtmann return -EFAULT; 1034b4148e9SMarcel Holtmann 1044b4148e9SMarcel Holtmann buf[buf_size] = '\0'; 1054b4148e9SMarcel Holtmann if (strtobool(buf, &enable)) 1064b4148e9SMarcel Holtmann return -EINVAL; 1074b4148e9SMarcel Holtmann 108b7cb93e5SMarcel Holtmann if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE)) 1094b4148e9SMarcel Holtmann return -EALREADY; 1104b4148e9SMarcel Holtmann 1114b4148e9SMarcel Holtmann hci_req_lock(hdev); 1124b4148e9SMarcel Holtmann if (enable) 1134b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 1144b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1154b4148e9SMarcel Holtmann else 1164b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 1174b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1184b4148e9SMarcel Holtmann hci_req_unlock(hdev); 1194b4148e9SMarcel Holtmann 1204b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1214b4148e9SMarcel Holtmann return PTR_ERR(skb); 1224b4148e9SMarcel Holtmann 1234b4148e9SMarcel Holtmann kfree_skb(skb); 1244b4148e9SMarcel Holtmann 125b7cb93e5SMarcel Holtmann hci_dev_change_flag(hdev, HCI_DUT_MODE); 1264b4148e9SMarcel Holtmann 1274b4148e9SMarcel Holtmann return count; 1284b4148e9SMarcel Holtmann } 1294b4148e9SMarcel Holtmann 1304b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1314b4148e9SMarcel Holtmann .open = simple_open, 1324b4148e9SMarcel Holtmann .read = dut_mode_read, 1334b4148e9SMarcel Holtmann .write = dut_mode_write, 1344b4148e9SMarcel Holtmann .llseek = default_llseek, 1354b4148e9SMarcel Holtmann }; 1364b4148e9SMarcel Holtmann 1374b4113d6SMarcel Holtmann static ssize_t vendor_diag_read(struct file *file, char __user *user_buf, 1384b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1394b4113d6SMarcel Holtmann { 1404b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1414b4113d6SMarcel Holtmann char buf[3]; 1424b4113d6SMarcel Holtmann 1434b4113d6SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y': 'N'; 1444b4113d6SMarcel Holtmann buf[1] = '\n'; 1454b4113d6SMarcel Holtmann buf[2] = '\0'; 1464b4113d6SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 1474b4113d6SMarcel Holtmann } 1484b4113d6SMarcel Holtmann 1494b4113d6SMarcel Holtmann static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf, 1504b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1514b4113d6SMarcel Holtmann { 1524b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1534b4113d6SMarcel Holtmann char buf[32]; 1544b4113d6SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 1554b4113d6SMarcel Holtmann bool enable; 1564b4113d6SMarcel Holtmann int err; 1574b4113d6SMarcel Holtmann 1584b4113d6SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 1594b4113d6SMarcel Holtmann return -EFAULT; 1604b4113d6SMarcel Holtmann 1614b4113d6SMarcel Holtmann buf[buf_size] = '\0'; 1624b4113d6SMarcel Holtmann if (strtobool(buf, &enable)) 1634b4113d6SMarcel Holtmann return -EINVAL; 1644b4113d6SMarcel Holtmann 1654b4113d6SMarcel Holtmann hci_req_lock(hdev); 1664b4113d6SMarcel Holtmann err = hdev->set_diag(hdev, enable); 1674b4113d6SMarcel Holtmann hci_req_unlock(hdev); 1684b4113d6SMarcel Holtmann 1694b4113d6SMarcel Holtmann if (err < 0) 1704b4113d6SMarcel Holtmann return err; 1714b4113d6SMarcel Holtmann 1724b4113d6SMarcel Holtmann if (enable) 1734b4113d6SMarcel Holtmann hci_dev_set_flag(hdev, HCI_VENDOR_DIAG); 1744b4113d6SMarcel Holtmann else 1754b4113d6SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG); 1764b4113d6SMarcel Holtmann 1774b4113d6SMarcel Holtmann return count; 1784b4113d6SMarcel Holtmann } 1794b4113d6SMarcel Holtmann 1804b4113d6SMarcel Holtmann static const struct file_operations vendor_diag_fops = { 1814b4113d6SMarcel Holtmann .open = simple_open, 1824b4113d6SMarcel Holtmann .read = vendor_diag_read, 1834b4113d6SMarcel Holtmann .write = vendor_diag_write, 1844b4113d6SMarcel Holtmann .llseek = default_llseek, 1854b4113d6SMarcel Holtmann }; 1864b4113d6SMarcel Holtmann 1871da177e4SLinus Torvalds /* ---- HCI requests ---- */ 1881da177e4SLinus Torvalds 189f60cb305SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result, u16 opcode, 190f60cb305SJohan Hedberg struct sk_buff *skb) 1911da177e4SLinus Torvalds { 19242c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 19375fb0e32SJohan Hedberg 1941da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1951da177e4SLinus Torvalds hdev->req_result = result; 1961da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 197f60cb305SJohan Hedberg if (skb) 198f60cb305SJohan Hedberg hdev->req_skb = skb_get(skb); 1991da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 2041da177e4SLinus Torvalds { 2051da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 2081da177e4SLinus Torvalds hdev->req_result = err; 2091da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 2101da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 2111da177e4SLinus Torvalds } 2121da177e4SLinus Torvalds } 2131da177e4SLinus Torvalds 2147b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 21507dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 21675e84b7cSJohan Hedberg { 21775e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 21875e84b7cSJohan Hedberg struct hci_request req; 219f60cb305SJohan Hedberg struct sk_buff *skb; 22075e84b7cSJohan Hedberg int err = 0; 22175e84b7cSJohan Hedberg 22275e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 22375e84b7cSJohan Hedberg 22475e84b7cSJohan Hedberg hci_req_init(&req, hdev); 22575e84b7cSJohan Hedberg 2267b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 22775e84b7cSJohan Hedberg 22875e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 22975e84b7cSJohan Hedberg 23075e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 23175e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 23275e84b7cSJohan Hedberg 233f60cb305SJohan Hedberg err = hci_req_run_skb(&req, hci_req_sync_complete); 234039fada5SChan-yeol Park if (err < 0) { 235039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 23622a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 237039fada5SChan-yeol Park return ERR_PTR(err); 238039fada5SChan-yeol Park } 239039fada5SChan-yeol Park 24075e84b7cSJohan Hedberg schedule_timeout(timeout); 24175e84b7cSJohan Hedberg 24275e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 24375e84b7cSJohan Hedberg 24475e84b7cSJohan Hedberg if (signal_pending(current)) 24575e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 24675e84b7cSJohan Hedberg 24775e84b7cSJohan Hedberg switch (hdev->req_status) { 24875e84b7cSJohan Hedberg case HCI_REQ_DONE: 24975e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 25075e84b7cSJohan Hedberg break; 25175e84b7cSJohan Hedberg 25275e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 25375e84b7cSJohan Hedberg err = -hdev->req_result; 25475e84b7cSJohan Hedberg break; 25575e84b7cSJohan Hedberg 25675e84b7cSJohan Hedberg default: 25775e84b7cSJohan Hedberg err = -ETIMEDOUT; 25875e84b7cSJohan Hedberg break; 25975e84b7cSJohan Hedberg } 26075e84b7cSJohan Hedberg 26175e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 262f60cb305SJohan Hedberg skb = hdev->req_skb; 263f60cb305SJohan Hedberg hdev->req_skb = NULL; 26475e84b7cSJohan Hedberg 26575e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 26675e84b7cSJohan Hedberg 267f60cb305SJohan Hedberg if (err < 0) { 268f60cb305SJohan Hedberg kfree_skb(skb); 26975e84b7cSJohan Hedberg return ERR_PTR(err); 270f60cb305SJohan Hedberg } 27175e84b7cSJohan Hedberg 272757aa0b5SJohan Hedberg if (!skb) 273757aa0b5SJohan Hedberg return ERR_PTR(-ENODATA); 274757aa0b5SJohan Hedberg 275757aa0b5SJohan Hedberg return skb; 2767b1abbbeSJohan Hedberg } 2777b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 2787b1abbbeSJohan Hedberg 2797b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 28007dc93ddSJohan Hedberg const void *param, u32 timeout) 2817b1abbbeSJohan Hedberg { 2827b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 28375e84b7cSJohan Hedberg } 28475e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 28575e84b7cSJohan Hedberg 2861da177e4SLinus Torvalds /* Execute request and wait for completion. */ 28701178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 28842c6b129SJohan Hedberg void (*func)(struct hci_request *req, 28942c6b129SJohan Hedberg unsigned long opt), 2901da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 2911da177e4SLinus Torvalds { 29242c6b129SJohan Hedberg struct hci_request req; 2931da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 2941da177e4SLinus Torvalds int err = 0; 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 2971da177e4SLinus Torvalds 29842c6b129SJohan Hedberg hci_req_init(&req, hdev); 29942c6b129SJohan Hedberg 3001da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 3011da177e4SLinus Torvalds 30242c6b129SJohan Hedberg func(&req, opt); 30353cce22dSJohan Hedberg 304039fada5SChan-yeol Park add_wait_queue(&hdev->req_wait_q, &wait); 305039fada5SChan-yeol Park set_current_state(TASK_INTERRUPTIBLE); 306039fada5SChan-yeol Park 307f60cb305SJohan Hedberg err = hci_req_run_skb(&req, hci_req_sync_complete); 30842c6b129SJohan Hedberg if (err < 0) { 30953cce22dSJohan Hedberg hdev->req_status = 0; 310920c8300SAndre Guedes 311039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 31222a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 313039fada5SChan-yeol Park 314920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 315920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 316920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 317920c8300SAndre Guedes * and should not trigger an error return. 31842c6b129SJohan Hedberg */ 319920c8300SAndre Guedes if (err == -ENODATA) 32042c6b129SJohan Hedberg return 0; 321920c8300SAndre Guedes 322920c8300SAndre Guedes return err; 32353cce22dSJohan Hedberg } 32453cce22dSJohan Hedberg 3251da177e4SLinus Torvalds schedule_timeout(timeout); 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds if (signal_pending(current)) 3301da177e4SLinus Torvalds return -EINTR; 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds switch (hdev->req_status) { 3331da177e4SLinus Torvalds case HCI_REQ_DONE: 334e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 3351da177e4SLinus Torvalds break; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds case HCI_REQ_CANCELED: 3381da177e4SLinus Torvalds err = -hdev->req_result; 3391da177e4SLinus Torvalds break; 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds default: 3421da177e4SLinus Torvalds err = -ETIMEDOUT; 3431da177e4SLinus Torvalds break; 3443ff50b79SStephen Hemminger } 3451da177e4SLinus Torvalds 346a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds return err; 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds 35301178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 35442c6b129SJohan Hedberg void (*req)(struct hci_request *req, 35542c6b129SJohan Hedberg unsigned long opt), 3561da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 3571da177e4SLinus Torvalds { 3581da177e4SLinus Torvalds int ret; 3591da177e4SLinus Torvalds 3607c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 3617c6a329eSMarcel Holtmann return -ENETDOWN; 3627c6a329eSMarcel Holtmann 3631da177e4SLinus Torvalds /* Serialize all requests */ 3641da177e4SLinus Torvalds hci_req_lock(hdev); 36501178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 3661da177e4SLinus Torvalds hci_req_unlock(hdev); 3671da177e4SLinus Torvalds 3681da177e4SLinus Torvalds return ret; 3691da177e4SLinus Torvalds } 3701da177e4SLinus Torvalds 37142c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 3721da177e4SLinus Torvalds { 37342c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds /* Reset device */ 37642c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 37742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds 38042c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 3811da177e4SLinus Torvalds { 38242c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 3832455a3eaSAndrei Emeltchenko 3841da177e4SLinus Torvalds /* Read Local Supported Features */ 38542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 3861da177e4SLinus Torvalds 3871143e5a6SMarcel Holtmann /* Read Local Version */ 38842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 3892177bab5SJohan Hedberg 3902177bab5SJohan Hedberg /* Read BD Address */ 39142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds 3940af801b9SJohan Hedberg static void amp_init1(struct hci_request *req) 395e61ef499SAndrei Emeltchenko { 39642c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 3972455a3eaSAndrei Emeltchenko 398e61ef499SAndrei Emeltchenko /* Read Local Version */ 39942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 4006bcbc489SAndrei Emeltchenko 401f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 402f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 403f6996cfeSMarcel Holtmann 4046bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 40542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 406e71dfabaSAndrei Emeltchenko 407e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 40842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 4097528ca1cSMarcel Holtmann 410f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 411f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 412f38ba941SMarcel Holtmann 4137528ca1cSMarcel Holtmann /* Read Location Data */ 4147528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 415e61ef499SAndrei Emeltchenko } 416e61ef499SAndrei Emeltchenko 4170af801b9SJohan Hedberg static void amp_init2(struct hci_request *req) 4180af801b9SJohan Hedberg { 4190af801b9SJohan Hedberg /* Read Local Supported Features. Not all AMP controllers 4200af801b9SJohan Hedberg * support this so it's placed conditionally in the second 4210af801b9SJohan Hedberg * stage init. 4220af801b9SJohan Hedberg */ 4230af801b9SJohan Hedberg if (req->hdev->commands[14] & 0x20) 4240af801b9SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 4250af801b9SJohan Hedberg } 4260af801b9SJohan Hedberg 42742c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 428e61ef499SAndrei Emeltchenko { 42942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 430e61ef499SAndrei Emeltchenko 431e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 432e61ef499SAndrei Emeltchenko 43311778716SAndrei Emeltchenko /* Reset */ 43411778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 43542c6b129SJohan Hedberg hci_reset_req(req, 0); 43611778716SAndrei Emeltchenko 437e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 438e61ef499SAndrei Emeltchenko case HCI_BREDR: 43942c6b129SJohan Hedberg bredr_init(req); 440e61ef499SAndrei Emeltchenko break; 441e61ef499SAndrei Emeltchenko 442e61ef499SAndrei Emeltchenko case HCI_AMP: 4430af801b9SJohan Hedberg amp_init1(req); 444e61ef499SAndrei Emeltchenko break; 445e61ef499SAndrei Emeltchenko 446e61ef499SAndrei Emeltchenko default: 447e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 448e61ef499SAndrei Emeltchenko break; 449e61ef499SAndrei Emeltchenko } 450e61ef499SAndrei Emeltchenko } 451e61ef499SAndrei Emeltchenko 45242c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 4532177bab5SJohan Hedberg { 4542177bab5SJohan Hedberg __le16 param; 4552177bab5SJohan Hedberg __u8 flt_type; 4562177bab5SJohan Hedberg 4572177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 45842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 4592177bab5SJohan Hedberg 4602177bab5SJohan Hedberg /* Read Class of Device */ 46142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 4622177bab5SJohan Hedberg 4632177bab5SJohan Hedberg /* Read Local Name */ 46442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 4652177bab5SJohan Hedberg 4662177bab5SJohan Hedberg /* Read Voice Setting */ 46742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 4682177bab5SJohan Hedberg 469b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 470b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 471b4cb9fb2SMarcel Holtmann 4724b836f39SMarcel Holtmann /* Read Current IAC LAP */ 4734b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 4744b836f39SMarcel Holtmann 4752177bab5SJohan Hedberg /* Clear Event Filters */ 4762177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 47742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 4782177bab5SJohan Hedberg 4792177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 480dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 48142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 4822177bab5SJohan Hedberg } 4832177bab5SJohan Hedberg 48442c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 4852177bab5SJohan Hedberg { 486c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 487c73eee91SJohan Hedberg 4882177bab5SJohan Hedberg /* Read LE Buffer Size */ 48942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 4902177bab5SJohan Hedberg 4912177bab5SJohan Hedberg /* Read LE Local Supported Features */ 49242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 4932177bab5SJohan Hedberg 494747d3f03SMarcel Holtmann /* Read LE Supported States */ 495747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 496747d3f03SMarcel Holtmann 4972177bab5SJohan Hedberg /* Read LE White List Size */ 49842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 4992177bab5SJohan Hedberg 500747d3f03SMarcel Holtmann /* Clear LE White List */ 501747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 502c73eee91SJohan Hedberg 503c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 504c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 505a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_LE_ENABLED); 5062177bab5SJohan Hedberg } 5072177bab5SJohan Hedberg 50842c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 5092177bab5SJohan Hedberg { 51042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 51142c6b129SJohan Hedberg 5122177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 5132177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 5142177bab5SJohan Hedberg * command otherwise. 5152177bab5SJohan Hedberg */ 5162177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 5172177bab5SJohan Hedberg 5182177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 5192177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 5202177bab5SJohan Hedberg */ 5212177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 5222177bab5SJohan Hedberg return; 5232177bab5SJohan Hedberg 5242177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 5252177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 5262177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 5272177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 5282177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 5292177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 530c7882cbdSMarcel Holtmann } else { 531c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 532c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 533c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 534c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 535c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 536c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 537c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 538c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 539c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 5400da71f1bSMarcel Holtmann 5410da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 5420da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 543c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5442177bab5SJohan Hedberg } 5450da71f1bSMarcel Holtmann } 5462177bab5SJohan Hedberg 5472177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 5482177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 5492177bab5SJohan Hedberg 5502177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 5512177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 5522177bab5SJohan Hedberg 5532177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 5542177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5552177bab5SJohan Hedberg 5562177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 5572177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 5582177bab5SJohan Hedberg 5592177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 5602177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 5612177bab5SJohan Hedberg 5622177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 5632177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 5642177bab5SJohan Hedberg 5652177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 5662177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 5672177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 5682177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 5692177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 5702177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 5712177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 5722177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 5732177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 5742177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 5752177bab5SJohan Hedberg * Features Notification 5762177bab5SJohan Hedberg */ 5772177bab5SJohan Hedberg } 5782177bab5SJohan Hedberg 5792177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 5802177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 5812177bab5SJohan Hedberg 58242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 5832177bab5SJohan Hedberg } 5842177bab5SJohan Hedberg 58542c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 5862177bab5SJohan Hedberg { 58742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 58842c6b129SJohan Hedberg 5890af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 5900af801b9SJohan Hedberg return amp_init2(req); 5910af801b9SJohan Hedberg 5922177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 59342c6b129SJohan Hedberg bredr_setup(req); 59456f87901SJohan Hedberg else 595a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 5962177bab5SJohan Hedberg 5972177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 59842c6b129SJohan Hedberg le_setup(req); 5992177bab5SJohan Hedberg 6000f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 6010f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 6020f3adeaeSMarcel Holtmann * 6030f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 6040f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 6050f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 6060f3adeaeSMarcel Holtmann * supported commands. 6073f8e2d75SJohan Hedberg */ 6080f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 6090f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 61042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 6112177bab5SJohan Hedberg 6122177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 61357af75a8SMarcel Holtmann /* When SSP is available, then the host features page 61457af75a8SMarcel Holtmann * should also be available as well. However some 61557af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 61657af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 61757af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 61857af75a8SMarcel Holtmann */ 61957af75a8SMarcel Holtmann hdev->max_page = 0x01; 62057af75a8SMarcel Holtmann 621d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 6222177bab5SJohan Hedberg u8 mode = 0x01; 623574ea3c7SMarcel Holtmann 62442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 6252177bab5SJohan Hedberg sizeof(mode), &mode); 6262177bab5SJohan Hedberg } else { 6272177bab5SJohan Hedberg struct hci_cp_write_eir cp; 6282177bab5SJohan Hedberg 6292177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 6302177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6312177bab5SJohan Hedberg 63242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 6332177bab5SJohan Hedberg } 6342177bab5SJohan Hedberg } 6352177bab5SJohan Hedberg 636043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 637043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 63804422da9SMarcel Holtmann u8 mode; 63904422da9SMarcel Holtmann 64004422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 64104422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 64204422da9SMarcel Holtmann * events. 64304422da9SMarcel Holtmann */ 64404422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 64504422da9SMarcel Holtmann 64604422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 64704422da9SMarcel Holtmann } 6482177bab5SJohan Hedberg 6492177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 65042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 6512177bab5SJohan Hedberg 6522177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 6532177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 6542177bab5SJohan Hedberg 6552177bab5SJohan Hedberg cp.page = 0x01; 65642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 65742c6b129SJohan Hedberg sizeof(cp), &cp); 6582177bab5SJohan Hedberg } 6592177bab5SJohan Hedberg 660d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 6612177bab5SJohan Hedberg u8 enable = 1; 66242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 6632177bab5SJohan Hedberg &enable); 6642177bab5SJohan Hedberg } 6652177bab5SJohan Hedberg } 6662177bab5SJohan Hedberg 66742c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 6682177bab5SJohan Hedberg { 66942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6702177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 6712177bab5SJohan Hedberg u16 link_policy = 0; 6722177bab5SJohan Hedberg 6732177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 6742177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 6752177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 6762177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 6772177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 6782177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 6792177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 6802177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 6812177bab5SJohan Hedberg 6822177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 68342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 6842177bab5SJohan Hedberg } 6852177bab5SJohan Hedberg 68642c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 6872177bab5SJohan Hedberg { 68842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6892177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 6902177bab5SJohan Hedberg 691c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 692c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 693c73eee91SJohan Hedberg return; 694c73eee91SJohan Hedberg 6952177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6962177bab5SJohan Hedberg 697d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 6982177bab5SJohan Hedberg cp.le = 0x01; 69932226e4fSMarcel Holtmann cp.simul = 0x00; 7002177bab5SJohan Hedberg } 7012177bab5SJohan Hedberg 7022177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 70342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 7042177bab5SJohan Hedberg &cp); 7052177bab5SJohan Hedberg } 7062177bab5SJohan Hedberg 707d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 708d62e6d67SJohan Hedberg { 709d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 710d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 711d62e6d67SJohan Hedberg 712d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 713d62e6d67SJohan Hedberg * enable all necessary events for it. 714d62e6d67SJohan Hedberg */ 71553b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 716d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 717d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 718d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 719d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 720d62e6d67SJohan Hedberg } 721d62e6d67SJohan Hedberg 722d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 723d62e6d67SJohan Hedberg * enable all necessary events for it. 724d62e6d67SJohan Hedberg */ 72553b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 726d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 727d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 728d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 729d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 730d62e6d67SJohan Hedberg } 731d62e6d67SJohan Hedberg 73240c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 733cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 73440c59fcbSMarcel Holtmann events[2] |= 0x80; 73540c59fcbSMarcel Holtmann 736d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 737d62e6d67SJohan Hedberg } 738d62e6d67SJohan Hedberg 73942c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 7402177bab5SJohan Hedberg { 74142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 742d2c5d77fSJohan Hedberg u8 p; 74342c6b129SJohan Hedberg 7440da71f1bSMarcel Holtmann hci_setup_event_mask(req); 7450da71f1bSMarcel Holtmann 746e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 747e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 74848ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 74948ce62c4SMarcel Holtmann 75048ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 75148ce62c4SMarcel Holtmann cp.read_all = 0x01; 75248ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 75348ce62c4SMarcel Holtmann } 75448ce62c4SMarcel Holtmann 7552177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 75642c6b129SJohan Hedberg hci_setup_link_policy(req); 7572177bab5SJohan Hedberg 758417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 759417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 760417287deSMarcel Holtmann 761417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 762417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 763417287deSMarcel Holtmann * this command in the bit mask of supported commands. 764417287deSMarcel Holtmann */ 765417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 766417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 767417287deSMarcel Holtmann 7689193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 7699193c6e8SAndre Guedes u8 events[8]; 7709193c6e8SAndre Guedes 7719193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 7724d6c705bSMarcel Holtmann events[0] = 0x0f; 7734d6c705bSMarcel Holtmann 7744d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 7754d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 776662bc2e6SAndre Guedes 777662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 778662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 779662bc2e6SAndre Guedes */ 780662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 781662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 782662bc2e6SAndre Guedes * Parameter Request 783662bc2e6SAndre Guedes */ 784662bc2e6SAndre Guedes 785a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 786a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 787a9f6068eSMarcel Holtmann */ 788a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 789a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 790a9f6068eSMarcel Holtmann 7914b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 7924b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 7934b71bba4SMarcel Holtmann */ 7944b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 7954b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 7964b71bba4SMarcel Holtmann * Report 7974b71bba4SMarcel Holtmann */ 7984b71bba4SMarcel Holtmann 7995a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 8005a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 8015a34bd5fSMarcel Holtmann */ 8025a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 8035a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 8045a34bd5fSMarcel Holtmann * Public Key Complete 8055a34bd5fSMarcel Holtmann */ 8065a34bd5fSMarcel Holtmann 8075a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 8085a34bd5fSMarcel Holtmann * command, enable the corresponding event. 8095a34bd5fSMarcel Holtmann */ 8105a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 8115a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 8125a34bd5fSMarcel Holtmann 8139193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 8149193c6e8SAndre Guedes events); 8159193c6e8SAndre Guedes 81615a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 81715a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 81815a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 81915a49ccaSMarcel Holtmann } 82015a49ccaSMarcel Holtmann 821a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 822a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 823a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 824a9f6068eSMarcel Holtmann 825a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 826a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 827a9f6068eSMarcel Holtmann } 828a9f6068eSMarcel Holtmann 82942c6b129SJohan Hedberg hci_set_le_support(req); 8309193c6e8SAndre Guedes } 831d2c5d77fSJohan Hedberg 832d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 833d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 834d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 835d2c5d77fSJohan Hedberg 836d2c5d77fSJohan Hedberg cp.page = p; 837d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 838d2c5d77fSJohan Hedberg sizeof(cp), &cp); 839d2c5d77fSJohan Hedberg } 8402177bab5SJohan Hedberg } 8412177bab5SJohan Hedberg 8425d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 8435d4e7e8dSJohan Hedberg { 8445d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 8455d4e7e8dSJohan Hedberg 84636f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 84736f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 84836f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 84936f260ceSMarcel Holtmann * 85036f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 85136f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 85236f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 85336f260ceSMarcel Holtmann * command redundant anyway. 85436f260ceSMarcel Holtmann * 85536f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 85636f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 85736f260ceSMarcel Holtmann * just disable this command. 85836f260ceSMarcel Holtmann */ 85936f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 86036f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 86136f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 86236f260ceSMarcel Holtmann 86336f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 86436f260ceSMarcel Holtmann cp.delete_all = 0x01; 86536f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 86636f260ceSMarcel Holtmann sizeof(cp), &cp); 86736f260ceSMarcel Holtmann } 86836f260ceSMarcel Holtmann 869d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 870d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 871d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 872d62e6d67SJohan Hedberg 873109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 874109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 875109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 876109e3191SMarcel Holtmann 877f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 878f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 879f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 880f4fe73edSMarcel Holtmann 8815d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 88253b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 8835d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 884a6d0d690SMarcel Holtmann 885a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 886d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 887574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 888a6d0d690SMarcel Holtmann u8 support = 0x01; 889574ea3c7SMarcel Holtmann 890a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 891a6d0d690SMarcel Holtmann sizeof(support), &support); 892a6d0d690SMarcel Holtmann } 8935d4e7e8dSJohan Hedberg } 8945d4e7e8dSJohan Hedberg 8952177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8962177bab5SJohan Hedberg { 8972177bab5SJohan Hedberg int err; 8982177bab5SJohan Hedberg 8992177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 9002177bab5SJohan Hedberg if (err < 0) 9012177bab5SJohan Hedberg return err; 9022177bab5SJohan Hedberg 903d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) { 9044b4113d6SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available 9054b4113d6SMarcel Holtmann * for all controller types. So just create it early on. 9064b4113d6SMarcel Holtmann */ 9074b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 9084b4148e9SMarcel Holtmann &dut_mode_fops); 9094b4113d6SMarcel Holtmann 9104b4113d6SMarcel Holtmann /* When the driver supports the set_diag callback, then 9114b4113d6SMarcel Holtmann * expose an entry to modify the vendor diagnostic setting. 9124b4113d6SMarcel Holtmann */ 9134b4113d6SMarcel Holtmann if (hdev->set_diag) 9144b4113d6SMarcel Holtmann debugfs_create_file("vendor_diag", 0644, hdev->debugfs, 9154b4113d6SMarcel Holtmann hdev, &vendor_diag_fops); 9164b4148e9SMarcel Holtmann } 9174b4148e9SMarcel Holtmann 9182177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 9192177bab5SJohan Hedberg if (err < 0) 9202177bab5SJohan Hedberg return err; 9212177bab5SJohan Hedberg 9220af801b9SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 9230af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 9240af801b9SJohan Hedberg * first two stages of init. 9250af801b9SJohan Hedberg */ 9260af801b9SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 9270af801b9SJohan Hedberg return 0; 9280af801b9SJohan Hedberg 9295d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 9305d4e7e8dSJohan Hedberg if (err < 0) 9315d4e7e8dSJohan Hedberg return err; 9325d4e7e8dSJohan Hedberg 933baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 934baf27f6eSMarcel Holtmann if (err < 0) 935baf27f6eSMarcel Holtmann return err; 936baf27f6eSMarcel Holtmann 937ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 938ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 939ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 940ec6cef9cSMarcel Holtmann * 941ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 942ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 943ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 944ec6cef9cSMarcel Holtmann * be called during the config phase. 945ec6cef9cSMarcel Holtmann * 946ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 947ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 948baf27f6eSMarcel Holtmann */ 949d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 950d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 951baf27f6eSMarcel Holtmann return 0; 952baf27f6eSMarcel Holtmann 95360c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 95460c5f5fbSMarcel Holtmann 95571c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 95660c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9572bfa3531SMarcel Holtmann 958162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 95960c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 960e7b8fc92SMarcel Holtmann 961baf27f6eSMarcel Holtmann return 0; 9622177bab5SJohan Hedberg } 9632177bab5SJohan Hedberg 9640ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 9650ebca7d6SMarcel Holtmann { 9660ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9670ebca7d6SMarcel Holtmann 9680ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9690ebca7d6SMarcel Holtmann 9700ebca7d6SMarcel Holtmann /* Reset */ 9710ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9720ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9730ebca7d6SMarcel Holtmann 9740ebca7d6SMarcel Holtmann /* Read Local Version */ 9750ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9760ebca7d6SMarcel Holtmann 9770ebca7d6SMarcel Holtmann /* Read BD Address */ 9780ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9790ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 9800ebca7d6SMarcel Holtmann } 9810ebca7d6SMarcel Holtmann 9820ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9830ebca7d6SMarcel Holtmann { 9840ebca7d6SMarcel Holtmann int err; 9850ebca7d6SMarcel Holtmann 986cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 987cc78b44bSMarcel Holtmann return 0; 988cc78b44bSMarcel Holtmann 9890ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 9900ebca7d6SMarcel Holtmann if (err < 0) 9910ebca7d6SMarcel Holtmann return err; 9920ebca7d6SMarcel Holtmann 9930ebca7d6SMarcel Holtmann return 0; 9940ebca7d6SMarcel Holtmann } 9950ebca7d6SMarcel Holtmann 99642c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 9971da177e4SLinus Torvalds { 9981da177e4SLinus Torvalds __u8 scan = opt; 9991da177e4SLinus Torvalds 100042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 10011da177e4SLinus Torvalds 10021da177e4SLinus Torvalds /* Inquiry and Page scans */ 100342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 100642c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 10071da177e4SLinus Torvalds { 10081da177e4SLinus Torvalds __u8 auth = opt; 10091da177e4SLinus Torvalds 101042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 10111da177e4SLinus Torvalds 10121da177e4SLinus Torvalds /* Authentication */ 101342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 10141da177e4SLinus Torvalds } 10151da177e4SLinus Torvalds 101642c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 10171da177e4SLinus Torvalds { 10181da177e4SLinus Torvalds __u8 encrypt = opt; 10191da177e4SLinus Torvalds 102042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 10211da177e4SLinus Torvalds 1022e4e8e37cSMarcel Holtmann /* Encryption */ 102342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 10241da177e4SLinus Torvalds } 10251da177e4SLinus Torvalds 102642c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1027e4e8e37cSMarcel Holtmann { 1028e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1029e4e8e37cSMarcel Holtmann 103042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1031e4e8e37cSMarcel Holtmann 1032e4e8e37cSMarcel Holtmann /* Default link policy */ 103342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1034e4e8e37cSMarcel Holtmann } 1035e4e8e37cSMarcel Holtmann 10361da177e4SLinus Torvalds /* Get HCI device by index. 10371da177e4SLinus Torvalds * Device is held on return. */ 10381da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10391da177e4SLinus Torvalds { 10408035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds BT_DBG("%d", index); 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds if (index < 0) 10451da177e4SLinus Torvalds return NULL; 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10488035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10491da177e4SLinus Torvalds if (d->id == index) { 10501da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10511da177e4SLinus Torvalds break; 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10551da177e4SLinus Torvalds return hdev; 10561da177e4SLinus Torvalds } 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1059ff9ef578SJohan Hedberg 106030dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 106130dc78e1SJohan Hedberg { 106230dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 106330dc78e1SJohan Hedberg 10646fbe195dSAndre Guedes switch (discov->state) { 1065343f935bSAndre Guedes case DISCOVERY_FINDING: 10666fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 106730dc78e1SJohan Hedberg return true; 106830dc78e1SJohan Hedberg 10696fbe195dSAndre Guedes default: 107030dc78e1SJohan Hedberg return false; 107130dc78e1SJohan Hedberg } 10726fbe195dSAndre Guedes } 107330dc78e1SJohan Hedberg 1074ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1075ff9ef578SJohan Hedberg { 1076bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1077bb3e0a33SJohan Hedberg 1078ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1079ff9ef578SJohan Hedberg 1080bb3e0a33SJohan Hedberg if (old_state == state) 1081ff9ef578SJohan Hedberg return; 1082ff9ef578SJohan Hedberg 1083bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1084bb3e0a33SJohan Hedberg 1085ff9ef578SJohan Hedberg switch (state) { 1086ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1087c54c3860SAndre Guedes hci_update_background_scan(hdev); 1088c54c3860SAndre Guedes 1089bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1090ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1091ff9ef578SJohan Hedberg break; 1092ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1093ff9ef578SJohan Hedberg break; 1094343f935bSAndre Guedes case DISCOVERY_FINDING: 1095ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1096ff9ef578SJohan Hedberg break; 109730dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 109830dc78e1SJohan Hedberg break; 1099ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1100ff9ef578SJohan Hedberg break; 1101ff9ef578SJohan Hedberg } 1102ff9ef578SJohan Hedberg } 1103ff9ef578SJohan Hedberg 11041f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 11051da177e4SLinus Torvalds { 110630883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1107b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 11081da177e4SLinus Torvalds 1109561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1110561aafbcSJohan Hedberg list_del(&p->all); 1111b57c1a56SJohan Hedberg kfree(p); 11121da177e4SLinus Torvalds } 1113561aafbcSJohan Hedberg 1114561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1115561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 11161da177e4SLinus Torvalds } 11171da177e4SLinus Torvalds 1118a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1119a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 11201da177e4SLinus Torvalds { 112130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11221da177e4SLinus Torvalds struct inquiry_entry *e; 11231da177e4SLinus Torvalds 11246ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 11251da177e4SLinus Torvalds 1126561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11271da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 11281da177e4SLinus Torvalds return e; 11291da177e4SLinus Torvalds } 11301da177e4SLinus Torvalds 1131b57c1a56SJohan Hedberg return NULL; 1132b57c1a56SJohan Hedberg } 1133b57c1a56SJohan Hedberg 1134561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1135561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1136561aafbcSJohan Hedberg { 113730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1138561aafbcSJohan Hedberg struct inquiry_entry *e; 1139561aafbcSJohan Hedberg 11406ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1141561aafbcSJohan Hedberg 1142561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1143561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1144561aafbcSJohan Hedberg return e; 1145561aafbcSJohan Hedberg } 1146561aafbcSJohan Hedberg 1147561aafbcSJohan Hedberg return NULL; 1148561aafbcSJohan Hedberg } 1149561aafbcSJohan Hedberg 115030dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 115130dc78e1SJohan Hedberg bdaddr_t *bdaddr, 115230dc78e1SJohan Hedberg int state) 115330dc78e1SJohan Hedberg { 115430dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 115530dc78e1SJohan Hedberg struct inquiry_entry *e; 115630dc78e1SJohan Hedberg 11576ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 115830dc78e1SJohan Hedberg 115930dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 116030dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 116130dc78e1SJohan Hedberg return e; 116230dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 116330dc78e1SJohan Hedberg return e; 116430dc78e1SJohan Hedberg } 116530dc78e1SJohan Hedberg 116630dc78e1SJohan Hedberg return NULL; 116730dc78e1SJohan Hedberg } 116830dc78e1SJohan Hedberg 1169a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1170a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1171a3d4e20aSJohan Hedberg { 1172a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1173a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1174a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1175a3d4e20aSJohan Hedberg 1176a3d4e20aSJohan Hedberg list_del(&ie->list); 1177a3d4e20aSJohan Hedberg 1178a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1179a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1180a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1181a3d4e20aSJohan Hedberg break; 1182a3d4e20aSJohan Hedberg pos = &p->list; 1183a3d4e20aSJohan Hedberg } 1184a3d4e20aSJohan Hedberg 1185a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1186a3d4e20aSJohan Hedberg } 1187a3d4e20aSJohan Hedberg 1188af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1189af58925cSMarcel Holtmann bool name_known) 11901da177e4SLinus Torvalds { 119130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 119270f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1193af58925cSMarcel Holtmann u32 flags = 0; 11941da177e4SLinus Torvalds 11956ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11961da177e4SLinus Torvalds 11976928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11982b2fec4dSSzymon Janc 1199af58925cSMarcel Holtmann if (!data->ssp_mode) 1200af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1201388fc8faSJohan Hedberg 120270f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1203a3d4e20aSJohan Hedberg if (ie) { 1204af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1205af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1206388fc8faSJohan Hedberg 1207a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1208a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1209a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1210a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1211a3d4e20aSJohan Hedberg } 1212a3d4e20aSJohan Hedberg 1213561aafbcSJohan Hedberg goto update; 1214a3d4e20aSJohan Hedberg } 1215561aafbcSJohan Hedberg 12161da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 121727f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1218af58925cSMarcel Holtmann if (!ie) { 1219af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1220af58925cSMarcel Holtmann goto done; 1221af58925cSMarcel Holtmann } 122270f23020SAndrei Emeltchenko 1223561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1224561aafbcSJohan Hedberg 1225561aafbcSJohan Hedberg if (name_known) { 1226561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1227561aafbcSJohan Hedberg } else { 1228561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1229561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1230561aafbcSJohan Hedberg } 1231561aafbcSJohan Hedberg 1232561aafbcSJohan Hedberg update: 1233561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1234561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1235561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1236561aafbcSJohan Hedberg list_del(&ie->list); 12371da177e4SLinus Torvalds } 12381da177e4SLinus Torvalds 123970f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 124070f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12411da177e4SLinus Torvalds cache->timestamp = jiffies; 12423175405bSJohan Hedberg 12433175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1244af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12453175405bSJohan Hedberg 1246af58925cSMarcel Holtmann done: 1247af58925cSMarcel Holtmann return flags; 12481da177e4SLinus Torvalds } 12491da177e4SLinus Torvalds 12501da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12511da177e4SLinus Torvalds { 125230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12531da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12541da177e4SLinus Torvalds struct inquiry_entry *e; 12551da177e4SLinus Torvalds int copied = 0; 12561da177e4SLinus Torvalds 1257561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12581da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1259b57c1a56SJohan Hedberg 1260b57c1a56SJohan Hedberg if (copied >= num) 1261b57c1a56SJohan Hedberg break; 1262b57c1a56SJohan Hedberg 12631da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12641da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12651da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12661da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12671da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12681da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1269b57c1a56SJohan Hedberg 12701da177e4SLinus Torvalds info++; 1271b57c1a56SJohan Hedberg copied++; 12721da177e4SLinus Torvalds } 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12751da177e4SLinus Torvalds return copied; 12761da177e4SLinus Torvalds } 12771da177e4SLinus Torvalds 127842c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 12791da177e4SLinus Torvalds { 12801da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 128142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12821da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12851da177e4SLinus Torvalds 12861da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 12871da177e4SLinus Torvalds return; 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds /* Start Inquiry */ 12901da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12911da177e4SLinus Torvalds cp.length = ir->length; 12921da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 129342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 12941da177e4SLinus Torvalds } 12951da177e4SLinus Torvalds 12961da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12971da177e4SLinus Torvalds { 12981da177e4SLinus Torvalds __u8 __user *ptr = arg; 12991da177e4SLinus Torvalds struct hci_inquiry_req ir; 13001da177e4SLinus Torvalds struct hci_dev *hdev; 13011da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 13021da177e4SLinus Torvalds long timeo; 13031da177e4SLinus Torvalds __u8 *buf; 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 13061da177e4SLinus Torvalds return -EFAULT; 13071da177e4SLinus Torvalds 13085a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 13095a08ecceSAndrei Emeltchenko if (!hdev) 13101da177e4SLinus Torvalds return -ENODEV; 13111da177e4SLinus Torvalds 1312d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 13130736cfa8SMarcel Holtmann err = -EBUSY; 13140736cfa8SMarcel Holtmann goto done; 13150736cfa8SMarcel Holtmann } 13160736cfa8SMarcel Holtmann 1317d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1318fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1319fee746b0SMarcel Holtmann goto done; 1320fee746b0SMarcel Holtmann } 1321fee746b0SMarcel Holtmann 13225b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 13235b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 13245b69bef5SMarcel Holtmann goto done; 13255b69bef5SMarcel Holtmann } 13265b69bef5SMarcel Holtmann 1327d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 132856f87901SJohan Hedberg err = -EOPNOTSUPP; 132956f87901SJohan Hedberg goto done; 133056f87901SJohan Hedberg } 133156f87901SJohan Hedberg 133209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13331da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1334a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13351f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13361da177e4SLinus Torvalds do_inquiry = 1; 13371da177e4SLinus Torvalds } 133809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13391da177e4SLinus Torvalds 134004837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 134170f23020SAndrei Emeltchenko 134270f23020SAndrei Emeltchenko if (do_inquiry) { 134301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 134401178cd4SJohan Hedberg timeo); 134570f23020SAndrei Emeltchenko if (err < 0) 13461da177e4SLinus Torvalds goto done; 13473e13fa1eSAndre Guedes 13483e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13493e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13503e13fa1eSAndre Guedes */ 135174316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13523e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13533e13fa1eSAndre Guedes return -EINTR; 135470f23020SAndrei Emeltchenko } 13551da177e4SLinus Torvalds 13568fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13578fc9ced3SGustavo Padovan * 255 entries 13588fc9ced3SGustavo Padovan */ 13591da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13601da177e4SLinus Torvalds 13611da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13621da177e4SLinus Torvalds * copy it to the user space. 13631da177e4SLinus Torvalds */ 136470f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 136570f23020SAndrei Emeltchenko if (!buf) { 13661da177e4SLinus Torvalds err = -ENOMEM; 13671da177e4SLinus Torvalds goto done; 13681da177e4SLinus Torvalds } 13691da177e4SLinus Torvalds 137009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13711da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 137209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13751da177e4SLinus Torvalds 13761da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13771da177e4SLinus Torvalds ptr += sizeof(ir); 13781da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13791da177e4SLinus Torvalds ir.num_rsp)) 13801da177e4SLinus Torvalds err = -EFAULT; 13811da177e4SLinus Torvalds } else 13821da177e4SLinus Torvalds err = -EFAULT; 13831da177e4SLinus Torvalds 13841da177e4SLinus Torvalds kfree(buf); 13851da177e4SLinus Torvalds 13861da177e4SLinus Torvalds done: 13871da177e4SLinus Torvalds hci_dev_put(hdev); 13881da177e4SLinus Torvalds return err; 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 1391cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13921da177e4SLinus Torvalds { 13931da177e4SLinus Torvalds int ret = 0; 13941da177e4SLinus Torvalds 13951da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds hci_req_lock(hdev); 13981da177e4SLinus Torvalds 1399d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 140094324962SJohan Hovold ret = -ENODEV; 140194324962SJohan Hovold goto done; 140294324962SJohan Hovold } 140394324962SJohan Hovold 1404d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1405d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1406a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1407a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1408bf543036SJohan Hedberg */ 1409d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1410611b30f7SMarcel Holtmann ret = -ERFKILL; 1411611b30f7SMarcel Holtmann goto done; 1412611b30f7SMarcel Holtmann } 1413611b30f7SMarcel Holtmann 1414a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1415a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1416a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1417a5c8f270SMarcel Holtmann * or not. 1418a5c8f270SMarcel Holtmann * 1419c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1420c6beca0eSMarcel Holtmann * if a public address or static random address is 1421c6beca0eSMarcel Holtmann * available. 1422c6beca0eSMarcel Holtmann * 1423a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1424a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1425a5c8f270SMarcel Holtmann */ 1426d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1427c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 1428a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1429a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1430a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1431a5c8f270SMarcel Holtmann goto done; 1432a5c8f270SMarcel Holtmann } 1433a5c8f270SMarcel Holtmann } 1434a5c8f270SMarcel Holtmann 14351da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14361da177e4SLinus Torvalds ret = -EALREADY; 14371da177e4SLinus Torvalds goto done; 14381da177e4SLinus Torvalds } 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds if (hdev->open(hdev)) { 14411da177e4SLinus Torvalds ret = -EIO; 14421da177e4SLinus Torvalds goto done; 14431da177e4SLinus Torvalds } 14441da177e4SLinus Torvalds 1445e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 14464a3f95b7SMarcel Holtmann hci_notify(hdev, HCI_DEV_OPEN); 14474a3f95b7SMarcel Holtmann 14481da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14491da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1450f41c70c4SMarcel Holtmann 1451d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) { 1452af202f84SMarcel Holtmann if (hdev->setup) 1453f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1454f41c70c4SMarcel Holtmann 1455af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1456af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1457af202f84SMarcel Holtmann * 1458af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1459af202f84SMarcel Holtmann * start up as unconfigured. 1460af202f84SMarcel Holtmann */ 1461eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1462eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 1463a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1464f41c70c4SMarcel Holtmann 14650ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 14660ebca7d6SMarcel Holtmann * read at least the version information provided by 14670ebca7d6SMarcel Holtmann * the Read Local Version Information command. 14680ebca7d6SMarcel Holtmann * 14690ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 14700ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 14710ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 14720ebca7d6SMarcel Holtmann */ 1473d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 14740ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 147589bc22d2SMarcel Holtmann } 147689bc22d2SMarcel Holtmann 1477d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 14789713c17bSMarcel Holtmann /* If public address change is configured, ensure that 14799713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 14809713c17bSMarcel Holtmann * support changing the public address, fail the power 14819713c17bSMarcel Holtmann * on procedure. 148224c457e2SMarcel Holtmann */ 14839713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14849713c17bSMarcel Holtmann hdev->set_bdaddr) 148524c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 148624c457e2SMarcel Holtmann else 148724c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 148824c457e2SMarcel Holtmann } 148924c457e2SMarcel Holtmann 1490f41c70c4SMarcel Holtmann if (!ret) { 1491d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1492d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 14932177bab5SJohan Hedberg ret = __hci_init(hdev); 14941da177e4SLinus Torvalds } 14951da177e4SLinus Torvalds 1496f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1497f41c70c4SMarcel Holtmann 14981da177e4SLinus Torvalds if (!ret) { 14991da177e4SLinus Torvalds hci_dev_hold(hdev); 1500a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 15011da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 15021da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1503d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1504d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1505d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1506d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15071514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 150809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1509744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 151009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 151156e5cb86SJohan Hedberg } 15121da177e4SLinus Torvalds } else { 15131da177e4SLinus Torvalds /* Init failed, cleanup */ 15143eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1515c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1516b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15171da177e4SLinus Torvalds 15181da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15191da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds if (hdev->flush) 15221da177e4SLinus Torvalds hdev->flush(hdev); 15231da177e4SLinus Torvalds 15241da177e4SLinus Torvalds if (hdev->sent_cmd) { 15251da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15261da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15271da177e4SLinus Torvalds } 15281da177e4SLinus Torvalds 1529e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 15304a3f95b7SMarcel Holtmann hci_notify(hdev, HCI_DEV_CLOSE); 15314a3f95b7SMarcel Holtmann 15321da177e4SLinus Torvalds hdev->close(hdev); 1533fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 15341da177e4SLinus Torvalds } 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds done: 15371da177e4SLinus Torvalds hci_req_unlock(hdev); 15381da177e4SLinus Torvalds return ret; 15391da177e4SLinus Torvalds } 15401da177e4SLinus Torvalds 1541cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1542cbed0ca1SJohan Hedberg 1543cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1544cbed0ca1SJohan Hedberg { 1545cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1546cbed0ca1SJohan Hedberg int err; 1547cbed0ca1SJohan Hedberg 1548cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1549cbed0ca1SJohan Hedberg if (!hdev) 1550cbed0ca1SJohan Hedberg return -ENODEV; 1551cbed0ca1SJohan Hedberg 15524a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1553fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1554fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1555fee746b0SMarcel Holtmann * possible. 1556fee746b0SMarcel Holtmann * 1557fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1558fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1559fee746b0SMarcel Holtmann * open the device. 1560fee746b0SMarcel Holtmann */ 1561d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1562d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1563fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1564fee746b0SMarcel Holtmann goto done; 1565fee746b0SMarcel Holtmann } 1566fee746b0SMarcel Holtmann 1567e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1568e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1569e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1570e1d08f40SJohan Hedberg * completed. 1571e1d08f40SJohan Hedberg */ 1572a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1573e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1574e1d08f40SJohan Hedberg 1575a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1576a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1577a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1578a5c8f270SMarcel Holtmann */ 1579e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1580e1d08f40SJohan Hedberg 158112aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1582b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 158312aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 158412aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 158512aa4f0aSMarcel Holtmann * to explicitly enable it. 158612aa4f0aSMarcel Holtmann */ 1587d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1588d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1589a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 159012aa4f0aSMarcel Holtmann 1591cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1592cbed0ca1SJohan Hedberg 1593fee746b0SMarcel Holtmann done: 1594cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1595cbed0ca1SJohan Hedberg return err; 1596cbed0ca1SJohan Hedberg } 1597cbed0ca1SJohan Hedberg 1598d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1599d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1600d7347f3cSJohan Hedberg { 1601d7347f3cSJohan Hedberg struct hci_conn_params *p; 1602d7347f3cSJohan Hedberg 1603f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1604f161dd41SJohan Hedberg if (p->conn) { 1605f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1606f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1607f161dd41SJohan Hedberg p->conn = NULL; 1608f161dd41SJohan Hedberg } 1609d7347f3cSJohan Hedberg list_del_init(&p->action); 1610f161dd41SJohan Hedberg } 1611d7347f3cSJohan Hedberg 1612d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1613d7347f3cSJohan Hedberg } 1614d7347f3cSJohan Hedberg 16156b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 16161da177e4SLinus Torvalds { 1617acc649c6SMarcel Holtmann bool auto_off; 1618acc649c6SMarcel Holtmann 16191da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 16201da177e4SLinus Torvalds 1621d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1622867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1623d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1624a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1625a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1626a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1627a44fecbdSTedd Ho-Jeong An } 1628a44fecbdSTedd Ho-Jeong An 162978c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 163078c04c0bSVinicius Costa Gomes 16311da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 16321da177e4SLinus Torvalds hci_req_lock(hdev); 16331da177e4SLinus Torvalds 16341da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 163565cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16361da177e4SLinus Torvalds hci_req_unlock(hdev); 16371da177e4SLinus Torvalds return 0; 16381da177e4SLinus Torvalds } 16391da177e4SLinus Torvalds 16403eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16413eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1642b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16431da177e4SLinus Torvalds 164416ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1645e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 164616ab91abSJohan Hedberg hdev->discov_timeout = 0; 1647a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1648a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 164916ab91abSJohan Hedberg } 165016ab91abSJohan Hedberg 1651a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 16527d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 16537d78525dSJohan Hedberg 16547ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 16552d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 16564518bb0fSJohan Hedberg 1657d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_MGMT)) 1658d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 16597ba8b4beSAndre Guedes 16605d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 16615d900e46SFlorian Grandel cancel_delayed_work_sync(&hdev->adv_instance_expire); 16625d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 16635d900e46SFlorian Grandel } 16645d900e46SFlorian Grandel 166576727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 166676727c02SJohan Hedberg * ensuring the workqueue is empty up front. 166776727c02SJohan Hedberg */ 166876727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 166976727c02SJohan Hedberg 167009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16711aeb9c65SJohan Hedberg 16728f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 16738f502f84SJohan Hedberg 1674acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1675acc649c6SMarcel Holtmann 1676acc649c6SMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_BREDR) 16771aeb9c65SJohan Hedberg mgmt_powered(hdev, 0); 16781aeb9c65SJohan Hedberg 16791f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1680d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1681f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 168209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16831da177e4SLinus Torvalds 168464dae967SMarcel Holtmann smp_unregister(hdev); 168564dae967SMarcel Holtmann 16861da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds if (hdev->flush) 16891da177e4SLinus Torvalds hdev->flush(hdev); 16901da177e4SLinus Torvalds 16911da177e4SLinus Torvalds /* Reset device */ 16921da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16931da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1694acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1695acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 16961da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 169701178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 16981da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 16991da177e4SLinus Torvalds } 17001da177e4SLinus Torvalds 1701c347b765SGustavo F. Padovan /* flush cmd work */ 1702c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 17031da177e4SLinus Torvalds 17041da177e4SLinus Torvalds /* Drop queues */ 17051da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17061da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17071da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 17081da177e4SLinus Torvalds 17091da177e4SLinus Torvalds /* Drop last sent command */ 17101da177e4SLinus Torvalds if (hdev->sent_cmd) { 171165cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 17121da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 17131da177e4SLinus Torvalds hdev->sent_cmd = NULL; 17141da177e4SLinus Torvalds } 17151da177e4SLinus Torvalds 1716e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 17174a3f95b7SMarcel Holtmann hci_notify(hdev, HCI_DEV_CLOSE); 17184a3f95b7SMarcel Holtmann 17191da177e4SLinus Torvalds /* After this point our queues are empty 17201da177e4SLinus Torvalds * and no tasks are scheduled. */ 17211da177e4SLinus Torvalds hdev->close(hdev); 17221da177e4SLinus Torvalds 172335b973c9SJohan Hedberg /* Clear flags */ 1724fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1725eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 172635b973c9SJohan Hedberg 1727ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1728536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1729ced5c338SAndrei Emeltchenko 1730e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 173109b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 17327a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1733e59fda8dSJohan Hedberg 17341da177e4SLinus Torvalds hci_req_unlock(hdev); 17351da177e4SLinus Torvalds 17361da177e4SLinus Torvalds hci_dev_put(hdev); 17371da177e4SLinus Torvalds return 0; 17381da177e4SLinus Torvalds } 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 17411da177e4SLinus Torvalds { 17421da177e4SLinus Torvalds struct hci_dev *hdev; 17431da177e4SLinus Torvalds int err; 17441da177e4SLinus Torvalds 174570f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 174670f23020SAndrei Emeltchenko if (!hdev) 17471da177e4SLinus Torvalds return -ENODEV; 17488ee56540SMarcel Holtmann 1749d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17500736cfa8SMarcel Holtmann err = -EBUSY; 17510736cfa8SMarcel Holtmann goto done; 17520736cfa8SMarcel Holtmann } 17530736cfa8SMarcel Holtmann 1754a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 17558ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 17568ee56540SMarcel Holtmann 17571da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 17588ee56540SMarcel Holtmann 17590736cfa8SMarcel Holtmann done: 17601da177e4SLinus Torvalds hci_dev_put(hdev); 17611da177e4SLinus Torvalds return err; 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds 17645c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 17651da177e4SLinus Torvalds { 17665c912495SMarcel Holtmann int ret; 17671da177e4SLinus Torvalds 17685c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds hci_req_lock(hdev); 17711da177e4SLinus Torvalds 17721da177e4SLinus Torvalds /* Drop queues */ 17731da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17741da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17751da177e4SLinus Torvalds 177676727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 177776727c02SJohan Hedberg * ensuring the workqueue is empty up front. 177876727c02SJohan Hedberg */ 177976727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 178076727c02SJohan Hedberg 178109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17821f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17831da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 178409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17851da177e4SLinus Torvalds 17861da177e4SLinus Torvalds if (hdev->flush) 17871da177e4SLinus Torvalds hdev->flush(hdev); 17881da177e4SLinus Torvalds 17891da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17906ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 17911da177e4SLinus Torvalds 179201178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 17931da177e4SLinus Torvalds 17941da177e4SLinus Torvalds hci_req_unlock(hdev); 17951da177e4SLinus Torvalds return ret; 17961da177e4SLinus Torvalds } 17971da177e4SLinus Torvalds 17985c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 17995c912495SMarcel Holtmann { 18005c912495SMarcel Holtmann struct hci_dev *hdev; 18015c912495SMarcel Holtmann int err; 18025c912495SMarcel Holtmann 18035c912495SMarcel Holtmann hdev = hci_dev_get(dev); 18045c912495SMarcel Holtmann if (!hdev) 18055c912495SMarcel Holtmann return -ENODEV; 18065c912495SMarcel Holtmann 18075c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 18085c912495SMarcel Holtmann err = -ENETDOWN; 18095c912495SMarcel Holtmann goto done; 18105c912495SMarcel Holtmann } 18115c912495SMarcel Holtmann 1812d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18135c912495SMarcel Holtmann err = -EBUSY; 18145c912495SMarcel Holtmann goto done; 18155c912495SMarcel Holtmann } 18165c912495SMarcel Holtmann 1817d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 18185c912495SMarcel Holtmann err = -EOPNOTSUPP; 18195c912495SMarcel Holtmann goto done; 18205c912495SMarcel Holtmann } 18215c912495SMarcel Holtmann 18225c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 18235c912495SMarcel Holtmann 18245c912495SMarcel Holtmann done: 18255c912495SMarcel Holtmann hci_dev_put(hdev); 18265c912495SMarcel Holtmann return err; 18275c912495SMarcel Holtmann } 18285c912495SMarcel Holtmann 18291da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 18301da177e4SLinus Torvalds { 18311da177e4SLinus Torvalds struct hci_dev *hdev; 18321da177e4SLinus Torvalds int ret = 0; 18331da177e4SLinus Torvalds 183470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 183570f23020SAndrei Emeltchenko if (!hdev) 18361da177e4SLinus Torvalds return -ENODEV; 18371da177e4SLinus Torvalds 1838d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18390736cfa8SMarcel Holtmann ret = -EBUSY; 18400736cfa8SMarcel Holtmann goto done; 18410736cfa8SMarcel Holtmann } 18420736cfa8SMarcel Holtmann 1843d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1844fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1845fee746b0SMarcel Holtmann goto done; 1846fee746b0SMarcel Holtmann } 1847fee746b0SMarcel Holtmann 18481da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 18491da177e4SLinus Torvalds 18500736cfa8SMarcel Holtmann done: 18511da177e4SLinus Torvalds hci_dev_put(hdev); 18521da177e4SLinus Torvalds return ret; 18531da177e4SLinus Torvalds } 18541da177e4SLinus Torvalds 1855123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1856123abc08SJohan Hedberg { 1857bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1858123abc08SJohan Hedberg 1859123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1860123abc08SJohan Hedberg 1861123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1862238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1863238be788SMarcel Holtmann HCI_CONNECTABLE); 1864123abc08SJohan Hedberg else 1865a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1866a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1867123abc08SJohan Hedberg 1868bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1869238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1870238be788SMarcel Holtmann HCI_DISCOVERABLE); 1871bc6d2d04SJohan Hedberg } else { 1872a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1873a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1874a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1875bc6d2d04SJohan Hedberg } 1876bc6d2d04SJohan Hedberg 1877d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1878123abc08SJohan Hedberg return; 1879123abc08SJohan Hedberg 1880bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1881bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1882a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1883bc6d2d04SJohan Hedberg 1884d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1885bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 1886bc6d2d04SJohan Hedberg 1887123abc08SJohan Hedberg mgmt_new_settings(hdev); 1888123abc08SJohan Hedberg } 1889bc6d2d04SJohan Hedberg } 1890123abc08SJohan Hedberg 18911da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 18921da177e4SLinus Torvalds { 18931da177e4SLinus Torvalds struct hci_dev *hdev; 18941da177e4SLinus Torvalds struct hci_dev_req dr; 18951da177e4SLinus Torvalds int err = 0; 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 18981da177e4SLinus Torvalds return -EFAULT; 18991da177e4SLinus Torvalds 190070f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 190170f23020SAndrei Emeltchenko if (!hdev) 19021da177e4SLinus Torvalds return -ENODEV; 19031da177e4SLinus Torvalds 1904d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19050736cfa8SMarcel Holtmann err = -EBUSY; 19060736cfa8SMarcel Holtmann goto done; 19070736cfa8SMarcel Holtmann } 19080736cfa8SMarcel Holtmann 1909d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1910fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1911fee746b0SMarcel Holtmann goto done; 1912fee746b0SMarcel Holtmann } 1913fee746b0SMarcel Holtmann 19145b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 19155b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 19165b69bef5SMarcel Holtmann goto done; 19175b69bef5SMarcel Holtmann } 19185b69bef5SMarcel Holtmann 1919d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 192056f87901SJohan Hedberg err = -EOPNOTSUPP; 192156f87901SJohan Hedberg goto done; 192256f87901SJohan Hedberg } 192356f87901SJohan Hedberg 19241da177e4SLinus Torvalds switch (cmd) { 19251da177e4SLinus Torvalds case HCISETAUTH: 192601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19275f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19281da177e4SLinus Torvalds break; 19291da177e4SLinus Torvalds 19301da177e4SLinus Torvalds case HCISETENCRYPT: 19311da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 19321da177e4SLinus Torvalds err = -EOPNOTSUPP; 19331da177e4SLinus Torvalds break; 19341da177e4SLinus Torvalds } 19351da177e4SLinus Torvalds 19361da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 19371da177e4SLinus Torvalds /* Auth must be enabled first */ 193801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19395f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19401da177e4SLinus Torvalds if (err) 19411da177e4SLinus Torvalds break; 19421da177e4SLinus Torvalds } 19431da177e4SLinus Torvalds 194401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19455f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19461da177e4SLinus Torvalds break; 19471da177e4SLinus Torvalds 19481da177e4SLinus Torvalds case HCISETSCAN: 194901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19505f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 195191a668b0SJohan Hedberg 1952bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1953bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 195491a668b0SJohan Hedberg */ 1955123abc08SJohan Hedberg if (!err) 1956123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 19571da177e4SLinus Torvalds break; 19581da177e4SLinus Torvalds 19591da177e4SLinus Torvalds case HCISETLINKPOL: 196001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19615f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19621da177e4SLinus Torvalds break; 19631da177e4SLinus Torvalds 19641da177e4SLinus Torvalds case HCISETLINKMODE: 1965e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1966e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1967e4e8e37cSMarcel Holtmann break; 1968e4e8e37cSMarcel Holtmann 1969e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1970e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 19711da177e4SLinus Torvalds break; 19721da177e4SLinus Torvalds 19731da177e4SLinus Torvalds case HCISETACLMTU: 19741da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 19751da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 19761da177e4SLinus Torvalds break; 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds case HCISETSCOMTU: 19791da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 19801da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 19811da177e4SLinus Torvalds break; 19821da177e4SLinus Torvalds 19831da177e4SLinus Torvalds default: 19841da177e4SLinus Torvalds err = -EINVAL; 19851da177e4SLinus Torvalds break; 19861da177e4SLinus Torvalds } 1987e4e8e37cSMarcel Holtmann 19880736cfa8SMarcel Holtmann done: 19891da177e4SLinus Torvalds hci_dev_put(hdev); 19901da177e4SLinus Torvalds return err; 19911da177e4SLinus Torvalds } 19921da177e4SLinus Torvalds 19931da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 19941da177e4SLinus Torvalds { 19958035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 19961da177e4SLinus Torvalds struct hci_dev_list_req *dl; 19971da177e4SLinus Torvalds struct hci_dev_req *dr; 19981da177e4SLinus Torvalds int n = 0, size, err; 19991da177e4SLinus Torvalds __u16 dev_num; 20001da177e4SLinus Torvalds 20011da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 20021da177e4SLinus Torvalds return -EFAULT; 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 20051da177e4SLinus Torvalds return -EINVAL; 20061da177e4SLinus Torvalds 20071da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 20081da177e4SLinus Torvalds 200970f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 201070f23020SAndrei Emeltchenko if (!dl) 20111da177e4SLinus Torvalds return -ENOMEM; 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds dr = dl->dev_req; 20141da177e4SLinus Torvalds 2015f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 20168035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 20172e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2018c542a06cSJohan Hedberg 20192e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20202e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20212e84d8dbSMarcel Holtmann * device is actually down. 20222e84d8dbSMarcel Holtmann */ 2023d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20242e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2025c542a06cSJohan Hedberg 20261da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 20272e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2028c542a06cSJohan Hedberg 20291da177e4SLinus Torvalds if (++n >= dev_num) 20301da177e4SLinus Torvalds break; 20311da177e4SLinus Torvalds } 2032f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds dl->dev_num = n; 20351da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 20381da177e4SLinus Torvalds kfree(dl); 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds return err ? -EFAULT : 0; 20411da177e4SLinus Torvalds } 20421da177e4SLinus Torvalds 20431da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20441da177e4SLinus Torvalds { 20451da177e4SLinus Torvalds struct hci_dev *hdev; 20461da177e4SLinus Torvalds struct hci_dev_info di; 20472e84d8dbSMarcel Holtmann unsigned long flags; 20481da177e4SLinus Torvalds int err = 0; 20491da177e4SLinus Torvalds 20501da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 20511da177e4SLinus Torvalds return -EFAULT; 20521da177e4SLinus Torvalds 205370f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 205470f23020SAndrei Emeltchenko if (!hdev) 20551da177e4SLinus Torvalds return -ENODEV; 20561da177e4SLinus Torvalds 20572e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20582e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20592e84d8dbSMarcel Holtmann * device is actually down. 20602e84d8dbSMarcel Holtmann */ 2061d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20622e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 20632e84d8dbSMarcel Holtmann else 20642e84d8dbSMarcel Holtmann flags = hdev->flags; 2065c542a06cSJohan Hedberg 20661da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20671da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 206860f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20692e84d8dbSMarcel Holtmann di.flags = flags; 20701da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2071572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 20721da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 20731da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 20741da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 20751da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2076572c7f84SJohan Hedberg } else { 2077572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2078572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2079572c7f84SJohan Hedberg di.sco_mtu = 0; 2080572c7f84SJohan Hedberg di.sco_pkts = 0; 2081572c7f84SJohan Hedberg } 20821da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 20831da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 20841da177e4SLinus Torvalds 20851da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 20861da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 20871da177e4SLinus Torvalds 20881da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 20891da177e4SLinus Torvalds err = -EFAULT; 20901da177e4SLinus Torvalds 20911da177e4SLinus Torvalds hci_dev_put(hdev); 20921da177e4SLinus Torvalds 20931da177e4SLinus Torvalds return err; 20941da177e4SLinus Torvalds } 20951da177e4SLinus Torvalds 20961da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 20971da177e4SLinus Torvalds 2098611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2099611b30f7SMarcel Holtmann { 2100611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2101611b30f7SMarcel Holtmann 2102611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2103611b30f7SMarcel Holtmann 2104d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 21050736cfa8SMarcel Holtmann return -EBUSY; 21060736cfa8SMarcel Holtmann 21075e130367SJohan Hedberg if (blocked) { 2108a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2109d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2110d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2111611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 21125e130367SJohan Hedberg } else { 2113a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 21145e130367SJohan Hedberg } 2115611b30f7SMarcel Holtmann 2116611b30f7SMarcel Holtmann return 0; 2117611b30f7SMarcel Holtmann } 2118611b30f7SMarcel Holtmann 2119611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2120611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2121611b30f7SMarcel Holtmann }; 2122611b30f7SMarcel Holtmann 2123ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2124ab81cbf9SJohan Hedberg { 2125ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 212696570ffcSJohan Hedberg int err; 2127ab81cbf9SJohan Hedberg 2128ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2129ab81cbf9SJohan Hedberg 2130cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 213196570ffcSJohan Hedberg if (err < 0) { 21323ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 213396570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 21343ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2135ab81cbf9SJohan Hedberg return; 213696570ffcSJohan Hedberg } 2137ab81cbf9SJohan Hedberg 2138a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2139a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2140a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2141a5c8f270SMarcel Holtmann */ 2142d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2143d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2144a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2145a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2146a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2147a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2148bf543036SJohan Hedberg hci_dev_do_close(hdev); 2149d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 215019202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 215119202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2152bf543036SJohan Hedberg } 2153ab81cbf9SJohan Hedberg 2154a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 21554a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 21564a964404SMarcel Holtmann * so that userspace can easily identify them. 21574a964404SMarcel Holtmann */ 2158d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 21594a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 21600602a8adSMarcel Holtmann 21610602a8adSMarcel Holtmann /* For fully configured devices, this will send 21620602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 21630602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 21640602a8adSMarcel Holtmann * 21650602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 21660602a8adSMarcel Holtmann * and no event will be send. 21670602a8adSMarcel Holtmann */ 2168744cf19eSJohan Hedberg mgmt_index_added(hdev); 2169a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 21705ea234d3SMarcel Holtmann /* When the controller is now configured, then it 21715ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 21725ea234d3SMarcel Holtmann */ 2173d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 21745ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 21755ea234d3SMarcel Holtmann 2176d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2177d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2178d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2179d603b76bSMarcel Holtmann */ 2180d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2181ab81cbf9SJohan Hedberg } 2182ab81cbf9SJohan Hedberg } 2183ab81cbf9SJohan Hedberg 2184ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2185ab81cbf9SJohan Hedberg { 21863243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 21873243553fSJohan Hedberg power_off.work); 2188ab81cbf9SJohan Hedberg 2189ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2190ab81cbf9SJohan Hedberg 21918ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2192ab81cbf9SJohan Hedberg } 2193ab81cbf9SJohan Hedberg 2194c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2195c7741d16SMarcel Holtmann { 2196c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2197c7741d16SMarcel Holtmann 2198c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2199c7741d16SMarcel Holtmann 2200c7741d16SMarcel Holtmann if (hdev->hw_error) 2201c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2202c7741d16SMarcel Holtmann else 2203c7741d16SMarcel Holtmann BT_ERR("%s hardware error 0x%2.2x", hdev->name, 2204c7741d16SMarcel Holtmann hdev->hw_error_code); 2205c7741d16SMarcel Holtmann 2206c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2207c7741d16SMarcel Holtmann return; 2208c7741d16SMarcel Holtmann 2209c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2210c7741d16SMarcel Holtmann } 2211c7741d16SMarcel Holtmann 221216ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 221316ab91abSJohan Hedberg { 221416ab91abSJohan Hedberg struct hci_dev *hdev; 221516ab91abSJohan Hedberg 221616ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 221716ab91abSJohan Hedberg 221816ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 221916ab91abSJohan Hedberg 2220d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 222116ab91abSJohan Hedberg } 222216ab91abSJohan Hedberg 22235d900e46SFlorian Grandel static void hci_adv_timeout_expire(struct work_struct *work) 22245d900e46SFlorian Grandel { 22255d900e46SFlorian Grandel struct hci_dev *hdev; 22265d900e46SFlorian Grandel 22275d900e46SFlorian Grandel hdev = container_of(work, struct hci_dev, adv_instance_expire.work); 22285d900e46SFlorian Grandel 22295d900e46SFlorian Grandel BT_DBG("%s", hdev->name); 22305d900e46SFlorian Grandel 22315d900e46SFlorian Grandel mgmt_adv_timeout_expired(hdev); 22325d900e46SFlorian Grandel } 22335d900e46SFlorian Grandel 223435f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 22352aeb9a1aSJohan Hedberg { 22364821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 22372aeb9a1aSJohan Hedberg 22384821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 22394821002cSJohan Hedberg list_del(&uuid->list); 22402aeb9a1aSJohan Hedberg kfree(uuid); 22412aeb9a1aSJohan Hedberg } 22422aeb9a1aSJohan Hedberg } 22432aeb9a1aSJohan Hedberg 224435f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 224555ed8ca1SJohan Hedberg { 224655ed8ca1SJohan Hedberg struct link_key *key; 224755ed8ca1SJohan Hedberg 22480378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 22490378b597SJohan Hedberg list_del_rcu(&key->list); 22500378b597SJohan Hedberg kfree_rcu(key, rcu); 225155ed8ca1SJohan Hedberg } 225255ed8ca1SJohan Hedberg } 225355ed8ca1SJohan Hedberg 225435f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2255b899efafSVinicius Costa Gomes { 2256970d0f1bSJohan Hedberg struct smp_ltk *k; 2257b899efafSVinicius Costa Gomes 2258970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2259970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2260970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2261b899efafSVinicius Costa Gomes } 2262b899efafSVinicius Costa Gomes } 2263b899efafSVinicius Costa Gomes 2264970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2265970c4e46SJohan Hedberg { 2266adae20cbSJohan Hedberg struct smp_irk *k; 2267970c4e46SJohan Hedberg 2268adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2269adae20cbSJohan Hedberg list_del_rcu(&k->list); 2270adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2271970c4e46SJohan Hedberg } 2272970c4e46SJohan Hedberg } 2273970c4e46SJohan Hedberg 227455ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 227555ed8ca1SJohan Hedberg { 227655ed8ca1SJohan Hedberg struct link_key *k; 227755ed8ca1SJohan Hedberg 22780378b597SJohan Hedberg rcu_read_lock(); 22790378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 22800378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 22810378b597SJohan Hedberg rcu_read_unlock(); 228255ed8ca1SJohan Hedberg return k; 22830378b597SJohan Hedberg } 22840378b597SJohan Hedberg } 22850378b597SJohan Hedberg rcu_read_unlock(); 228655ed8ca1SJohan Hedberg 228755ed8ca1SJohan Hedberg return NULL; 228855ed8ca1SJohan Hedberg } 228955ed8ca1SJohan Hedberg 2290745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2291d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2292d25e28abSJohan Hedberg { 2293d25e28abSJohan Hedberg /* Legacy key */ 2294d25e28abSJohan Hedberg if (key_type < 0x03) 2295745c0ce3SVishal Agarwal return true; 2296d25e28abSJohan Hedberg 2297d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2298d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2299745c0ce3SVishal Agarwal return false; 2300d25e28abSJohan Hedberg 2301d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2302d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2303745c0ce3SVishal Agarwal return false; 2304d25e28abSJohan Hedberg 2305d25e28abSJohan Hedberg /* Security mode 3 case */ 2306d25e28abSJohan Hedberg if (!conn) 2307745c0ce3SVishal Agarwal return true; 2308d25e28abSJohan Hedberg 2309e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2310e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2311e3befab9SJohan Hedberg return true; 2312e3befab9SJohan Hedberg 2313d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2314d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2315745c0ce3SVishal Agarwal return true; 2316d25e28abSJohan Hedberg 2317d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2318d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2319745c0ce3SVishal Agarwal return true; 2320d25e28abSJohan Hedberg 2321d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2322d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2323745c0ce3SVishal Agarwal return true; 2324d25e28abSJohan Hedberg 2325d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2326d25e28abSJohan Hedberg * persistently */ 2327745c0ce3SVishal Agarwal return false; 2328d25e28abSJohan Hedberg } 2329d25e28abSJohan Hedberg 2330e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 233198a0b845SJohan Hedberg { 2332e804d25dSJohan Hedberg if (type == SMP_LTK) 2333e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 233498a0b845SJohan Hedberg 2335e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 233698a0b845SJohan Hedberg } 233798a0b845SJohan Hedberg 2338f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2339e804d25dSJohan Hedberg u8 addr_type, u8 role) 234075d262c2SVinicius Costa Gomes { 2341c9839a11SVinicius Costa Gomes struct smp_ltk *k; 234275d262c2SVinicius Costa Gomes 2343970d0f1bSJohan Hedberg rcu_read_lock(); 2344970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 23455378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 23465378bc56SJohan Hedberg continue; 23475378bc56SJohan Hedberg 2348923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2349970d0f1bSJohan Hedberg rcu_read_unlock(); 235075d262c2SVinicius Costa Gomes return k; 2351970d0f1bSJohan Hedberg } 2352970d0f1bSJohan Hedberg } 2353970d0f1bSJohan Hedberg rcu_read_unlock(); 235475d262c2SVinicius Costa Gomes 235575d262c2SVinicius Costa Gomes return NULL; 235675d262c2SVinicius Costa Gomes } 235775d262c2SVinicius Costa Gomes 2358970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2359970c4e46SJohan Hedberg { 2360970c4e46SJohan Hedberg struct smp_irk *irk; 2361970c4e46SJohan Hedberg 2362adae20cbSJohan Hedberg rcu_read_lock(); 2363adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2364adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2365adae20cbSJohan Hedberg rcu_read_unlock(); 2366970c4e46SJohan Hedberg return irk; 2367970c4e46SJohan Hedberg } 2368adae20cbSJohan Hedberg } 2369970c4e46SJohan Hedberg 2370adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2371defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2372970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2373adae20cbSJohan Hedberg rcu_read_unlock(); 2374970c4e46SJohan Hedberg return irk; 2375970c4e46SJohan Hedberg } 2376970c4e46SJohan Hedberg } 2377adae20cbSJohan Hedberg rcu_read_unlock(); 2378970c4e46SJohan Hedberg 2379970c4e46SJohan Hedberg return NULL; 2380970c4e46SJohan Hedberg } 2381970c4e46SJohan Hedberg 2382970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2383970c4e46SJohan Hedberg u8 addr_type) 2384970c4e46SJohan Hedberg { 2385970c4e46SJohan Hedberg struct smp_irk *irk; 2386970c4e46SJohan Hedberg 23876cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 23886cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 23896cfc9988SJohan Hedberg return NULL; 23906cfc9988SJohan Hedberg 2391adae20cbSJohan Hedberg rcu_read_lock(); 2392adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2393970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2394adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2395adae20cbSJohan Hedberg rcu_read_unlock(); 2396970c4e46SJohan Hedberg return irk; 2397970c4e46SJohan Hedberg } 2398adae20cbSJohan Hedberg } 2399adae20cbSJohan Hedberg rcu_read_unlock(); 2400970c4e46SJohan Hedberg 2401970c4e46SJohan Hedberg return NULL; 2402970c4e46SJohan Hedberg } 2403970c4e46SJohan Hedberg 2404567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 24057652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 24067652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 240755ed8ca1SJohan Hedberg { 240855ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2409745c0ce3SVishal Agarwal u8 old_key_type; 241055ed8ca1SJohan Hedberg 241155ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 241255ed8ca1SJohan Hedberg if (old_key) { 241355ed8ca1SJohan Hedberg old_key_type = old_key->type; 241455ed8ca1SJohan Hedberg key = old_key; 241555ed8ca1SJohan Hedberg } else { 241612adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 24170a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 241855ed8ca1SJohan Hedberg if (!key) 2419567fa2aaSJohan Hedberg return NULL; 24200378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 242155ed8ca1SJohan Hedberg } 242255ed8ca1SJohan Hedberg 24236ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 242455ed8ca1SJohan Hedberg 2425d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2426d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2427d25e28abSJohan Hedberg * previous key */ 2428d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2429a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2430d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2431655fe6ecSJohan Hedberg if (conn) 2432655fe6ecSJohan Hedberg conn->key_type = type; 2433655fe6ecSJohan Hedberg } 2434d25e28abSJohan Hedberg 243555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 24369b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 243755ed8ca1SJohan Hedberg key->pin_len = pin_len; 243855ed8ca1SJohan Hedberg 2439b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 244055ed8ca1SJohan Hedberg key->type = old_key_type; 24414748fed2SJohan Hedberg else 24424748fed2SJohan Hedberg key->type = type; 24434748fed2SJohan Hedberg 24447652ff6aSJohan Hedberg if (persistent) 24457652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 24467652ff6aSJohan Hedberg old_key_type); 24474df378a1SJohan Hedberg 2448567fa2aaSJohan Hedberg return key; 244955ed8ca1SJohan Hedberg } 245055ed8ca1SJohan Hedberg 2451ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 245235d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2453fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 245475d262c2SVinicius Costa Gomes { 2455c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2456e804d25dSJohan Hedberg u8 role = ltk_role(type); 245775d262c2SVinicius Costa Gomes 2458f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2459c9839a11SVinicius Costa Gomes if (old_key) 246075d262c2SVinicius Costa Gomes key = old_key; 2461c9839a11SVinicius Costa Gomes else { 24620a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 246375d262c2SVinicius Costa Gomes if (!key) 2464ca9142b8SJohan Hedberg return NULL; 2465970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 246675d262c2SVinicius Costa Gomes } 246775d262c2SVinicius Costa Gomes 246875d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2469c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2470c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2471c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2472c9839a11SVinicius Costa Gomes key->ediv = ediv; 2473fe39c7b2SMarcel Holtmann key->rand = rand; 2474c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2475c9839a11SVinicius Costa Gomes key->type = type; 247675d262c2SVinicius Costa Gomes 2477ca9142b8SJohan Hedberg return key; 247875d262c2SVinicius Costa Gomes } 247975d262c2SVinicius Costa Gomes 2480ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2481ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2482970c4e46SJohan Hedberg { 2483970c4e46SJohan Hedberg struct smp_irk *irk; 2484970c4e46SJohan Hedberg 2485970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2486970c4e46SJohan Hedberg if (!irk) { 2487970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2488970c4e46SJohan Hedberg if (!irk) 2489ca9142b8SJohan Hedberg return NULL; 2490970c4e46SJohan Hedberg 2491970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2492970c4e46SJohan Hedberg irk->addr_type = addr_type; 2493970c4e46SJohan Hedberg 2494adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2495970c4e46SJohan Hedberg } 2496970c4e46SJohan Hedberg 2497970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2498970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2499970c4e46SJohan Hedberg 2500ca9142b8SJohan Hedberg return irk; 2501970c4e46SJohan Hedberg } 2502970c4e46SJohan Hedberg 250355ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 250455ed8ca1SJohan Hedberg { 250555ed8ca1SJohan Hedberg struct link_key *key; 250655ed8ca1SJohan Hedberg 250755ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 250855ed8ca1SJohan Hedberg if (!key) 250955ed8ca1SJohan Hedberg return -ENOENT; 251055ed8ca1SJohan Hedberg 25116ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 251255ed8ca1SJohan Hedberg 25130378b597SJohan Hedberg list_del_rcu(&key->list); 25140378b597SJohan Hedberg kfree_rcu(key, rcu); 251555ed8ca1SJohan Hedberg 251655ed8ca1SJohan Hedberg return 0; 251755ed8ca1SJohan Hedberg } 251855ed8ca1SJohan Hedberg 2519e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2520b899efafSVinicius Costa Gomes { 2521970d0f1bSJohan Hedberg struct smp_ltk *k; 2522c51ffa0bSJohan Hedberg int removed = 0; 2523b899efafSVinicius Costa Gomes 2524970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2525e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2526b899efafSVinicius Costa Gomes continue; 2527b899efafSVinicius Costa Gomes 25286ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2529b899efafSVinicius Costa Gomes 2530970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2531970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2532c51ffa0bSJohan Hedberg removed++; 2533b899efafSVinicius Costa Gomes } 2534b899efafSVinicius Costa Gomes 2535c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2536b899efafSVinicius Costa Gomes } 2537b899efafSVinicius Costa Gomes 2538a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2539a7ec7338SJohan Hedberg { 2540adae20cbSJohan Hedberg struct smp_irk *k; 2541a7ec7338SJohan Hedberg 2542adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2543a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2544a7ec7338SJohan Hedberg continue; 2545a7ec7338SJohan Hedberg 2546a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2547a7ec7338SJohan Hedberg 2548adae20cbSJohan Hedberg list_del_rcu(&k->list); 2549adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2550a7ec7338SJohan Hedberg } 2551a7ec7338SJohan Hedberg } 2552a7ec7338SJohan Hedberg 255355e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 255455e76b38SJohan Hedberg { 255555e76b38SJohan Hedberg struct smp_ltk *k; 25564ba9faf3SJohan Hedberg struct smp_irk *irk; 255755e76b38SJohan Hedberg u8 addr_type; 255855e76b38SJohan Hedberg 255955e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 256055e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 256155e76b38SJohan Hedberg return true; 256255e76b38SJohan Hedberg return false; 256355e76b38SJohan Hedberg } 256455e76b38SJohan Hedberg 256555e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 256655e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 256755e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 256855e76b38SJohan Hedberg else 256955e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 257055e76b38SJohan Hedberg 25714ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 25724ba9faf3SJohan Hedberg if (irk) { 25734ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 25744ba9faf3SJohan Hedberg addr_type = irk->addr_type; 25754ba9faf3SJohan Hedberg } 25764ba9faf3SJohan Hedberg 257755e76b38SJohan Hedberg rcu_read_lock(); 257855e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 257987c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 258087c8b28dSJohan Hedberg rcu_read_unlock(); 258155e76b38SJohan Hedberg return true; 258255e76b38SJohan Hedberg } 258387c8b28dSJohan Hedberg } 258455e76b38SJohan Hedberg rcu_read_unlock(); 258555e76b38SJohan Hedberg 258655e76b38SJohan Hedberg return false; 258755e76b38SJohan Hedberg } 258855e76b38SJohan Hedberg 25896bd32326SVille Tervo /* HCI command timer function */ 259065cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 25916bd32326SVille Tervo { 259265cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 259365cc2b49SMarcel Holtmann cmd_timer.work); 25946bd32326SVille Tervo 2595bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2596bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2597bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2598bda4f23aSAndrei Emeltchenko 2599bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2600bda4f23aSAndrei Emeltchenko } else { 26016bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2602bda4f23aSAndrei Emeltchenko } 2603bda4f23aSAndrei Emeltchenko 26046bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2605c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 26066bd32326SVille Tervo } 26076bd32326SVille Tervo 26082763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 26096928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 26102763eda6SSzymon Janc { 26112763eda6SSzymon Janc struct oob_data *data; 26122763eda6SSzymon Janc 26136928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 26146928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 26156928a924SJohan Hedberg continue; 26166928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 26176928a924SJohan Hedberg continue; 26182763eda6SSzymon Janc return data; 26196928a924SJohan Hedberg } 26202763eda6SSzymon Janc 26212763eda6SSzymon Janc return NULL; 26222763eda6SSzymon Janc } 26232763eda6SSzymon Janc 26246928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26256928a924SJohan Hedberg u8 bdaddr_type) 26262763eda6SSzymon Janc { 26272763eda6SSzymon Janc struct oob_data *data; 26282763eda6SSzymon Janc 26296928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26302763eda6SSzymon Janc if (!data) 26312763eda6SSzymon Janc return -ENOENT; 26322763eda6SSzymon Janc 26336928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 26342763eda6SSzymon Janc 26352763eda6SSzymon Janc list_del(&data->list); 26362763eda6SSzymon Janc kfree(data); 26372763eda6SSzymon Janc 26382763eda6SSzymon Janc return 0; 26392763eda6SSzymon Janc } 26402763eda6SSzymon Janc 264135f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 26422763eda6SSzymon Janc { 26432763eda6SSzymon Janc struct oob_data *data, *n; 26442763eda6SSzymon Janc 26452763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 26462763eda6SSzymon Janc list_del(&data->list); 26472763eda6SSzymon Janc kfree(data); 26482763eda6SSzymon Janc } 26492763eda6SSzymon Janc } 26502763eda6SSzymon Janc 26510798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26526928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 265338da1703SJohan Hedberg u8 *hash256, u8 *rand256) 26540798872eSMarcel Holtmann { 26550798872eSMarcel Holtmann struct oob_data *data; 26560798872eSMarcel Holtmann 26576928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26580798872eSMarcel Holtmann if (!data) { 26590a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 26600798872eSMarcel Holtmann if (!data) 26610798872eSMarcel Holtmann return -ENOMEM; 26620798872eSMarcel Holtmann 26630798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 26646928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 26650798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 26660798872eSMarcel Holtmann } 26670798872eSMarcel Holtmann 266881328d5cSJohan Hedberg if (hash192 && rand192) { 26690798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 267038da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2671f7697b16SMarcel Holtmann if (hash256 && rand256) 2672f7697b16SMarcel Holtmann data->present = 0x03; 267381328d5cSJohan Hedberg } else { 267481328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 267581328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2676f7697b16SMarcel Holtmann if (hash256 && rand256) 2677f7697b16SMarcel Holtmann data->present = 0x02; 2678f7697b16SMarcel Holtmann else 2679f7697b16SMarcel Holtmann data->present = 0x00; 268081328d5cSJohan Hedberg } 26810798872eSMarcel Holtmann 268281328d5cSJohan Hedberg if (hash256 && rand256) { 26830798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 268438da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 268581328d5cSJohan Hedberg } else { 268681328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 268781328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2688f7697b16SMarcel Holtmann if (hash192 && rand192) 2689f7697b16SMarcel Holtmann data->present = 0x01; 269081328d5cSJohan Hedberg } 26910798872eSMarcel Holtmann 26926ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 26932763eda6SSzymon Janc 26942763eda6SSzymon Janc return 0; 26952763eda6SSzymon Janc } 26962763eda6SSzymon Janc 2697d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2698d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2699d2609b34SFlorian Grandel { 2700d2609b34SFlorian Grandel struct adv_info *adv_instance; 2701d2609b34SFlorian Grandel 2702d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2703d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2704d2609b34SFlorian Grandel return adv_instance; 2705d2609b34SFlorian Grandel } 2706d2609b34SFlorian Grandel 2707d2609b34SFlorian Grandel return NULL; 2708d2609b34SFlorian Grandel } 2709d2609b34SFlorian Grandel 2710d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2711d2609b34SFlorian Grandel struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) { 2712d2609b34SFlorian Grandel struct adv_info *cur_instance; 2713d2609b34SFlorian Grandel 2714d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2715d2609b34SFlorian Grandel if (!cur_instance) 2716d2609b34SFlorian Grandel return NULL; 2717d2609b34SFlorian Grandel 2718d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2719d2609b34SFlorian Grandel struct adv_info, list)) 2720d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2721d2609b34SFlorian Grandel struct adv_info, list); 2722d2609b34SFlorian Grandel else 2723d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2724d2609b34SFlorian Grandel } 2725d2609b34SFlorian Grandel 2726d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2727d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2728d2609b34SFlorian Grandel { 2729d2609b34SFlorian Grandel struct adv_info *adv_instance; 2730d2609b34SFlorian Grandel 2731d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2732d2609b34SFlorian Grandel if (!adv_instance) 2733d2609b34SFlorian Grandel return -ENOENT; 2734d2609b34SFlorian Grandel 2735d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2736d2609b34SFlorian Grandel 27375d900e46SFlorian Grandel if (hdev->cur_adv_instance == instance && hdev->adv_instance_timeout) { 27385d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27395d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27405d900e46SFlorian Grandel } 27415d900e46SFlorian Grandel 2742d2609b34SFlorian Grandel list_del(&adv_instance->list); 2743d2609b34SFlorian Grandel kfree(adv_instance); 2744d2609b34SFlorian Grandel 2745d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2746d2609b34SFlorian Grandel 2747d2609b34SFlorian Grandel return 0; 2748d2609b34SFlorian Grandel } 2749d2609b34SFlorian Grandel 2750d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2751d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2752d2609b34SFlorian Grandel { 2753d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2754d2609b34SFlorian Grandel 27555d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 27565d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27575d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27585d900e46SFlorian Grandel } 27595d900e46SFlorian Grandel 2760d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2761d2609b34SFlorian Grandel list_del(&adv_instance->list); 2762d2609b34SFlorian Grandel kfree(adv_instance); 2763d2609b34SFlorian Grandel } 2764d2609b34SFlorian Grandel 2765d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2766d2609b34SFlorian Grandel } 2767d2609b34SFlorian Grandel 2768d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2769d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2770d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2771d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2772d2609b34SFlorian Grandel u16 timeout, u16 duration) 2773d2609b34SFlorian Grandel { 2774d2609b34SFlorian Grandel struct adv_info *adv_instance; 2775d2609b34SFlorian Grandel 2776d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2777d2609b34SFlorian Grandel if (adv_instance) { 2778d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2779d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2780d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2781d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2782d2609b34SFlorian Grandel } else { 2783d2609b34SFlorian Grandel if (hdev->adv_instance_cnt >= HCI_MAX_ADV_INSTANCES || 2784d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2785d2609b34SFlorian Grandel return -EOVERFLOW; 2786d2609b34SFlorian Grandel 278739ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2788d2609b34SFlorian Grandel if (!adv_instance) 2789d2609b34SFlorian Grandel return -ENOMEM; 2790d2609b34SFlorian Grandel 2791fffd38bcSFlorian Grandel adv_instance->pending = true; 2792d2609b34SFlorian Grandel adv_instance->instance = instance; 2793d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2794d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2795d2609b34SFlorian Grandel } 2796d2609b34SFlorian Grandel 2797d2609b34SFlorian Grandel adv_instance->flags = flags; 2798d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2799d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2800d2609b34SFlorian Grandel 2801d2609b34SFlorian Grandel if (adv_data_len) 2802d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2803d2609b34SFlorian Grandel 2804d2609b34SFlorian Grandel if (scan_rsp_len) 2805d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2806d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2807d2609b34SFlorian Grandel 2808d2609b34SFlorian Grandel adv_instance->timeout = timeout; 28095d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2810d2609b34SFlorian Grandel 2811d2609b34SFlorian Grandel if (duration == 0) 2812d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2813d2609b34SFlorian Grandel else 2814d2609b34SFlorian Grandel adv_instance->duration = duration; 2815d2609b34SFlorian Grandel 2816d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2817d2609b34SFlorian Grandel 2818d2609b34SFlorian Grandel return 0; 2819d2609b34SFlorian Grandel } 2820d2609b34SFlorian Grandel 2821dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2822b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2823b2a66aadSAntti Julku { 2824b2a66aadSAntti Julku struct bdaddr_list *b; 2825b2a66aadSAntti Julku 2826dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2827b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2828b2a66aadSAntti Julku return b; 2829b9ee0a78SMarcel Holtmann } 2830b2a66aadSAntti Julku 2831b2a66aadSAntti Julku return NULL; 2832b2a66aadSAntti Julku } 2833b2a66aadSAntti Julku 2834dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2835b2a66aadSAntti Julku { 2836b2a66aadSAntti Julku struct list_head *p, *n; 2837b2a66aadSAntti Julku 2838dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 2839b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2840b2a66aadSAntti Julku 2841b2a66aadSAntti Julku list_del(p); 2842b2a66aadSAntti Julku kfree(b); 2843b2a66aadSAntti Julku } 2844b2a66aadSAntti Julku } 2845b2a66aadSAntti Julku 2846dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2847b2a66aadSAntti Julku { 2848b2a66aadSAntti Julku struct bdaddr_list *entry; 2849b2a66aadSAntti Julku 2850b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2851b2a66aadSAntti Julku return -EBADF; 2852b2a66aadSAntti Julku 2853dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 28545e762444SAntti Julku return -EEXIST; 2855b2a66aadSAntti Julku 285627f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 28575e762444SAntti Julku if (!entry) 28585e762444SAntti Julku return -ENOMEM; 2859b2a66aadSAntti Julku 2860b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2861b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2862b2a66aadSAntti Julku 2863dcc36c16SJohan Hedberg list_add(&entry->list, list); 2864b2a66aadSAntti Julku 28652a8357f2SJohan Hedberg return 0; 2866b2a66aadSAntti Julku } 2867b2a66aadSAntti Julku 2868dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2869b2a66aadSAntti Julku { 2870b2a66aadSAntti Julku struct bdaddr_list *entry; 2871b2a66aadSAntti Julku 287235f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2873dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 287435f7498aSJohan Hedberg return 0; 287535f7498aSJohan Hedberg } 2876b2a66aadSAntti Julku 2877dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2878d2ab0ac1SMarcel Holtmann if (!entry) 2879d2ab0ac1SMarcel Holtmann return -ENOENT; 2880d2ab0ac1SMarcel Holtmann 2881d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2882d2ab0ac1SMarcel Holtmann kfree(entry); 2883d2ab0ac1SMarcel Holtmann 2884d2ab0ac1SMarcel Holtmann return 0; 2885d2ab0ac1SMarcel Holtmann } 2886d2ab0ac1SMarcel Holtmann 288715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 288815819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 288915819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 289015819a70SAndre Guedes { 289115819a70SAndre Guedes struct hci_conn_params *params; 289215819a70SAndre Guedes 289315819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 289415819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 289515819a70SAndre Guedes params->addr_type == addr_type) { 289615819a70SAndre Guedes return params; 289715819a70SAndre Guedes } 289815819a70SAndre Guedes } 289915819a70SAndre Guedes 290015819a70SAndre Guedes return NULL; 290115819a70SAndre Guedes } 290215819a70SAndre Guedes 290315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2904501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 29054b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 290615819a70SAndre Guedes { 2907912b42efSJohan Hedberg struct hci_conn_params *param; 290815819a70SAndre Guedes 2909501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2910912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2911912b42efSJohan Hedberg param->addr_type == addr_type) 2912912b42efSJohan Hedberg return param; 29134b10966fSMarcel Holtmann } 29144b10966fSMarcel Holtmann 29154b10966fSMarcel Holtmann return NULL; 291615819a70SAndre Guedes } 291715819a70SAndre Guedes 291815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2919f75113a2SJakub Pawlowski struct hci_conn_params *hci_explicit_connect_lookup(struct hci_dev *hdev, 2920f75113a2SJakub Pawlowski bdaddr_t *addr, 2921f75113a2SJakub Pawlowski u8 addr_type) 2922f75113a2SJakub Pawlowski { 2923f75113a2SJakub Pawlowski struct hci_conn_params *param; 2924f75113a2SJakub Pawlowski 2925f75113a2SJakub Pawlowski list_for_each_entry(param, &hdev->pend_le_conns, action) { 2926f75113a2SJakub Pawlowski if (bacmp(¶m->addr, addr) == 0 && 2927f75113a2SJakub Pawlowski param->addr_type == addr_type && 2928f75113a2SJakub Pawlowski param->explicit_connect) 2929f75113a2SJakub Pawlowski return param; 2930f75113a2SJakub Pawlowski } 2931f75113a2SJakub Pawlowski 2932f75113a2SJakub Pawlowski list_for_each_entry(param, &hdev->pend_le_reports, action) { 2933f75113a2SJakub Pawlowski if (bacmp(¶m->addr, addr) == 0 && 2934f75113a2SJakub Pawlowski param->addr_type == addr_type && 2935f75113a2SJakub Pawlowski param->explicit_connect) 2936f75113a2SJakub Pawlowski return param; 2937f75113a2SJakub Pawlowski } 2938f75113a2SJakub Pawlowski 2939f75113a2SJakub Pawlowski return NULL; 2940f75113a2SJakub Pawlowski } 2941f75113a2SJakub Pawlowski 2942f75113a2SJakub Pawlowski /* This function requires the caller holds hdev->lock */ 294351d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 294451d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 294515819a70SAndre Guedes { 294615819a70SAndre Guedes struct hci_conn_params *params; 294715819a70SAndre Guedes 294815819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2949cef952ceSAndre Guedes if (params) 295051d167c0SMarcel Holtmann return params; 295115819a70SAndre Guedes 295215819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 295315819a70SAndre Guedes if (!params) { 295415819a70SAndre Guedes BT_ERR("Out of memory"); 295551d167c0SMarcel Holtmann return NULL; 295615819a70SAndre Guedes } 295715819a70SAndre Guedes 295815819a70SAndre Guedes bacpy(¶ms->addr, addr); 295915819a70SAndre Guedes params->addr_type = addr_type; 2960cef952ceSAndre Guedes 2961cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 296293450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2963cef952ceSAndre Guedes 2964bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2965bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2966bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2967bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2968bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2969bf5b3c8bSMarcel Holtmann 2970bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2971bf5b3c8bSMarcel Holtmann 297251d167c0SMarcel Holtmann return params; 2973bf5b3c8bSMarcel Holtmann } 2974bf5b3c8bSMarcel Holtmann 2975f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2976f6c63249SJohan Hedberg { 2977f6c63249SJohan Hedberg if (params->conn) { 2978f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2979f6c63249SJohan Hedberg hci_conn_put(params->conn); 2980f6c63249SJohan Hedberg } 2981f6c63249SJohan Hedberg 2982f6c63249SJohan Hedberg list_del(¶ms->action); 2983f6c63249SJohan Hedberg list_del(¶ms->list); 2984f6c63249SJohan Hedberg kfree(params); 2985f6c63249SJohan Hedberg } 2986f6c63249SJohan Hedberg 298715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 298815819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 298915819a70SAndre Guedes { 299015819a70SAndre Guedes struct hci_conn_params *params; 299115819a70SAndre Guedes 299215819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 299315819a70SAndre Guedes if (!params) 299415819a70SAndre Guedes return; 299515819a70SAndre Guedes 2996f6c63249SJohan Hedberg hci_conn_params_free(params); 299715819a70SAndre Guedes 299895305baaSJohan Hedberg hci_update_background_scan(hdev); 299995305baaSJohan Hedberg 300015819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 300115819a70SAndre Guedes } 300215819a70SAndre Guedes 300315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 300455af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 300515819a70SAndre Guedes { 300615819a70SAndre Guedes struct hci_conn_params *params, *tmp; 300715819a70SAndre Guedes 300815819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 300955af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 301055af49a8SJohan Hedberg continue; 3011f75113a2SJakub Pawlowski 3012f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 3013f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 3014f75113a2SJakub Pawlowski */ 3015f75113a2SJakub Pawlowski if (params->explicit_connect) { 3016f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 3017f75113a2SJakub Pawlowski continue; 3018f75113a2SJakub Pawlowski } 3019f75113a2SJakub Pawlowski 302015819a70SAndre Guedes list_del(¶ms->list); 302115819a70SAndre Guedes kfree(params); 302215819a70SAndre Guedes } 302315819a70SAndre Guedes 302455af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 302555af49a8SJohan Hedberg } 302655af49a8SJohan Hedberg 302755af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3028373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 302915819a70SAndre Guedes { 303015819a70SAndre Guedes struct hci_conn_params *params, *tmp; 303115819a70SAndre Guedes 3032f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3033f6c63249SJohan Hedberg hci_conn_params_free(params); 303415819a70SAndre Guedes 3035a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 30361089b67dSMarcel Holtmann 303715819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 303815819a70SAndre Guedes } 303915819a70SAndre Guedes 30401904a853SMarcel Holtmann static void inquiry_complete(struct hci_dev *hdev, u8 status, u16 opcode) 30417ba8b4beSAndre Guedes { 30424c87eaabSAndre Guedes if (status) { 30434c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 30447ba8b4beSAndre Guedes 30454c87eaabSAndre Guedes hci_dev_lock(hdev); 30464c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 30474c87eaabSAndre Guedes hci_dev_unlock(hdev); 30484c87eaabSAndre Guedes return; 30494c87eaabSAndre Guedes } 30507ba8b4beSAndre Guedes } 30517ba8b4beSAndre Guedes 30521904a853SMarcel Holtmann static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status, 30531904a853SMarcel Holtmann u16 opcode) 30547ba8b4beSAndre Guedes { 30554c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 30564c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 30574c87eaabSAndre Guedes struct hci_cp_inquiry cp; 30587ba8b4beSAndre Guedes int err; 30597ba8b4beSAndre Guedes 30604c87eaabSAndre Guedes if (status) { 30614c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 30624c87eaabSAndre Guedes return; 30637ba8b4beSAndre Guedes } 30647ba8b4beSAndre Guedes 30652d28cfe7SJakub Pawlowski hdev->discovery.scan_start = 0; 30662d28cfe7SJakub Pawlowski 30674c87eaabSAndre Guedes switch (hdev->discovery.type) { 30684c87eaabSAndre Guedes case DISCOV_TYPE_LE: 30694c87eaabSAndre Guedes hci_dev_lock(hdev); 30704c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 30714c87eaabSAndre Guedes hci_dev_unlock(hdev); 30724c87eaabSAndre Guedes break; 30737dbfac1dSAndre Guedes 30744c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 30754c87eaabSAndre Guedes hci_dev_lock(hdev); 30764c87eaabSAndre Guedes 307707d2334aSJakub Pawlowski if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, 307807d2334aSJakub Pawlowski &hdev->quirks)) { 307907d2334aSJakub Pawlowski /* If we were running LE only scan, change discovery 308007d2334aSJakub Pawlowski * state. If we were running both LE and BR/EDR inquiry 308107d2334aSJakub Pawlowski * simultaneously, and BR/EDR inquiry is already 308207d2334aSJakub Pawlowski * finished, stop discovery, otherwise BR/EDR inquiry 3083177d0506SWesley Kuo * will stop discovery when finished. If we will resolve 3084177d0506SWesley Kuo * remote device name, do not change discovery state. 308507d2334aSJakub Pawlowski */ 3086177d0506SWesley Kuo if (!test_bit(HCI_INQUIRY, &hdev->flags) && 3087177d0506SWesley Kuo hdev->discovery.state != DISCOVERY_RESOLVING) 308807d2334aSJakub Pawlowski hci_discovery_set_state(hdev, 308907d2334aSJakub Pawlowski DISCOVERY_STOPPED); 309007d2334aSJakub Pawlowski } else { 3091baf880a9SJohan Hedberg struct hci_request req; 3092baf880a9SJohan Hedberg 30934c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 30944c87eaabSAndre Guedes 3095baf880a9SJohan Hedberg hci_req_init(&req, hdev); 3096baf880a9SJohan Hedberg 3097baf880a9SJohan Hedberg memset(&cp, 0, sizeof(cp)); 3098baf880a9SJohan Hedberg memcpy(&cp.lap, lap, sizeof(cp.lap)); 3099baf880a9SJohan Hedberg cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 3100baf880a9SJohan Hedberg hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 3101baf880a9SJohan Hedberg 31024c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 31034c87eaabSAndre Guedes if (err) { 31044c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 310507d2334aSJakub Pawlowski hci_discovery_set_state(hdev, 310607d2334aSJakub Pawlowski DISCOVERY_STOPPED); 310707d2334aSJakub Pawlowski } 31087dbfac1dSAndre Guedes } 31097dbfac1dSAndre Guedes 31104c87eaabSAndre Guedes hci_dev_unlock(hdev); 31114c87eaabSAndre Guedes break; 31124c87eaabSAndre Guedes } 31137dbfac1dSAndre Guedes } 31147dbfac1dSAndre Guedes 31157ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 31167ba8b4beSAndre Guedes { 31177ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 31187ba8b4beSAndre Guedes le_scan_disable.work); 31194c87eaabSAndre Guedes struct hci_request req; 31204c87eaabSAndre Guedes int err; 31217ba8b4beSAndre Guedes 31227ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 31237ba8b4beSAndre Guedes 31242d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 31252d28cfe7SJakub Pawlowski 31264c87eaabSAndre Guedes hci_req_init(&req, hdev); 31277ba8b4beSAndre Guedes 3128b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 31297ba8b4beSAndre Guedes 31304c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 31314c87eaabSAndre Guedes if (err) 31324c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 313328b75a89SAndre Guedes } 313428b75a89SAndre Guedes 31352d28cfe7SJakub Pawlowski static void le_scan_restart_work_complete(struct hci_dev *hdev, u8 status, 31362d28cfe7SJakub Pawlowski u16 opcode) 31372d28cfe7SJakub Pawlowski { 31382d28cfe7SJakub Pawlowski unsigned long timeout, duration, scan_start, now; 31392d28cfe7SJakub Pawlowski 31402d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 31412d28cfe7SJakub Pawlowski 31422d28cfe7SJakub Pawlowski if (status) { 31432d28cfe7SJakub Pawlowski BT_ERR("Failed to restart LE scan: status %d", status); 31442d28cfe7SJakub Pawlowski return; 31452d28cfe7SJakub Pawlowski } 31462d28cfe7SJakub Pawlowski 31472d28cfe7SJakub Pawlowski if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) || 31482d28cfe7SJakub Pawlowski !hdev->discovery.scan_start) 31492d28cfe7SJakub Pawlowski return; 31502d28cfe7SJakub Pawlowski 31512d28cfe7SJakub Pawlowski /* When the scan was started, hdev->le_scan_disable has been queued 31522d28cfe7SJakub Pawlowski * after duration from scan_start. During scan restart this job 31532d28cfe7SJakub Pawlowski * has been canceled, and we need to queue it again after proper 31542d28cfe7SJakub Pawlowski * timeout, to make sure that scan does not run indefinitely. 31552d28cfe7SJakub Pawlowski */ 31562d28cfe7SJakub Pawlowski duration = hdev->discovery.scan_duration; 31572d28cfe7SJakub Pawlowski scan_start = hdev->discovery.scan_start; 31582d28cfe7SJakub Pawlowski now = jiffies; 31592d28cfe7SJakub Pawlowski if (now - scan_start <= duration) { 31602d28cfe7SJakub Pawlowski int elapsed; 31612d28cfe7SJakub Pawlowski 31622d28cfe7SJakub Pawlowski if (now >= scan_start) 31632d28cfe7SJakub Pawlowski elapsed = now - scan_start; 31642d28cfe7SJakub Pawlowski else 31652d28cfe7SJakub Pawlowski elapsed = ULONG_MAX - scan_start + now; 31662d28cfe7SJakub Pawlowski 31672d28cfe7SJakub Pawlowski timeout = duration - elapsed; 31682d28cfe7SJakub Pawlowski } else { 31692d28cfe7SJakub Pawlowski timeout = 0; 31702d28cfe7SJakub Pawlowski } 31712d28cfe7SJakub Pawlowski queue_delayed_work(hdev->workqueue, 31722d28cfe7SJakub Pawlowski &hdev->le_scan_disable, timeout); 31732d28cfe7SJakub Pawlowski } 31742d28cfe7SJakub Pawlowski 31752d28cfe7SJakub Pawlowski static void le_scan_restart_work(struct work_struct *work) 31762d28cfe7SJakub Pawlowski { 31772d28cfe7SJakub Pawlowski struct hci_dev *hdev = container_of(work, struct hci_dev, 31782d28cfe7SJakub Pawlowski le_scan_restart.work); 31792d28cfe7SJakub Pawlowski struct hci_request req; 31802d28cfe7SJakub Pawlowski struct hci_cp_le_set_scan_enable cp; 31812d28cfe7SJakub Pawlowski int err; 31822d28cfe7SJakub Pawlowski 31832d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 31842d28cfe7SJakub Pawlowski 31852d28cfe7SJakub Pawlowski /* If controller is not scanning we are done. */ 3186d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_LE_SCAN)) 31872d28cfe7SJakub Pawlowski return; 31882d28cfe7SJakub Pawlowski 31892d28cfe7SJakub Pawlowski hci_req_init(&req, hdev); 31902d28cfe7SJakub Pawlowski 31912d28cfe7SJakub Pawlowski hci_req_add_le_scan_disable(&req); 31922d28cfe7SJakub Pawlowski 31932d28cfe7SJakub Pawlowski memset(&cp, 0, sizeof(cp)); 31942d28cfe7SJakub Pawlowski cp.enable = LE_SCAN_ENABLE; 31952d28cfe7SJakub Pawlowski cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 31962d28cfe7SJakub Pawlowski hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 31972d28cfe7SJakub Pawlowski 31982d28cfe7SJakub Pawlowski err = hci_req_run(&req, le_scan_restart_work_complete); 31992d28cfe7SJakub Pawlowski if (err) 32002d28cfe7SJakub Pawlowski BT_ERR("Restart LE scan request failed: err %d", err); 32012d28cfe7SJakub Pawlowski } 32022d28cfe7SJakub Pawlowski 3203a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3204a1f4c318SJohan Hedberg * 3205a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3206a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3207a1f4c318SJohan Hedberg * the static random address. 3208a1f4c318SJohan Hedberg * 3209a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3210a1f4c318SJohan Hedberg * public address to use the static random address instead. 321150b5b952SMarcel Holtmann * 321250b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 321350b5b952SMarcel Holtmann * userspace has configured a static address, then that address 321450b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 3215a1f4c318SJohan Hedberg */ 3216a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3217a1f4c318SJohan Hedberg u8 *bdaddr_type) 3218a1f4c318SJohan Hedberg { 3219b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 322050b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 3221d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 322250b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 3223a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3224a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3225a1f4c318SJohan Hedberg } else { 3226a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3227a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3228a1f4c318SJohan Hedberg } 3229a1f4c318SJohan Hedberg } 3230a1f4c318SJohan Hedberg 32319be0dab7SDavid Herrmann /* Alloc HCI device */ 32329be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 32339be0dab7SDavid Herrmann { 32349be0dab7SDavid Herrmann struct hci_dev *hdev; 32359be0dab7SDavid Herrmann 323627f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 32379be0dab7SDavid Herrmann if (!hdev) 32389be0dab7SDavid Herrmann return NULL; 32399be0dab7SDavid Herrmann 3240b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3241b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3242b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3243b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3244b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 324596c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3246bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3247bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3248d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 3249d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 32505d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 3251b1b813d4SDavid Herrmann 3252b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3253b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3254b1b813d4SDavid Herrmann 32553f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3256628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3257628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3258bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3259bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 32604e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 32614e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 326204fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 326304fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3264a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3265a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3266a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3267a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3268a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3269a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 3270bef64738SMarcel Holtmann 3271d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3272b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 327331ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 327431ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3275d6bfd59cSJohan Hedberg 3276b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3277b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3278b1b813d4SDavid Herrmann 3279b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3280b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 32816659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3282b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3283b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3284b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3285970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3286b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3287d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 328815819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 328977a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 329066f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 32916b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3292d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3293b1b813d4SDavid Herrmann 3294b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3295b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3296b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3297b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3298c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3299b1b813d4SDavid Herrmann 3300b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3301b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3302b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 33032d28cfe7SJakub Pawlowski INIT_DELAYED_WORK(&hdev->le_scan_restart, le_scan_restart_work); 33045d900e46SFlorian Grandel INIT_DELAYED_WORK(&hdev->adv_instance_expire, hci_adv_timeout_expire); 3305b1b813d4SDavid Herrmann 3306b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3307b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3308b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3309b1b813d4SDavid Herrmann 3310b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3311b1b813d4SDavid Herrmann 331265cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3313b1b813d4SDavid Herrmann 3314b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3315b1b813d4SDavid Herrmann discovery_init(hdev); 33169be0dab7SDavid Herrmann 33179be0dab7SDavid Herrmann return hdev; 33189be0dab7SDavid Herrmann } 33199be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 33209be0dab7SDavid Herrmann 33219be0dab7SDavid Herrmann /* Free HCI device */ 33229be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 33239be0dab7SDavid Herrmann { 33249be0dab7SDavid Herrmann /* will free via device release */ 33259be0dab7SDavid Herrmann put_device(&hdev->dev); 33269be0dab7SDavid Herrmann } 33279be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 33289be0dab7SDavid Herrmann 33291da177e4SLinus Torvalds /* Register HCI device */ 33301da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 33311da177e4SLinus Torvalds { 3332b1b813d4SDavid Herrmann int id, error; 33331da177e4SLinus Torvalds 333474292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 33351da177e4SLinus Torvalds return -EINVAL; 33361da177e4SLinus Torvalds 333708add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 333808add513SMat Martineau * so the index can be used as the AMP controller ID. 333908add513SMat Martineau */ 33403df92b31SSasha Levin switch (hdev->dev_type) { 33413df92b31SSasha Levin case HCI_BREDR: 33423df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 33431da177e4SLinus Torvalds break; 33443df92b31SSasha Levin case HCI_AMP: 33453df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 33463df92b31SSasha Levin break; 33473df92b31SSasha Levin default: 33483df92b31SSasha Levin return -EINVAL; 33491da177e4SLinus Torvalds } 33501da177e4SLinus Torvalds 33513df92b31SSasha Levin if (id < 0) 33523df92b31SSasha Levin return id; 33533df92b31SSasha Levin 33541da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 33551da177e4SLinus Torvalds hdev->id = id; 33562d8b3a11SAndrei Emeltchenko 33572d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 33582d8b3a11SAndrei Emeltchenko 3359d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3360d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 336133ca954dSDavid Herrmann if (!hdev->workqueue) { 336233ca954dSDavid Herrmann error = -ENOMEM; 336333ca954dSDavid Herrmann goto err; 336433ca954dSDavid Herrmann } 3365f48fd9c8SMarcel Holtmann 3366d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3367d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 33686ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 33696ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 33706ead1bbcSJohan Hedberg error = -ENOMEM; 33716ead1bbcSJohan Hedberg goto err; 33726ead1bbcSJohan Hedberg } 33736ead1bbcSJohan Hedberg 33740153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 33750153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 33760153e2ecSMarcel Holtmann 3377bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3378bdc3e0f1SMarcel Holtmann 3379bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 338033ca954dSDavid Herrmann if (error < 0) 338154506918SJohan Hedberg goto err_wqueue; 33821da177e4SLinus Torvalds 3383611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3384a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3385a8c5fb1aSGustavo Padovan hdev); 3386611b30f7SMarcel Holtmann if (hdev->rfkill) { 3387611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3388611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3389611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3390611b30f7SMarcel Holtmann } 3391611b30f7SMarcel Holtmann } 3392611b30f7SMarcel Holtmann 33935e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3394a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 33955e130367SJohan Hedberg 3396a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3397a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3398ce2be9acSAndrei Emeltchenko 339901cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 340056f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 340156f87901SJohan Hedberg * through reading supported features during init. 340256f87901SJohan Hedberg */ 3403a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 340456f87901SJohan Hedberg } 3405ce2be9acSAndrei Emeltchenko 3406fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3407fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3408fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3409fcee3377SGustavo Padovan 34104a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 34114a964404SMarcel Holtmann * and should not be included in normal operation. 3412fee746b0SMarcel Holtmann */ 3413fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3414a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3415fee746b0SMarcel Holtmann 34161da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 3417dc946bd8SDavid Herrmann hci_dev_hold(hdev); 34181da177e4SLinus Torvalds 341919202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3420fbe96d6fSMarcel Holtmann 34211da177e4SLinus Torvalds return id; 3422f48fd9c8SMarcel Holtmann 342333ca954dSDavid Herrmann err_wqueue: 342433ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 34256ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 342633ca954dSDavid Herrmann err: 34273df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3428f48fd9c8SMarcel Holtmann 342933ca954dSDavid Herrmann return error; 34301da177e4SLinus Torvalds } 34311da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 34321da177e4SLinus Torvalds 34331da177e4SLinus Torvalds /* Unregister HCI device */ 343459735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 34351da177e4SLinus Torvalds { 34362d7cc19eSMarcel Holtmann int id; 3437ef222013SMarcel Holtmann 3438c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 34391da177e4SLinus Torvalds 3440a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 344194324962SJohan Hovold 34423df92b31SSasha Levin id = hdev->id; 34433df92b31SSasha Levin 3444f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 34451da177e4SLinus Torvalds list_del(&hdev->list); 3446f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 34471da177e4SLinus Torvalds 34481da177e4SLinus Torvalds hci_dev_do_close(hdev); 34491da177e4SLinus Torvalds 3450b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3451b9b5ef18SGustavo Padovan 3452ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3453d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3454d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 345509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3456744cf19eSJohan Hedberg mgmt_index_removed(hdev); 345709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 345856e5cb86SJohan Hedberg } 3459ab81cbf9SJohan Hedberg 34602e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 34612e58ef3eSJohan Hedberg * pending list */ 34622e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 34632e58ef3eSJohan Hedberg 34641da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 34651da177e4SLinus Torvalds 3466611b30f7SMarcel Holtmann if (hdev->rfkill) { 3467611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3468611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3469611b30f7SMarcel Holtmann } 3470611b30f7SMarcel Holtmann 3471bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3472147e2d59SDave Young 34730153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 34740153e2ecSMarcel Holtmann 3475f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 34766ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3477f48fd9c8SMarcel Holtmann 347809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3479dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 34806659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 34812aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 348255ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3483b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3484970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 34852763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3486d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3487dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3488373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 348922078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 349009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3491e2e0cacbSJohan Hedberg 3492dc946bd8SDavid Herrmann hci_dev_put(hdev); 34933df92b31SSasha Levin 34943df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 34951da177e4SLinus Torvalds } 34961da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 34971da177e4SLinus Torvalds 34981da177e4SLinus Torvalds /* Suspend HCI device */ 34991da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 35001da177e4SLinus Torvalds { 35011da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 35021da177e4SLinus Torvalds return 0; 35031da177e4SLinus Torvalds } 35041da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 35051da177e4SLinus Torvalds 35061da177e4SLinus Torvalds /* Resume HCI device */ 35071da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 35081da177e4SLinus Torvalds { 35091da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 35101da177e4SLinus Torvalds return 0; 35111da177e4SLinus Torvalds } 35121da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 35131da177e4SLinus Torvalds 351475e0569fSMarcel Holtmann /* Reset HCI device */ 351575e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 351675e0569fSMarcel Holtmann { 351775e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 351875e0569fSMarcel Holtmann struct sk_buff *skb; 351975e0569fSMarcel Holtmann 352075e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 352175e0569fSMarcel Holtmann if (!skb) 352275e0569fSMarcel Holtmann return -ENOMEM; 352375e0569fSMarcel Holtmann 352475e0569fSMarcel Holtmann bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 352575e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 352675e0569fSMarcel Holtmann 352775e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 352875e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 352975e0569fSMarcel Holtmann } 353075e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 353175e0569fSMarcel Holtmann 353276bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3533e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 353476bca880SMarcel Holtmann { 353576bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 353676bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 353776bca880SMarcel Holtmann kfree_skb(skb); 353876bca880SMarcel Holtmann return -ENXIO; 353976bca880SMarcel Holtmann } 354076bca880SMarcel Holtmann 3541*fe806dceSMarcel Holtmann if (bt_cb(skb)->pkt_type != HCI_EVENT_PKT && 3542*fe806dceSMarcel Holtmann bt_cb(skb)->pkt_type != HCI_ACLDATA_PKT && 3543*fe806dceSMarcel Holtmann bt_cb(skb)->pkt_type != HCI_SCODATA_PKT) { 3544*fe806dceSMarcel Holtmann kfree_skb(skb); 3545*fe806dceSMarcel Holtmann return -EINVAL; 3546*fe806dceSMarcel Holtmann } 3547*fe806dceSMarcel Holtmann 3548d82603c6SJorrit Schippers /* Incoming skb */ 354976bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 355076bca880SMarcel Holtmann 355176bca880SMarcel Holtmann /* Time stamp */ 355276bca880SMarcel Holtmann __net_timestamp(skb); 355376bca880SMarcel Holtmann 355476bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3555b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3556c78ae283SMarcel Holtmann 355776bca880SMarcel Holtmann return 0; 355876bca880SMarcel Holtmann } 355976bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 356076bca880SMarcel Holtmann 3561e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3562e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3563e875ff84SMarcel Holtmann { 3564e875ff84SMarcel Holtmann /* Time stamp */ 3565e875ff84SMarcel Holtmann __net_timestamp(skb); 3566e875ff84SMarcel Holtmann 3567e875ff84SMarcel Holtmann /* Mark as diagnostic packet and send to monitor */ 3568e875ff84SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_DIAG_PKT; 3569e875ff84SMarcel Holtmann hci_send_to_monitor(hdev, skb); 3570e875ff84SMarcel Holtmann 3571e875ff84SMarcel Holtmann kfree_skb(skb); 3572e875ff84SMarcel Holtmann return 0; 3573e875ff84SMarcel Holtmann } 3574e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3575e875ff84SMarcel Holtmann 35761da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 35771da177e4SLinus Torvalds 35781da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 35791da177e4SLinus Torvalds { 35801da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35811da177e4SLinus Torvalds 3582fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 358300629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3584fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 35851da177e4SLinus Torvalds 35861da177e4SLinus Torvalds return 0; 35871da177e4SLinus Torvalds } 35881da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 35891da177e4SLinus Torvalds 35901da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 35911da177e4SLinus Torvalds { 35921da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35931da177e4SLinus Torvalds 3594fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 35951da177e4SLinus Torvalds list_del(&cb->list); 3596fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 35971da177e4SLinus Torvalds 35981da177e4SLinus Torvalds return 0; 35991da177e4SLinus Torvalds } 36001da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 36011da177e4SLinus Torvalds 360251086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 36031da177e4SLinus Torvalds { 3604cdc52faaSMarcel Holtmann int err; 3605cdc52faaSMarcel Holtmann 36060d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 36071da177e4SLinus Torvalds 36081da177e4SLinus Torvalds /* Time stamp */ 3609a61bbcf2SPatrick McHardy __net_timestamp(skb); 36101da177e4SLinus Torvalds 3611cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3612cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3613cd82e61cSMarcel Holtmann 3614cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3615cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3616470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 36171da177e4SLinus Torvalds } 36181da177e4SLinus Torvalds 36191da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 36201da177e4SLinus Torvalds skb_orphan(skb); 36211da177e4SLinus Torvalds 362273d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 362373d0d3c8SMarcel Holtmann kfree_skb(skb); 362473d0d3c8SMarcel Holtmann return; 362573d0d3c8SMarcel Holtmann } 362673d0d3c8SMarcel Holtmann 3627cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3628cdc52faaSMarcel Holtmann if (err < 0) { 3629cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3630cdc52faaSMarcel Holtmann kfree_skb(skb); 3631cdc52faaSMarcel Holtmann } 36321da177e4SLinus Torvalds } 36331da177e4SLinus Torvalds 36341ca3a9d0SJohan Hedberg /* Send HCI command */ 363507dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 363607dc93ddSJohan Hedberg const void *param) 36371ca3a9d0SJohan Hedberg { 36381ca3a9d0SJohan Hedberg struct sk_buff *skb; 36391ca3a9d0SJohan Hedberg 36401ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 36411ca3a9d0SJohan Hedberg 36421ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 36431ca3a9d0SJohan Hedberg if (!skb) { 36441ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 36451ca3a9d0SJohan Hedberg return -ENOMEM; 36461ca3a9d0SJohan Hedberg } 36471ca3a9d0SJohan Hedberg 364849c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 364911714b3dSJohan Hedberg * single-command requests. 365011714b3dSJohan Hedberg */ 3651db6e3e8dSJohan Hedberg bt_cb(skb)->req.start = true; 365211714b3dSJohan Hedberg 36531da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3654c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 36551da177e4SLinus Torvalds 36561da177e4SLinus Torvalds return 0; 36571da177e4SLinus Torvalds } 36581da177e4SLinus Torvalds 36591da177e4SLinus Torvalds /* Get data from the previously sent command */ 3660a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 36611da177e4SLinus Torvalds { 36621da177e4SLinus Torvalds struct hci_command_hdr *hdr; 36631da177e4SLinus Torvalds 36641da177e4SLinus Torvalds if (!hdev->sent_cmd) 36651da177e4SLinus Torvalds return NULL; 36661da177e4SLinus Torvalds 36671da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 36681da177e4SLinus Torvalds 3669a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 36701da177e4SLinus Torvalds return NULL; 36711da177e4SLinus Torvalds 3672f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 36731da177e4SLinus Torvalds 36741da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 36751da177e4SLinus Torvalds } 36761da177e4SLinus Torvalds 3677fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3678fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3679fbef168fSLoic Poulain const void *param, u32 timeout) 3680fbef168fSLoic Poulain { 3681fbef168fSLoic Poulain struct sk_buff *skb; 3682fbef168fSLoic Poulain 3683fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3684fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3685fbef168fSLoic Poulain 3686fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3687fbef168fSLoic Poulain 3688fbef168fSLoic Poulain hci_req_lock(hdev); 3689fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3690fbef168fSLoic Poulain hci_req_unlock(hdev); 3691fbef168fSLoic Poulain 3692fbef168fSLoic Poulain return skb; 3693fbef168fSLoic Poulain } 3694fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3695fbef168fSLoic Poulain 36961da177e4SLinus Torvalds /* Send ACL data */ 36971da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 36981da177e4SLinus Torvalds { 36991da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 37001da177e4SLinus Torvalds int len = skb->len; 37011da177e4SLinus Torvalds 3702badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3703badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 37049c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3705aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3706aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 37071da177e4SLinus Torvalds } 37081da177e4SLinus Torvalds 3709ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 371073d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 37111da177e4SLinus Torvalds { 3712ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 37131da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37141da177e4SLinus Torvalds struct sk_buff *list; 37151da177e4SLinus Torvalds 3716087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3717087bfd99SGustavo Padovan skb->data_len = 0; 3718087bfd99SGustavo Padovan 3719087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3720204a6e54SAndrei Emeltchenko 3721204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3722204a6e54SAndrei Emeltchenko case HCI_BREDR: 3723087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3724204a6e54SAndrei Emeltchenko break; 3725204a6e54SAndrei Emeltchenko case HCI_AMP: 3726204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3727204a6e54SAndrei Emeltchenko break; 3728204a6e54SAndrei Emeltchenko default: 3729204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3730204a6e54SAndrei Emeltchenko return; 3731204a6e54SAndrei Emeltchenko } 3732087bfd99SGustavo Padovan 373370f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 373470f23020SAndrei Emeltchenko if (!list) { 37351da177e4SLinus Torvalds /* Non fragmented */ 37361da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 37371da177e4SLinus Torvalds 373873d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 37391da177e4SLinus Torvalds } else { 37401da177e4SLinus Torvalds /* Fragmented */ 37411da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37421da177e4SLinus Torvalds 37431da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 37441da177e4SLinus Torvalds 37459cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 37469cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 37479cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 37489cfd5a23SJukka Rissanen * deadlocks. 37499cfd5a23SJukka Rissanen */ 37509cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 37511da177e4SLinus Torvalds 375273d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3753e702112fSAndrei Emeltchenko 3754e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3755e702112fSAndrei Emeltchenko flags |= ACL_CONT; 37561da177e4SLinus Torvalds do { 37571da177e4SLinus Torvalds skb = list; list = list->next; 37581da177e4SLinus Torvalds 37590d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3760e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 37611da177e4SLinus Torvalds 37621da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37631da177e4SLinus Torvalds 376473d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 37651da177e4SLinus Torvalds } while (list); 37661da177e4SLinus Torvalds 37679cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 37681da177e4SLinus Torvalds } 376973d80debSLuiz Augusto von Dentz } 377073d80debSLuiz Augusto von Dentz 377173d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 377273d80debSLuiz Augusto von Dentz { 3773ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 377473d80debSLuiz Augusto von Dentz 3775f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 377673d80debSLuiz Augusto von Dentz 3777ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 37781da177e4SLinus Torvalds 37793eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 37801da177e4SLinus Torvalds } 37811da177e4SLinus Torvalds 37821da177e4SLinus Torvalds /* Send SCO data */ 37830d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 37841da177e4SLinus Torvalds { 37851da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37861da177e4SLinus Torvalds struct hci_sco_hdr hdr; 37871da177e4SLinus Torvalds 37881da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 37891da177e4SLinus Torvalds 3790aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 37911da177e4SLinus Torvalds hdr.dlen = skb->len; 37921da177e4SLinus Torvalds 3793badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3794badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 37959c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 37961da177e4SLinus Torvalds 37970d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3798c78ae283SMarcel Holtmann 37991da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 38003eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 38011da177e4SLinus Torvalds } 38021da177e4SLinus Torvalds 38031da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 38041da177e4SLinus Torvalds 38051da177e4SLinus Torvalds /* HCI Connection scheduler */ 38066039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3807a8c5fb1aSGustavo Padovan int *quote) 38081da177e4SLinus Torvalds { 38091da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38108035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3811abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 38121da177e4SLinus Torvalds 38131da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 38141da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3815bf4c6325SGustavo F. Padovan 3816bf4c6325SGustavo F. Padovan rcu_read_lock(); 3817bf4c6325SGustavo F. Padovan 3818bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3819769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 38201da177e4SLinus Torvalds continue; 3821769be974SMarcel Holtmann 3822769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3823769be974SMarcel Holtmann continue; 3824769be974SMarcel Holtmann 38251da177e4SLinus Torvalds num++; 38261da177e4SLinus Torvalds 38271da177e4SLinus Torvalds if (c->sent < min) { 38281da177e4SLinus Torvalds min = c->sent; 38291da177e4SLinus Torvalds conn = c; 38301da177e4SLinus Torvalds } 383152087a79SLuiz Augusto von Dentz 383252087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 383352087a79SLuiz Augusto von Dentz break; 38341da177e4SLinus Torvalds } 38351da177e4SLinus Torvalds 3836bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3837bf4c6325SGustavo F. Padovan 38381da177e4SLinus Torvalds if (conn) { 38396ed58ec5SVille Tervo int cnt, q; 38406ed58ec5SVille Tervo 38416ed58ec5SVille Tervo switch (conn->type) { 38426ed58ec5SVille Tervo case ACL_LINK: 38436ed58ec5SVille Tervo cnt = hdev->acl_cnt; 38446ed58ec5SVille Tervo break; 38456ed58ec5SVille Tervo case SCO_LINK: 38466ed58ec5SVille Tervo case ESCO_LINK: 38476ed58ec5SVille Tervo cnt = hdev->sco_cnt; 38486ed58ec5SVille Tervo break; 38496ed58ec5SVille Tervo case LE_LINK: 38506ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 38516ed58ec5SVille Tervo break; 38526ed58ec5SVille Tervo default: 38536ed58ec5SVille Tervo cnt = 0; 38546ed58ec5SVille Tervo BT_ERR("Unknown link type"); 38556ed58ec5SVille Tervo } 38566ed58ec5SVille Tervo 38576ed58ec5SVille Tervo q = cnt / num; 38581da177e4SLinus Torvalds *quote = q ? q : 1; 38591da177e4SLinus Torvalds } else 38601da177e4SLinus Torvalds *quote = 0; 38611da177e4SLinus Torvalds 38621da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 38631da177e4SLinus Torvalds return conn; 38641da177e4SLinus Torvalds } 38651da177e4SLinus Torvalds 38666039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 38671da177e4SLinus Torvalds { 38681da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38691da177e4SLinus Torvalds struct hci_conn *c; 38701da177e4SLinus Torvalds 3871bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 38721da177e4SLinus Torvalds 3873bf4c6325SGustavo F. Padovan rcu_read_lock(); 3874bf4c6325SGustavo F. Padovan 38751da177e4SLinus Torvalds /* Kill stalled connections */ 3876bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3877bae1f5d9SVille Tervo if (c->type == type && c->sent) { 38786ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 38796ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3880bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 38811da177e4SLinus Torvalds } 38821da177e4SLinus Torvalds } 3883bf4c6325SGustavo F. Padovan 3884bf4c6325SGustavo F. Padovan rcu_read_unlock(); 38851da177e4SLinus Torvalds } 38861da177e4SLinus Torvalds 38876039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 388873d80debSLuiz Augusto von Dentz int *quote) 388973d80debSLuiz Augusto von Dentz { 389073d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 389173d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3892abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 389373d80debSLuiz Augusto von Dentz struct hci_conn *conn; 389473d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 389573d80debSLuiz Augusto von Dentz 389673d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 389773d80debSLuiz Augusto von Dentz 3898bf4c6325SGustavo F. Padovan rcu_read_lock(); 3899bf4c6325SGustavo F. Padovan 3900bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 390173d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 390273d80debSLuiz Augusto von Dentz 390373d80debSLuiz Augusto von Dentz if (conn->type != type) 390473d80debSLuiz Augusto von Dentz continue; 390573d80debSLuiz Augusto von Dentz 390673d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 390773d80debSLuiz Augusto von Dentz continue; 390873d80debSLuiz Augusto von Dentz 390973d80debSLuiz Augusto von Dentz conn_num++; 391073d80debSLuiz Augusto von Dentz 39118192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 391273d80debSLuiz Augusto von Dentz struct sk_buff *skb; 391373d80debSLuiz Augusto von Dentz 391473d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 391573d80debSLuiz Augusto von Dentz continue; 391673d80debSLuiz Augusto von Dentz 391773d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 391873d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 391973d80debSLuiz Augusto von Dentz continue; 392073d80debSLuiz Augusto von Dentz 392173d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 392273d80debSLuiz Augusto von Dentz num = 0; 392373d80debSLuiz Augusto von Dentz min = ~0; 392473d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 392573d80debSLuiz Augusto von Dentz } 392673d80debSLuiz Augusto von Dentz 392773d80debSLuiz Augusto von Dentz num++; 392873d80debSLuiz Augusto von Dentz 392973d80debSLuiz Augusto von Dentz if (conn->sent < min) { 393073d80debSLuiz Augusto von Dentz min = conn->sent; 393173d80debSLuiz Augusto von Dentz chan = tmp; 393273d80debSLuiz Augusto von Dentz } 393373d80debSLuiz Augusto von Dentz } 393473d80debSLuiz Augusto von Dentz 393573d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 393673d80debSLuiz Augusto von Dentz break; 393773d80debSLuiz Augusto von Dentz } 393873d80debSLuiz Augusto von Dentz 3939bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3940bf4c6325SGustavo F. Padovan 394173d80debSLuiz Augusto von Dentz if (!chan) 394273d80debSLuiz Augusto von Dentz return NULL; 394373d80debSLuiz Augusto von Dentz 394473d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 394573d80debSLuiz Augusto von Dentz case ACL_LINK: 394673d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 394773d80debSLuiz Augusto von Dentz break; 3948bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3949bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3950bd1eb66bSAndrei Emeltchenko break; 395173d80debSLuiz Augusto von Dentz case SCO_LINK: 395273d80debSLuiz Augusto von Dentz case ESCO_LINK: 395373d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 395473d80debSLuiz Augusto von Dentz break; 395573d80debSLuiz Augusto von Dentz case LE_LINK: 395673d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 395773d80debSLuiz Augusto von Dentz break; 395873d80debSLuiz Augusto von Dentz default: 395973d80debSLuiz Augusto von Dentz cnt = 0; 396073d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 396173d80debSLuiz Augusto von Dentz } 396273d80debSLuiz Augusto von Dentz 396373d80debSLuiz Augusto von Dentz q = cnt / num; 396473d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 396573d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 396673d80debSLuiz Augusto von Dentz return chan; 396773d80debSLuiz Augusto von Dentz } 396873d80debSLuiz Augusto von Dentz 396902b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 397002b20f0bSLuiz Augusto von Dentz { 397102b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 397202b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 397302b20f0bSLuiz Augusto von Dentz int num = 0; 397402b20f0bSLuiz Augusto von Dentz 397502b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 397602b20f0bSLuiz Augusto von Dentz 3977bf4c6325SGustavo F. Padovan rcu_read_lock(); 3978bf4c6325SGustavo F. Padovan 3979bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 398002b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 398102b20f0bSLuiz Augusto von Dentz 398202b20f0bSLuiz Augusto von Dentz if (conn->type != type) 398302b20f0bSLuiz Augusto von Dentz continue; 398402b20f0bSLuiz Augusto von Dentz 398502b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 398602b20f0bSLuiz Augusto von Dentz continue; 398702b20f0bSLuiz Augusto von Dentz 398802b20f0bSLuiz Augusto von Dentz num++; 398902b20f0bSLuiz Augusto von Dentz 39908192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 399102b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 399202b20f0bSLuiz Augusto von Dentz 399302b20f0bSLuiz Augusto von Dentz if (chan->sent) { 399402b20f0bSLuiz Augusto von Dentz chan->sent = 0; 399502b20f0bSLuiz Augusto von Dentz continue; 399602b20f0bSLuiz Augusto von Dentz } 399702b20f0bSLuiz Augusto von Dentz 399802b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 399902b20f0bSLuiz Augusto von Dentz continue; 400002b20f0bSLuiz Augusto von Dentz 400102b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 400202b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 400302b20f0bSLuiz Augusto von Dentz continue; 400402b20f0bSLuiz Augusto von Dentz 400502b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 400602b20f0bSLuiz Augusto von Dentz 400702b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 400802b20f0bSLuiz Augusto von Dentz skb->priority); 400902b20f0bSLuiz Augusto von Dentz } 401002b20f0bSLuiz Augusto von Dentz 401102b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 401202b20f0bSLuiz Augusto von Dentz break; 401302b20f0bSLuiz Augusto von Dentz } 4014bf4c6325SGustavo F. Padovan 4015bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4016bf4c6325SGustavo F. Padovan 401702b20f0bSLuiz Augusto von Dentz } 401802b20f0bSLuiz Augusto von Dentz 4019b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4020b71d385aSAndrei Emeltchenko { 4021b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4022b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4023b71d385aSAndrei Emeltchenko } 4024b71d385aSAndrei Emeltchenko 40256039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 40261da177e4SLinus Torvalds { 4027d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 40281da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 40291da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 403063d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 40315f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4032bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 40331da177e4SLinus Torvalds } 403463d2bc1bSAndrei Emeltchenko } 40351da177e4SLinus Torvalds 40366039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 403763d2bc1bSAndrei Emeltchenko { 403863d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 403963d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 404063d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 404163d2bc1bSAndrei Emeltchenko int quote; 404263d2bc1bSAndrei Emeltchenko 404363d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 404404837f64SMarcel Holtmann 404573d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 404673d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4047ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4048ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 404973d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 405073d80debSLuiz Augusto von Dentz skb->len, skb->priority); 405173d80debSLuiz Augusto von Dentz 4052ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4053ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4054ec1cce24SLuiz Augusto von Dentz break; 4055ec1cce24SLuiz Augusto von Dentz 4056ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4057ec1cce24SLuiz Augusto von Dentz 405873d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 405973d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 406004837f64SMarcel Holtmann 406157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40621da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 40631da177e4SLinus Torvalds 40641da177e4SLinus Torvalds hdev->acl_cnt--; 406573d80debSLuiz Augusto von Dentz chan->sent++; 406673d80debSLuiz Augusto von Dentz chan->conn->sent++; 40671da177e4SLinus Torvalds } 40681da177e4SLinus Torvalds } 406902b20f0bSLuiz Augusto von Dentz 407002b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 407102b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 40721da177e4SLinus Torvalds } 40731da177e4SLinus Torvalds 40746039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4075b71d385aSAndrei Emeltchenko { 407663d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4077b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4078b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4079b71d385aSAndrei Emeltchenko int quote; 4080bd1eb66bSAndrei Emeltchenko u8 type; 4081b71d385aSAndrei Emeltchenko 408263d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4083b71d385aSAndrei Emeltchenko 4084bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4085bd1eb66bSAndrei Emeltchenko 4086bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4087bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4088bd1eb66bSAndrei Emeltchenko else 4089bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4090bd1eb66bSAndrei Emeltchenko 4091b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4092bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4093b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4094b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4095b71d385aSAndrei Emeltchenko int blocks; 4096b71d385aSAndrei Emeltchenko 4097b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4098b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4099b71d385aSAndrei Emeltchenko 4100b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4101b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4102b71d385aSAndrei Emeltchenko break; 4103b71d385aSAndrei Emeltchenko 4104b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4105b71d385aSAndrei Emeltchenko 4106b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4107b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4108b71d385aSAndrei Emeltchenko return; 4109b71d385aSAndrei Emeltchenko 4110b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4111b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4112b71d385aSAndrei Emeltchenko 411357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4114b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4115b71d385aSAndrei Emeltchenko 4116b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4117b71d385aSAndrei Emeltchenko quote -= blocks; 4118b71d385aSAndrei Emeltchenko 4119b71d385aSAndrei Emeltchenko chan->sent += blocks; 4120b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4121b71d385aSAndrei Emeltchenko } 4122b71d385aSAndrei Emeltchenko } 4123b71d385aSAndrei Emeltchenko 4124b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4125bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4126b71d385aSAndrei Emeltchenko } 4127b71d385aSAndrei Emeltchenko 41286039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4129b71d385aSAndrei Emeltchenko { 4130b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4131b71d385aSAndrei Emeltchenko 4132bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4133bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 4134bd1eb66bSAndrei Emeltchenko return; 4135bd1eb66bSAndrei Emeltchenko 4136bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4137bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4138b71d385aSAndrei Emeltchenko return; 4139b71d385aSAndrei Emeltchenko 4140b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4141b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4142b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4143b71d385aSAndrei Emeltchenko break; 4144b71d385aSAndrei Emeltchenko 4145b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4146b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4147b71d385aSAndrei Emeltchenko break; 4148b71d385aSAndrei Emeltchenko } 4149b71d385aSAndrei Emeltchenko } 4150b71d385aSAndrei Emeltchenko 41511da177e4SLinus Torvalds /* Schedule SCO */ 41526039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 41531da177e4SLinus Torvalds { 41541da177e4SLinus Torvalds struct hci_conn *conn; 41551da177e4SLinus Torvalds struct sk_buff *skb; 41561da177e4SLinus Torvalds int quote; 41571da177e4SLinus Torvalds 41581da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 41591da177e4SLinus Torvalds 416052087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 416152087a79SLuiz Augusto von Dentz return; 416252087a79SLuiz Augusto von Dentz 41631da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 41641da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 41651da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 416657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41671da177e4SLinus Torvalds 41681da177e4SLinus Torvalds conn->sent++; 41691da177e4SLinus Torvalds if (conn->sent == ~0) 41701da177e4SLinus Torvalds conn->sent = 0; 41711da177e4SLinus Torvalds } 41721da177e4SLinus Torvalds } 41731da177e4SLinus Torvalds } 41741da177e4SLinus Torvalds 41756039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4176b6a0dc82SMarcel Holtmann { 4177b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4178b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4179b6a0dc82SMarcel Holtmann int quote; 4180b6a0dc82SMarcel Holtmann 4181b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4182b6a0dc82SMarcel Holtmann 418352087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 418452087a79SLuiz Augusto von Dentz return; 418552087a79SLuiz Augusto von Dentz 41868fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 41878fc9ced3SGustavo Padovan "e))) { 4188b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4189b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 419057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4191b6a0dc82SMarcel Holtmann 4192b6a0dc82SMarcel Holtmann conn->sent++; 4193b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4194b6a0dc82SMarcel Holtmann conn->sent = 0; 4195b6a0dc82SMarcel Holtmann } 4196b6a0dc82SMarcel Holtmann } 4197b6a0dc82SMarcel Holtmann } 4198b6a0dc82SMarcel Holtmann 41996039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 42006ed58ec5SVille Tervo { 420173d80debSLuiz Augusto von Dentz struct hci_chan *chan; 42026ed58ec5SVille Tervo struct sk_buff *skb; 420302b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 42046ed58ec5SVille Tervo 42056ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 42066ed58ec5SVille Tervo 420752087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 420852087a79SLuiz Augusto von Dentz return; 420952087a79SLuiz Augusto von Dentz 4210d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 42116ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 42126ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4213bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 42146ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4215bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 42166ed58ec5SVille Tervo } 42176ed58ec5SVille Tervo 42186ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 421902b20f0bSLuiz Augusto von Dentz tmp = cnt; 422073d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4221ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4222ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 422373d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 422473d80debSLuiz Augusto von Dentz skb->len, skb->priority); 42256ed58ec5SVille Tervo 4226ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4227ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4228ec1cce24SLuiz Augusto von Dentz break; 4229ec1cce24SLuiz Augusto von Dentz 4230ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4231ec1cce24SLuiz Augusto von Dentz 423257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42336ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 42346ed58ec5SVille Tervo 42356ed58ec5SVille Tervo cnt--; 423673d80debSLuiz Augusto von Dentz chan->sent++; 423773d80debSLuiz Augusto von Dentz chan->conn->sent++; 42386ed58ec5SVille Tervo } 42396ed58ec5SVille Tervo } 424073d80debSLuiz Augusto von Dentz 42416ed58ec5SVille Tervo if (hdev->le_pkts) 42426ed58ec5SVille Tervo hdev->le_cnt = cnt; 42436ed58ec5SVille Tervo else 42446ed58ec5SVille Tervo hdev->acl_cnt = cnt; 424502b20f0bSLuiz Augusto von Dentz 424602b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 424702b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 42486ed58ec5SVille Tervo } 42496ed58ec5SVille Tervo 42503eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 42511da177e4SLinus Torvalds { 42523eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 42531da177e4SLinus Torvalds struct sk_buff *skb; 42541da177e4SLinus Torvalds 42556ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 42566ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 42571da177e4SLinus Torvalds 4258d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 42591da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 42601da177e4SLinus Torvalds hci_sched_acl(hdev); 42611da177e4SLinus Torvalds hci_sched_sco(hdev); 4262b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 42636ed58ec5SVille Tervo hci_sched_le(hdev); 426452de599eSMarcel Holtmann } 42656ed58ec5SVille Tervo 42661da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 42671da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 426857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42691da177e4SLinus Torvalds } 42701da177e4SLinus Torvalds 427125985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 42721da177e4SLinus Torvalds 42731da177e4SLinus Torvalds /* ACL data packet */ 42746039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 42751da177e4SLinus Torvalds { 42761da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 42771da177e4SLinus Torvalds struct hci_conn *conn; 42781da177e4SLinus Torvalds __u16 handle, flags; 42791da177e4SLinus Torvalds 42801da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 42811da177e4SLinus Torvalds 42821da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 42831da177e4SLinus Torvalds flags = hci_flags(handle); 42841da177e4SLinus Torvalds handle = hci_handle(handle); 42851da177e4SLinus Torvalds 4286f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4287a8c5fb1aSGustavo Padovan handle, flags); 42881da177e4SLinus Torvalds 42891da177e4SLinus Torvalds hdev->stat.acl_rx++; 42901da177e4SLinus Torvalds 42911da177e4SLinus Torvalds hci_dev_lock(hdev); 42921da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 42931da177e4SLinus Torvalds hci_dev_unlock(hdev); 42941da177e4SLinus Torvalds 42951da177e4SLinus Torvalds if (conn) { 429665983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 429704837f64SMarcel Holtmann 42981da177e4SLinus Torvalds /* Send to upper protocol */ 4299686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 43001da177e4SLinus Torvalds return; 43011da177e4SLinus Torvalds } else { 43021da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 43031da177e4SLinus Torvalds hdev->name, handle); 43041da177e4SLinus Torvalds } 43051da177e4SLinus Torvalds 43061da177e4SLinus Torvalds kfree_skb(skb); 43071da177e4SLinus Torvalds } 43081da177e4SLinus Torvalds 43091da177e4SLinus Torvalds /* SCO data packet */ 43106039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 43111da177e4SLinus Torvalds { 43121da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 43131da177e4SLinus Torvalds struct hci_conn *conn; 43141da177e4SLinus Torvalds __u16 handle; 43151da177e4SLinus Torvalds 43161da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 43171da177e4SLinus Torvalds 43181da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 43191da177e4SLinus Torvalds 4320f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 43211da177e4SLinus Torvalds 43221da177e4SLinus Torvalds hdev->stat.sco_rx++; 43231da177e4SLinus Torvalds 43241da177e4SLinus Torvalds hci_dev_lock(hdev); 43251da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 43261da177e4SLinus Torvalds hci_dev_unlock(hdev); 43271da177e4SLinus Torvalds 43281da177e4SLinus Torvalds if (conn) { 43291da177e4SLinus Torvalds /* Send to upper protocol */ 4330686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 43311da177e4SLinus Torvalds return; 43321da177e4SLinus Torvalds } else { 43331da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 43341da177e4SLinus Torvalds hdev->name, handle); 43351da177e4SLinus Torvalds } 43361da177e4SLinus Torvalds 43371da177e4SLinus Torvalds kfree_skb(skb); 43381da177e4SLinus Torvalds } 43391da177e4SLinus Torvalds 43409238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 43419238f36aSJohan Hedberg { 43429238f36aSJohan Hedberg struct sk_buff *skb; 43439238f36aSJohan Hedberg 43449238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 43459238f36aSJohan Hedberg if (!skb) 43469238f36aSJohan Hedberg return true; 43479238f36aSJohan Hedberg 4348db6e3e8dSJohan Hedberg return bt_cb(skb)->req.start; 43499238f36aSJohan Hedberg } 43509238f36aSJohan Hedberg 435142c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 435242c6b129SJohan Hedberg { 435342c6b129SJohan Hedberg struct hci_command_hdr *sent; 435442c6b129SJohan Hedberg struct sk_buff *skb; 435542c6b129SJohan Hedberg u16 opcode; 435642c6b129SJohan Hedberg 435742c6b129SJohan Hedberg if (!hdev->sent_cmd) 435842c6b129SJohan Hedberg return; 435942c6b129SJohan Hedberg 436042c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 436142c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 436242c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 436342c6b129SJohan Hedberg return; 436442c6b129SJohan Hedberg 436542c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 436642c6b129SJohan Hedberg if (!skb) 436742c6b129SJohan Hedberg return; 436842c6b129SJohan Hedberg 436942c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 437042c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 437142c6b129SJohan Hedberg } 437242c6b129SJohan Hedberg 4373e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4374e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4375e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 43769238f36aSJohan Hedberg { 43779238f36aSJohan Hedberg struct sk_buff *skb; 43789238f36aSJohan Hedberg unsigned long flags; 43799238f36aSJohan Hedberg 43809238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 43819238f36aSJohan Hedberg 438242c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 438342c6b129SJohan Hedberg * sent we need to do special handling of it. 43849238f36aSJohan Hedberg */ 438542c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 438642c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 438742c6b129SJohan Hedberg * reset complete event during init and any pending 438842c6b129SJohan Hedberg * command will never be completed. In such a case we 438942c6b129SJohan Hedberg * need to resend whatever was the last sent 439042c6b129SJohan Hedberg * command. 439142c6b129SJohan Hedberg */ 439242c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 439342c6b129SJohan Hedberg hci_resend_last(hdev); 439442c6b129SJohan Hedberg 43959238f36aSJohan Hedberg return; 439642c6b129SJohan Hedberg } 43979238f36aSJohan Hedberg 43989238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 43999238f36aSJohan Hedberg * this request the request is not yet complete. 44009238f36aSJohan Hedberg */ 44019238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 44029238f36aSJohan Hedberg return; 44039238f36aSJohan Hedberg 44049238f36aSJohan Hedberg /* If this was the last command in a request the complete 44059238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 44069238f36aSJohan Hedberg * command queue (hdev->cmd_q). 44079238f36aSJohan Hedberg */ 4408e6214487SJohan Hedberg if (bt_cb(hdev->sent_cmd)->req.complete) { 4409e6214487SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->req.complete; 4410e6214487SJohan Hedberg return; 44119238f36aSJohan Hedberg } 4412e6214487SJohan Hedberg 4413e6214487SJohan Hedberg if (bt_cb(hdev->sent_cmd)->req.complete_skb) { 4414e6214487SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->req.complete_skb; 4415e6214487SJohan Hedberg return; 441653e21fbcSJohan Hedberg } 44179238f36aSJohan Hedberg 44189238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 44199238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44209238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 4421db6e3e8dSJohan Hedberg if (bt_cb(skb)->req.start) { 44229238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 44239238f36aSJohan Hedberg break; 44249238f36aSJohan Hedberg } 44259238f36aSJohan Hedberg 4426e6214487SJohan Hedberg *req_complete = bt_cb(skb)->req.complete; 4427e6214487SJohan Hedberg *req_complete_skb = bt_cb(skb)->req.complete_skb; 44289238f36aSJohan Hedberg kfree_skb(skb); 44299238f36aSJohan Hedberg } 44309238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44319238f36aSJohan Hedberg } 44329238f36aSJohan Hedberg 4433b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 44341da177e4SLinus Torvalds { 4435b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 44361da177e4SLinus Torvalds struct sk_buff *skb; 44371da177e4SLinus Torvalds 44381da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 44391da177e4SLinus Torvalds 44401da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4441cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4442cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4443cd82e61cSMarcel Holtmann 44441da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 44451da177e4SLinus Torvalds /* Send copy to the sockets */ 4446470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44471da177e4SLinus Torvalds } 44481da177e4SLinus Torvalds 4449d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 44501da177e4SLinus Torvalds kfree_skb(skb); 44511da177e4SLinus Torvalds continue; 44521da177e4SLinus Torvalds } 44531da177e4SLinus Torvalds 44541da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 44551da177e4SLinus Torvalds /* Don't process data packets in this states. */ 44560d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 44571da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44581da177e4SLinus Torvalds case HCI_SCODATA_PKT: 44591da177e4SLinus Torvalds kfree_skb(skb); 44601da177e4SLinus Torvalds continue; 44613ff50b79SStephen Hemminger } 44621da177e4SLinus Torvalds } 44631da177e4SLinus Torvalds 44641da177e4SLinus Torvalds /* Process frame */ 44650d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 44661da177e4SLinus Torvalds case HCI_EVENT_PKT: 4467b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 44681da177e4SLinus Torvalds hci_event_packet(hdev, skb); 44691da177e4SLinus Torvalds break; 44701da177e4SLinus Torvalds 44711da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44721da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 44731da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 44741da177e4SLinus Torvalds break; 44751da177e4SLinus Torvalds 44761da177e4SLinus Torvalds case HCI_SCODATA_PKT: 44771da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 44781da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 44791da177e4SLinus Torvalds break; 44801da177e4SLinus Torvalds 44811da177e4SLinus Torvalds default: 44821da177e4SLinus Torvalds kfree_skb(skb); 44831da177e4SLinus Torvalds break; 44841da177e4SLinus Torvalds } 44851da177e4SLinus Torvalds } 44861da177e4SLinus Torvalds } 44871da177e4SLinus Torvalds 4488c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 44891da177e4SLinus Torvalds { 4490c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 44911da177e4SLinus Torvalds struct sk_buff *skb; 44921da177e4SLinus Torvalds 44932104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 44942104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 44951da177e4SLinus Torvalds 44961da177e4SLinus Torvalds /* Send queued commands */ 44975a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 44985a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 44995a08ecceSAndrei Emeltchenko if (!skb) 45005a08ecceSAndrei Emeltchenko return; 45015a08ecceSAndrei Emeltchenko 45021da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 45031da177e4SLinus Torvalds 4504a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 450570f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 45061da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 450757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 45087bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 450965cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 45107bdb8a5cSSzymon Janc else 451165cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 451265cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 45131da177e4SLinus Torvalds } else { 45141da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4515c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45161da177e4SLinus Torvalds } 45171da177e4SLinus Torvalds } 45181da177e4SLinus Torvalds } 4519