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 68baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 69baf27f6eSMarcel Holtmann 704b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 714b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 724b4148e9SMarcel Holtmann { 734b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 744b4148e9SMarcel Holtmann char buf[3]; 754b4148e9SMarcel Holtmann 76b7cb93e5SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y': 'N'; 774b4148e9SMarcel Holtmann buf[1] = '\n'; 784b4148e9SMarcel Holtmann buf[2] = '\0'; 794b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 804b4148e9SMarcel Holtmann } 814b4148e9SMarcel Holtmann 824b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 834b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 844b4148e9SMarcel Holtmann { 854b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 864b4148e9SMarcel Holtmann struct sk_buff *skb; 874b4148e9SMarcel Holtmann char buf[32]; 884b4148e9SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 894b4148e9SMarcel Holtmann bool enable; 904b4148e9SMarcel Holtmann 914b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 924b4148e9SMarcel Holtmann return -ENETDOWN; 934b4148e9SMarcel Holtmann 944b4148e9SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 954b4148e9SMarcel Holtmann return -EFAULT; 964b4148e9SMarcel Holtmann 974b4148e9SMarcel Holtmann buf[buf_size] = '\0'; 984b4148e9SMarcel Holtmann if (strtobool(buf, &enable)) 994b4148e9SMarcel Holtmann return -EINVAL; 1004b4148e9SMarcel Holtmann 101b7cb93e5SMarcel Holtmann if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE)) 1024b4148e9SMarcel Holtmann return -EALREADY; 1034b4148e9SMarcel Holtmann 1044b4148e9SMarcel Holtmann hci_req_lock(hdev); 1054b4148e9SMarcel Holtmann if (enable) 1064b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 1074b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1084b4148e9SMarcel Holtmann else 1094b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 1104b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1114b4148e9SMarcel Holtmann hci_req_unlock(hdev); 1124b4148e9SMarcel Holtmann 1134b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1144b4148e9SMarcel Holtmann return PTR_ERR(skb); 1154b4148e9SMarcel Holtmann 1164b4148e9SMarcel Holtmann kfree_skb(skb); 1174b4148e9SMarcel Holtmann 118b7cb93e5SMarcel Holtmann hci_dev_change_flag(hdev, HCI_DUT_MODE); 1194b4148e9SMarcel Holtmann 1204b4148e9SMarcel Holtmann return count; 1214b4148e9SMarcel Holtmann } 1224b4148e9SMarcel Holtmann 1234b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1244b4148e9SMarcel Holtmann .open = simple_open, 1254b4148e9SMarcel Holtmann .read = dut_mode_read, 1264b4148e9SMarcel Holtmann .write = dut_mode_write, 1274b4148e9SMarcel Holtmann .llseek = default_llseek, 1284b4148e9SMarcel Holtmann }; 1294b4148e9SMarcel Holtmann 1304b4113d6SMarcel Holtmann static ssize_t vendor_diag_read(struct file *file, char __user *user_buf, 1314b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1324b4113d6SMarcel Holtmann { 1334b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1344b4113d6SMarcel Holtmann char buf[3]; 1354b4113d6SMarcel Holtmann 1364b4113d6SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y': 'N'; 1374b4113d6SMarcel Holtmann buf[1] = '\n'; 1384b4113d6SMarcel Holtmann buf[2] = '\0'; 1394b4113d6SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 1404b4113d6SMarcel Holtmann } 1414b4113d6SMarcel Holtmann 1424b4113d6SMarcel Holtmann static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf, 1434b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1444b4113d6SMarcel Holtmann { 1454b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1464b4113d6SMarcel Holtmann char buf[32]; 1474b4113d6SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 1484b4113d6SMarcel Holtmann bool enable; 1494b4113d6SMarcel Holtmann int err; 1504b4113d6SMarcel Holtmann 1514b4113d6SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 1524b4113d6SMarcel Holtmann return -EFAULT; 1534b4113d6SMarcel Holtmann 1544b4113d6SMarcel Holtmann buf[buf_size] = '\0'; 1554b4113d6SMarcel Holtmann if (strtobool(buf, &enable)) 1564b4113d6SMarcel Holtmann return -EINVAL; 1574b4113d6SMarcel Holtmann 1587e995b9eSMarcel Holtmann /* When the diagnostic flags are not persistent and the transport 1597e995b9eSMarcel Holtmann * is not active, then there is no need for the vendor callback. 1607e995b9eSMarcel Holtmann * 1617e995b9eSMarcel Holtmann * Instead just store the desired value. If needed the setting 1627e995b9eSMarcel Holtmann * will be programmed when the controller gets powered on. 1637e995b9eSMarcel Holtmann */ 1647e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1657e995b9eSMarcel Holtmann !test_bit(HCI_RUNNING, &hdev->flags)) 1667e995b9eSMarcel Holtmann goto done; 1677e995b9eSMarcel Holtmann 1684b4113d6SMarcel Holtmann hci_req_lock(hdev); 1694b4113d6SMarcel Holtmann err = hdev->set_diag(hdev, enable); 1704b4113d6SMarcel Holtmann hci_req_unlock(hdev); 1714b4113d6SMarcel Holtmann 1724b4113d6SMarcel Holtmann if (err < 0) 1734b4113d6SMarcel Holtmann return err; 1744b4113d6SMarcel Holtmann 1757e995b9eSMarcel Holtmann done: 1764b4113d6SMarcel Holtmann if (enable) 1774b4113d6SMarcel Holtmann hci_dev_set_flag(hdev, HCI_VENDOR_DIAG); 1784b4113d6SMarcel Holtmann else 1794b4113d6SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG); 1804b4113d6SMarcel Holtmann 1814b4113d6SMarcel Holtmann return count; 1824b4113d6SMarcel Holtmann } 1834b4113d6SMarcel Holtmann 1844b4113d6SMarcel Holtmann static const struct file_operations vendor_diag_fops = { 1854b4113d6SMarcel Holtmann .open = simple_open, 1864b4113d6SMarcel Holtmann .read = vendor_diag_read, 1874b4113d6SMarcel Holtmann .write = vendor_diag_write, 1884b4113d6SMarcel Holtmann .llseek = default_llseek, 1894b4113d6SMarcel Holtmann }; 1904b4113d6SMarcel Holtmann 191f640ee98SMarcel Holtmann static void hci_debugfs_create_basic(struct hci_dev *hdev) 192f640ee98SMarcel Holtmann { 193f640ee98SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 194f640ee98SMarcel Holtmann &dut_mode_fops); 195f640ee98SMarcel Holtmann 196f640ee98SMarcel Holtmann if (hdev->set_diag) 197f640ee98SMarcel Holtmann debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev, 198f640ee98SMarcel Holtmann &vendor_diag_fops); 199f640ee98SMarcel Holtmann } 200f640ee98SMarcel Holtmann 2011da177e4SLinus Torvalds /* ---- HCI requests ---- */ 2021da177e4SLinus Torvalds 203f60cb305SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result, u16 opcode, 204f60cb305SJohan Hedberg struct sk_buff *skb) 2051da177e4SLinus Torvalds { 20642c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 20775fb0e32SJohan Hedberg 2081da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 2091da177e4SLinus Torvalds hdev->req_result = result; 2101da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 211f60cb305SJohan Hedberg if (skb) 212f60cb305SJohan Hedberg hdev->req_skb = skb_get(skb); 2131da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 2141da177e4SLinus Torvalds } 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 2181da177e4SLinus Torvalds { 2191da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 2201da177e4SLinus Torvalds 2211da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 2221da177e4SLinus Torvalds hdev->req_result = err; 2231da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 2241da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds 2287b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 22907dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 23075e84b7cSJohan Hedberg { 23175e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 23275e84b7cSJohan Hedberg struct hci_request req; 233f60cb305SJohan Hedberg struct sk_buff *skb; 23475e84b7cSJohan Hedberg int err = 0; 23575e84b7cSJohan Hedberg 23675e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 23775e84b7cSJohan Hedberg 23875e84b7cSJohan Hedberg hci_req_init(&req, hdev); 23975e84b7cSJohan Hedberg 2407b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 24175e84b7cSJohan Hedberg 24275e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 24375e84b7cSJohan Hedberg 24475e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 24575e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 24675e84b7cSJohan Hedberg 247f60cb305SJohan Hedberg err = hci_req_run_skb(&req, hci_req_sync_complete); 248039fada5SChan-yeol Park if (err < 0) { 249039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 25022a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 251039fada5SChan-yeol Park return ERR_PTR(err); 252039fada5SChan-yeol Park } 253039fada5SChan-yeol Park 25475e84b7cSJohan Hedberg schedule_timeout(timeout); 25575e84b7cSJohan Hedberg 25675e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 25775e84b7cSJohan Hedberg 25875e84b7cSJohan Hedberg if (signal_pending(current)) 25975e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 26075e84b7cSJohan Hedberg 26175e84b7cSJohan Hedberg switch (hdev->req_status) { 26275e84b7cSJohan Hedberg case HCI_REQ_DONE: 26375e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 26475e84b7cSJohan Hedberg break; 26575e84b7cSJohan Hedberg 26675e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 26775e84b7cSJohan Hedberg err = -hdev->req_result; 26875e84b7cSJohan Hedberg break; 26975e84b7cSJohan Hedberg 27075e84b7cSJohan Hedberg default: 27175e84b7cSJohan Hedberg err = -ETIMEDOUT; 27275e84b7cSJohan Hedberg break; 27375e84b7cSJohan Hedberg } 27475e84b7cSJohan Hedberg 27575e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 276f60cb305SJohan Hedberg skb = hdev->req_skb; 277f60cb305SJohan Hedberg hdev->req_skb = NULL; 27875e84b7cSJohan Hedberg 27975e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 28075e84b7cSJohan Hedberg 281f60cb305SJohan Hedberg if (err < 0) { 282f60cb305SJohan Hedberg kfree_skb(skb); 28375e84b7cSJohan Hedberg return ERR_PTR(err); 284f60cb305SJohan Hedberg } 28575e84b7cSJohan Hedberg 286757aa0b5SJohan Hedberg if (!skb) 287757aa0b5SJohan Hedberg return ERR_PTR(-ENODATA); 288757aa0b5SJohan Hedberg 289757aa0b5SJohan Hedberg return skb; 2907b1abbbeSJohan Hedberg } 2917b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 2927b1abbbeSJohan Hedberg 2937b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 29407dc93ddSJohan Hedberg const void *param, u32 timeout) 2957b1abbbeSJohan Hedberg { 2967b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 29775e84b7cSJohan Hedberg } 29875e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 29975e84b7cSJohan Hedberg 3001da177e4SLinus Torvalds /* Execute request and wait for completion. */ 30101178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 30242c6b129SJohan Hedberg void (*func)(struct hci_request *req, 30342c6b129SJohan Hedberg unsigned long opt), 3041da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 3051da177e4SLinus Torvalds { 30642c6b129SJohan Hedberg struct hci_request req; 3071da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 3081da177e4SLinus Torvalds int err = 0; 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 3111da177e4SLinus Torvalds 31242c6b129SJohan Hedberg hci_req_init(&req, hdev); 31342c6b129SJohan Hedberg 3141da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 3151da177e4SLinus Torvalds 31642c6b129SJohan Hedberg func(&req, opt); 31753cce22dSJohan Hedberg 318039fada5SChan-yeol Park add_wait_queue(&hdev->req_wait_q, &wait); 319039fada5SChan-yeol Park set_current_state(TASK_INTERRUPTIBLE); 320039fada5SChan-yeol Park 321f60cb305SJohan Hedberg err = hci_req_run_skb(&req, hci_req_sync_complete); 32242c6b129SJohan Hedberg if (err < 0) { 32353cce22dSJohan Hedberg hdev->req_status = 0; 324920c8300SAndre Guedes 325039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 32622a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 327039fada5SChan-yeol Park 328920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 329920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 330920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 331920c8300SAndre Guedes * and should not trigger an error return. 33242c6b129SJohan Hedberg */ 333920c8300SAndre Guedes if (err == -ENODATA) 33442c6b129SJohan Hedberg return 0; 335920c8300SAndre Guedes 336920c8300SAndre Guedes return err; 33753cce22dSJohan Hedberg } 33853cce22dSJohan Hedberg 3391da177e4SLinus Torvalds schedule_timeout(timeout); 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds if (signal_pending(current)) 3441da177e4SLinus Torvalds return -EINTR; 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds switch (hdev->req_status) { 3471da177e4SLinus Torvalds case HCI_REQ_DONE: 348e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 3491da177e4SLinus Torvalds break; 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds case HCI_REQ_CANCELED: 3521da177e4SLinus Torvalds err = -hdev->req_result; 3531da177e4SLinus Torvalds break; 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds default: 3561da177e4SLinus Torvalds err = -ETIMEDOUT; 3571da177e4SLinus Torvalds break; 3583ff50b79SStephen Hemminger } 3591da177e4SLinus Torvalds 360a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds return err; 3651da177e4SLinus Torvalds } 3661da177e4SLinus Torvalds 36701178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 36842c6b129SJohan Hedberg void (*req)(struct hci_request *req, 36942c6b129SJohan Hedberg unsigned long opt), 3701da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 3711da177e4SLinus Torvalds { 3721da177e4SLinus Torvalds int ret; 3731da177e4SLinus Torvalds 3747c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 3757c6a329eSMarcel Holtmann return -ENETDOWN; 3767c6a329eSMarcel Holtmann 3771da177e4SLinus Torvalds /* Serialize all requests */ 3781da177e4SLinus Torvalds hci_req_lock(hdev); 37901178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 3801da177e4SLinus Torvalds hci_req_unlock(hdev); 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds return ret; 3831da177e4SLinus Torvalds } 3841da177e4SLinus Torvalds 38542c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 3861da177e4SLinus Torvalds { 38742c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds /* Reset device */ 39042c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 39142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds 39442c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 3951da177e4SLinus Torvalds { 39642c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 3972455a3eaSAndrei Emeltchenko 3981da177e4SLinus Torvalds /* Read Local Supported Features */ 39942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 4001da177e4SLinus Torvalds 4011143e5a6SMarcel Holtmann /* Read Local Version */ 40242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 4032177bab5SJohan Hedberg 4042177bab5SJohan Hedberg /* Read BD Address */ 40542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 4061da177e4SLinus Torvalds } 4071da177e4SLinus Torvalds 4080af801b9SJohan Hedberg static void amp_init1(struct hci_request *req) 409e61ef499SAndrei Emeltchenko { 41042c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 4112455a3eaSAndrei Emeltchenko 412e61ef499SAndrei Emeltchenko /* Read Local Version */ 41342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 4146bcbc489SAndrei Emeltchenko 415f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 416f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 417f6996cfeSMarcel Holtmann 4186bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 41942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 420e71dfabaSAndrei Emeltchenko 421e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 42242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 4237528ca1cSMarcel Holtmann 424f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 425f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 426f38ba941SMarcel Holtmann 4277528ca1cSMarcel Holtmann /* Read Location Data */ 4287528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 429e61ef499SAndrei Emeltchenko } 430e61ef499SAndrei Emeltchenko 4310af801b9SJohan Hedberg static void amp_init2(struct hci_request *req) 4320af801b9SJohan Hedberg { 4330af801b9SJohan Hedberg /* Read Local Supported Features. Not all AMP controllers 4340af801b9SJohan Hedberg * support this so it's placed conditionally in the second 4350af801b9SJohan Hedberg * stage init. 4360af801b9SJohan Hedberg */ 4370af801b9SJohan Hedberg if (req->hdev->commands[14] & 0x20) 4380af801b9SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 4390af801b9SJohan Hedberg } 4400af801b9SJohan Hedberg 44142c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 442e61ef499SAndrei Emeltchenko { 44342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 444e61ef499SAndrei Emeltchenko 445e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 446e61ef499SAndrei Emeltchenko 44711778716SAndrei Emeltchenko /* Reset */ 44811778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 44942c6b129SJohan Hedberg hci_reset_req(req, 0); 45011778716SAndrei Emeltchenko 451e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 452e61ef499SAndrei Emeltchenko case HCI_BREDR: 45342c6b129SJohan Hedberg bredr_init(req); 454e61ef499SAndrei Emeltchenko break; 455e61ef499SAndrei Emeltchenko 456e61ef499SAndrei Emeltchenko case HCI_AMP: 4570af801b9SJohan Hedberg amp_init1(req); 458e61ef499SAndrei Emeltchenko break; 459e61ef499SAndrei Emeltchenko 460e61ef499SAndrei Emeltchenko default: 461e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 462e61ef499SAndrei Emeltchenko break; 463e61ef499SAndrei Emeltchenko } 464e61ef499SAndrei Emeltchenko } 465e61ef499SAndrei Emeltchenko 46642c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 4672177bab5SJohan Hedberg { 4682177bab5SJohan Hedberg __le16 param; 4692177bab5SJohan Hedberg __u8 flt_type; 4702177bab5SJohan Hedberg 4712177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 47242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 4732177bab5SJohan Hedberg 4742177bab5SJohan Hedberg /* Read Class of Device */ 47542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 4762177bab5SJohan Hedberg 4772177bab5SJohan Hedberg /* Read Local Name */ 47842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 4792177bab5SJohan Hedberg 4802177bab5SJohan Hedberg /* Read Voice Setting */ 48142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 4822177bab5SJohan Hedberg 483b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 484b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 485b4cb9fb2SMarcel Holtmann 4864b836f39SMarcel Holtmann /* Read Current IAC LAP */ 4874b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 4884b836f39SMarcel Holtmann 4892177bab5SJohan Hedberg /* Clear Event Filters */ 4902177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 49142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 4922177bab5SJohan Hedberg 4932177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 494dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 49542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 4962177bab5SJohan Hedberg } 4972177bab5SJohan Hedberg 49842c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 4992177bab5SJohan Hedberg { 500c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 501c73eee91SJohan Hedberg 5022177bab5SJohan Hedberg /* Read LE Buffer Size */ 50342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 5042177bab5SJohan Hedberg 5052177bab5SJohan Hedberg /* Read LE Local Supported Features */ 50642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 5072177bab5SJohan Hedberg 508747d3f03SMarcel Holtmann /* Read LE Supported States */ 509747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 510747d3f03SMarcel Holtmann 511c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 512c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 513a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_LE_ENABLED); 5142177bab5SJohan Hedberg } 5152177bab5SJohan Hedberg 51642c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 5172177bab5SJohan Hedberg { 51842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 51942c6b129SJohan Hedberg 5202177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 5212177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 5222177bab5SJohan Hedberg * command otherwise. 5232177bab5SJohan Hedberg */ 5242177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 5252177bab5SJohan Hedberg 5262177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 5272177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 5282177bab5SJohan Hedberg */ 5292177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 5302177bab5SJohan Hedberg return; 5312177bab5SJohan Hedberg 5322177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 5332177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 534c7882cbdSMarcel Holtmann } else { 535c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 536c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 537c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 538c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 539c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 5405c3d3b4cSMarcel Holtmann 5415c3d3b4cSMarcel Holtmann /* If the controller supports the Disconnect command, enable 5425c3d3b4cSMarcel Holtmann * the corresponding event. In addition enable packet flow 5435c3d3b4cSMarcel Holtmann * control related events. 5445c3d3b4cSMarcel Holtmann */ 5455c3d3b4cSMarcel Holtmann if (hdev->commands[0] & 0x20) { 5465c3d3b4cSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 547c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 548c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 5495c3d3b4cSMarcel Holtmann } 5505c3d3b4cSMarcel Holtmann 5515c3d3b4cSMarcel Holtmann /* If the controller supports the Read Remote Version 5525c3d3b4cSMarcel Holtmann * Information command, enable the corresponding event. 5535c3d3b4cSMarcel Holtmann */ 5545c3d3b4cSMarcel Holtmann if (hdev->commands[2] & 0x80) 5555c3d3b4cSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information 5565c3d3b4cSMarcel Holtmann * Complete 5575c3d3b4cSMarcel Holtmann */ 5580da71f1bSMarcel Holtmann 5590da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 5600da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 561c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5622177bab5SJohan Hedberg } 5630da71f1bSMarcel Holtmann } 5642177bab5SJohan Hedberg 5659fe759ceSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 5669fe759ceSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) 5672177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 5682177bab5SJohan Hedberg 56970f56aa2SMarcel Holtmann if (lmp_ext_feat_capable(hdev)) 57070f56aa2SMarcel Holtmann events[4] |= 0x04; /* Read Remote Extended Features Complete */ 57170f56aa2SMarcel Holtmann 57270f56aa2SMarcel Holtmann if (lmp_esco_capable(hdev)) { 57370f56aa2SMarcel Holtmann events[5] |= 0x08; /* Synchronous Connection Complete */ 57470f56aa2SMarcel Holtmann events[5] |= 0x10; /* Synchronous Connection Changed */ 57570f56aa2SMarcel Holtmann } 57670f56aa2SMarcel Holtmann 5772177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 5782177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 5792177bab5SJohan Hedberg 5802177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 5812177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5822177bab5SJohan Hedberg 5832177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 5842177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 5852177bab5SJohan Hedberg 5862177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 5872177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 5882177bab5SJohan Hedberg 5892177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 5902177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 5912177bab5SJohan Hedberg 5922177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 5932177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 5942177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 5952177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 5962177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 5972177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 5982177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 5992177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 6002177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 6012177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 6022177bab5SJohan Hedberg * Features Notification 6032177bab5SJohan Hedberg */ 6042177bab5SJohan Hedberg } 6052177bab5SJohan Hedberg 6062177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 6072177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 6082177bab5SJohan Hedberg 60942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 6102177bab5SJohan Hedberg } 6112177bab5SJohan Hedberg 61242c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 6132177bab5SJohan Hedberg { 61442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 61542c6b129SJohan Hedberg 6160af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 6170af801b9SJohan Hedberg return amp_init2(req); 6180af801b9SJohan Hedberg 6192177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 62042c6b129SJohan Hedberg bredr_setup(req); 62156f87901SJohan Hedberg else 622a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 6232177bab5SJohan Hedberg 6242177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 62542c6b129SJohan Hedberg le_setup(req); 6262177bab5SJohan Hedberg 6270f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 6280f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 6290f3adeaeSMarcel Holtmann * 6300f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 6310f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 6320f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 6330f3adeaeSMarcel Holtmann * supported commands. 6343f8e2d75SJohan Hedberg */ 6350f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 6360f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 63742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 6382177bab5SJohan Hedberg 6392177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 64057af75a8SMarcel Holtmann /* When SSP is available, then the host features page 64157af75a8SMarcel Holtmann * should also be available as well. However some 64257af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 64357af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 64457af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 64557af75a8SMarcel Holtmann */ 64657af75a8SMarcel Holtmann hdev->max_page = 0x01; 64757af75a8SMarcel Holtmann 648d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 6492177bab5SJohan Hedberg u8 mode = 0x01; 650574ea3c7SMarcel Holtmann 65142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 6522177bab5SJohan Hedberg sizeof(mode), &mode); 6532177bab5SJohan Hedberg } else { 6542177bab5SJohan Hedberg struct hci_cp_write_eir cp; 6552177bab5SJohan Hedberg 6562177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 6572177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6582177bab5SJohan Hedberg 65942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 6602177bab5SJohan Hedberg } 6612177bab5SJohan Hedberg } 6622177bab5SJohan Hedberg 663043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 664043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 66504422da9SMarcel Holtmann u8 mode; 66604422da9SMarcel Holtmann 66704422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 66804422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 66904422da9SMarcel Holtmann * events. 67004422da9SMarcel Holtmann */ 67104422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 67204422da9SMarcel Holtmann 67304422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 67404422da9SMarcel Holtmann } 6752177bab5SJohan Hedberg 6762177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 67742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 6782177bab5SJohan Hedberg 6792177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 6802177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 6812177bab5SJohan Hedberg 6822177bab5SJohan Hedberg cp.page = 0x01; 68342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 68442c6b129SJohan Hedberg sizeof(cp), &cp); 6852177bab5SJohan Hedberg } 6862177bab5SJohan Hedberg 687d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 6882177bab5SJohan Hedberg u8 enable = 1; 68942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 6902177bab5SJohan Hedberg &enable); 6912177bab5SJohan Hedberg } 6922177bab5SJohan Hedberg } 6932177bab5SJohan Hedberg 69442c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 6952177bab5SJohan Hedberg { 69642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6972177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 6982177bab5SJohan Hedberg u16 link_policy = 0; 6992177bab5SJohan Hedberg 7002177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 7012177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 7022177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 7032177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 7042177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 7052177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 7062177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 7072177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 7082177bab5SJohan Hedberg 7092177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 71042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 7112177bab5SJohan Hedberg } 7122177bab5SJohan Hedberg 71342c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 7142177bab5SJohan Hedberg { 71542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 7162177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 7172177bab5SJohan Hedberg 718c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 719c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 720c73eee91SJohan Hedberg return; 721c73eee91SJohan Hedberg 7222177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 7232177bab5SJohan Hedberg 724d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 7252177bab5SJohan Hedberg cp.le = 0x01; 72632226e4fSMarcel Holtmann cp.simul = 0x00; 7272177bab5SJohan Hedberg } 7282177bab5SJohan Hedberg 7292177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 73042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 7312177bab5SJohan Hedberg &cp); 7322177bab5SJohan Hedberg } 7332177bab5SJohan Hedberg 734d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 735d62e6d67SJohan Hedberg { 736d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 737d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 738d62e6d67SJohan Hedberg 739d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 740d62e6d67SJohan Hedberg * enable all necessary events for it. 741d62e6d67SJohan Hedberg */ 74253b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 743d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 744d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 745d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 746d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 747d62e6d67SJohan Hedberg } 748d62e6d67SJohan Hedberg 749d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 750d62e6d67SJohan Hedberg * enable all necessary events for it. 751d62e6d67SJohan Hedberg */ 75253b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 753d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 754d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 755d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 756d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 757d62e6d67SJohan Hedberg } 758d62e6d67SJohan Hedberg 75940c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 760cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 76140c59fcbSMarcel Holtmann events[2] |= 0x80; 76240c59fcbSMarcel Holtmann 763d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 764d62e6d67SJohan Hedberg } 765d62e6d67SJohan Hedberg 76642c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 7672177bab5SJohan Hedberg { 76842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 769d2c5d77fSJohan Hedberg u8 p; 77042c6b129SJohan Hedberg 7710da71f1bSMarcel Holtmann hci_setup_event_mask(req); 7720da71f1bSMarcel Holtmann 773e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 774e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 77548ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 77648ce62c4SMarcel Holtmann 77748ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 77848ce62c4SMarcel Holtmann cp.read_all = 0x01; 77948ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 78048ce62c4SMarcel Holtmann } 78148ce62c4SMarcel Holtmann 7822177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 78342c6b129SJohan Hedberg hci_setup_link_policy(req); 7842177bab5SJohan Hedberg 785417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 786417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 787417287deSMarcel Holtmann 788417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 789417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 790417287deSMarcel Holtmann * this command in the bit mask of supported commands. 791417287deSMarcel Holtmann */ 792417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 793417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 794417287deSMarcel Holtmann 7959193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 7969193c6e8SAndre Guedes u8 events[8]; 7979193c6e8SAndre Guedes 7989193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 7994d6c705bSMarcel Holtmann 8004d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 8014d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 802662bc2e6SAndre Guedes 803662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 804662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 805662bc2e6SAndre Guedes */ 806662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 807662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 808662bc2e6SAndre Guedes * Parameter Request 809662bc2e6SAndre Guedes */ 810662bc2e6SAndre Guedes 811a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 812a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 813a9f6068eSMarcel Holtmann */ 814a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 815a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 816a9f6068eSMarcel Holtmann 8174b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 8184b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 8194b71bba4SMarcel Holtmann */ 8204b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 8214b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 8224b71bba4SMarcel Holtmann * Report 8234b71bba4SMarcel Holtmann */ 8244b71bba4SMarcel Holtmann 8257d26f5c4SMarcel Holtmann /* If the controller supports the LE Set Scan Enable command, 8267d26f5c4SMarcel Holtmann * enable the corresponding advertising report event. 8277d26f5c4SMarcel Holtmann */ 8287d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x08) 8297d26f5c4SMarcel Holtmann events[0] |= 0x02; /* LE Advertising Report */ 8307d26f5c4SMarcel Holtmann 8317d26f5c4SMarcel Holtmann /* If the controller supports the LE Create Connection 8327d26f5c4SMarcel Holtmann * command, enable the corresponding event. 8337d26f5c4SMarcel Holtmann */ 8347d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x10) 8357d26f5c4SMarcel Holtmann events[0] |= 0x01; /* LE Connection Complete */ 8367d26f5c4SMarcel Holtmann 8377d26f5c4SMarcel Holtmann /* If the controller supports the LE Connection Update 8387d26f5c4SMarcel Holtmann * command, enable the corresponding event. 8397d26f5c4SMarcel Holtmann */ 8407d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x04) 8417d26f5c4SMarcel Holtmann events[0] |= 0x04; /* LE Connection Update 8427d26f5c4SMarcel Holtmann * Complete 8437d26f5c4SMarcel Holtmann */ 8447d26f5c4SMarcel Holtmann 8457d26f5c4SMarcel Holtmann /* If the controller supports the LE Read Remote Used Features 8467d26f5c4SMarcel Holtmann * command, enable the corresponding event. 8477d26f5c4SMarcel Holtmann */ 8487d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x20) 8497d26f5c4SMarcel Holtmann events[0] |= 0x08; /* LE Read Remote Used 8507d26f5c4SMarcel Holtmann * Features Complete 8517d26f5c4SMarcel Holtmann */ 8527d26f5c4SMarcel Holtmann 8535a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 8545a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 8555a34bd5fSMarcel Holtmann */ 8565a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 8575a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 8585a34bd5fSMarcel Holtmann * Public Key Complete 8595a34bd5fSMarcel Holtmann */ 8605a34bd5fSMarcel Holtmann 8615a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 8625a34bd5fSMarcel Holtmann * command, enable the corresponding event. 8635a34bd5fSMarcel Holtmann */ 8645a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 8655a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 8665a34bd5fSMarcel Holtmann 8679193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 8689193c6e8SAndre Guedes events); 8699193c6e8SAndre Guedes 87015a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 87115a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 87215a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 87315a49ccaSMarcel Holtmann } 87415a49ccaSMarcel Holtmann 8752ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 8762ab216a7SMarcel Holtmann /* Read LE White List Size */ 8772ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 8782ab216a7SMarcel Holtmann 0, NULL); 8792ab216a7SMarcel Holtmann } 8802ab216a7SMarcel Holtmann 8812ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 8822ab216a7SMarcel Holtmann /* Clear LE White List */ 8832ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 8842ab216a7SMarcel Holtmann } 8852ab216a7SMarcel Holtmann 886a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 887a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 888a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 889a9f6068eSMarcel Holtmann 890a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 891a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 892a9f6068eSMarcel Holtmann } 893a9f6068eSMarcel Holtmann 89442c6b129SJohan Hedberg hci_set_le_support(req); 8959193c6e8SAndre Guedes } 896d2c5d77fSJohan Hedberg 897d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 898d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 899d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 900d2c5d77fSJohan Hedberg 901d2c5d77fSJohan Hedberg cp.page = p; 902d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 903d2c5d77fSJohan Hedberg sizeof(cp), &cp); 904d2c5d77fSJohan Hedberg } 9052177bab5SJohan Hedberg } 9062177bab5SJohan Hedberg 9075d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 9085d4e7e8dSJohan Hedberg { 9095d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 9105d4e7e8dSJohan Hedberg 91136f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 91236f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 91336f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 91436f260ceSMarcel Holtmann * 91536f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 91636f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 91736f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 91836f260ceSMarcel Holtmann * command redundant anyway. 91936f260ceSMarcel Holtmann * 92036f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 92136f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 92236f260ceSMarcel Holtmann * just disable this command. 92336f260ceSMarcel Holtmann */ 92436f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 92536f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 92636f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 92736f260ceSMarcel Holtmann 92836f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 92936f260ceSMarcel Holtmann cp.delete_all = 0x01; 93036f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 93136f260ceSMarcel Holtmann sizeof(cp), &cp); 93236f260ceSMarcel Holtmann } 93336f260ceSMarcel Holtmann 934d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 935d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 936d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 937d62e6d67SJohan Hedberg 938109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 939109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 940109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 941109e3191SMarcel Holtmann 942f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 943f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 944f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 945f4fe73edSMarcel Holtmann 9465d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 94753b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 9485d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 949a6d0d690SMarcel Holtmann 950a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 951d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 952574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 953a6d0d690SMarcel Holtmann u8 support = 0x01; 954574ea3c7SMarcel Holtmann 955a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 956a6d0d690SMarcel Holtmann sizeof(support), &support); 957a6d0d690SMarcel Holtmann } 9585d4e7e8dSJohan Hedberg } 9595d4e7e8dSJohan Hedberg 9602177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 9612177bab5SJohan Hedberg { 9622177bab5SJohan Hedberg int err; 9632177bab5SJohan Hedberg 9642177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 9652177bab5SJohan Hedberg if (err < 0) 9662177bab5SJohan Hedberg return err; 9672177bab5SJohan Hedberg 968f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 969f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 9704b4148e9SMarcel Holtmann 9712177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 9722177bab5SJohan Hedberg if (err < 0) 9732177bab5SJohan Hedberg return err; 9742177bab5SJohan Hedberg 9750af801b9SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 9760af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 9770af801b9SJohan Hedberg * first two stages of init. 9780af801b9SJohan Hedberg */ 9790af801b9SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 9800af801b9SJohan Hedberg return 0; 9810af801b9SJohan Hedberg 9825d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 9835d4e7e8dSJohan Hedberg if (err < 0) 9845d4e7e8dSJohan Hedberg return err; 9855d4e7e8dSJohan Hedberg 986baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 987baf27f6eSMarcel Holtmann if (err < 0) 988baf27f6eSMarcel Holtmann return err; 989baf27f6eSMarcel Holtmann 990ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 991ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 992ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 993ec6cef9cSMarcel Holtmann * 994ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 995ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 996ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 997ec6cef9cSMarcel Holtmann * be called during the config phase. 998ec6cef9cSMarcel Holtmann * 999ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 1000ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 1001baf27f6eSMarcel Holtmann */ 1002d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1003d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 1004baf27f6eSMarcel Holtmann return 0; 1005baf27f6eSMarcel Holtmann 100660c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 100760c5f5fbSMarcel Holtmann 100871c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 100960c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 10102bfa3531SMarcel Holtmann 1011162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 101260c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 1013e7b8fc92SMarcel Holtmann 1014baf27f6eSMarcel Holtmann return 0; 10152177bab5SJohan Hedberg } 10162177bab5SJohan Hedberg 10170ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 10180ebca7d6SMarcel Holtmann { 10190ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 10200ebca7d6SMarcel Holtmann 10210ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 10220ebca7d6SMarcel Holtmann 10230ebca7d6SMarcel Holtmann /* Reset */ 10240ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 10250ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 10260ebca7d6SMarcel Holtmann 10270ebca7d6SMarcel Holtmann /* Read Local Version */ 10280ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 10290ebca7d6SMarcel Holtmann 10300ebca7d6SMarcel Holtmann /* Read BD Address */ 10310ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 10320ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 10330ebca7d6SMarcel Holtmann } 10340ebca7d6SMarcel Holtmann 10350ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 10360ebca7d6SMarcel Holtmann { 10370ebca7d6SMarcel Holtmann int err; 10380ebca7d6SMarcel Holtmann 1039cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1040cc78b44bSMarcel Holtmann return 0; 1041cc78b44bSMarcel Holtmann 10420ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 10430ebca7d6SMarcel Holtmann if (err < 0) 10440ebca7d6SMarcel Holtmann return err; 10450ebca7d6SMarcel Holtmann 1046f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 1047f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 1048f640ee98SMarcel Holtmann 10490ebca7d6SMarcel Holtmann return 0; 10500ebca7d6SMarcel Holtmann } 10510ebca7d6SMarcel Holtmann 105242c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 10531da177e4SLinus Torvalds { 10541da177e4SLinus Torvalds __u8 scan = opt; 10551da177e4SLinus Torvalds 105642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds /* Inquiry and Page scans */ 105942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 10601da177e4SLinus Torvalds } 10611da177e4SLinus Torvalds 106242c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 10631da177e4SLinus Torvalds { 10641da177e4SLinus Torvalds __u8 auth = opt; 10651da177e4SLinus Torvalds 106642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 10671da177e4SLinus Torvalds 10681da177e4SLinus Torvalds /* Authentication */ 106942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 10701da177e4SLinus Torvalds } 10711da177e4SLinus Torvalds 107242c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 10731da177e4SLinus Torvalds { 10741da177e4SLinus Torvalds __u8 encrypt = opt; 10751da177e4SLinus Torvalds 107642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 10771da177e4SLinus Torvalds 1078e4e8e37cSMarcel Holtmann /* Encryption */ 107942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 10801da177e4SLinus Torvalds } 10811da177e4SLinus Torvalds 108242c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1083e4e8e37cSMarcel Holtmann { 1084e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1085e4e8e37cSMarcel Holtmann 108642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1087e4e8e37cSMarcel Holtmann 1088e4e8e37cSMarcel Holtmann /* Default link policy */ 108942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1090e4e8e37cSMarcel Holtmann } 1091e4e8e37cSMarcel Holtmann 10921da177e4SLinus Torvalds /* Get HCI device by index. 10931da177e4SLinus Torvalds * Device is held on return. */ 10941da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10951da177e4SLinus Torvalds { 10968035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10971da177e4SLinus Torvalds 10981da177e4SLinus Torvalds BT_DBG("%d", index); 10991da177e4SLinus Torvalds 11001da177e4SLinus Torvalds if (index < 0) 11011da177e4SLinus Torvalds return NULL; 11021da177e4SLinus Torvalds 11031da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 11048035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 11051da177e4SLinus Torvalds if (d->id == index) { 11061da177e4SLinus Torvalds hdev = hci_dev_hold(d); 11071da177e4SLinus Torvalds break; 11081da177e4SLinus Torvalds } 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 11111da177e4SLinus Torvalds return hdev; 11121da177e4SLinus Torvalds } 11131da177e4SLinus Torvalds 11141da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1115ff9ef578SJohan Hedberg 111630dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 111730dc78e1SJohan Hedberg { 111830dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 111930dc78e1SJohan Hedberg 11206fbe195dSAndre Guedes switch (discov->state) { 1121343f935bSAndre Guedes case DISCOVERY_FINDING: 11226fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 112330dc78e1SJohan Hedberg return true; 112430dc78e1SJohan Hedberg 11256fbe195dSAndre Guedes default: 112630dc78e1SJohan Hedberg return false; 112730dc78e1SJohan Hedberg } 11286fbe195dSAndre Guedes } 112930dc78e1SJohan Hedberg 1130ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1131ff9ef578SJohan Hedberg { 1132bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1133bb3e0a33SJohan Hedberg 1134ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1135ff9ef578SJohan Hedberg 1136bb3e0a33SJohan Hedberg if (old_state == state) 1137ff9ef578SJohan Hedberg return; 1138ff9ef578SJohan Hedberg 1139bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1140bb3e0a33SJohan Hedberg 1141ff9ef578SJohan Hedberg switch (state) { 1142ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1143c54c3860SAndre Guedes hci_update_background_scan(hdev); 1144c54c3860SAndre Guedes 1145bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1146ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1147ff9ef578SJohan Hedberg break; 1148ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1149ff9ef578SJohan Hedberg break; 1150343f935bSAndre Guedes case DISCOVERY_FINDING: 1151ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1152ff9ef578SJohan Hedberg break; 115330dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 115430dc78e1SJohan Hedberg break; 1155ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1156ff9ef578SJohan Hedberg break; 1157ff9ef578SJohan Hedberg } 1158ff9ef578SJohan Hedberg } 1159ff9ef578SJohan Hedberg 11601f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 11611da177e4SLinus Torvalds { 116230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1163b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 11641da177e4SLinus Torvalds 1165561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1166561aafbcSJohan Hedberg list_del(&p->all); 1167b57c1a56SJohan Hedberg kfree(p); 11681da177e4SLinus Torvalds } 1169561aafbcSJohan Hedberg 1170561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1171561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds 1174a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1175a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 11761da177e4SLinus Torvalds { 117730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11781da177e4SLinus Torvalds struct inquiry_entry *e; 11791da177e4SLinus Torvalds 11806ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 11811da177e4SLinus Torvalds 1182561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11831da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 11841da177e4SLinus Torvalds return e; 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds 1187b57c1a56SJohan Hedberg return NULL; 1188b57c1a56SJohan Hedberg } 1189b57c1a56SJohan Hedberg 1190561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1191561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1192561aafbcSJohan Hedberg { 119330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1194561aafbcSJohan Hedberg struct inquiry_entry *e; 1195561aafbcSJohan Hedberg 11966ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1197561aafbcSJohan Hedberg 1198561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1199561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1200561aafbcSJohan Hedberg return e; 1201561aafbcSJohan Hedberg } 1202561aafbcSJohan Hedberg 1203561aafbcSJohan Hedberg return NULL; 1204561aafbcSJohan Hedberg } 1205561aafbcSJohan Hedberg 120630dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 120730dc78e1SJohan Hedberg bdaddr_t *bdaddr, 120830dc78e1SJohan Hedberg int state) 120930dc78e1SJohan Hedberg { 121030dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 121130dc78e1SJohan Hedberg struct inquiry_entry *e; 121230dc78e1SJohan Hedberg 12136ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 121430dc78e1SJohan Hedberg 121530dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 121630dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 121730dc78e1SJohan Hedberg return e; 121830dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 121930dc78e1SJohan Hedberg return e; 122030dc78e1SJohan Hedberg } 122130dc78e1SJohan Hedberg 122230dc78e1SJohan Hedberg return NULL; 122330dc78e1SJohan Hedberg } 122430dc78e1SJohan Hedberg 1225a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1226a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1227a3d4e20aSJohan Hedberg { 1228a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1229a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1230a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1231a3d4e20aSJohan Hedberg 1232a3d4e20aSJohan Hedberg list_del(&ie->list); 1233a3d4e20aSJohan Hedberg 1234a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1235a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1236a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1237a3d4e20aSJohan Hedberg break; 1238a3d4e20aSJohan Hedberg pos = &p->list; 1239a3d4e20aSJohan Hedberg } 1240a3d4e20aSJohan Hedberg 1241a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1242a3d4e20aSJohan Hedberg } 1243a3d4e20aSJohan Hedberg 1244af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1245af58925cSMarcel Holtmann bool name_known) 12461da177e4SLinus Torvalds { 124730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 124870f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1249af58925cSMarcel Holtmann u32 flags = 0; 12501da177e4SLinus Torvalds 12516ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 12521da177e4SLinus Torvalds 12536928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 12542b2fec4dSSzymon Janc 1255af58925cSMarcel Holtmann if (!data->ssp_mode) 1256af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1257388fc8faSJohan Hedberg 125870f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1259a3d4e20aSJohan Hedberg if (ie) { 1260af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1261af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1262388fc8faSJohan Hedberg 1263a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1264a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1265a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1266a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1267a3d4e20aSJohan Hedberg } 1268a3d4e20aSJohan Hedberg 1269561aafbcSJohan Hedberg goto update; 1270a3d4e20aSJohan Hedberg } 1271561aafbcSJohan Hedberg 12721da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 127327f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1274af58925cSMarcel Holtmann if (!ie) { 1275af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1276af58925cSMarcel Holtmann goto done; 1277af58925cSMarcel Holtmann } 127870f23020SAndrei Emeltchenko 1279561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1280561aafbcSJohan Hedberg 1281561aafbcSJohan Hedberg if (name_known) { 1282561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1283561aafbcSJohan Hedberg } else { 1284561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1285561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1286561aafbcSJohan Hedberg } 1287561aafbcSJohan Hedberg 1288561aafbcSJohan Hedberg update: 1289561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1290561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1291561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1292561aafbcSJohan Hedberg list_del(&ie->list); 12931da177e4SLinus Torvalds } 12941da177e4SLinus Torvalds 129570f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 129670f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12971da177e4SLinus Torvalds cache->timestamp = jiffies; 12983175405bSJohan Hedberg 12993175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1300af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 13013175405bSJohan Hedberg 1302af58925cSMarcel Holtmann done: 1303af58925cSMarcel Holtmann return flags; 13041da177e4SLinus Torvalds } 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 13071da177e4SLinus Torvalds { 130830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 13091da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 13101da177e4SLinus Torvalds struct inquiry_entry *e; 13111da177e4SLinus Torvalds int copied = 0; 13121da177e4SLinus Torvalds 1313561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 13141da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1315b57c1a56SJohan Hedberg 1316b57c1a56SJohan Hedberg if (copied >= num) 1317b57c1a56SJohan Hedberg break; 1318b57c1a56SJohan Hedberg 13191da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 13201da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 13211da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 13221da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 13231da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 13241da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1325b57c1a56SJohan Hedberg 13261da177e4SLinus Torvalds info++; 1327b57c1a56SJohan Hedberg copied++; 13281da177e4SLinus Torvalds } 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 13311da177e4SLinus Torvalds return copied; 13321da177e4SLinus Torvalds } 13331da177e4SLinus Torvalds 133442c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 13351da177e4SLinus Torvalds { 13361da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 133742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 13381da177e4SLinus Torvalds struct hci_cp_inquiry cp; 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 13411da177e4SLinus Torvalds 13421da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 13431da177e4SLinus Torvalds return; 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds /* Start Inquiry */ 13461da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 13471da177e4SLinus Torvalds cp.length = ir->length; 13481da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 134942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 13501da177e4SLinus Torvalds } 13511da177e4SLinus Torvalds 13521da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 13531da177e4SLinus Torvalds { 13541da177e4SLinus Torvalds __u8 __user *ptr = arg; 13551da177e4SLinus Torvalds struct hci_inquiry_req ir; 13561da177e4SLinus Torvalds struct hci_dev *hdev; 13571da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 13581da177e4SLinus Torvalds long timeo; 13591da177e4SLinus Torvalds __u8 *buf; 13601da177e4SLinus Torvalds 13611da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 13621da177e4SLinus Torvalds return -EFAULT; 13631da177e4SLinus Torvalds 13645a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 13655a08ecceSAndrei Emeltchenko if (!hdev) 13661da177e4SLinus Torvalds return -ENODEV; 13671da177e4SLinus Torvalds 1368d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 13690736cfa8SMarcel Holtmann err = -EBUSY; 13700736cfa8SMarcel Holtmann goto done; 13710736cfa8SMarcel Holtmann } 13720736cfa8SMarcel Holtmann 1373d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1374fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1375fee746b0SMarcel Holtmann goto done; 1376fee746b0SMarcel Holtmann } 1377fee746b0SMarcel Holtmann 13785b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 13795b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 13805b69bef5SMarcel Holtmann goto done; 13815b69bef5SMarcel Holtmann } 13825b69bef5SMarcel Holtmann 1383d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 138456f87901SJohan Hedberg err = -EOPNOTSUPP; 138556f87901SJohan Hedberg goto done; 138656f87901SJohan Hedberg } 138756f87901SJohan Hedberg 138809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13891da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1390a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13911f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13921da177e4SLinus Torvalds do_inquiry = 1; 13931da177e4SLinus Torvalds } 139409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13951da177e4SLinus Torvalds 139604837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 139770f23020SAndrei Emeltchenko 139870f23020SAndrei Emeltchenko if (do_inquiry) { 139901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 140001178cd4SJohan Hedberg timeo); 140170f23020SAndrei Emeltchenko if (err < 0) 14021da177e4SLinus Torvalds goto done; 14033e13fa1eSAndre Guedes 14043e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 14053e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 14063e13fa1eSAndre Guedes */ 140774316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 14083e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 14093e13fa1eSAndre Guedes return -EINTR; 141070f23020SAndrei Emeltchenko } 14111da177e4SLinus Torvalds 14128fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 14138fc9ced3SGustavo Padovan * 255 entries 14148fc9ced3SGustavo Padovan */ 14151da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 14161da177e4SLinus Torvalds 14171da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 14181da177e4SLinus Torvalds * copy it to the user space. 14191da177e4SLinus Torvalds */ 142070f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 142170f23020SAndrei Emeltchenko if (!buf) { 14221da177e4SLinus Torvalds err = -ENOMEM; 14231da177e4SLinus Torvalds goto done; 14241da177e4SLinus Torvalds } 14251da177e4SLinus Torvalds 142609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14271da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 142809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 14291da177e4SLinus Torvalds 14301da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 14311da177e4SLinus Torvalds 14321da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 14331da177e4SLinus Torvalds ptr += sizeof(ir); 14341da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 14351da177e4SLinus Torvalds ir.num_rsp)) 14361da177e4SLinus Torvalds err = -EFAULT; 14371da177e4SLinus Torvalds } else 14381da177e4SLinus Torvalds err = -EFAULT; 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds kfree(buf); 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds done: 14431da177e4SLinus Torvalds hci_dev_put(hdev); 14441da177e4SLinus Torvalds return err; 14451da177e4SLinus Torvalds } 14461da177e4SLinus Torvalds 1447cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 14481da177e4SLinus Torvalds { 14491da177e4SLinus Torvalds int ret = 0; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds hci_req_lock(hdev); 14541da177e4SLinus Torvalds 1455d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 145694324962SJohan Hovold ret = -ENODEV; 145794324962SJohan Hovold goto done; 145894324962SJohan Hovold } 145994324962SJohan Hovold 1460d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1461d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1462a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1463a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1464bf543036SJohan Hedberg */ 1465d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1466611b30f7SMarcel Holtmann ret = -ERFKILL; 1467611b30f7SMarcel Holtmann goto done; 1468611b30f7SMarcel Holtmann } 1469611b30f7SMarcel Holtmann 1470a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1471a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1472a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1473a5c8f270SMarcel Holtmann * or not. 1474a5c8f270SMarcel Holtmann * 1475c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1476c6beca0eSMarcel Holtmann * if a public address or static random address is 1477c6beca0eSMarcel Holtmann * available. 1478c6beca0eSMarcel Holtmann * 1479a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1480a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1481a5c8f270SMarcel Holtmann */ 1482d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1483c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 1484a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1485a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1486a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1487a5c8f270SMarcel Holtmann goto done; 1488a5c8f270SMarcel Holtmann } 1489a5c8f270SMarcel Holtmann } 1490a5c8f270SMarcel Holtmann 14911da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14921da177e4SLinus Torvalds ret = -EALREADY; 14931da177e4SLinus Torvalds goto done; 14941da177e4SLinus Torvalds } 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds if (hdev->open(hdev)) { 14971da177e4SLinus Torvalds ret = -EIO; 14981da177e4SLinus Torvalds goto done; 14991da177e4SLinus Torvalds } 15001da177e4SLinus Torvalds 1501e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 150205fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 15034a3f95b7SMarcel Holtmann 15041da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 15051da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1506f41c70c4SMarcel Holtmann 1507d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) { 1508e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1509e131d74aSMarcel Holtmann 1510af202f84SMarcel Holtmann if (hdev->setup) 1511f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1512f41c70c4SMarcel Holtmann 1513af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1514af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1515af202f84SMarcel Holtmann * 1516af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1517af202f84SMarcel Holtmann * start up as unconfigured. 1518af202f84SMarcel Holtmann */ 1519eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1520eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 1521a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1522f41c70c4SMarcel Holtmann 15230ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 15240ebca7d6SMarcel Holtmann * read at least the version information provided by 15250ebca7d6SMarcel Holtmann * the Read Local Version Information command. 15260ebca7d6SMarcel Holtmann * 15270ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 15280ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 15290ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 15300ebca7d6SMarcel Holtmann */ 1531d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 15320ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 153389bc22d2SMarcel Holtmann } 153489bc22d2SMarcel Holtmann 1535d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 15369713c17bSMarcel Holtmann /* If public address change is configured, ensure that 15379713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 15389713c17bSMarcel Holtmann * support changing the public address, fail the power 15399713c17bSMarcel Holtmann * on procedure. 154024c457e2SMarcel Holtmann */ 15419713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 15429713c17bSMarcel Holtmann hdev->set_bdaddr) 154324c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 154424c457e2SMarcel Holtmann else 154524c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 154624c457e2SMarcel Holtmann } 154724c457e2SMarcel Holtmann 1548f41c70c4SMarcel Holtmann if (!ret) { 1549d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 155098a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 15512177bab5SJohan Hedberg ret = __hci_init(hdev); 155298a63aafSMarcel Holtmann if (!ret && hdev->post_init) 155398a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 155498a63aafSMarcel Holtmann } 15551da177e4SLinus Torvalds } 15561da177e4SLinus Torvalds 15577e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 15587e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 15597e995b9eSMarcel Holtmann * completed. 15607e995b9eSMarcel Holtmann */ 15617e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 15627e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 15637e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 15647e995b9eSMarcel Holtmann 1565f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1566f41c70c4SMarcel Holtmann 15671da177e4SLinus Torvalds if (!ret) { 15681da177e4SLinus Torvalds hci_dev_hold(hdev); 1569a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 15701da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 157105fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 1572d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1573d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1574d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1575d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15761514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 157709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1578744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 157909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 158056e5cb86SJohan Hedberg } 15811da177e4SLinus Torvalds } else { 15821da177e4SLinus Torvalds /* Init failed, cleanup */ 15833eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1584c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1585b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15861da177e4SLinus Torvalds 15871da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15881da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds if (hdev->flush) 15911da177e4SLinus Torvalds hdev->flush(hdev); 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds if (hdev->sent_cmd) { 15941da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15951da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15961da177e4SLinus Torvalds } 15971da177e4SLinus Torvalds 1598e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 159905fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 16004a3f95b7SMarcel Holtmann 16011da177e4SLinus Torvalds hdev->close(hdev); 1602fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds done: 16061da177e4SLinus Torvalds hci_req_unlock(hdev); 16071da177e4SLinus Torvalds return ret; 16081da177e4SLinus Torvalds } 16091da177e4SLinus Torvalds 1610cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1611cbed0ca1SJohan Hedberg 1612cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1613cbed0ca1SJohan Hedberg { 1614cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1615cbed0ca1SJohan Hedberg int err; 1616cbed0ca1SJohan Hedberg 1617cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1618cbed0ca1SJohan Hedberg if (!hdev) 1619cbed0ca1SJohan Hedberg return -ENODEV; 1620cbed0ca1SJohan Hedberg 16214a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1622fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1623fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1624fee746b0SMarcel Holtmann * possible. 1625fee746b0SMarcel Holtmann * 1626fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1627fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1628fee746b0SMarcel Holtmann * open the device. 1629fee746b0SMarcel Holtmann */ 1630d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1631d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1632fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1633fee746b0SMarcel Holtmann goto done; 1634fee746b0SMarcel Holtmann } 1635fee746b0SMarcel Holtmann 1636e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1637e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1638e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1639e1d08f40SJohan Hedberg * completed. 1640e1d08f40SJohan Hedberg */ 1641a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1642e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1643e1d08f40SJohan Hedberg 1644a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1645a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1646a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1647a5c8f270SMarcel Holtmann */ 1648e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1649e1d08f40SJohan Hedberg 165012aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1651b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 165212aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 165312aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 165412aa4f0aSMarcel Holtmann * to explicitly enable it. 165512aa4f0aSMarcel Holtmann */ 1656d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1657d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1658a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 165912aa4f0aSMarcel Holtmann 1660cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1661cbed0ca1SJohan Hedberg 1662fee746b0SMarcel Holtmann done: 1663cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1664cbed0ca1SJohan Hedberg return err; 1665cbed0ca1SJohan Hedberg } 1666cbed0ca1SJohan Hedberg 1667d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1668d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1669d7347f3cSJohan Hedberg { 1670d7347f3cSJohan Hedberg struct hci_conn_params *p; 1671d7347f3cSJohan Hedberg 1672f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1673f161dd41SJohan Hedberg if (p->conn) { 1674f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1675f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1676f161dd41SJohan Hedberg p->conn = NULL; 1677f161dd41SJohan Hedberg } 1678d7347f3cSJohan Hedberg list_del_init(&p->action); 1679f161dd41SJohan Hedberg } 1680d7347f3cSJohan Hedberg 1681d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1682d7347f3cSJohan Hedberg } 1683d7347f3cSJohan Hedberg 16846b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 16851da177e4SLinus Torvalds { 1686acc649c6SMarcel Holtmann bool auto_off; 1687acc649c6SMarcel Holtmann 16881da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 16891da177e4SLinus Torvalds 1690d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1691867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1692d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1693a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1694a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1695a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1696a44fecbdSTedd Ho-Jeong An } 1697a44fecbdSTedd Ho-Jeong An 169878c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 169978c04c0bSVinicius Costa Gomes 17001da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 17011da177e4SLinus Torvalds hci_req_lock(hdev); 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 170465cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 17051da177e4SLinus Torvalds hci_req_unlock(hdev); 17061da177e4SLinus Torvalds return 0; 17071da177e4SLinus Torvalds } 17081da177e4SLinus Torvalds 17093eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 17103eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1711b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 17121da177e4SLinus Torvalds 171316ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1714e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 171516ab91abSJohan Hedberg hdev->discov_timeout = 0; 1716a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1717a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 171816ab91abSJohan Hedberg } 171916ab91abSJohan Hedberg 1720a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 17217d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 17227d78525dSJohan Hedberg 17237ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 17242d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 17254518bb0fSJohan Hedberg 1726d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_MGMT)) 1727d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 17287ba8b4beSAndre Guedes 17295d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 17305d900e46SFlorian Grandel cancel_delayed_work_sync(&hdev->adv_instance_expire); 17315d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 17325d900e46SFlorian Grandel } 17335d900e46SFlorian Grandel 173476727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 173576727c02SJohan Hedberg * ensuring the workqueue is empty up front. 173676727c02SJohan Hedberg */ 173776727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 173876727c02SJohan Hedberg 173909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17401aeb9c65SJohan Hedberg 17418f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 17428f502f84SJohan Hedberg 1743acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1744acc649c6SMarcel Holtmann 1745acc649c6SMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_BREDR) 17461aeb9c65SJohan Hedberg mgmt_powered(hdev, 0); 17471aeb9c65SJohan Hedberg 17481f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1749d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1750f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 175109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17521da177e4SLinus Torvalds 175364dae967SMarcel Holtmann smp_unregister(hdev); 175464dae967SMarcel Holtmann 175505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds if (hdev->flush) 17581da177e4SLinus Torvalds hdev->flush(hdev); 17591da177e4SLinus Torvalds 17601da177e4SLinus Torvalds /* Reset device */ 17611da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17621da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1763acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1764acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17651da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 176601178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 17671da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 17681da177e4SLinus Torvalds } 17691da177e4SLinus Torvalds 1770c347b765SGustavo F. Padovan /* flush cmd work */ 1771c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds /* Drop queues */ 17741da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17751da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17761da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 17771da177e4SLinus Torvalds 17781da177e4SLinus Torvalds /* Drop last sent command */ 17791da177e4SLinus Torvalds if (hdev->sent_cmd) { 178065cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 17811da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 17821da177e4SLinus Torvalds hdev->sent_cmd = NULL; 17831da177e4SLinus Torvalds } 17841da177e4SLinus Torvalds 1785e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 178605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 17874a3f95b7SMarcel Holtmann 17881da177e4SLinus Torvalds /* After this point our queues are empty 17891da177e4SLinus Torvalds * and no tasks are scheduled. */ 17901da177e4SLinus Torvalds hdev->close(hdev); 17911da177e4SLinus Torvalds 179235b973c9SJohan Hedberg /* Clear flags */ 1793fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1794eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 179535b973c9SJohan Hedberg 1796ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1797536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1798ced5c338SAndrei Emeltchenko 1799e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 180009b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 18017a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1802e59fda8dSJohan Hedberg 18031da177e4SLinus Torvalds hci_req_unlock(hdev); 18041da177e4SLinus Torvalds 18051da177e4SLinus Torvalds hci_dev_put(hdev); 18061da177e4SLinus Torvalds return 0; 18071da177e4SLinus Torvalds } 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 18101da177e4SLinus Torvalds { 18111da177e4SLinus Torvalds struct hci_dev *hdev; 18121da177e4SLinus Torvalds int err; 18131da177e4SLinus Torvalds 181470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 181570f23020SAndrei Emeltchenko if (!hdev) 18161da177e4SLinus Torvalds return -ENODEV; 18178ee56540SMarcel Holtmann 1818d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18190736cfa8SMarcel Holtmann err = -EBUSY; 18200736cfa8SMarcel Holtmann goto done; 18210736cfa8SMarcel Holtmann } 18220736cfa8SMarcel Holtmann 1823a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 18248ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 18258ee56540SMarcel Holtmann 18261da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 18278ee56540SMarcel Holtmann 18280736cfa8SMarcel Holtmann done: 18291da177e4SLinus Torvalds hci_dev_put(hdev); 18301da177e4SLinus Torvalds return err; 18311da177e4SLinus Torvalds } 18321da177e4SLinus Torvalds 18335c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 18341da177e4SLinus Torvalds { 18355c912495SMarcel Holtmann int ret; 18361da177e4SLinus Torvalds 18375c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 18381da177e4SLinus Torvalds 18391da177e4SLinus Torvalds hci_req_lock(hdev); 18401da177e4SLinus Torvalds 18411da177e4SLinus Torvalds /* Drop queues */ 18421da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18431da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18441da177e4SLinus Torvalds 184576727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 184676727c02SJohan Hedberg * ensuring the workqueue is empty up front. 184776727c02SJohan Hedberg */ 184876727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 184976727c02SJohan Hedberg 185009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 18511f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 18521da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 185309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18541da177e4SLinus Torvalds 18551da177e4SLinus Torvalds if (hdev->flush) 18561da177e4SLinus Torvalds hdev->flush(hdev); 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18596ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 18601da177e4SLinus Torvalds 186101178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 18621da177e4SLinus Torvalds 18631da177e4SLinus Torvalds hci_req_unlock(hdev); 18641da177e4SLinus Torvalds return ret; 18651da177e4SLinus Torvalds } 18661da177e4SLinus Torvalds 18675c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 18685c912495SMarcel Holtmann { 18695c912495SMarcel Holtmann struct hci_dev *hdev; 18705c912495SMarcel Holtmann int err; 18715c912495SMarcel Holtmann 18725c912495SMarcel Holtmann hdev = hci_dev_get(dev); 18735c912495SMarcel Holtmann if (!hdev) 18745c912495SMarcel Holtmann return -ENODEV; 18755c912495SMarcel Holtmann 18765c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 18775c912495SMarcel Holtmann err = -ENETDOWN; 18785c912495SMarcel Holtmann goto done; 18795c912495SMarcel Holtmann } 18805c912495SMarcel Holtmann 1881d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18825c912495SMarcel Holtmann err = -EBUSY; 18835c912495SMarcel Holtmann goto done; 18845c912495SMarcel Holtmann } 18855c912495SMarcel Holtmann 1886d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 18875c912495SMarcel Holtmann err = -EOPNOTSUPP; 18885c912495SMarcel Holtmann goto done; 18895c912495SMarcel Holtmann } 18905c912495SMarcel Holtmann 18915c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 18925c912495SMarcel Holtmann 18935c912495SMarcel Holtmann done: 18945c912495SMarcel Holtmann hci_dev_put(hdev); 18955c912495SMarcel Holtmann return err; 18965c912495SMarcel Holtmann } 18975c912495SMarcel Holtmann 18981da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 18991da177e4SLinus Torvalds { 19001da177e4SLinus Torvalds struct hci_dev *hdev; 19011da177e4SLinus Torvalds int ret = 0; 19021da177e4SLinus Torvalds 190370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 190470f23020SAndrei Emeltchenko if (!hdev) 19051da177e4SLinus Torvalds return -ENODEV; 19061da177e4SLinus Torvalds 1907d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19080736cfa8SMarcel Holtmann ret = -EBUSY; 19090736cfa8SMarcel Holtmann goto done; 19100736cfa8SMarcel Holtmann } 19110736cfa8SMarcel Holtmann 1912d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1913fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1914fee746b0SMarcel Holtmann goto done; 1915fee746b0SMarcel Holtmann } 1916fee746b0SMarcel Holtmann 19171da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 19181da177e4SLinus Torvalds 19190736cfa8SMarcel Holtmann done: 19201da177e4SLinus Torvalds hci_dev_put(hdev); 19211da177e4SLinus Torvalds return ret; 19221da177e4SLinus Torvalds } 19231da177e4SLinus Torvalds 1924123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1925123abc08SJohan Hedberg { 1926bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1927123abc08SJohan Hedberg 1928123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1929123abc08SJohan Hedberg 1930123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1931238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1932238be788SMarcel Holtmann HCI_CONNECTABLE); 1933123abc08SJohan Hedberg else 1934a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1935a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1936123abc08SJohan Hedberg 1937bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1938238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1939238be788SMarcel Holtmann HCI_DISCOVERABLE); 1940bc6d2d04SJohan Hedberg } else { 1941a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1942a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1943a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1944bc6d2d04SJohan Hedberg } 1945bc6d2d04SJohan Hedberg 1946d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1947123abc08SJohan Hedberg return; 1948123abc08SJohan Hedberg 1949bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1950bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1951a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1952bc6d2d04SJohan Hedberg 1953d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1954bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 1955bc6d2d04SJohan Hedberg 1956123abc08SJohan Hedberg mgmt_new_settings(hdev); 1957123abc08SJohan Hedberg } 1958bc6d2d04SJohan Hedberg } 1959123abc08SJohan Hedberg 19601da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 19611da177e4SLinus Torvalds { 19621da177e4SLinus Torvalds struct hci_dev *hdev; 19631da177e4SLinus Torvalds struct hci_dev_req dr; 19641da177e4SLinus Torvalds int err = 0; 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 19671da177e4SLinus Torvalds return -EFAULT; 19681da177e4SLinus Torvalds 196970f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 197070f23020SAndrei Emeltchenko if (!hdev) 19711da177e4SLinus Torvalds return -ENODEV; 19721da177e4SLinus Torvalds 1973d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19740736cfa8SMarcel Holtmann err = -EBUSY; 19750736cfa8SMarcel Holtmann goto done; 19760736cfa8SMarcel Holtmann } 19770736cfa8SMarcel Holtmann 1978d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1979fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1980fee746b0SMarcel Holtmann goto done; 1981fee746b0SMarcel Holtmann } 1982fee746b0SMarcel Holtmann 19835b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 19845b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 19855b69bef5SMarcel Holtmann goto done; 19865b69bef5SMarcel Holtmann } 19875b69bef5SMarcel Holtmann 1988d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 198956f87901SJohan Hedberg err = -EOPNOTSUPP; 199056f87901SJohan Hedberg goto done; 199156f87901SJohan Hedberg } 199256f87901SJohan Hedberg 19931da177e4SLinus Torvalds switch (cmd) { 19941da177e4SLinus Torvalds case HCISETAUTH: 199501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19965f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19971da177e4SLinus Torvalds break; 19981da177e4SLinus Torvalds 19991da177e4SLinus Torvalds case HCISETENCRYPT: 20001da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 20011da177e4SLinus Torvalds err = -EOPNOTSUPP; 20021da177e4SLinus Torvalds break; 20031da177e4SLinus Torvalds } 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 20061da177e4SLinus Torvalds /* Auth must be enabled first */ 200701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 20085f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 20091da177e4SLinus Torvalds if (err) 20101da177e4SLinus Torvalds break; 20111da177e4SLinus Torvalds } 20121da177e4SLinus Torvalds 201301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 20145f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 20151da177e4SLinus Torvalds break; 20161da177e4SLinus Torvalds 20171da177e4SLinus Torvalds case HCISETSCAN: 201801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 20195f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 202091a668b0SJohan Hedberg 2021bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2022bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 202391a668b0SJohan Hedberg */ 2024123abc08SJohan Hedberg if (!err) 2025123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 20261da177e4SLinus Torvalds break; 20271da177e4SLinus Torvalds 20281da177e4SLinus Torvalds case HCISETLINKPOL: 202901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 20305f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 20311da177e4SLinus Torvalds break; 20321da177e4SLinus Torvalds 20331da177e4SLinus Torvalds case HCISETLINKMODE: 2034e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2035e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2036e4e8e37cSMarcel Holtmann break; 2037e4e8e37cSMarcel Holtmann 2038e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2039e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 20401da177e4SLinus Torvalds break; 20411da177e4SLinus Torvalds 20421da177e4SLinus Torvalds case HCISETACLMTU: 20431da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 20441da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 20451da177e4SLinus Torvalds break; 20461da177e4SLinus Torvalds 20471da177e4SLinus Torvalds case HCISETSCOMTU: 20481da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 20491da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 20501da177e4SLinus Torvalds break; 20511da177e4SLinus Torvalds 20521da177e4SLinus Torvalds default: 20531da177e4SLinus Torvalds err = -EINVAL; 20541da177e4SLinus Torvalds break; 20551da177e4SLinus Torvalds } 2056e4e8e37cSMarcel Holtmann 20570736cfa8SMarcel Holtmann done: 20581da177e4SLinus Torvalds hci_dev_put(hdev); 20591da177e4SLinus Torvalds return err; 20601da177e4SLinus Torvalds } 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 20631da177e4SLinus Torvalds { 20648035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 20651da177e4SLinus Torvalds struct hci_dev_list_req *dl; 20661da177e4SLinus Torvalds struct hci_dev_req *dr; 20671da177e4SLinus Torvalds int n = 0, size, err; 20681da177e4SLinus Torvalds __u16 dev_num; 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 20711da177e4SLinus Torvalds return -EFAULT; 20721da177e4SLinus Torvalds 20731da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 20741da177e4SLinus Torvalds return -EINVAL; 20751da177e4SLinus Torvalds 20761da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 20771da177e4SLinus Torvalds 207870f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 207970f23020SAndrei Emeltchenko if (!dl) 20801da177e4SLinus Torvalds return -ENOMEM; 20811da177e4SLinus Torvalds 20821da177e4SLinus Torvalds dr = dl->dev_req; 20831da177e4SLinus Torvalds 2084f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 20858035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 20862e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2087c542a06cSJohan Hedberg 20882e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20892e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20902e84d8dbSMarcel Holtmann * device is actually down. 20912e84d8dbSMarcel Holtmann */ 2092d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20932e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2094c542a06cSJohan Hedberg 20951da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 20962e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2097c542a06cSJohan Hedberg 20981da177e4SLinus Torvalds if (++n >= dev_num) 20991da177e4SLinus Torvalds break; 21001da177e4SLinus Torvalds } 2101f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 21021da177e4SLinus Torvalds 21031da177e4SLinus Torvalds dl->dev_num = n; 21041da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 21051da177e4SLinus Torvalds 21061da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 21071da177e4SLinus Torvalds kfree(dl); 21081da177e4SLinus Torvalds 21091da177e4SLinus Torvalds return err ? -EFAULT : 0; 21101da177e4SLinus Torvalds } 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 21131da177e4SLinus Torvalds { 21141da177e4SLinus Torvalds struct hci_dev *hdev; 21151da177e4SLinus Torvalds struct hci_dev_info di; 21162e84d8dbSMarcel Holtmann unsigned long flags; 21171da177e4SLinus Torvalds int err = 0; 21181da177e4SLinus Torvalds 21191da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 21201da177e4SLinus Torvalds return -EFAULT; 21211da177e4SLinus Torvalds 212270f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 212370f23020SAndrei Emeltchenko if (!hdev) 21241da177e4SLinus Torvalds return -ENODEV; 21251da177e4SLinus Torvalds 21262e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 21272e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 21282e84d8dbSMarcel Holtmann * device is actually down. 21292e84d8dbSMarcel Holtmann */ 2130d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 21312e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 21322e84d8dbSMarcel Holtmann else 21332e84d8dbSMarcel Holtmann flags = hdev->flags; 2134c542a06cSJohan Hedberg 21351da177e4SLinus Torvalds strcpy(di.name, hdev->name); 21361da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 213760f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 21382e84d8dbSMarcel Holtmann di.flags = flags; 21391da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2140572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 21411da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 21421da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 21431da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 21441da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2145572c7f84SJohan Hedberg } else { 2146572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2147572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2148572c7f84SJohan Hedberg di.sco_mtu = 0; 2149572c7f84SJohan Hedberg di.sco_pkts = 0; 2150572c7f84SJohan Hedberg } 21511da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 21521da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 21531da177e4SLinus Torvalds 21541da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 21551da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 21561da177e4SLinus Torvalds 21571da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 21581da177e4SLinus Torvalds err = -EFAULT; 21591da177e4SLinus Torvalds 21601da177e4SLinus Torvalds hci_dev_put(hdev); 21611da177e4SLinus Torvalds 21621da177e4SLinus Torvalds return err; 21631da177e4SLinus Torvalds } 21641da177e4SLinus Torvalds 21651da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 21661da177e4SLinus Torvalds 2167611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2168611b30f7SMarcel Holtmann { 2169611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2170611b30f7SMarcel Holtmann 2171611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2172611b30f7SMarcel Holtmann 2173d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 21740736cfa8SMarcel Holtmann return -EBUSY; 21750736cfa8SMarcel Holtmann 21765e130367SJohan Hedberg if (blocked) { 2177a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2178d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2179d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2180611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 21815e130367SJohan Hedberg } else { 2182a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 21835e130367SJohan Hedberg } 2184611b30f7SMarcel Holtmann 2185611b30f7SMarcel Holtmann return 0; 2186611b30f7SMarcel Holtmann } 2187611b30f7SMarcel Holtmann 2188611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2189611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2190611b30f7SMarcel Holtmann }; 2191611b30f7SMarcel Holtmann 2192ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2193ab81cbf9SJohan Hedberg { 2194ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 219596570ffcSJohan Hedberg int err; 2196ab81cbf9SJohan Hedberg 2197ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2198ab81cbf9SJohan Hedberg 2199cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 220096570ffcSJohan Hedberg if (err < 0) { 22013ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 220296570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 22033ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2204ab81cbf9SJohan Hedberg return; 220596570ffcSJohan Hedberg } 2206ab81cbf9SJohan Hedberg 2207a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2208a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2209a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2210a5c8f270SMarcel Holtmann */ 2211d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2212d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2213a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2214a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2215a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2216a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2217bf543036SJohan Hedberg hci_dev_do_close(hdev); 2218d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 221919202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 222019202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2221bf543036SJohan Hedberg } 2222ab81cbf9SJohan Hedberg 2223a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 22244a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 22254a964404SMarcel Holtmann * so that userspace can easily identify them. 22264a964404SMarcel Holtmann */ 2227d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22284a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 22290602a8adSMarcel Holtmann 22300602a8adSMarcel Holtmann /* For fully configured devices, this will send 22310602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 22320602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 22330602a8adSMarcel Holtmann * 22340602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 22350602a8adSMarcel Holtmann * and no event will be send. 22360602a8adSMarcel Holtmann */ 2237744cf19eSJohan Hedberg mgmt_index_added(hdev); 2238a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 22395ea234d3SMarcel Holtmann /* When the controller is now configured, then it 22405ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 22415ea234d3SMarcel Holtmann */ 2242d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22435ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 22445ea234d3SMarcel Holtmann 2245d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2246d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2247d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2248d603b76bSMarcel Holtmann */ 2249d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2250ab81cbf9SJohan Hedberg } 2251ab81cbf9SJohan Hedberg } 2252ab81cbf9SJohan Hedberg 2253ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2254ab81cbf9SJohan Hedberg { 22553243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 22563243553fSJohan Hedberg power_off.work); 2257ab81cbf9SJohan Hedberg 2258ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2259ab81cbf9SJohan Hedberg 22608ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2261ab81cbf9SJohan Hedberg } 2262ab81cbf9SJohan Hedberg 2263c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2264c7741d16SMarcel Holtmann { 2265c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2266c7741d16SMarcel Holtmann 2267c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2268c7741d16SMarcel Holtmann 2269c7741d16SMarcel Holtmann if (hdev->hw_error) 2270c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2271c7741d16SMarcel Holtmann else 2272c7741d16SMarcel Holtmann BT_ERR("%s hardware error 0x%2.2x", hdev->name, 2273c7741d16SMarcel Holtmann hdev->hw_error_code); 2274c7741d16SMarcel Holtmann 2275c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2276c7741d16SMarcel Holtmann return; 2277c7741d16SMarcel Holtmann 2278c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2279c7741d16SMarcel Holtmann } 2280c7741d16SMarcel Holtmann 228116ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 228216ab91abSJohan Hedberg { 228316ab91abSJohan Hedberg struct hci_dev *hdev; 228416ab91abSJohan Hedberg 228516ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 228616ab91abSJohan Hedberg 228716ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 228816ab91abSJohan Hedberg 2289d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 229016ab91abSJohan Hedberg } 229116ab91abSJohan Hedberg 22925d900e46SFlorian Grandel static void hci_adv_timeout_expire(struct work_struct *work) 22935d900e46SFlorian Grandel { 22945d900e46SFlorian Grandel struct hci_dev *hdev; 22955d900e46SFlorian Grandel 22965d900e46SFlorian Grandel hdev = container_of(work, struct hci_dev, adv_instance_expire.work); 22975d900e46SFlorian Grandel 22985d900e46SFlorian Grandel BT_DBG("%s", hdev->name); 22995d900e46SFlorian Grandel 23005d900e46SFlorian Grandel mgmt_adv_timeout_expired(hdev); 23015d900e46SFlorian Grandel } 23025d900e46SFlorian Grandel 230335f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 23042aeb9a1aSJohan Hedberg { 23054821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 23062aeb9a1aSJohan Hedberg 23074821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 23084821002cSJohan Hedberg list_del(&uuid->list); 23092aeb9a1aSJohan Hedberg kfree(uuid); 23102aeb9a1aSJohan Hedberg } 23112aeb9a1aSJohan Hedberg } 23122aeb9a1aSJohan Hedberg 231335f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 231455ed8ca1SJohan Hedberg { 231555ed8ca1SJohan Hedberg struct link_key *key; 231655ed8ca1SJohan Hedberg 23170378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 23180378b597SJohan Hedberg list_del_rcu(&key->list); 23190378b597SJohan Hedberg kfree_rcu(key, rcu); 232055ed8ca1SJohan Hedberg } 232155ed8ca1SJohan Hedberg } 232255ed8ca1SJohan Hedberg 232335f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2324b899efafSVinicius Costa Gomes { 2325970d0f1bSJohan Hedberg struct smp_ltk *k; 2326b899efafSVinicius Costa Gomes 2327970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2328970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2329970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2330b899efafSVinicius Costa Gomes } 2331b899efafSVinicius Costa Gomes } 2332b899efafSVinicius Costa Gomes 2333970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2334970c4e46SJohan Hedberg { 2335adae20cbSJohan Hedberg struct smp_irk *k; 2336970c4e46SJohan Hedberg 2337adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2338adae20cbSJohan Hedberg list_del_rcu(&k->list); 2339adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2340970c4e46SJohan Hedberg } 2341970c4e46SJohan Hedberg } 2342970c4e46SJohan Hedberg 234355ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 234455ed8ca1SJohan Hedberg { 234555ed8ca1SJohan Hedberg struct link_key *k; 234655ed8ca1SJohan Hedberg 23470378b597SJohan Hedberg rcu_read_lock(); 23480378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 23490378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 23500378b597SJohan Hedberg rcu_read_unlock(); 235155ed8ca1SJohan Hedberg return k; 23520378b597SJohan Hedberg } 23530378b597SJohan Hedberg } 23540378b597SJohan Hedberg rcu_read_unlock(); 235555ed8ca1SJohan Hedberg 235655ed8ca1SJohan Hedberg return NULL; 235755ed8ca1SJohan Hedberg } 235855ed8ca1SJohan Hedberg 2359745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2360d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2361d25e28abSJohan Hedberg { 2362d25e28abSJohan Hedberg /* Legacy key */ 2363d25e28abSJohan Hedberg if (key_type < 0x03) 2364745c0ce3SVishal Agarwal return true; 2365d25e28abSJohan Hedberg 2366d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2367d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2368745c0ce3SVishal Agarwal return false; 2369d25e28abSJohan Hedberg 2370d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2371d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2372745c0ce3SVishal Agarwal return false; 2373d25e28abSJohan Hedberg 2374d25e28abSJohan Hedberg /* Security mode 3 case */ 2375d25e28abSJohan Hedberg if (!conn) 2376745c0ce3SVishal Agarwal return true; 2377d25e28abSJohan Hedberg 2378e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2379e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2380e3befab9SJohan Hedberg return true; 2381e3befab9SJohan Hedberg 2382d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2383d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2384745c0ce3SVishal Agarwal return true; 2385d25e28abSJohan Hedberg 2386d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2387d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2388745c0ce3SVishal Agarwal return true; 2389d25e28abSJohan Hedberg 2390d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2391d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2392745c0ce3SVishal Agarwal return true; 2393d25e28abSJohan Hedberg 2394d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2395d25e28abSJohan Hedberg * persistently */ 2396745c0ce3SVishal Agarwal return false; 2397d25e28abSJohan Hedberg } 2398d25e28abSJohan Hedberg 2399e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 240098a0b845SJohan Hedberg { 2401e804d25dSJohan Hedberg if (type == SMP_LTK) 2402e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 240398a0b845SJohan Hedberg 2404e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 240598a0b845SJohan Hedberg } 240698a0b845SJohan Hedberg 2407f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2408e804d25dSJohan Hedberg u8 addr_type, u8 role) 240975d262c2SVinicius Costa Gomes { 2410c9839a11SVinicius Costa Gomes struct smp_ltk *k; 241175d262c2SVinicius Costa Gomes 2412970d0f1bSJohan Hedberg rcu_read_lock(); 2413970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 24145378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 24155378bc56SJohan Hedberg continue; 24165378bc56SJohan Hedberg 2417923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2418970d0f1bSJohan Hedberg rcu_read_unlock(); 241975d262c2SVinicius Costa Gomes return k; 2420970d0f1bSJohan Hedberg } 2421970d0f1bSJohan Hedberg } 2422970d0f1bSJohan Hedberg rcu_read_unlock(); 242375d262c2SVinicius Costa Gomes 242475d262c2SVinicius Costa Gomes return NULL; 242575d262c2SVinicius Costa Gomes } 242675d262c2SVinicius Costa Gomes 2427970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2428970c4e46SJohan Hedberg { 2429970c4e46SJohan Hedberg struct smp_irk *irk; 2430970c4e46SJohan Hedberg 2431adae20cbSJohan Hedberg rcu_read_lock(); 2432adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2433adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2434adae20cbSJohan Hedberg rcu_read_unlock(); 2435970c4e46SJohan Hedberg return irk; 2436970c4e46SJohan Hedberg } 2437adae20cbSJohan Hedberg } 2438970c4e46SJohan Hedberg 2439adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2440defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2441970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2442adae20cbSJohan Hedberg rcu_read_unlock(); 2443970c4e46SJohan Hedberg return irk; 2444970c4e46SJohan Hedberg } 2445970c4e46SJohan Hedberg } 2446adae20cbSJohan Hedberg rcu_read_unlock(); 2447970c4e46SJohan Hedberg 2448970c4e46SJohan Hedberg return NULL; 2449970c4e46SJohan Hedberg } 2450970c4e46SJohan Hedberg 2451970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2452970c4e46SJohan Hedberg u8 addr_type) 2453970c4e46SJohan Hedberg { 2454970c4e46SJohan Hedberg struct smp_irk *irk; 2455970c4e46SJohan Hedberg 24566cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 24576cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 24586cfc9988SJohan Hedberg return NULL; 24596cfc9988SJohan Hedberg 2460adae20cbSJohan Hedberg rcu_read_lock(); 2461adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2462970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2463adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2464adae20cbSJohan Hedberg rcu_read_unlock(); 2465970c4e46SJohan Hedberg return irk; 2466970c4e46SJohan Hedberg } 2467adae20cbSJohan Hedberg } 2468adae20cbSJohan Hedberg rcu_read_unlock(); 2469970c4e46SJohan Hedberg 2470970c4e46SJohan Hedberg return NULL; 2471970c4e46SJohan Hedberg } 2472970c4e46SJohan Hedberg 2473567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 24747652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 24757652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 247655ed8ca1SJohan Hedberg { 247755ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2478745c0ce3SVishal Agarwal u8 old_key_type; 247955ed8ca1SJohan Hedberg 248055ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 248155ed8ca1SJohan Hedberg if (old_key) { 248255ed8ca1SJohan Hedberg old_key_type = old_key->type; 248355ed8ca1SJohan Hedberg key = old_key; 248455ed8ca1SJohan Hedberg } else { 248512adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 24860a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 248755ed8ca1SJohan Hedberg if (!key) 2488567fa2aaSJohan Hedberg return NULL; 24890378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 249055ed8ca1SJohan Hedberg } 249155ed8ca1SJohan Hedberg 24926ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 249355ed8ca1SJohan Hedberg 2494d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2495d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2496d25e28abSJohan Hedberg * previous key */ 2497d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2498a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2499d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2500655fe6ecSJohan Hedberg if (conn) 2501655fe6ecSJohan Hedberg conn->key_type = type; 2502655fe6ecSJohan Hedberg } 2503d25e28abSJohan Hedberg 250455ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 25059b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 250655ed8ca1SJohan Hedberg key->pin_len = pin_len; 250755ed8ca1SJohan Hedberg 2508b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 250955ed8ca1SJohan Hedberg key->type = old_key_type; 25104748fed2SJohan Hedberg else 25114748fed2SJohan Hedberg key->type = type; 25124748fed2SJohan Hedberg 25137652ff6aSJohan Hedberg if (persistent) 25147652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 25157652ff6aSJohan Hedberg old_key_type); 25164df378a1SJohan Hedberg 2517567fa2aaSJohan Hedberg return key; 251855ed8ca1SJohan Hedberg } 251955ed8ca1SJohan Hedberg 2520ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 252135d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2522fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 252375d262c2SVinicius Costa Gomes { 2524c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2525e804d25dSJohan Hedberg u8 role = ltk_role(type); 252675d262c2SVinicius Costa Gomes 2527f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2528c9839a11SVinicius Costa Gomes if (old_key) 252975d262c2SVinicius Costa Gomes key = old_key; 2530c9839a11SVinicius Costa Gomes else { 25310a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 253275d262c2SVinicius Costa Gomes if (!key) 2533ca9142b8SJohan Hedberg return NULL; 2534970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 253575d262c2SVinicius Costa Gomes } 253675d262c2SVinicius Costa Gomes 253775d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2538c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2539c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2540c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2541c9839a11SVinicius Costa Gomes key->ediv = ediv; 2542fe39c7b2SMarcel Holtmann key->rand = rand; 2543c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2544c9839a11SVinicius Costa Gomes key->type = type; 254575d262c2SVinicius Costa Gomes 2546ca9142b8SJohan Hedberg return key; 254775d262c2SVinicius Costa Gomes } 254875d262c2SVinicius Costa Gomes 2549ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2550ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2551970c4e46SJohan Hedberg { 2552970c4e46SJohan Hedberg struct smp_irk *irk; 2553970c4e46SJohan Hedberg 2554970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2555970c4e46SJohan Hedberg if (!irk) { 2556970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2557970c4e46SJohan Hedberg if (!irk) 2558ca9142b8SJohan Hedberg return NULL; 2559970c4e46SJohan Hedberg 2560970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2561970c4e46SJohan Hedberg irk->addr_type = addr_type; 2562970c4e46SJohan Hedberg 2563adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2564970c4e46SJohan Hedberg } 2565970c4e46SJohan Hedberg 2566970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2567970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2568970c4e46SJohan Hedberg 2569ca9142b8SJohan Hedberg return irk; 2570970c4e46SJohan Hedberg } 2571970c4e46SJohan Hedberg 257255ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 257355ed8ca1SJohan Hedberg { 257455ed8ca1SJohan Hedberg struct link_key *key; 257555ed8ca1SJohan Hedberg 257655ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 257755ed8ca1SJohan Hedberg if (!key) 257855ed8ca1SJohan Hedberg return -ENOENT; 257955ed8ca1SJohan Hedberg 25806ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 258155ed8ca1SJohan Hedberg 25820378b597SJohan Hedberg list_del_rcu(&key->list); 25830378b597SJohan Hedberg kfree_rcu(key, rcu); 258455ed8ca1SJohan Hedberg 258555ed8ca1SJohan Hedberg return 0; 258655ed8ca1SJohan Hedberg } 258755ed8ca1SJohan Hedberg 2588e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2589b899efafSVinicius Costa Gomes { 2590970d0f1bSJohan Hedberg struct smp_ltk *k; 2591c51ffa0bSJohan Hedberg int removed = 0; 2592b899efafSVinicius Costa Gomes 2593970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2594e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2595b899efafSVinicius Costa Gomes continue; 2596b899efafSVinicius Costa Gomes 25976ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2598b899efafSVinicius Costa Gomes 2599970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2600970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2601c51ffa0bSJohan Hedberg removed++; 2602b899efafSVinicius Costa Gomes } 2603b899efafSVinicius Costa Gomes 2604c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2605b899efafSVinicius Costa Gomes } 2606b899efafSVinicius Costa Gomes 2607a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2608a7ec7338SJohan Hedberg { 2609adae20cbSJohan Hedberg struct smp_irk *k; 2610a7ec7338SJohan Hedberg 2611adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2612a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2613a7ec7338SJohan Hedberg continue; 2614a7ec7338SJohan Hedberg 2615a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2616a7ec7338SJohan Hedberg 2617adae20cbSJohan Hedberg list_del_rcu(&k->list); 2618adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2619a7ec7338SJohan Hedberg } 2620a7ec7338SJohan Hedberg } 2621a7ec7338SJohan Hedberg 262255e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 262355e76b38SJohan Hedberg { 262455e76b38SJohan Hedberg struct smp_ltk *k; 26254ba9faf3SJohan Hedberg struct smp_irk *irk; 262655e76b38SJohan Hedberg u8 addr_type; 262755e76b38SJohan Hedberg 262855e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 262955e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 263055e76b38SJohan Hedberg return true; 263155e76b38SJohan Hedberg return false; 263255e76b38SJohan Hedberg } 263355e76b38SJohan Hedberg 263455e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 263555e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 263655e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 263755e76b38SJohan Hedberg else 263855e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 263955e76b38SJohan Hedberg 26404ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 26414ba9faf3SJohan Hedberg if (irk) { 26424ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 26434ba9faf3SJohan Hedberg addr_type = irk->addr_type; 26444ba9faf3SJohan Hedberg } 26454ba9faf3SJohan Hedberg 264655e76b38SJohan Hedberg rcu_read_lock(); 264755e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 264887c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 264987c8b28dSJohan Hedberg rcu_read_unlock(); 265055e76b38SJohan Hedberg return true; 265155e76b38SJohan Hedberg } 265287c8b28dSJohan Hedberg } 265355e76b38SJohan Hedberg rcu_read_unlock(); 265455e76b38SJohan Hedberg 265555e76b38SJohan Hedberg return false; 265655e76b38SJohan Hedberg } 265755e76b38SJohan Hedberg 26586bd32326SVille Tervo /* HCI command timer function */ 265965cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 26606bd32326SVille Tervo { 266165cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 266265cc2b49SMarcel Holtmann cmd_timer.work); 26636bd32326SVille Tervo 2664bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2665bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2666bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2667bda4f23aSAndrei Emeltchenko 2668bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2669bda4f23aSAndrei Emeltchenko } else { 26706bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2671bda4f23aSAndrei Emeltchenko } 2672bda4f23aSAndrei Emeltchenko 26736bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2674c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 26756bd32326SVille Tervo } 26766bd32326SVille Tervo 26772763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 26786928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 26792763eda6SSzymon Janc { 26802763eda6SSzymon Janc struct oob_data *data; 26812763eda6SSzymon Janc 26826928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 26836928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 26846928a924SJohan Hedberg continue; 26856928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 26866928a924SJohan Hedberg continue; 26872763eda6SSzymon Janc return data; 26886928a924SJohan Hedberg } 26892763eda6SSzymon Janc 26902763eda6SSzymon Janc return NULL; 26912763eda6SSzymon Janc } 26922763eda6SSzymon Janc 26936928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26946928a924SJohan Hedberg u8 bdaddr_type) 26952763eda6SSzymon Janc { 26962763eda6SSzymon Janc struct oob_data *data; 26972763eda6SSzymon Janc 26986928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26992763eda6SSzymon Janc if (!data) 27002763eda6SSzymon Janc return -ENOENT; 27012763eda6SSzymon Janc 27026928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 27032763eda6SSzymon Janc 27042763eda6SSzymon Janc list_del(&data->list); 27052763eda6SSzymon Janc kfree(data); 27062763eda6SSzymon Janc 27072763eda6SSzymon Janc return 0; 27082763eda6SSzymon Janc } 27092763eda6SSzymon Janc 271035f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 27112763eda6SSzymon Janc { 27122763eda6SSzymon Janc struct oob_data *data, *n; 27132763eda6SSzymon Janc 27142763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 27152763eda6SSzymon Janc list_del(&data->list); 27162763eda6SSzymon Janc kfree(data); 27172763eda6SSzymon Janc } 27182763eda6SSzymon Janc } 27192763eda6SSzymon Janc 27200798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 27216928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 272238da1703SJohan Hedberg u8 *hash256, u8 *rand256) 27230798872eSMarcel Holtmann { 27240798872eSMarcel Holtmann struct oob_data *data; 27250798872eSMarcel Holtmann 27266928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 27270798872eSMarcel Holtmann if (!data) { 27280a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 27290798872eSMarcel Holtmann if (!data) 27300798872eSMarcel Holtmann return -ENOMEM; 27310798872eSMarcel Holtmann 27320798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 27336928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 27340798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 27350798872eSMarcel Holtmann } 27360798872eSMarcel Holtmann 273781328d5cSJohan Hedberg if (hash192 && rand192) { 27380798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 273938da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2740f7697b16SMarcel Holtmann if (hash256 && rand256) 2741f7697b16SMarcel Holtmann data->present = 0x03; 274281328d5cSJohan Hedberg } else { 274381328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 274481328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2745f7697b16SMarcel Holtmann if (hash256 && rand256) 2746f7697b16SMarcel Holtmann data->present = 0x02; 2747f7697b16SMarcel Holtmann else 2748f7697b16SMarcel Holtmann data->present = 0x00; 274981328d5cSJohan Hedberg } 27500798872eSMarcel Holtmann 275181328d5cSJohan Hedberg if (hash256 && rand256) { 27520798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 275338da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 275481328d5cSJohan Hedberg } else { 275581328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 275681328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2757f7697b16SMarcel Holtmann if (hash192 && rand192) 2758f7697b16SMarcel Holtmann data->present = 0x01; 275981328d5cSJohan Hedberg } 27600798872eSMarcel Holtmann 27616ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 27622763eda6SSzymon Janc 27632763eda6SSzymon Janc return 0; 27642763eda6SSzymon Janc } 27652763eda6SSzymon Janc 2766d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2767d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2768d2609b34SFlorian Grandel { 2769d2609b34SFlorian Grandel struct adv_info *adv_instance; 2770d2609b34SFlorian Grandel 2771d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2772d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2773d2609b34SFlorian Grandel return adv_instance; 2774d2609b34SFlorian Grandel } 2775d2609b34SFlorian Grandel 2776d2609b34SFlorian Grandel return NULL; 2777d2609b34SFlorian Grandel } 2778d2609b34SFlorian Grandel 2779d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2780d2609b34SFlorian Grandel struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) { 2781d2609b34SFlorian Grandel struct adv_info *cur_instance; 2782d2609b34SFlorian Grandel 2783d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2784d2609b34SFlorian Grandel if (!cur_instance) 2785d2609b34SFlorian Grandel return NULL; 2786d2609b34SFlorian Grandel 2787d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2788d2609b34SFlorian Grandel struct adv_info, list)) 2789d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2790d2609b34SFlorian Grandel struct adv_info, list); 2791d2609b34SFlorian Grandel else 2792d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2793d2609b34SFlorian Grandel } 2794d2609b34SFlorian Grandel 2795d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2796d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2797d2609b34SFlorian Grandel { 2798d2609b34SFlorian Grandel struct adv_info *adv_instance; 2799d2609b34SFlorian Grandel 2800d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2801d2609b34SFlorian Grandel if (!adv_instance) 2802d2609b34SFlorian Grandel return -ENOENT; 2803d2609b34SFlorian Grandel 2804d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2805d2609b34SFlorian Grandel 28065d900e46SFlorian Grandel if (hdev->cur_adv_instance == instance && hdev->adv_instance_timeout) { 28075d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 28085d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 28095d900e46SFlorian Grandel } 28105d900e46SFlorian Grandel 2811d2609b34SFlorian Grandel list_del(&adv_instance->list); 2812d2609b34SFlorian Grandel kfree(adv_instance); 2813d2609b34SFlorian Grandel 2814d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2815d2609b34SFlorian Grandel 2816d2609b34SFlorian Grandel return 0; 2817d2609b34SFlorian Grandel } 2818d2609b34SFlorian Grandel 2819d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2820d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2821d2609b34SFlorian Grandel { 2822d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2823d2609b34SFlorian Grandel 28245d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 28255d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 28265d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 28275d900e46SFlorian Grandel } 28285d900e46SFlorian Grandel 2829d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2830d2609b34SFlorian Grandel list_del(&adv_instance->list); 2831d2609b34SFlorian Grandel kfree(adv_instance); 2832d2609b34SFlorian Grandel } 2833d2609b34SFlorian Grandel 2834d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2835d2609b34SFlorian Grandel } 2836d2609b34SFlorian Grandel 2837d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2838d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2839d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2840d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2841d2609b34SFlorian Grandel u16 timeout, u16 duration) 2842d2609b34SFlorian Grandel { 2843d2609b34SFlorian Grandel struct adv_info *adv_instance; 2844d2609b34SFlorian Grandel 2845d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2846d2609b34SFlorian Grandel if (adv_instance) { 2847d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2848d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2849d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2850d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2851d2609b34SFlorian Grandel } else { 2852d2609b34SFlorian Grandel if (hdev->adv_instance_cnt >= HCI_MAX_ADV_INSTANCES || 2853d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2854d2609b34SFlorian Grandel return -EOVERFLOW; 2855d2609b34SFlorian Grandel 285639ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2857d2609b34SFlorian Grandel if (!adv_instance) 2858d2609b34SFlorian Grandel return -ENOMEM; 2859d2609b34SFlorian Grandel 2860fffd38bcSFlorian Grandel adv_instance->pending = true; 2861d2609b34SFlorian Grandel adv_instance->instance = instance; 2862d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2863d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2864d2609b34SFlorian Grandel } 2865d2609b34SFlorian Grandel 2866d2609b34SFlorian Grandel adv_instance->flags = flags; 2867d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2868d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2869d2609b34SFlorian Grandel 2870d2609b34SFlorian Grandel if (adv_data_len) 2871d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2872d2609b34SFlorian Grandel 2873d2609b34SFlorian Grandel if (scan_rsp_len) 2874d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2875d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2876d2609b34SFlorian Grandel 2877d2609b34SFlorian Grandel adv_instance->timeout = timeout; 28785d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2879d2609b34SFlorian Grandel 2880d2609b34SFlorian Grandel if (duration == 0) 2881d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2882d2609b34SFlorian Grandel else 2883d2609b34SFlorian Grandel adv_instance->duration = duration; 2884d2609b34SFlorian Grandel 2885d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2886d2609b34SFlorian Grandel 2887d2609b34SFlorian Grandel return 0; 2888d2609b34SFlorian Grandel } 2889d2609b34SFlorian Grandel 2890dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2891b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2892b2a66aadSAntti Julku { 2893b2a66aadSAntti Julku struct bdaddr_list *b; 2894b2a66aadSAntti Julku 2895dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2896b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2897b2a66aadSAntti Julku return b; 2898b9ee0a78SMarcel Holtmann } 2899b2a66aadSAntti Julku 2900b2a66aadSAntti Julku return NULL; 2901b2a66aadSAntti Julku } 2902b2a66aadSAntti Julku 2903dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2904b2a66aadSAntti Julku { 2905b2a66aadSAntti Julku struct list_head *p, *n; 2906b2a66aadSAntti Julku 2907dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 2908b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2909b2a66aadSAntti Julku 2910b2a66aadSAntti Julku list_del(p); 2911b2a66aadSAntti Julku kfree(b); 2912b2a66aadSAntti Julku } 2913b2a66aadSAntti Julku } 2914b2a66aadSAntti Julku 2915dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2916b2a66aadSAntti Julku { 2917b2a66aadSAntti Julku struct bdaddr_list *entry; 2918b2a66aadSAntti Julku 2919b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2920b2a66aadSAntti Julku return -EBADF; 2921b2a66aadSAntti Julku 2922dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 29235e762444SAntti Julku return -EEXIST; 2924b2a66aadSAntti Julku 292527f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 29265e762444SAntti Julku if (!entry) 29275e762444SAntti Julku return -ENOMEM; 2928b2a66aadSAntti Julku 2929b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2930b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2931b2a66aadSAntti Julku 2932dcc36c16SJohan Hedberg list_add(&entry->list, list); 2933b2a66aadSAntti Julku 29342a8357f2SJohan Hedberg return 0; 2935b2a66aadSAntti Julku } 2936b2a66aadSAntti Julku 2937dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2938b2a66aadSAntti Julku { 2939b2a66aadSAntti Julku struct bdaddr_list *entry; 2940b2a66aadSAntti Julku 294135f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2942dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 294335f7498aSJohan Hedberg return 0; 294435f7498aSJohan Hedberg } 2945b2a66aadSAntti Julku 2946dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2947d2ab0ac1SMarcel Holtmann if (!entry) 2948d2ab0ac1SMarcel Holtmann return -ENOENT; 2949d2ab0ac1SMarcel Holtmann 2950d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2951d2ab0ac1SMarcel Holtmann kfree(entry); 2952d2ab0ac1SMarcel Holtmann 2953d2ab0ac1SMarcel Holtmann return 0; 2954d2ab0ac1SMarcel Holtmann } 2955d2ab0ac1SMarcel Holtmann 295615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 295715819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 295815819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 295915819a70SAndre Guedes { 296015819a70SAndre Guedes struct hci_conn_params *params; 296115819a70SAndre Guedes 296215819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 296315819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 296415819a70SAndre Guedes params->addr_type == addr_type) { 296515819a70SAndre Guedes return params; 296615819a70SAndre Guedes } 296715819a70SAndre Guedes } 296815819a70SAndre Guedes 296915819a70SAndre Guedes return NULL; 297015819a70SAndre Guedes } 297115819a70SAndre Guedes 297215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2973501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 29744b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 297515819a70SAndre Guedes { 2976912b42efSJohan Hedberg struct hci_conn_params *param; 297715819a70SAndre Guedes 2978501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2979912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2980912b42efSJohan Hedberg param->addr_type == addr_type) 2981912b42efSJohan Hedberg return param; 29824b10966fSMarcel Holtmann } 29834b10966fSMarcel Holtmann 29844b10966fSMarcel Holtmann return NULL; 298515819a70SAndre Guedes } 298615819a70SAndre Guedes 298715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 298851d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 298951d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 299015819a70SAndre Guedes { 299115819a70SAndre Guedes struct hci_conn_params *params; 299215819a70SAndre Guedes 299315819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2994cef952ceSAndre Guedes if (params) 299551d167c0SMarcel Holtmann return params; 299615819a70SAndre Guedes 299715819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 299815819a70SAndre Guedes if (!params) { 299915819a70SAndre Guedes BT_ERR("Out of memory"); 300051d167c0SMarcel Holtmann return NULL; 300115819a70SAndre Guedes } 300215819a70SAndre Guedes 300315819a70SAndre Guedes bacpy(¶ms->addr, addr); 300415819a70SAndre Guedes params->addr_type = addr_type; 3005cef952ceSAndre Guedes 3006cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 300793450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3008cef952ceSAndre Guedes 3009bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3010bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3011bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3012bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3013bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3014bf5b3c8bSMarcel Holtmann 3015bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3016bf5b3c8bSMarcel Holtmann 301751d167c0SMarcel Holtmann return params; 3018bf5b3c8bSMarcel Holtmann } 3019bf5b3c8bSMarcel Holtmann 3020f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 3021f6c63249SJohan Hedberg { 3022f6c63249SJohan Hedberg if (params->conn) { 3023f6c63249SJohan Hedberg hci_conn_drop(params->conn); 3024f6c63249SJohan Hedberg hci_conn_put(params->conn); 3025f6c63249SJohan Hedberg } 3026f6c63249SJohan Hedberg 3027f6c63249SJohan Hedberg list_del(¶ms->action); 3028f6c63249SJohan Hedberg list_del(¶ms->list); 3029f6c63249SJohan Hedberg kfree(params); 3030f6c63249SJohan Hedberg } 3031f6c63249SJohan Hedberg 303215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 303315819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 303415819a70SAndre Guedes { 303515819a70SAndre Guedes struct hci_conn_params *params; 303615819a70SAndre Guedes 303715819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 303815819a70SAndre Guedes if (!params) 303915819a70SAndre Guedes return; 304015819a70SAndre Guedes 3041f6c63249SJohan Hedberg hci_conn_params_free(params); 304215819a70SAndre Guedes 304395305baaSJohan Hedberg hci_update_background_scan(hdev); 304495305baaSJohan Hedberg 304515819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 304615819a70SAndre Guedes } 304715819a70SAndre Guedes 304815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 304955af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 305015819a70SAndre Guedes { 305115819a70SAndre Guedes struct hci_conn_params *params, *tmp; 305215819a70SAndre Guedes 305315819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 305455af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 305555af49a8SJohan Hedberg continue; 3056f75113a2SJakub Pawlowski 3057f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 3058f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 3059f75113a2SJakub Pawlowski */ 3060f75113a2SJakub Pawlowski if (params->explicit_connect) { 3061f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 3062f75113a2SJakub Pawlowski continue; 3063f75113a2SJakub Pawlowski } 3064f75113a2SJakub Pawlowski 306515819a70SAndre Guedes list_del(¶ms->list); 306615819a70SAndre Guedes kfree(params); 306715819a70SAndre Guedes } 306815819a70SAndre Guedes 306955af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 307055af49a8SJohan Hedberg } 307155af49a8SJohan Hedberg 307255af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3073373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 307415819a70SAndre Guedes { 307515819a70SAndre Guedes struct hci_conn_params *params, *tmp; 307615819a70SAndre Guedes 3077f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3078f6c63249SJohan Hedberg hci_conn_params_free(params); 307915819a70SAndre Guedes 3080a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 30811089b67dSMarcel Holtmann 308215819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 308315819a70SAndre Guedes } 308415819a70SAndre Guedes 30851904a853SMarcel Holtmann static void inquiry_complete(struct hci_dev *hdev, u8 status, u16 opcode) 30867ba8b4beSAndre Guedes { 30874c87eaabSAndre Guedes if (status) { 30884c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 30897ba8b4beSAndre Guedes 30904c87eaabSAndre Guedes hci_dev_lock(hdev); 30914c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 30924c87eaabSAndre Guedes hci_dev_unlock(hdev); 30934c87eaabSAndre Guedes return; 30944c87eaabSAndre Guedes } 30957ba8b4beSAndre Guedes } 30967ba8b4beSAndre Guedes 30971904a853SMarcel Holtmann static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status, 30981904a853SMarcel Holtmann u16 opcode) 30997ba8b4beSAndre Guedes { 31004c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 31014c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 31024c87eaabSAndre Guedes struct hci_cp_inquiry cp; 31037ba8b4beSAndre Guedes int err; 31047ba8b4beSAndre Guedes 31054c87eaabSAndre Guedes if (status) { 31064c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 31074c87eaabSAndre Guedes return; 31087ba8b4beSAndre Guedes } 31097ba8b4beSAndre Guedes 31102d28cfe7SJakub Pawlowski hdev->discovery.scan_start = 0; 31112d28cfe7SJakub Pawlowski 31124c87eaabSAndre Guedes switch (hdev->discovery.type) { 31134c87eaabSAndre Guedes case DISCOV_TYPE_LE: 31144c87eaabSAndre Guedes hci_dev_lock(hdev); 31154c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 31164c87eaabSAndre Guedes hci_dev_unlock(hdev); 31174c87eaabSAndre Guedes break; 31187dbfac1dSAndre Guedes 31194c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 31204c87eaabSAndre Guedes hci_dev_lock(hdev); 31214c87eaabSAndre Guedes 312207d2334aSJakub Pawlowski if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, 312307d2334aSJakub Pawlowski &hdev->quirks)) { 312407d2334aSJakub Pawlowski /* If we were running LE only scan, change discovery 312507d2334aSJakub Pawlowski * state. If we were running both LE and BR/EDR inquiry 312607d2334aSJakub Pawlowski * simultaneously, and BR/EDR inquiry is already 312707d2334aSJakub Pawlowski * finished, stop discovery, otherwise BR/EDR inquiry 3128177d0506SWesley Kuo * will stop discovery when finished. If we will resolve 3129177d0506SWesley Kuo * remote device name, do not change discovery state. 313007d2334aSJakub Pawlowski */ 3131177d0506SWesley Kuo if (!test_bit(HCI_INQUIRY, &hdev->flags) && 3132177d0506SWesley Kuo hdev->discovery.state != DISCOVERY_RESOLVING) 313307d2334aSJakub Pawlowski hci_discovery_set_state(hdev, 313407d2334aSJakub Pawlowski DISCOVERY_STOPPED); 313507d2334aSJakub Pawlowski } else { 3136baf880a9SJohan Hedberg struct hci_request req; 3137baf880a9SJohan Hedberg 31384c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 31394c87eaabSAndre Guedes 3140baf880a9SJohan Hedberg hci_req_init(&req, hdev); 3141baf880a9SJohan Hedberg 3142baf880a9SJohan Hedberg memset(&cp, 0, sizeof(cp)); 3143baf880a9SJohan Hedberg memcpy(&cp.lap, lap, sizeof(cp.lap)); 3144baf880a9SJohan Hedberg cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 3145baf880a9SJohan Hedberg hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 3146baf880a9SJohan Hedberg 31474c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 31484c87eaabSAndre Guedes if (err) { 31494c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 315007d2334aSJakub Pawlowski hci_discovery_set_state(hdev, 315107d2334aSJakub Pawlowski DISCOVERY_STOPPED); 315207d2334aSJakub Pawlowski } 31537dbfac1dSAndre Guedes } 31547dbfac1dSAndre Guedes 31554c87eaabSAndre Guedes hci_dev_unlock(hdev); 31564c87eaabSAndre Guedes break; 31574c87eaabSAndre Guedes } 31587dbfac1dSAndre Guedes } 31597dbfac1dSAndre Guedes 31607ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 31617ba8b4beSAndre Guedes { 31627ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 31637ba8b4beSAndre Guedes le_scan_disable.work); 31644c87eaabSAndre Guedes struct hci_request req; 31654c87eaabSAndre Guedes int err; 31667ba8b4beSAndre Guedes 31677ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 31687ba8b4beSAndre Guedes 31692d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 31702d28cfe7SJakub Pawlowski 31714c87eaabSAndre Guedes hci_req_init(&req, hdev); 31727ba8b4beSAndre Guedes 3173b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 31747ba8b4beSAndre Guedes 31754c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 31764c87eaabSAndre Guedes if (err) 31774c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 317828b75a89SAndre Guedes } 317928b75a89SAndre Guedes 31802d28cfe7SJakub Pawlowski static void le_scan_restart_work_complete(struct hci_dev *hdev, u8 status, 31812d28cfe7SJakub Pawlowski u16 opcode) 31822d28cfe7SJakub Pawlowski { 31832d28cfe7SJakub Pawlowski unsigned long timeout, duration, scan_start, now; 31842d28cfe7SJakub Pawlowski 31852d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 31862d28cfe7SJakub Pawlowski 31872d28cfe7SJakub Pawlowski if (status) { 31882d28cfe7SJakub Pawlowski BT_ERR("Failed to restart LE scan: status %d", status); 31892d28cfe7SJakub Pawlowski return; 31902d28cfe7SJakub Pawlowski } 31912d28cfe7SJakub Pawlowski 31922d28cfe7SJakub Pawlowski if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) || 31932d28cfe7SJakub Pawlowski !hdev->discovery.scan_start) 31942d28cfe7SJakub Pawlowski return; 31952d28cfe7SJakub Pawlowski 31962d28cfe7SJakub Pawlowski /* When the scan was started, hdev->le_scan_disable has been queued 31972d28cfe7SJakub Pawlowski * after duration from scan_start. During scan restart this job 31982d28cfe7SJakub Pawlowski * has been canceled, and we need to queue it again after proper 31992d28cfe7SJakub Pawlowski * timeout, to make sure that scan does not run indefinitely. 32002d28cfe7SJakub Pawlowski */ 32012d28cfe7SJakub Pawlowski duration = hdev->discovery.scan_duration; 32022d28cfe7SJakub Pawlowski scan_start = hdev->discovery.scan_start; 32032d28cfe7SJakub Pawlowski now = jiffies; 32042d28cfe7SJakub Pawlowski if (now - scan_start <= duration) { 32052d28cfe7SJakub Pawlowski int elapsed; 32062d28cfe7SJakub Pawlowski 32072d28cfe7SJakub Pawlowski if (now >= scan_start) 32082d28cfe7SJakub Pawlowski elapsed = now - scan_start; 32092d28cfe7SJakub Pawlowski else 32102d28cfe7SJakub Pawlowski elapsed = ULONG_MAX - scan_start + now; 32112d28cfe7SJakub Pawlowski 32122d28cfe7SJakub Pawlowski timeout = duration - elapsed; 32132d28cfe7SJakub Pawlowski } else { 32142d28cfe7SJakub Pawlowski timeout = 0; 32152d28cfe7SJakub Pawlowski } 32162d28cfe7SJakub Pawlowski queue_delayed_work(hdev->workqueue, 32172d28cfe7SJakub Pawlowski &hdev->le_scan_disable, timeout); 32182d28cfe7SJakub Pawlowski } 32192d28cfe7SJakub Pawlowski 32202d28cfe7SJakub Pawlowski static void le_scan_restart_work(struct work_struct *work) 32212d28cfe7SJakub Pawlowski { 32222d28cfe7SJakub Pawlowski struct hci_dev *hdev = container_of(work, struct hci_dev, 32232d28cfe7SJakub Pawlowski le_scan_restart.work); 32242d28cfe7SJakub Pawlowski struct hci_request req; 32252d28cfe7SJakub Pawlowski struct hci_cp_le_set_scan_enable cp; 32262d28cfe7SJakub Pawlowski int err; 32272d28cfe7SJakub Pawlowski 32282d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 32292d28cfe7SJakub Pawlowski 32302d28cfe7SJakub Pawlowski /* If controller is not scanning we are done. */ 3231d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_LE_SCAN)) 32322d28cfe7SJakub Pawlowski return; 32332d28cfe7SJakub Pawlowski 32342d28cfe7SJakub Pawlowski hci_req_init(&req, hdev); 32352d28cfe7SJakub Pawlowski 32362d28cfe7SJakub Pawlowski hci_req_add_le_scan_disable(&req); 32372d28cfe7SJakub Pawlowski 32382d28cfe7SJakub Pawlowski memset(&cp, 0, sizeof(cp)); 32392d28cfe7SJakub Pawlowski cp.enable = LE_SCAN_ENABLE; 32402d28cfe7SJakub Pawlowski cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 32412d28cfe7SJakub Pawlowski hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 32422d28cfe7SJakub Pawlowski 32432d28cfe7SJakub Pawlowski err = hci_req_run(&req, le_scan_restart_work_complete); 32442d28cfe7SJakub Pawlowski if (err) 32452d28cfe7SJakub Pawlowski BT_ERR("Restart LE scan request failed: err %d", err); 32462d28cfe7SJakub Pawlowski } 32472d28cfe7SJakub Pawlowski 3248a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3249a1f4c318SJohan Hedberg * 3250a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3251a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3252a1f4c318SJohan Hedberg * the static random address. 3253a1f4c318SJohan Hedberg * 3254a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3255a1f4c318SJohan Hedberg * public address to use the static random address instead. 325650b5b952SMarcel Holtmann * 325750b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 325850b5b952SMarcel Holtmann * userspace has configured a static address, then that address 325950b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 3260a1f4c318SJohan Hedberg */ 3261a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3262a1f4c318SJohan Hedberg u8 *bdaddr_type) 3263a1f4c318SJohan Hedberg { 3264b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 326550b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 3266d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 326750b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 3268a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3269a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3270a1f4c318SJohan Hedberg } else { 3271a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3272a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3273a1f4c318SJohan Hedberg } 3274a1f4c318SJohan Hedberg } 3275a1f4c318SJohan Hedberg 32769be0dab7SDavid Herrmann /* Alloc HCI device */ 32779be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 32789be0dab7SDavid Herrmann { 32799be0dab7SDavid Herrmann struct hci_dev *hdev; 32809be0dab7SDavid Herrmann 328127f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 32829be0dab7SDavid Herrmann if (!hdev) 32839be0dab7SDavid Herrmann return NULL; 32849be0dab7SDavid Herrmann 3285b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3286b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3287b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3288b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3289b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 329096c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3291bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3292bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3293d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 3294d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 32955d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 3296b1b813d4SDavid Herrmann 3297b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3298b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3299b1b813d4SDavid Herrmann 33003f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3301628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3302628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3303bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3304bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 33054e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 33064e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 330704fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 330804fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3309a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3310a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3311a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3312a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3313a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3314a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 3315bef64738SMarcel Holtmann 3316d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3317b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 331831ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 331931ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3320d6bfd59cSJohan Hedberg 3321b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3322b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3323b1b813d4SDavid Herrmann 3324b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3325b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 33266659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3327b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3328b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3329b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3330970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3331b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3332d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 333315819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 333477a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 333566f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 33366b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3337d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3338b1b813d4SDavid Herrmann 3339b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3340b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3341b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3342b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3343c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3344b1b813d4SDavid Herrmann 3345b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3346b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3347b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 33482d28cfe7SJakub Pawlowski INIT_DELAYED_WORK(&hdev->le_scan_restart, le_scan_restart_work); 33495d900e46SFlorian Grandel INIT_DELAYED_WORK(&hdev->adv_instance_expire, hci_adv_timeout_expire); 3350b1b813d4SDavid Herrmann 3351b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3352b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3353b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3354b1b813d4SDavid Herrmann 3355b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3356b1b813d4SDavid Herrmann 335765cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3358b1b813d4SDavid Herrmann 3359b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3360b1b813d4SDavid Herrmann discovery_init(hdev); 33619be0dab7SDavid Herrmann 33629be0dab7SDavid Herrmann return hdev; 33639be0dab7SDavid Herrmann } 33649be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 33659be0dab7SDavid Herrmann 33669be0dab7SDavid Herrmann /* Free HCI device */ 33679be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 33689be0dab7SDavid Herrmann { 33699be0dab7SDavid Herrmann /* will free via device release */ 33709be0dab7SDavid Herrmann put_device(&hdev->dev); 33719be0dab7SDavid Herrmann } 33729be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 33739be0dab7SDavid Herrmann 33741da177e4SLinus Torvalds /* Register HCI device */ 33751da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 33761da177e4SLinus Torvalds { 3377b1b813d4SDavid Herrmann int id, error; 33781da177e4SLinus Torvalds 337974292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 33801da177e4SLinus Torvalds return -EINVAL; 33811da177e4SLinus Torvalds 338208add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 338308add513SMat Martineau * so the index can be used as the AMP controller ID. 338408add513SMat Martineau */ 33853df92b31SSasha Levin switch (hdev->dev_type) { 33863df92b31SSasha Levin case HCI_BREDR: 33873df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 33881da177e4SLinus Torvalds break; 33893df92b31SSasha Levin case HCI_AMP: 33903df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 33913df92b31SSasha Levin break; 33923df92b31SSasha Levin default: 33933df92b31SSasha Levin return -EINVAL; 33941da177e4SLinus Torvalds } 33951da177e4SLinus Torvalds 33963df92b31SSasha Levin if (id < 0) 33973df92b31SSasha Levin return id; 33983df92b31SSasha Levin 33991da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 34001da177e4SLinus Torvalds hdev->id = id; 34012d8b3a11SAndrei Emeltchenko 34022d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 34032d8b3a11SAndrei Emeltchenko 3404d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3405d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 340633ca954dSDavid Herrmann if (!hdev->workqueue) { 340733ca954dSDavid Herrmann error = -ENOMEM; 340833ca954dSDavid Herrmann goto err; 340933ca954dSDavid Herrmann } 3410f48fd9c8SMarcel Holtmann 3411d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3412d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 34136ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 34146ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 34156ead1bbcSJohan Hedberg error = -ENOMEM; 34166ead1bbcSJohan Hedberg goto err; 34176ead1bbcSJohan Hedberg } 34186ead1bbcSJohan Hedberg 34190153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 34200153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 34210153e2ecSMarcel Holtmann 3422bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3423bdc3e0f1SMarcel Holtmann 3424bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 342533ca954dSDavid Herrmann if (error < 0) 342654506918SJohan Hedberg goto err_wqueue; 34271da177e4SLinus Torvalds 3428611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3429a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3430a8c5fb1aSGustavo Padovan hdev); 3431611b30f7SMarcel Holtmann if (hdev->rfkill) { 3432611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3433611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3434611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3435611b30f7SMarcel Holtmann } 3436611b30f7SMarcel Holtmann } 3437611b30f7SMarcel Holtmann 34385e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3439a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 34405e130367SJohan Hedberg 3441a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3442a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3443ce2be9acSAndrei Emeltchenko 344401cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 344556f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 344656f87901SJohan Hedberg * through reading supported features during init. 344756f87901SJohan Hedberg */ 3448a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 344956f87901SJohan Hedberg } 3450ce2be9acSAndrei Emeltchenko 3451fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3452fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3453fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3454fcee3377SGustavo Padovan 34554a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 34564a964404SMarcel Holtmann * and should not be included in normal operation. 3457fee746b0SMarcel Holtmann */ 3458fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3459a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3460fee746b0SMarcel Holtmann 346105fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3462dc946bd8SDavid Herrmann hci_dev_hold(hdev); 34631da177e4SLinus Torvalds 346419202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3465fbe96d6fSMarcel Holtmann 34661da177e4SLinus Torvalds return id; 3467f48fd9c8SMarcel Holtmann 346833ca954dSDavid Herrmann err_wqueue: 346933ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 34706ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 347133ca954dSDavid Herrmann err: 34723df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3473f48fd9c8SMarcel Holtmann 347433ca954dSDavid Herrmann return error; 34751da177e4SLinus Torvalds } 34761da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 34771da177e4SLinus Torvalds 34781da177e4SLinus Torvalds /* Unregister HCI device */ 347959735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 34801da177e4SLinus Torvalds { 34812d7cc19eSMarcel Holtmann int id; 3482ef222013SMarcel Holtmann 3483c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 34841da177e4SLinus Torvalds 3485a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 348694324962SJohan Hovold 34873df92b31SSasha Levin id = hdev->id; 34883df92b31SSasha Levin 3489f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 34901da177e4SLinus Torvalds list_del(&hdev->list); 3491f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 34921da177e4SLinus Torvalds 34931da177e4SLinus Torvalds hci_dev_do_close(hdev); 34941da177e4SLinus Torvalds 3495b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3496b9b5ef18SGustavo Padovan 3497ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3498d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3499d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 350009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3501744cf19eSJohan Hedberg mgmt_index_removed(hdev); 350209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 350356e5cb86SJohan Hedberg } 3504ab81cbf9SJohan Hedberg 35052e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 35062e58ef3eSJohan Hedberg * pending list */ 35072e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 35082e58ef3eSJohan Hedberg 350905fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 35101da177e4SLinus Torvalds 3511611b30f7SMarcel Holtmann if (hdev->rfkill) { 3512611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3513611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3514611b30f7SMarcel Holtmann } 3515611b30f7SMarcel Holtmann 3516bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3517147e2d59SDave Young 35180153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 35190153e2ecSMarcel Holtmann 3520f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 35216ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3522f48fd9c8SMarcel Holtmann 352309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3524dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 35256659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 35262aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 352755ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3528b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3529970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 35302763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3531d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3532dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3533373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 353422078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 353509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3536e2e0cacbSJohan Hedberg 3537dc946bd8SDavid Herrmann hci_dev_put(hdev); 35383df92b31SSasha Levin 35393df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 35401da177e4SLinus Torvalds } 35411da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 35421da177e4SLinus Torvalds 35431da177e4SLinus Torvalds /* Suspend HCI device */ 35441da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 35451da177e4SLinus Torvalds { 354605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 35471da177e4SLinus Torvalds return 0; 35481da177e4SLinus Torvalds } 35491da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 35501da177e4SLinus Torvalds 35511da177e4SLinus Torvalds /* Resume HCI device */ 35521da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 35531da177e4SLinus Torvalds { 355405fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 35551da177e4SLinus Torvalds return 0; 35561da177e4SLinus Torvalds } 35571da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 35581da177e4SLinus Torvalds 355975e0569fSMarcel Holtmann /* Reset HCI device */ 356075e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 356175e0569fSMarcel Holtmann { 356275e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 356375e0569fSMarcel Holtmann struct sk_buff *skb; 356475e0569fSMarcel Holtmann 356575e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 356675e0569fSMarcel Holtmann if (!skb) 356775e0569fSMarcel Holtmann return -ENOMEM; 356875e0569fSMarcel Holtmann 3569d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 357075e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 357175e0569fSMarcel Holtmann 357275e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 357375e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 357475e0569fSMarcel Holtmann } 357575e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 357675e0569fSMarcel Holtmann 357776bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3578e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 357976bca880SMarcel Holtmann { 358076bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 358176bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 358276bca880SMarcel Holtmann kfree_skb(skb); 358376bca880SMarcel Holtmann return -ENXIO; 358476bca880SMarcel Holtmann } 358576bca880SMarcel Holtmann 3586d79f34e3SMarcel Holtmann if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT && 3587d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT && 3588d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_SCODATA_PKT) { 3589fe806dceSMarcel Holtmann kfree_skb(skb); 3590fe806dceSMarcel Holtmann return -EINVAL; 3591fe806dceSMarcel Holtmann } 3592fe806dceSMarcel Holtmann 3593d82603c6SJorrit Schippers /* Incoming skb */ 359476bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 359576bca880SMarcel Holtmann 359676bca880SMarcel Holtmann /* Time stamp */ 359776bca880SMarcel Holtmann __net_timestamp(skb); 359876bca880SMarcel Holtmann 359976bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3600b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3601c78ae283SMarcel Holtmann 360276bca880SMarcel Holtmann return 0; 360376bca880SMarcel Holtmann } 360476bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 360576bca880SMarcel Holtmann 3606e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3607e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3608e875ff84SMarcel Holtmann { 3609581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3610d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_DIAG_PKT; 3611581d6fd6SMarcel Holtmann 3612e875ff84SMarcel Holtmann /* Time stamp */ 3613e875ff84SMarcel Holtmann __net_timestamp(skb); 3614e875ff84SMarcel Holtmann 3615581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3616581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3617e875ff84SMarcel Holtmann 3618e875ff84SMarcel Holtmann return 0; 3619e875ff84SMarcel Holtmann } 3620e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3621e875ff84SMarcel Holtmann 36221da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 36231da177e4SLinus Torvalds 36241da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 36251da177e4SLinus Torvalds { 36261da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 36271da177e4SLinus Torvalds 3628fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 362900629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3630fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 36311da177e4SLinus Torvalds 36321da177e4SLinus Torvalds return 0; 36331da177e4SLinus Torvalds } 36341da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 36351da177e4SLinus Torvalds 36361da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 36371da177e4SLinus Torvalds { 36381da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 36391da177e4SLinus Torvalds 3640fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 36411da177e4SLinus Torvalds list_del(&cb->list); 3642fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 36431da177e4SLinus Torvalds 36441da177e4SLinus Torvalds return 0; 36451da177e4SLinus Torvalds } 36461da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 36471da177e4SLinus Torvalds 364851086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 36491da177e4SLinus Torvalds { 3650cdc52faaSMarcel Holtmann int err; 3651cdc52faaSMarcel Holtmann 3652d79f34e3SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb), 3653d79f34e3SMarcel Holtmann skb->len); 36541da177e4SLinus Torvalds 36551da177e4SLinus Torvalds /* Time stamp */ 3656a61bbcf2SPatrick McHardy __net_timestamp(skb); 36571da177e4SLinus Torvalds 3658cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3659cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3660cd82e61cSMarcel Holtmann 3661cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3662cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3663470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 36641da177e4SLinus Torvalds } 36651da177e4SLinus Torvalds 36661da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 36671da177e4SLinus Torvalds skb_orphan(skb); 36681da177e4SLinus Torvalds 366973d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 367073d0d3c8SMarcel Holtmann kfree_skb(skb); 367173d0d3c8SMarcel Holtmann return; 367273d0d3c8SMarcel Holtmann } 367373d0d3c8SMarcel Holtmann 3674cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3675cdc52faaSMarcel Holtmann if (err < 0) { 3676cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3677cdc52faaSMarcel Holtmann kfree_skb(skb); 3678cdc52faaSMarcel Holtmann } 36791da177e4SLinus Torvalds } 36801da177e4SLinus Torvalds 36811ca3a9d0SJohan Hedberg /* Send HCI command */ 368207dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 368307dc93ddSJohan Hedberg const void *param) 36841ca3a9d0SJohan Hedberg { 36851ca3a9d0SJohan Hedberg struct sk_buff *skb; 36861ca3a9d0SJohan Hedberg 36871ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 36881ca3a9d0SJohan Hedberg 36891ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 36901ca3a9d0SJohan Hedberg if (!skb) { 36911ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 36921ca3a9d0SJohan Hedberg return -ENOMEM; 36931ca3a9d0SJohan Hedberg } 36941ca3a9d0SJohan Hedberg 369549c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 369611714b3dSJohan Hedberg * single-command requests. 369711714b3dSJohan Hedberg */ 369844d27137SJohan Hedberg bt_cb(skb)->hci.req_flags |= HCI_REQ_START; 369911714b3dSJohan Hedberg 37001da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3701c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 37021da177e4SLinus Torvalds 37031da177e4SLinus Torvalds return 0; 37041da177e4SLinus Torvalds } 37051da177e4SLinus Torvalds 37061da177e4SLinus Torvalds /* Get data from the previously sent command */ 3707a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 37081da177e4SLinus Torvalds { 37091da177e4SLinus Torvalds struct hci_command_hdr *hdr; 37101da177e4SLinus Torvalds 37111da177e4SLinus Torvalds if (!hdev->sent_cmd) 37121da177e4SLinus Torvalds return NULL; 37131da177e4SLinus Torvalds 37141da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 37151da177e4SLinus Torvalds 3716a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 37171da177e4SLinus Torvalds return NULL; 37181da177e4SLinus Torvalds 3719f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 37201da177e4SLinus Torvalds 37211da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 37221da177e4SLinus Torvalds } 37231da177e4SLinus Torvalds 3724fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3725fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3726fbef168fSLoic Poulain const void *param, u32 timeout) 3727fbef168fSLoic Poulain { 3728fbef168fSLoic Poulain struct sk_buff *skb; 3729fbef168fSLoic Poulain 3730fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3731fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3732fbef168fSLoic Poulain 3733fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3734fbef168fSLoic Poulain 3735fbef168fSLoic Poulain hci_req_lock(hdev); 3736fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3737fbef168fSLoic Poulain hci_req_unlock(hdev); 3738fbef168fSLoic Poulain 3739fbef168fSLoic Poulain return skb; 3740fbef168fSLoic Poulain } 3741fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3742fbef168fSLoic Poulain 37431da177e4SLinus Torvalds /* Send ACL data */ 37441da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 37451da177e4SLinus Torvalds { 37461da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 37471da177e4SLinus Torvalds int len = skb->len; 37481da177e4SLinus Torvalds 3749badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3750badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 37519c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3752aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3753aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 37541da177e4SLinus Torvalds } 37551da177e4SLinus Torvalds 3756ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 375773d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 37581da177e4SLinus Torvalds { 3759ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 37601da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37611da177e4SLinus Torvalds struct sk_buff *list; 37621da177e4SLinus Torvalds 3763087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3764087bfd99SGustavo Padovan skb->data_len = 0; 3765087bfd99SGustavo Padovan 3766d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3767204a6e54SAndrei Emeltchenko 3768204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3769204a6e54SAndrei Emeltchenko case HCI_BREDR: 3770087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3771204a6e54SAndrei Emeltchenko break; 3772204a6e54SAndrei Emeltchenko case HCI_AMP: 3773204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3774204a6e54SAndrei Emeltchenko break; 3775204a6e54SAndrei Emeltchenko default: 3776204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3777204a6e54SAndrei Emeltchenko return; 3778204a6e54SAndrei Emeltchenko } 3779087bfd99SGustavo Padovan 378070f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 378170f23020SAndrei Emeltchenko if (!list) { 37821da177e4SLinus Torvalds /* Non fragmented */ 37831da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 37841da177e4SLinus Torvalds 378573d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 37861da177e4SLinus Torvalds } else { 37871da177e4SLinus Torvalds /* Fragmented */ 37881da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37891da177e4SLinus Torvalds 37901da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 37911da177e4SLinus Torvalds 37929cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 37939cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 37949cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 37959cfd5a23SJukka Rissanen * deadlocks. 37969cfd5a23SJukka Rissanen */ 37979cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 37981da177e4SLinus Torvalds 379973d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3800e702112fSAndrei Emeltchenko 3801e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3802e702112fSAndrei Emeltchenko flags |= ACL_CONT; 38031da177e4SLinus Torvalds do { 38041da177e4SLinus Torvalds skb = list; list = list->next; 38051da177e4SLinus Torvalds 3806d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3807e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 38081da177e4SLinus Torvalds 38091da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 38101da177e4SLinus Torvalds 381173d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 38121da177e4SLinus Torvalds } while (list); 38131da177e4SLinus Torvalds 38149cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 38151da177e4SLinus Torvalds } 381673d80debSLuiz Augusto von Dentz } 381773d80debSLuiz Augusto von Dentz 381873d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 381973d80debSLuiz Augusto von Dentz { 3820ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 382173d80debSLuiz Augusto von Dentz 3822f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 382373d80debSLuiz Augusto von Dentz 3824ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 38251da177e4SLinus Torvalds 38263eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 38271da177e4SLinus Torvalds } 38281da177e4SLinus Torvalds 38291da177e4SLinus Torvalds /* Send SCO data */ 38300d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 38311da177e4SLinus Torvalds { 38321da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 38331da177e4SLinus Torvalds struct hci_sco_hdr hdr; 38341da177e4SLinus Torvalds 38351da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 38361da177e4SLinus Torvalds 3837aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 38381da177e4SLinus Torvalds hdr.dlen = skb->len; 38391da177e4SLinus Torvalds 3840badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3841badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 38429c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 38431da177e4SLinus Torvalds 3844d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 3845c78ae283SMarcel Holtmann 38461da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 38473eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 38481da177e4SLinus Torvalds } 38491da177e4SLinus Torvalds 38501da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 38511da177e4SLinus Torvalds 38521da177e4SLinus Torvalds /* HCI Connection scheduler */ 38536039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3854a8c5fb1aSGustavo Padovan int *quote) 38551da177e4SLinus Torvalds { 38561da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38578035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3858abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 38591da177e4SLinus Torvalds 38601da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 38611da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3862bf4c6325SGustavo F. Padovan 3863bf4c6325SGustavo F. Padovan rcu_read_lock(); 3864bf4c6325SGustavo F. Padovan 3865bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3866769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 38671da177e4SLinus Torvalds continue; 3868769be974SMarcel Holtmann 3869769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3870769be974SMarcel Holtmann continue; 3871769be974SMarcel Holtmann 38721da177e4SLinus Torvalds num++; 38731da177e4SLinus Torvalds 38741da177e4SLinus Torvalds if (c->sent < min) { 38751da177e4SLinus Torvalds min = c->sent; 38761da177e4SLinus Torvalds conn = c; 38771da177e4SLinus Torvalds } 387852087a79SLuiz Augusto von Dentz 387952087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 388052087a79SLuiz Augusto von Dentz break; 38811da177e4SLinus Torvalds } 38821da177e4SLinus Torvalds 3883bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3884bf4c6325SGustavo F. Padovan 38851da177e4SLinus Torvalds if (conn) { 38866ed58ec5SVille Tervo int cnt, q; 38876ed58ec5SVille Tervo 38886ed58ec5SVille Tervo switch (conn->type) { 38896ed58ec5SVille Tervo case ACL_LINK: 38906ed58ec5SVille Tervo cnt = hdev->acl_cnt; 38916ed58ec5SVille Tervo break; 38926ed58ec5SVille Tervo case SCO_LINK: 38936ed58ec5SVille Tervo case ESCO_LINK: 38946ed58ec5SVille Tervo cnt = hdev->sco_cnt; 38956ed58ec5SVille Tervo break; 38966ed58ec5SVille Tervo case LE_LINK: 38976ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 38986ed58ec5SVille Tervo break; 38996ed58ec5SVille Tervo default: 39006ed58ec5SVille Tervo cnt = 0; 39016ed58ec5SVille Tervo BT_ERR("Unknown link type"); 39026ed58ec5SVille Tervo } 39036ed58ec5SVille Tervo 39046ed58ec5SVille Tervo q = cnt / num; 39051da177e4SLinus Torvalds *quote = q ? q : 1; 39061da177e4SLinus Torvalds } else 39071da177e4SLinus Torvalds *quote = 0; 39081da177e4SLinus Torvalds 39091da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 39101da177e4SLinus Torvalds return conn; 39111da177e4SLinus Torvalds } 39121da177e4SLinus Torvalds 39136039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 39141da177e4SLinus Torvalds { 39151da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 39161da177e4SLinus Torvalds struct hci_conn *c; 39171da177e4SLinus Torvalds 3918bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 39191da177e4SLinus Torvalds 3920bf4c6325SGustavo F. Padovan rcu_read_lock(); 3921bf4c6325SGustavo F. Padovan 39221da177e4SLinus Torvalds /* Kill stalled connections */ 3923bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3924bae1f5d9SVille Tervo if (c->type == type && c->sent) { 39256ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 39266ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3927bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 39281da177e4SLinus Torvalds } 39291da177e4SLinus Torvalds } 3930bf4c6325SGustavo F. Padovan 3931bf4c6325SGustavo F. Padovan rcu_read_unlock(); 39321da177e4SLinus Torvalds } 39331da177e4SLinus Torvalds 39346039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 393573d80debSLuiz Augusto von Dentz int *quote) 393673d80debSLuiz Augusto von Dentz { 393773d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 393873d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3939abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 394073d80debSLuiz Augusto von Dentz struct hci_conn *conn; 394173d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 394273d80debSLuiz Augusto von Dentz 394373d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 394473d80debSLuiz Augusto von Dentz 3945bf4c6325SGustavo F. Padovan rcu_read_lock(); 3946bf4c6325SGustavo F. Padovan 3947bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 394873d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 394973d80debSLuiz Augusto von Dentz 395073d80debSLuiz Augusto von Dentz if (conn->type != type) 395173d80debSLuiz Augusto von Dentz continue; 395273d80debSLuiz Augusto von Dentz 395373d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 395473d80debSLuiz Augusto von Dentz continue; 395573d80debSLuiz Augusto von Dentz 395673d80debSLuiz Augusto von Dentz conn_num++; 395773d80debSLuiz Augusto von Dentz 39588192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 395973d80debSLuiz Augusto von Dentz struct sk_buff *skb; 396073d80debSLuiz Augusto von Dentz 396173d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 396273d80debSLuiz Augusto von Dentz continue; 396373d80debSLuiz Augusto von Dentz 396473d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 396573d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 396673d80debSLuiz Augusto von Dentz continue; 396773d80debSLuiz Augusto von Dentz 396873d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 396973d80debSLuiz Augusto von Dentz num = 0; 397073d80debSLuiz Augusto von Dentz min = ~0; 397173d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 397273d80debSLuiz Augusto von Dentz } 397373d80debSLuiz Augusto von Dentz 397473d80debSLuiz Augusto von Dentz num++; 397573d80debSLuiz Augusto von Dentz 397673d80debSLuiz Augusto von Dentz if (conn->sent < min) { 397773d80debSLuiz Augusto von Dentz min = conn->sent; 397873d80debSLuiz Augusto von Dentz chan = tmp; 397973d80debSLuiz Augusto von Dentz } 398073d80debSLuiz Augusto von Dentz } 398173d80debSLuiz Augusto von Dentz 398273d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 398373d80debSLuiz Augusto von Dentz break; 398473d80debSLuiz Augusto von Dentz } 398573d80debSLuiz Augusto von Dentz 3986bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3987bf4c6325SGustavo F. Padovan 398873d80debSLuiz Augusto von Dentz if (!chan) 398973d80debSLuiz Augusto von Dentz return NULL; 399073d80debSLuiz Augusto von Dentz 399173d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 399273d80debSLuiz Augusto von Dentz case ACL_LINK: 399373d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 399473d80debSLuiz Augusto von Dentz break; 3995bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3996bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3997bd1eb66bSAndrei Emeltchenko break; 399873d80debSLuiz Augusto von Dentz case SCO_LINK: 399973d80debSLuiz Augusto von Dentz case ESCO_LINK: 400073d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 400173d80debSLuiz Augusto von Dentz break; 400273d80debSLuiz Augusto von Dentz case LE_LINK: 400373d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 400473d80debSLuiz Augusto von Dentz break; 400573d80debSLuiz Augusto von Dentz default: 400673d80debSLuiz Augusto von Dentz cnt = 0; 400773d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 400873d80debSLuiz Augusto von Dentz } 400973d80debSLuiz Augusto von Dentz 401073d80debSLuiz Augusto von Dentz q = cnt / num; 401173d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 401273d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 401373d80debSLuiz Augusto von Dentz return chan; 401473d80debSLuiz Augusto von Dentz } 401573d80debSLuiz Augusto von Dentz 401602b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 401702b20f0bSLuiz Augusto von Dentz { 401802b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 401902b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 402002b20f0bSLuiz Augusto von Dentz int num = 0; 402102b20f0bSLuiz Augusto von Dentz 402202b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 402302b20f0bSLuiz Augusto von Dentz 4024bf4c6325SGustavo F. Padovan rcu_read_lock(); 4025bf4c6325SGustavo F. Padovan 4026bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 402702b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 402802b20f0bSLuiz Augusto von Dentz 402902b20f0bSLuiz Augusto von Dentz if (conn->type != type) 403002b20f0bSLuiz Augusto von Dentz continue; 403102b20f0bSLuiz Augusto von Dentz 403202b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 403302b20f0bSLuiz Augusto von Dentz continue; 403402b20f0bSLuiz Augusto von Dentz 403502b20f0bSLuiz Augusto von Dentz num++; 403602b20f0bSLuiz Augusto von Dentz 40378192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 403802b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 403902b20f0bSLuiz Augusto von Dentz 404002b20f0bSLuiz Augusto von Dentz if (chan->sent) { 404102b20f0bSLuiz Augusto von Dentz chan->sent = 0; 404202b20f0bSLuiz Augusto von Dentz continue; 404302b20f0bSLuiz Augusto von Dentz } 404402b20f0bSLuiz Augusto von Dentz 404502b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 404602b20f0bSLuiz Augusto von Dentz continue; 404702b20f0bSLuiz Augusto von Dentz 404802b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 404902b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 405002b20f0bSLuiz Augusto von Dentz continue; 405102b20f0bSLuiz Augusto von Dentz 405202b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 405302b20f0bSLuiz Augusto von Dentz 405402b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 405502b20f0bSLuiz Augusto von Dentz skb->priority); 405602b20f0bSLuiz Augusto von Dentz } 405702b20f0bSLuiz Augusto von Dentz 405802b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 405902b20f0bSLuiz Augusto von Dentz break; 406002b20f0bSLuiz Augusto von Dentz } 4061bf4c6325SGustavo F. Padovan 4062bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4063bf4c6325SGustavo F. Padovan 406402b20f0bSLuiz Augusto von Dentz } 406502b20f0bSLuiz Augusto von Dentz 4066b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4067b71d385aSAndrei Emeltchenko { 4068b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4069b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4070b71d385aSAndrei Emeltchenko } 4071b71d385aSAndrei Emeltchenko 40726039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 40731da177e4SLinus Torvalds { 4074d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 40751da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 40761da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 407763d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 40785f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4079bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 40801da177e4SLinus Torvalds } 408163d2bc1bSAndrei Emeltchenko } 40821da177e4SLinus Torvalds 40836039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 408463d2bc1bSAndrei Emeltchenko { 408563d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 408663d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 408763d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 408863d2bc1bSAndrei Emeltchenko int quote; 408963d2bc1bSAndrei Emeltchenko 409063d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 409104837f64SMarcel Holtmann 409273d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 409373d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4094ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4095ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 409673d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 409773d80debSLuiz Augusto von Dentz skb->len, skb->priority); 409873d80debSLuiz Augusto von Dentz 4099ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4100ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4101ec1cce24SLuiz Augusto von Dentz break; 4102ec1cce24SLuiz Augusto von Dentz 4103ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4104ec1cce24SLuiz Augusto von Dentz 410573d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 410673d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 410704837f64SMarcel Holtmann 410857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41091da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 41101da177e4SLinus Torvalds 41111da177e4SLinus Torvalds hdev->acl_cnt--; 411273d80debSLuiz Augusto von Dentz chan->sent++; 411373d80debSLuiz Augusto von Dentz chan->conn->sent++; 41141da177e4SLinus Torvalds } 41151da177e4SLinus Torvalds } 411602b20f0bSLuiz Augusto von Dentz 411702b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 411802b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 41191da177e4SLinus Torvalds } 41201da177e4SLinus Torvalds 41216039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4122b71d385aSAndrei Emeltchenko { 412363d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4124b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4125b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4126b71d385aSAndrei Emeltchenko int quote; 4127bd1eb66bSAndrei Emeltchenko u8 type; 4128b71d385aSAndrei Emeltchenko 412963d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4130b71d385aSAndrei Emeltchenko 4131bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4132bd1eb66bSAndrei Emeltchenko 4133bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4134bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4135bd1eb66bSAndrei Emeltchenko else 4136bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4137bd1eb66bSAndrei Emeltchenko 4138b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4139bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4140b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4141b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4142b71d385aSAndrei Emeltchenko int blocks; 4143b71d385aSAndrei Emeltchenko 4144b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4145b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4146b71d385aSAndrei Emeltchenko 4147b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4148b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4149b71d385aSAndrei Emeltchenko break; 4150b71d385aSAndrei Emeltchenko 4151b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4152b71d385aSAndrei Emeltchenko 4153b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4154b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4155b71d385aSAndrei Emeltchenko return; 4156b71d385aSAndrei Emeltchenko 4157b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4158b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4159b71d385aSAndrei Emeltchenko 416057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4161b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4162b71d385aSAndrei Emeltchenko 4163b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4164b71d385aSAndrei Emeltchenko quote -= blocks; 4165b71d385aSAndrei Emeltchenko 4166b71d385aSAndrei Emeltchenko chan->sent += blocks; 4167b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4168b71d385aSAndrei Emeltchenko } 4169b71d385aSAndrei Emeltchenko } 4170b71d385aSAndrei Emeltchenko 4171b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4172bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4173b71d385aSAndrei Emeltchenko } 4174b71d385aSAndrei Emeltchenko 41756039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4176b71d385aSAndrei Emeltchenko { 4177b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4178b71d385aSAndrei Emeltchenko 4179bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4180bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 4181bd1eb66bSAndrei Emeltchenko return; 4182bd1eb66bSAndrei Emeltchenko 4183bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4184bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4185b71d385aSAndrei Emeltchenko return; 4186b71d385aSAndrei Emeltchenko 4187b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4188b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4189b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4190b71d385aSAndrei Emeltchenko break; 4191b71d385aSAndrei Emeltchenko 4192b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4193b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4194b71d385aSAndrei Emeltchenko break; 4195b71d385aSAndrei Emeltchenko } 4196b71d385aSAndrei Emeltchenko } 4197b71d385aSAndrei Emeltchenko 41981da177e4SLinus Torvalds /* Schedule SCO */ 41996039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 42001da177e4SLinus Torvalds { 42011da177e4SLinus Torvalds struct hci_conn *conn; 42021da177e4SLinus Torvalds struct sk_buff *skb; 42031da177e4SLinus Torvalds int quote; 42041da177e4SLinus Torvalds 42051da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 42061da177e4SLinus Torvalds 420752087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 420852087a79SLuiz Augusto von Dentz return; 420952087a79SLuiz Augusto von Dentz 42101da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 42111da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 42121da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 421357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42141da177e4SLinus Torvalds 42151da177e4SLinus Torvalds conn->sent++; 42161da177e4SLinus Torvalds if (conn->sent == ~0) 42171da177e4SLinus Torvalds conn->sent = 0; 42181da177e4SLinus Torvalds } 42191da177e4SLinus Torvalds } 42201da177e4SLinus Torvalds } 42211da177e4SLinus Torvalds 42226039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4223b6a0dc82SMarcel Holtmann { 4224b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4225b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4226b6a0dc82SMarcel Holtmann int quote; 4227b6a0dc82SMarcel Holtmann 4228b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4229b6a0dc82SMarcel Holtmann 423052087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 423152087a79SLuiz Augusto von Dentz return; 423252087a79SLuiz Augusto von Dentz 42338fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 42348fc9ced3SGustavo Padovan "e))) { 4235b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4236b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 423757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4238b6a0dc82SMarcel Holtmann 4239b6a0dc82SMarcel Holtmann conn->sent++; 4240b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4241b6a0dc82SMarcel Holtmann conn->sent = 0; 4242b6a0dc82SMarcel Holtmann } 4243b6a0dc82SMarcel Holtmann } 4244b6a0dc82SMarcel Holtmann } 4245b6a0dc82SMarcel Holtmann 42466039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 42476ed58ec5SVille Tervo { 424873d80debSLuiz Augusto von Dentz struct hci_chan *chan; 42496ed58ec5SVille Tervo struct sk_buff *skb; 425002b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 42516ed58ec5SVille Tervo 42526ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 42536ed58ec5SVille Tervo 425452087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 425552087a79SLuiz Augusto von Dentz return; 425652087a79SLuiz Augusto von Dentz 4257d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 42586ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 42596ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4260bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 42616ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4262bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 42636ed58ec5SVille Tervo } 42646ed58ec5SVille Tervo 42656ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 426602b20f0bSLuiz Augusto von Dentz tmp = cnt; 426773d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4268ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4269ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 427073d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 427173d80debSLuiz Augusto von Dentz skb->len, skb->priority); 42726ed58ec5SVille Tervo 4273ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4274ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4275ec1cce24SLuiz Augusto von Dentz break; 4276ec1cce24SLuiz Augusto von Dentz 4277ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4278ec1cce24SLuiz Augusto von Dentz 427957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42806ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 42816ed58ec5SVille Tervo 42826ed58ec5SVille Tervo cnt--; 428373d80debSLuiz Augusto von Dentz chan->sent++; 428473d80debSLuiz Augusto von Dentz chan->conn->sent++; 42856ed58ec5SVille Tervo } 42866ed58ec5SVille Tervo } 428773d80debSLuiz Augusto von Dentz 42886ed58ec5SVille Tervo if (hdev->le_pkts) 42896ed58ec5SVille Tervo hdev->le_cnt = cnt; 42906ed58ec5SVille Tervo else 42916ed58ec5SVille Tervo hdev->acl_cnt = cnt; 429202b20f0bSLuiz Augusto von Dentz 429302b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 429402b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 42956ed58ec5SVille Tervo } 42966ed58ec5SVille Tervo 42973eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 42981da177e4SLinus Torvalds { 42993eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 43001da177e4SLinus Torvalds struct sk_buff *skb; 43011da177e4SLinus Torvalds 43026ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 43036ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 43041da177e4SLinus Torvalds 4305d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 43061da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 43071da177e4SLinus Torvalds hci_sched_acl(hdev); 43081da177e4SLinus Torvalds hci_sched_sco(hdev); 4309b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 43106ed58ec5SVille Tervo hci_sched_le(hdev); 431152de599eSMarcel Holtmann } 43126ed58ec5SVille Tervo 43131da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 43141da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 431557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 43161da177e4SLinus Torvalds } 43171da177e4SLinus Torvalds 431825985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 43191da177e4SLinus Torvalds 43201da177e4SLinus Torvalds /* ACL data packet */ 43216039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 43221da177e4SLinus Torvalds { 43231da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 43241da177e4SLinus Torvalds struct hci_conn *conn; 43251da177e4SLinus Torvalds __u16 handle, flags; 43261da177e4SLinus Torvalds 43271da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 43281da177e4SLinus Torvalds 43291da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 43301da177e4SLinus Torvalds flags = hci_flags(handle); 43311da177e4SLinus Torvalds handle = hci_handle(handle); 43321da177e4SLinus Torvalds 4333f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4334a8c5fb1aSGustavo Padovan handle, flags); 43351da177e4SLinus Torvalds 43361da177e4SLinus Torvalds hdev->stat.acl_rx++; 43371da177e4SLinus Torvalds 43381da177e4SLinus Torvalds hci_dev_lock(hdev); 43391da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 43401da177e4SLinus Torvalds hci_dev_unlock(hdev); 43411da177e4SLinus Torvalds 43421da177e4SLinus Torvalds if (conn) { 434365983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 434404837f64SMarcel Holtmann 43451da177e4SLinus Torvalds /* Send to upper protocol */ 4346686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 43471da177e4SLinus Torvalds return; 43481da177e4SLinus Torvalds } else { 43491da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 43501da177e4SLinus Torvalds hdev->name, handle); 43511da177e4SLinus Torvalds } 43521da177e4SLinus Torvalds 43531da177e4SLinus Torvalds kfree_skb(skb); 43541da177e4SLinus Torvalds } 43551da177e4SLinus Torvalds 43561da177e4SLinus Torvalds /* SCO data packet */ 43576039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 43581da177e4SLinus Torvalds { 43591da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 43601da177e4SLinus Torvalds struct hci_conn *conn; 43611da177e4SLinus Torvalds __u16 handle; 43621da177e4SLinus Torvalds 43631da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 43641da177e4SLinus Torvalds 43651da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 43661da177e4SLinus Torvalds 4367f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 43681da177e4SLinus Torvalds 43691da177e4SLinus Torvalds hdev->stat.sco_rx++; 43701da177e4SLinus Torvalds 43711da177e4SLinus Torvalds hci_dev_lock(hdev); 43721da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 43731da177e4SLinus Torvalds hci_dev_unlock(hdev); 43741da177e4SLinus Torvalds 43751da177e4SLinus Torvalds if (conn) { 43761da177e4SLinus Torvalds /* Send to upper protocol */ 4377686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 43781da177e4SLinus Torvalds return; 43791da177e4SLinus Torvalds } else { 43801da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 43811da177e4SLinus Torvalds hdev->name, handle); 43821da177e4SLinus Torvalds } 43831da177e4SLinus Torvalds 43841da177e4SLinus Torvalds kfree_skb(skb); 43851da177e4SLinus Torvalds } 43861da177e4SLinus Torvalds 43879238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 43889238f36aSJohan Hedberg { 43899238f36aSJohan Hedberg struct sk_buff *skb; 43909238f36aSJohan Hedberg 43919238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 43929238f36aSJohan Hedberg if (!skb) 43939238f36aSJohan Hedberg return true; 43949238f36aSJohan Hedberg 439544d27137SJohan Hedberg return (bt_cb(skb)->hci.req_flags & HCI_REQ_START); 43969238f36aSJohan Hedberg } 43979238f36aSJohan Hedberg 439842c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 439942c6b129SJohan Hedberg { 440042c6b129SJohan Hedberg struct hci_command_hdr *sent; 440142c6b129SJohan Hedberg struct sk_buff *skb; 440242c6b129SJohan Hedberg u16 opcode; 440342c6b129SJohan Hedberg 440442c6b129SJohan Hedberg if (!hdev->sent_cmd) 440542c6b129SJohan Hedberg return; 440642c6b129SJohan Hedberg 440742c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 440842c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 440942c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 441042c6b129SJohan Hedberg return; 441142c6b129SJohan Hedberg 441242c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 441342c6b129SJohan Hedberg if (!skb) 441442c6b129SJohan Hedberg return; 441542c6b129SJohan Hedberg 441642c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 441742c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 441842c6b129SJohan Hedberg } 441942c6b129SJohan Hedberg 4420e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4421e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4422e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 44239238f36aSJohan Hedberg { 44249238f36aSJohan Hedberg struct sk_buff *skb; 44259238f36aSJohan Hedberg unsigned long flags; 44269238f36aSJohan Hedberg 44279238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 44289238f36aSJohan Hedberg 442942c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 443042c6b129SJohan Hedberg * sent we need to do special handling of it. 44319238f36aSJohan Hedberg */ 443242c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 443342c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 443442c6b129SJohan Hedberg * reset complete event during init and any pending 443542c6b129SJohan Hedberg * command will never be completed. In such a case we 443642c6b129SJohan Hedberg * need to resend whatever was the last sent 443742c6b129SJohan Hedberg * command. 443842c6b129SJohan Hedberg */ 443942c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 444042c6b129SJohan Hedberg hci_resend_last(hdev); 444142c6b129SJohan Hedberg 44429238f36aSJohan Hedberg return; 444342c6b129SJohan Hedberg } 44449238f36aSJohan Hedberg 44459238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 44469238f36aSJohan Hedberg * this request the request is not yet complete. 44479238f36aSJohan Hedberg */ 44489238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 44499238f36aSJohan Hedberg return; 44509238f36aSJohan Hedberg 44519238f36aSJohan Hedberg /* If this was the last command in a request the complete 44529238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 44539238f36aSJohan Hedberg * command queue (hdev->cmd_q). 44549238f36aSJohan Hedberg */ 445544d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_flags & HCI_REQ_SKB) { 445644d27137SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4457e6214487SJohan Hedberg return; 44589238f36aSJohan Hedberg } 4459e6214487SJohan Hedberg 446044d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 446144d27137SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4462e6214487SJohan Hedberg return; 446353e21fbcSJohan Hedberg } 44649238f36aSJohan Hedberg 44659238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 44669238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44679238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 446844d27137SJohan Hedberg if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) { 44699238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 44709238f36aSJohan Hedberg break; 44719238f36aSJohan Hedberg } 44729238f36aSJohan Hedberg 4473242c0ebdSMarcel Holtmann *req_complete = bt_cb(skb)->hci.req_complete; 4474242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 44759238f36aSJohan Hedberg kfree_skb(skb); 44769238f36aSJohan Hedberg } 44779238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44789238f36aSJohan Hedberg } 44799238f36aSJohan Hedberg 4480b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 44811da177e4SLinus Torvalds { 4482b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 44831da177e4SLinus Torvalds struct sk_buff *skb; 44841da177e4SLinus Torvalds 44851da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 44861da177e4SLinus Torvalds 44871da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4488cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4489cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4490cd82e61cSMarcel Holtmann 44911da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 44921da177e4SLinus Torvalds /* Send copy to the sockets */ 4493470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44941da177e4SLinus Torvalds } 44951da177e4SLinus Torvalds 4496d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 44971da177e4SLinus Torvalds kfree_skb(skb); 44981da177e4SLinus Torvalds continue; 44991da177e4SLinus Torvalds } 45001da177e4SLinus Torvalds 45011da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 45021da177e4SLinus Torvalds /* Don't process data packets in this states. */ 4503d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 45041da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 45051da177e4SLinus Torvalds case HCI_SCODATA_PKT: 45061da177e4SLinus Torvalds kfree_skb(skb); 45071da177e4SLinus Torvalds continue; 45083ff50b79SStephen Hemminger } 45091da177e4SLinus Torvalds } 45101da177e4SLinus Torvalds 45111da177e4SLinus Torvalds /* Process frame */ 4512d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 45131da177e4SLinus Torvalds case HCI_EVENT_PKT: 4514b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 45151da177e4SLinus Torvalds hci_event_packet(hdev, skb); 45161da177e4SLinus Torvalds break; 45171da177e4SLinus Torvalds 45181da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 45191da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 45201da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 45211da177e4SLinus Torvalds break; 45221da177e4SLinus Torvalds 45231da177e4SLinus Torvalds case HCI_SCODATA_PKT: 45241da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 45251da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 45261da177e4SLinus Torvalds break; 45271da177e4SLinus Torvalds 45281da177e4SLinus Torvalds default: 45291da177e4SLinus Torvalds kfree_skb(skb); 45301da177e4SLinus Torvalds break; 45311da177e4SLinus Torvalds } 45321da177e4SLinus Torvalds } 45331da177e4SLinus Torvalds } 45341da177e4SLinus Torvalds 4535c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 45361da177e4SLinus Torvalds { 4537c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 45381da177e4SLinus Torvalds struct sk_buff *skb; 45391da177e4SLinus Torvalds 45402104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 45412104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 45421da177e4SLinus Torvalds 45431da177e4SLinus Torvalds /* Send queued commands */ 45445a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 45455a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 45465a08ecceSAndrei Emeltchenko if (!skb) 45475a08ecceSAndrei Emeltchenko return; 45485a08ecceSAndrei Emeltchenko 45491da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 45501da177e4SLinus Torvalds 4551a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 455270f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 45531da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 455457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 45557bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 455665cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 45577bdb8a5cSSzymon Janc else 455865cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 455965cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 45601da177e4SLinus Torvalds } else { 45611da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4562c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45631da177e4SLinus Torvalds } 45641da177e4SLinus Torvalds } 45651da177e4SLinus Torvalds } 4566