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[0] |= 0x10; /* Disconnection Complete */ 538c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 539c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 540c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 541c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 542c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 543c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 5440da71f1bSMarcel Holtmann 5450da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 5460da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 547c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5482177bab5SJohan Hedberg } 5490da71f1bSMarcel Holtmann } 5502177bab5SJohan Hedberg 5512177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 5522177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 5532177bab5SJohan Hedberg 554*70f56aa2SMarcel Holtmann if (lmp_ext_feat_capable(hdev)) 555*70f56aa2SMarcel Holtmann events[4] |= 0x04; /* Read Remote Extended Features Complete */ 556*70f56aa2SMarcel Holtmann 557*70f56aa2SMarcel Holtmann if (lmp_esco_capable(hdev)) { 558*70f56aa2SMarcel Holtmann events[5] |= 0x08; /* Synchronous Connection Complete */ 559*70f56aa2SMarcel Holtmann events[5] |= 0x10; /* Synchronous Connection Changed */ 560*70f56aa2SMarcel Holtmann } 561*70f56aa2SMarcel Holtmann 5622177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 5632177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 5642177bab5SJohan Hedberg 5652177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 5662177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5672177bab5SJohan Hedberg 5682177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 5692177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 5702177bab5SJohan Hedberg 5712177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 5722177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 5732177bab5SJohan Hedberg 5742177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 5752177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 5762177bab5SJohan Hedberg 5772177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 5782177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 5792177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 5802177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 5812177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 5822177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 5832177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 5842177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 5852177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 5862177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 5872177bab5SJohan Hedberg * Features Notification 5882177bab5SJohan Hedberg */ 5892177bab5SJohan Hedberg } 5902177bab5SJohan Hedberg 5912177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 5922177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 5932177bab5SJohan Hedberg 59442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 5952177bab5SJohan Hedberg } 5962177bab5SJohan Hedberg 59742c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 5982177bab5SJohan Hedberg { 59942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 60042c6b129SJohan Hedberg 6010af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 6020af801b9SJohan Hedberg return amp_init2(req); 6030af801b9SJohan Hedberg 6042177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 60542c6b129SJohan Hedberg bredr_setup(req); 60656f87901SJohan Hedberg else 607a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 6082177bab5SJohan Hedberg 6092177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 61042c6b129SJohan Hedberg le_setup(req); 6112177bab5SJohan Hedberg 6120f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 6130f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 6140f3adeaeSMarcel Holtmann * 6150f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 6160f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 6170f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 6180f3adeaeSMarcel Holtmann * supported commands. 6193f8e2d75SJohan Hedberg */ 6200f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 6210f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 62242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 6232177bab5SJohan Hedberg 6242177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 62557af75a8SMarcel Holtmann /* When SSP is available, then the host features page 62657af75a8SMarcel Holtmann * should also be available as well. However some 62757af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 62857af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 62957af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 63057af75a8SMarcel Holtmann */ 63157af75a8SMarcel Holtmann hdev->max_page = 0x01; 63257af75a8SMarcel Holtmann 633d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 6342177bab5SJohan Hedberg u8 mode = 0x01; 635574ea3c7SMarcel Holtmann 63642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 6372177bab5SJohan Hedberg sizeof(mode), &mode); 6382177bab5SJohan Hedberg } else { 6392177bab5SJohan Hedberg struct hci_cp_write_eir cp; 6402177bab5SJohan Hedberg 6412177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 6422177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6432177bab5SJohan Hedberg 64442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 6452177bab5SJohan Hedberg } 6462177bab5SJohan Hedberg } 6472177bab5SJohan Hedberg 648043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 649043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 65004422da9SMarcel Holtmann u8 mode; 65104422da9SMarcel Holtmann 65204422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 65304422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 65404422da9SMarcel Holtmann * events. 65504422da9SMarcel Holtmann */ 65604422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 65704422da9SMarcel Holtmann 65804422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 65904422da9SMarcel Holtmann } 6602177bab5SJohan Hedberg 6612177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 66242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 6632177bab5SJohan Hedberg 6642177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 6652177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 6662177bab5SJohan Hedberg 6672177bab5SJohan Hedberg cp.page = 0x01; 66842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 66942c6b129SJohan Hedberg sizeof(cp), &cp); 6702177bab5SJohan Hedberg } 6712177bab5SJohan Hedberg 672d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 6732177bab5SJohan Hedberg u8 enable = 1; 67442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 6752177bab5SJohan Hedberg &enable); 6762177bab5SJohan Hedberg } 6772177bab5SJohan Hedberg } 6782177bab5SJohan Hedberg 67942c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 6802177bab5SJohan Hedberg { 68142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6822177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 6832177bab5SJohan Hedberg u16 link_policy = 0; 6842177bab5SJohan Hedberg 6852177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 6862177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 6872177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 6882177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 6892177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 6902177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 6912177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 6922177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 6932177bab5SJohan Hedberg 6942177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 69542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 6962177bab5SJohan Hedberg } 6972177bab5SJohan Hedberg 69842c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 6992177bab5SJohan Hedberg { 70042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 7012177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 7022177bab5SJohan Hedberg 703c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 704c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 705c73eee91SJohan Hedberg return; 706c73eee91SJohan Hedberg 7072177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 7082177bab5SJohan Hedberg 709d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 7102177bab5SJohan Hedberg cp.le = 0x01; 71132226e4fSMarcel Holtmann cp.simul = 0x00; 7122177bab5SJohan Hedberg } 7132177bab5SJohan Hedberg 7142177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 71542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 7162177bab5SJohan Hedberg &cp); 7172177bab5SJohan Hedberg } 7182177bab5SJohan Hedberg 719d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 720d62e6d67SJohan Hedberg { 721d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 722d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 723d62e6d67SJohan Hedberg 724d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 725d62e6d67SJohan Hedberg * enable all necessary events for it. 726d62e6d67SJohan Hedberg */ 72753b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 728d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 729d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 730d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 731d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 732d62e6d67SJohan Hedberg } 733d62e6d67SJohan Hedberg 734d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 735d62e6d67SJohan Hedberg * enable all necessary events for it. 736d62e6d67SJohan Hedberg */ 73753b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 738d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 739d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 740d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 741d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 742d62e6d67SJohan Hedberg } 743d62e6d67SJohan Hedberg 74440c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 745cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 74640c59fcbSMarcel Holtmann events[2] |= 0x80; 74740c59fcbSMarcel Holtmann 748d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 749d62e6d67SJohan Hedberg } 750d62e6d67SJohan Hedberg 75142c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 7522177bab5SJohan Hedberg { 75342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 754d2c5d77fSJohan Hedberg u8 p; 75542c6b129SJohan Hedberg 7560da71f1bSMarcel Holtmann hci_setup_event_mask(req); 7570da71f1bSMarcel Holtmann 758e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 759e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 76048ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 76148ce62c4SMarcel Holtmann 76248ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 76348ce62c4SMarcel Holtmann cp.read_all = 0x01; 76448ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 76548ce62c4SMarcel Holtmann } 76648ce62c4SMarcel Holtmann 7672177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 76842c6b129SJohan Hedberg hci_setup_link_policy(req); 7692177bab5SJohan Hedberg 770417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 771417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 772417287deSMarcel Holtmann 773417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 774417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 775417287deSMarcel Holtmann * this command in the bit mask of supported commands. 776417287deSMarcel Holtmann */ 777417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 778417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 779417287deSMarcel Holtmann 7809193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 7819193c6e8SAndre Guedes u8 events[8]; 7829193c6e8SAndre Guedes 7839193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 7844d6c705bSMarcel Holtmann events[0] = 0x0f; 7854d6c705bSMarcel Holtmann 7864d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 7874d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 788662bc2e6SAndre Guedes 789662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 790662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 791662bc2e6SAndre Guedes */ 792662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 793662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 794662bc2e6SAndre Guedes * Parameter Request 795662bc2e6SAndre Guedes */ 796662bc2e6SAndre Guedes 797a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 798a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 799a9f6068eSMarcel Holtmann */ 800a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 801a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 802a9f6068eSMarcel Holtmann 8034b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 8044b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 8054b71bba4SMarcel Holtmann */ 8064b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 8074b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 8084b71bba4SMarcel Holtmann * Report 8094b71bba4SMarcel Holtmann */ 8104b71bba4SMarcel Holtmann 8115a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 8125a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 8135a34bd5fSMarcel Holtmann */ 8145a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 8155a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 8165a34bd5fSMarcel Holtmann * Public Key Complete 8175a34bd5fSMarcel Holtmann */ 8185a34bd5fSMarcel Holtmann 8195a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 8205a34bd5fSMarcel Holtmann * command, enable the corresponding event. 8215a34bd5fSMarcel Holtmann */ 8225a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 8235a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 8245a34bd5fSMarcel Holtmann 8259193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 8269193c6e8SAndre Guedes events); 8279193c6e8SAndre Guedes 82815a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 82915a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 83015a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 83115a49ccaSMarcel Holtmann } 83215a49ccaSMarcel Holtmann 8332ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 8342ab216a7SMarcel Holtmann /* Read LE White List Size */ 8352ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 8362ab216a7SMarcel Holtmann 0, NULL); 8372ab216a7SMarcel Holtmann } 8382ab216a7SMarcel Holtmann 8392ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 8402ab216a7SMarcel Holtmann /* Clear LE White List */ 8412ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 8422ab216a7SMarcel Holtmann } 8432ab216a7SMarcel Holtmann 844a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 845a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 846a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 847a9f6068eSMarcel Holtmann 848a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 849a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 850a9f6068eSMarcel Holtmann } 851a9f6068eSMarcel Holtmann 85242c6b129SJohan Hedberg hci_set_le_support(req); 8539193c6e8SAndre Guedes } 854d2c5d77fSJohan Hedberg 855d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 856d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 857d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 858d2c5d77fSJohan Hedberg 859d2c5d77fSJohan Hedberg cp.page = p; 860d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 861d2c5d77fSJohan Hedberg sizeof(cp), &cp); 862d2c5d77fSJohan Hedberg } 8632177bab5SJohan Hedberg } 8642177bab5SJohan Hedberg 8655d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 8665d4e7e8dSJohan Hedberg { 8675d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 8685d4e7e8dSJohan Hedberg 86936f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 87036f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 87136f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 87236f260ceSMarcel Holtmann * 87336f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 87436f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 87536f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 87636f260ceSMarcel Holtmann * command redundant anyway. 87736f260ceSMarcel Holtmann * 87836f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 87936f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 88036f260ceSMarcel Holtmann * just disable this command. 88136f260ceSMarcel Holtmann */ 88236f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 88336f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 88436f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 88536f260ceSMarcel Holtmann 88636f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 88736f260ceSMarcel Holtmann cp.delete_all = 0x01; 88836f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 88936f260ceSMarcel Holtmann sizeof(cp), &cp); 89036f260ceSMarcel Holtmann } 89136f260ceSMarcel Holtmann 892d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 893d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 894d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 895d62e6d67SJohan Hedberg 896109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 897109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 898109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 899109e3191SMarcel Holtmann 900f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 901f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 902f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 903f4fe73edSMarcel Holtmann 9045d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 90553b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 9065d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 907a6d0d690SMarcel Holtmann 908a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 909d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 910574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 911a6d0d690SMarcel Holtmann u8 support = 0x01; 912574ea3c7SMarcel Holtmann 913a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 914a6d0d690SMarcel Holtmann sizeof(support), &support); 915a6d0d690SMarcel Holtmann } 9165d4e7e8dSJohan Hedberg } 9175d4e7e8dSJohan Hedberg 9182177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 9192177bab5SJohan Hedberg { 9202177bab5SJohan Hedberg int err; 9212177bab5SJohan Hedberg 9222177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 9232177bab5SJohan Hedberg if (err < 0) 9242177bab5SJohan Hedberg return err; 9252177bab5SJohan Hedberg 926f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 927f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 9284b4148e9SMarcel Holtmann 9292177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 9302177bab5SJohan Hedberg if (err < 0) 9312177bab5SJohan Hedberg return err; 9322177bab5SJohan Hedberg 9330af801b9SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 9340af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 9350af801b9SJohan Hedberg * first two stages of init. 9360af801b9SJohan Hedberg */ 9370af801b9SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 9380af801b9SJohan Hedberg return 0; 9390af801b9SJohan Hedberg 9405d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 9415d4e7e8dSJohan Hedberg if (err < 0) 9425d4e7e8dSJohan Hedberg return err; 9435d4e7e8dSJohan Hedberg 944baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 945baf27f6eSMarcel Holtmann if (err < 0) 946baf27f6eSMarcel Holtmann return err; 947baf27f6eSMarcel Holtmann 948ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 949ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 950ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 951ec6cef9cSMarcel Holtmann * 952ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 953ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 954ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 955ec6cef9cSMarcel Holtmann * be called during the config phase. 956ec6cef9cSMarcel Holtmann * 957ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 958ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 959baf27f6eSMarcel Holtmann */ 960d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 961d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 962baf27f6eSMarcel Holtmann return 0; 963baf27f6eSMarcel Holtmann 96460c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 96560c5f5fbSMarcel Holtmann 96671c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 96760c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9682bfa3531SMarcel Holtmann 969162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 97060c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 971e7b8fc92SMarcel Holtmann 972baf27f6eSMarcel Holtmann return 0; 9732177bab5SJohan Hedberg } 9742177bab5SJohan Hedberg 9750ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 9760ebca7d6SMarcel Holtmann { 9770ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9780ebca7d6SMarcel Holtmann 9790ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9800ebca7d6SMarcel Holtmann 9810ebca7d6SMarcel Holtmann /* Reset */ 9820ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9830ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9840ebca7d6SMarcel Holtmann 9850ebca7d6SMarcel Holtmann /* Read Local Version */ 9860ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9870ebca7d6SMarcel Holtmann 9880ebca7d6SMarcel Holtmann /* Read BD Address */ 9890ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9900ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 9910ebca7d6SMarcel Holtmann } 9920ebca7d6SMarcel Holtmann 9930ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9940ebca7d6SMarcel Holtmann { 9950ebca7d6SMarcel Holtmann int err; 9960ebca7d6SMarcel Holtmann 997cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 998cc78b44bSMarcel Holtmann return 0; 999cc78b44bSMarcel Holtmann 10000ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 10010ebca7d6SMarcel Holtmann if (err < 0) 10020ebca7d6SMarcel Holtmann return err; 10030ebca7d6SMarcel Holtmann 1004f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 1005f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 1006f640ee98SMarcel Holtmann 10070ebca7d6SMarcel Holtmann return 0; 10080ebca7d6SMarcel Holtmann } 10090ebca7d6SMarcel Holtmann 101042c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 10111da177e4SLinus Torvalds { 10121da177e4SLinus Torvalds __u8 scan = opt; 10131da177e4SLinus Torvalds 101442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds /* Inquiry and Page scans */ 101742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 10181da177e4SLinus Torvalds } 10191da177e4SLinus Torvalds 102042c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 10211da177e4SLinus Torvalds { 10221da177e4SLinus Torvalds __u8 auth = opt; 10231da177e4SLinus Torvalds 102442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 10251da177e4SLinus Torvalds 10261da177e4SLinus Torvalds /* Authentication */ 102742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 10281da177e4SLinus Torvalds } 10291da177e4SLinus Torvalds 103042c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 10311da177e4SLinus Torvalds { 10321da177e4SLinus Torvalds __u8 encrypt = opt; 10331da177e4SLinus Torvalds 103442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 10351da177e4SLinus Torvalds 1036e4e8e37cSMarcel Holtmann /* Encryption */ 103742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 10381da177e4SLinus Torvalds } 10391da177e4SLinus Torvalds 104042c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1041e4e8e37cSMarcel Holtmann { 1042e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1043e4e8e37cSMarcel Holtmann 104442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1045e4e8e37cSMarcel Holtmann 1046e4e8e37cSMarcel Holtmann /* Default link policy */ 104742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1048e4e8e37cSMarcel Holtmann } 1049e4e8e37cSMarcel Holtmann 10501da177e4SLinus Torvalds /* Get HCI device by index. 10511da177e4SLinus Torvalds * Device is held on return. */ 10521da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10531da177e4SLinus Torvalds { 10548035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds BT_DBG("%d", index); 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds if (index < 0) 10591da177e4SLinus Torvalds return NULL; 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10628035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10631da177e4SLinus Torvalds if (d->id == index) { 10641da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10651da177e4SLinus Torvalds break; 10661da177e4SLinus Torvalds } 10671da177e4SLinus Torvalds } 10681da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10691da177e4SLinus Torvalds return hdev; 10701da177e4SLinus Torvalds } 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1073ff9ef578SJohan Hedberg 107430dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 107530dc78e1SJohan Hedberg { 107630dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 107730dc78e1SJohan Hedberg 10786fbe195dSAndre Guedes switch (discov->state) { 1079343f935bSAndre Guedes case DISCOVERY_FINDING: 10806fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 108130dc78e1SJohan Hedberg return true; 108230dc78e1SJohan Hedberg 10836fbe195dSAndre Guedes default: 108430dc78e1SJohan Hedberg return false; 108530dc78e1SJohan Hedberg } 10866fbe195dSAndre Guedes } 108730dc78e1SJohan Hedberg 1088ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1089ff9ef578SJohan Hedberg { 1090bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1091bb3e0a33SJohan Hedberg 1092ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1093ff9ef578SJohan Hedberg 1094bb3e0a33SJohan Hedberg if (old_state == state) 1095ff9ef578SJohan Hedberg return; 1096ff9ef578SJohan Hedberg 1097bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1098bb3e0a33SJohan Hedberg 1099ff9ef578SJohan Hedberg switch (state) { 1100ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1101c54c3860SAndre Guedes hci_update_background_scan(hdev); 1102c54c3860SAndre Guedes 1103bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1104ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1105ff9ef578SJohan Hedberg break; 1106ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1107ff9ef578SJohan Hedberg break; 1108343f935bSAndre Guedes case DISCOVERY_FINDING: 1109ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1110ff9ef578SJohan Hedberg break; 111130dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 111230dc78e1SJohan Hedberg break; 1113ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1114ff9ef578SJohan Hedberg break; 1115ff9ef578SJohan Hedberg } 1116ff9ef578SJohan Hedberg } 1117ff9ef578SJohan Hedberg 11181f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 11191da177e4SLinus Torvalds { 112030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1121b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 11221da177e4SLinus Torvalds 1123561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1124561aafbcSJohan Hedberg list_del(&p->all); 1125b57c1a56SJohan Hedberg kfree(p); 11261da177e4SLinus Torvalds } 1127561aafbcSJohan Hedberg 1128561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1129561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 11301da177e4SLinus Torvalds } 11311da177e4SLinus Torvalds 1132a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1133a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 11341da177e4SLinus Torvalds { 113530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11361da177e4SLinus Torvalds struct inquiry_entry *e; 11371da177e4SLinus Torvalds 11386ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 11391da177e4SLinus Torvalds 1140561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11411da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 11421da177e4SLinus Torvalds return e; 11431da177e4SLinus Torvalds } 11441da177e4SLinus Torvalds 1145b57c1a56SJohan Hedberg return NULL; 1146b57c1a56SJohan Hedberg } 1147b57c1a56SJohan Hedberg 1148561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1149561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1150561aafbcSJohan Hedberg { 115130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1152561aafbcSJohan Hedberg struct inquiry_entry *e; 1153561aafbcSJohan Hedberg 11546ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1155561aafbcSJohan Hedberg 1156561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1157561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1158561aafbcSJohan Hedberg return e; 1159561aafbcSJohan Hedberg } 1160561aafbcSJohan Hedberg 1161561aafbcSJohan Hedberg return NULL; 1162561aafbcSJohan Hedberg } 1163561aafbcSJohan Hedberg 116430dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 116530dc78e1SJohan Hedberg bdaddr_t *bdaddr, 116630dc78e1SJohan Hedberg int state) 116730dc78e1SJohan Hedberg { 116830dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 116930dc78e1SJohan Hedberg struct inquiry_entry *e; 117030dc78e1SJohan Hedberg 11716ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 117230dc78e1SJohan Hedberg 117330dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 117430dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 117530dc78e1SJohan Hedberg return e; 117630dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 117730dc78e1SJohan Hedberg return e; 117830dc78e1SJohan Hedberg } 117930dc78e1SJohan Hedberg 118030dc78e1SJohan Hedberg return NULL; 118130dc78e1SJohan Hedberg } 118230dc78e1SJohan Hedberg 1183a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1184a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1185a3d4e20aSJohan Hedberg { 1186a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1187a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1188a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1189a3d4e20aSJohan Hedberg 1190a3d4e20aSJohan Hedberg list_del(&ie->list); 1191a3d4e20aSJohan Hedberg 1192a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1193a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1194a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1195a3d4e20aSJohan Hedberg break; 1196a3d4e20aSJohan Hedberg pos = &p->list; 1197a3d4e20aSJohan Hedberg } 1198a3d4e20aSJohan Hedberg 1199a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1200a3d4e20aSJohan Hedberg } 1201a3d4e20aSJohan Hedberg 1202af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1203af58925cSMarcel Holtmann bool name_known) 12041da177e4SLinus Torvalds { 120530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 120670f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1207af58925cSMarcel Holtmann u32 flags = 0; 12081da177e4SLinus Torvalds 12096ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 12101da177e4SLinus Torvalds 12116928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 12122b2fec4dSSzymon Janc 1213af58925cSMarcel Holtmann if (!data->ssp_mode) 1214af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1215388fc8faSJohan Hedberg 121670f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1217a3d4e20aSJohan Hedberg if (ie) { 1218af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1219af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1220388fc8faSJohan Hedberg 1221a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1222a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1223a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1224a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1225a3d4e20aSJohan Hedberg } 1226a3d4e20aSJohan Hedberg 1227561aafbcSJohan Hedberg goto update; 1228a3d4e20aSJohan Hedberg } 1229561aafbcSJohan Hedberg 12301da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 123127f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1232af58925cSMarcel Holtmann if (!ie) { 1233af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1234af58925cSMarcel Holtmann goto done; 1235af58925cSMarcel Holtmann } 123670f23020SAndrei Emeltchenko 1237561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1238561aafbcSJohan Hedberg 1239561aafbcSJohan Hedberg if (name_known) { 1240561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1241561aafbcSJohan Hedberg } else { 1242561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1243561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1244561aafbcSJohan Hedberg } 1245561aafbcSJohan Hedberg 1246561aafbcSJohan Hedberg update: 1247561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1248561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1249561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1250561aafbcSJohan Hedberg list_del(&ie->list); 12511da177e4SLinus Torvalds } 12521da177e4SLinus Torvalds 125370f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 125470f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12551da177e4SLinus Torvalds cache->timestamp = jiffies; 12563175405bSJohan Hedberg 12573175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1258af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12593175405bSJohan Hedberg 1260af58925cSMarcel Holtmann done: 1261af58925cSMarcel Holtmann return flags; 12621da177e4SLinus Torvalds } 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12651da177e4SLinus Torvalds { 126630883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12671da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12681da177e4SLinus Torvalds struct inquiry_entry *e; 12691da177e4SLinus Torvalds int copied = 0; 12701da177e4SLinus Torvalds 1271561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12721da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1273b57c1a56SJohan Hedberg 1274b57c1a56SJohan Hedberg if (copied >= num) 1275b57c1a56SJohan Hedberg break; 1276b57c1a56SJohan Hedberg 12771da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12781da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12791da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12801da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12811da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12821da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1283b57c1a56SJohan Hedberg 12841da177e4SLinus Torvalds info++; 1285b57c1a56SJohan Hedberg copied++; 12861da177e4SLinus Torvalds } 12871da177e4SLinus Torvalds 12881da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12891da177e4SLinus Torvalds return copied; 12901da177e4SLinus Torvalds } 12911da177e4SLinus Torvalds 129242c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 12931da177e4SLinus Torvalds { 12941da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 129542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12961da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12971da177e4SLinus Torvalds 12981da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 13011da177e4SLinus Torvalds return; 13021da177e4SLinus Torvalds 13031da177e4SLinus Torvalds /* Start Inquiry */ 13041da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 13051da177e4SLinus Torvalds cp.length = ir->length; 13061da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 130742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 13081da177e4SLinus Torvalds } 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 13111da177e4SLinus Torvalds { 13121da177e4SLinus Torvalds __u8 __user *ptr = arg; 13131da177e4SLinus Torvalds struct hci_inquiry_req ir; 13141da177e4SLinus Torvalds struct hci_dev *hdev; 13151da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 13161da177e4SLinus Torvalds long timeo; 13171da177e4SLinus Torvalds __u8 *buf; 13181da177e4SLinus Torvalds 13191da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 13201da177e4SLinus Torvalds return -EFAULT; 13211da177e4SLinus Torvalds 13225a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 13235a08ecceSAndrei Emeltchenko if (!hdev) 13241da177e4SLinus Torvalds return -ENODEV; 13251da177e4SLinus Torvalds 1326d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 13270736cfa8SMarcel Holtmann err = -EBUSY; 13280736cfa8SMarcel Holtmann goto done; 13290736cfa8SMarcel Holtmann } 13300736cfa8SMarcel Holtmann 1331d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1332fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1333fee746b0SMarcel Holtmann goto done; 1334fee746b0SMarcel Holtmann } 1335fee746b0SMarcel Holtmann 13365b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 13375b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 13385b69bef5SMarcel Holtmann goto done; 13395b69bef5SMarcel Holtmann } 13405b69bef5SMarcel Holtmann 1341d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 134256f87901SJohan Hedberg err = -EOPNOTSUPP; 134356f87901SJohan Hedberg goto done; 134456f87901SJohan Hedberg } 134556f87901SJohan Hedberg 134609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13471da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1348a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13491f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13501da177e4SLinus Torvalds do_inquiry = 1; 13511da177e4SLinus Torvalds } 135209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13531da177e4SLinus Torvalds 135404837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 135570f23020SAndrei Emeltchenko 135670f23020SAndrei Emeltchenko if (do_inquiry) { 135701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 135801178cd4SJohan Hedberg timeo); 135970f23020SAndrei Emeltchenko if (err < 0) 13601da177e4SLinus Torvalds goto done; 13613e13fa1eSAndre Guedes 13623e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13633e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13643e13fa1eSAndre Guedes */ 136574316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13663e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13673e13fa1eSAndre Guedes return -EINTR; 136870f23020SAndrei Emeltchenko } 13691da177e4SLinus Torvalds 13708fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13718fc9ced3SGustavo Padovan * 255 entries 13728fc9ced3SGustavo Padovan */ 13731da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13741da177e4SLinus Torvalds 13751da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13761da177e4SLinus Torvalds * copy it to the user space. 13771da177e4SLinus Torvalds */ 137870f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 137970f23020SAndrei Emeltchenko if (!buf) { 13801da177e4SLinus Torvalds err = -ENOMEM; 13811da177e4SLinus Torvalds goto done; 13821da177e4SLinus Torvalds } 13831da177e4SLinus Torvalds 138409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13851da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 138609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13871da177e4SLinus Torvalds 13881da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13911da177e4SLinus Torvalds ptr += sizeof(ir); 13921da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13931da177e4SLinus Torvalds ir.num_rsp)) 13941da177e4SLinus Torvalds err = -EFAULT; 13951da177e4SLinus Torvalds } else 13961da177e4SLinus Torvalds err = -EFAULT; 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds kfree(buf); 13991da177e4SLinus Torvalds 14001da177e4SLinus Torvalds done: 14011da177e4SLinus Torvalds hci_dev_put(hdev); 14021da177e4SLinus Torvalds return err; 14031da177e4SLinus Torvalds } 14041da177e4SLinus Torvalds 1405cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 14061da177e4SLinus Torvalds { 14071da177e4SLinus Torvalds int ret = 0; 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds hci_req_lock(hdev); 14121da177e4SLinus Torvalds 1413d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 141494324962SJohan Hovold ret = -ENODEV; 141594324962SJohan Hovold goto done; 141694324962SJohan Hovold } 141794324962SJohan Hovold 1418d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1419d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1420a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1421a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1422bf543036SJohan Hedberg */ 1423d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1424611b30f7SMarcel Holtmann ret = -ERFKILL; 1425611b30f7SMarcel Holtmann goto done; 1426611b30f7SMarcel Holtmann } 1427611b30f7SMarcel Holtmann 1428a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1429a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1430a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1431a5c8f270SMarcel Holtmann * or not. 1432a5c8f270SMarcel Holtmann * 1433c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1434c6beca0eSMarcel Holtmann * if a public address or static random address is 1435c6beca0eSMarcel Holtmann * available. 1436c6beca0eSMarcel Holtmann * 1437a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1438a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1439a5c8f270SMarcel Holtmann */ 1440d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1441c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 1442a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1443a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1444a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1445a5c8f270SMarcel Holtmann goto done; 1446a5c8f270SMarcel Holtmann } 1447a5c8f270SMarcel Holtmann } 1448a5c8f270SMarcel Holtmann 14491da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14501da177e4SLinus Torvalds ret = -EALREADY; 14511da177e4SLinus Torvalds goto done; 14521da177e4SLinus Torvalds } 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds if (hdev->open(hdev)) { 14551da177e4SLinus Torvalds ret = -EIO; 14561da177e4SLinus Torvalds goto done; 14571da177e4SLinus Torvalds } 14581da177e4SLinus Torvalds 1459e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 146005fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 14614a3f95b7SMarcel Holtmann 14621da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14631da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1464f41c70c4SMarcel Holtmann 1465d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) { 1466e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1467e131d74aSMarcel Holtmann 1468af202f84SMarcel Holtmann if (hdev->setup) 1469f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1470f41c70c4SMarcel Holtmann 1471af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1472af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1473af202f84SMarcel Holtmann * 1474af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1475af202f84SMarcel Holtmann * start up as unconfigured. 1476af202f84SMarcel Holtmann */ 1477eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1478eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 1479a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1480f41c70c4SMarcel Holtmann 14810ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 14820ebca7d6SMarcel Holtmann * read at least the version information provided by 14830ebca7d6SMarcel Holtmann * the Read Local Version Information command. 14840ebca7d6SMarcel Holtmann * 14850ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 14860ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 14870ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 14880ebca7d6SMarcel Holtmann */ 1489d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 14900ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 149189bc22d2SMarcel Holtmann } 149289bc22d2SMarcel Holtmann 1493d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 14949713c17bSMarcel Holtmann /* If public address change is configured, ensure that 14959713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 14969713c17bSMarcel Holtmann * support changing the public address, fail the power 14979713c17bSMarcel Holtmann * on procedure. 149824c457e2SMarcel Holtmann */ 14999713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 15009713c17bSMarcel Holtmann hdev->set_bdaddr) 150124c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 150224c457e2SMarcel Holtmann else 150324c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 150424c457e2SMarcel Holtmann } 150524c457e2SMarcel Holtmann 1506f41c70c4SMarcel Holtmann if (!ret) { 1507d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 150898a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 15092177bab5SJohan Hedberg ret = __hci_init(hdev); 151098a63aafSMarcel Holtmann if (!ret && hdev->post_init) 151198a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 151298a63aafSMarcel Holtmann } 15131da177e4SLinus Torvalds } 15141da177e4SLinus Torvalds 15157e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 15167e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 15177e995b9eSMarcel Holtmann * completed. 15187e995b9eSMarcel Holtmann */ 15197e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 15207e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 15217e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 15227e995b9eSMarcel Holtmann 1523f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1524f41c70c4SMarcel Holtmann 15251da177e4SLinus Torvalds if (!ret) { 15261da177e4SLinus Torvalds hci_dev_hold(hdev); 1527a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 15281da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 152905fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 1530d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1531d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1532d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1533d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15341514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 153509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1536744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 153709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 153856e5cb86SJohan Hedberg } 15391da177e4SLinus Torvalds } else { 15401da177e4SLinus Torvalds /* Init failed, cleanup */ 15413eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1542c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1543b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15441da177e4SLinus Torvalds 15451da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15461da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15471da177e4SLinus Torvalds 15481da177e4SLinus Torvalds if (hdev->flush) 15491da177e4SLinus Torvalds hdev->flush(hdev); 15501da177e4SLinus Torvalds 15511da177e4SLinus Torvalds if (hdev->sent_cmd) { 15521da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15531da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15541da177e4SLinus Torvalds } 15551da177e4SLinus Torvalds 1556e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 155705fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 15584a3f95b7SMarcel Holtmann 15591da177e4SLinus Torvalds hdev->close(hdev); 1560fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 15611da177e4SLinus Torvalds } 15621da177e4SLinus Torvalds 15631da177e4SLinus Torvalds done: 15641da177e4SLinus Torvalds hci_req_unlock(hdev); 15651da177e4SLinus Torvalds return ret; 15661da177e4SLinus Torvalds } 15671da177e4SLinus Torvalds 1568cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1569cbed0ca1SJohan Hedberg 1570cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1571cbed0ca1SJohan Hedberg { 1572cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1573cbed0ca1SJohan Hedberg int err; 1574cbed0ca1SJohan Hedberg 1575cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1576cbed0ca1SJohan Hedberg if (!hdev) 1577cbed0ca1SJohan Hedberg return -ENODEV; 1578cbed0ca1SJohan Hedberg 15794a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1580fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1581fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1582fee746b0SMarcel Holtmann * possible. 1583fee746b0SMarcel Holtmann * 1584fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1585fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1586fee746b0SMarcel Holtmann * open the device. 1587fee746b0SMarcel Holtmann */ 1588d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1589d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1590fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1591fee746b0SMarcel Holtmann goto done; 1592fee746b0SMarcel Holtmann } 1593fee746b0SMarcel Holtmann 1594e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1595e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1596e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1597e1d08f40SJohan Hedberg * completed. 1598e1d08f40SJohan Hedberg */ 1599a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1600e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1601e1d08f40SJohan Hedberg 1602a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1603a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1604a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1605a5c8f270SMarcel Holtmann */ 1606e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1607e1d08f40SJohan Hedberg 160812aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1609b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 161012aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 161112aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 161212aa4f0aSMarcel Holtmann * to explicitly enable it. 161312aa4f0aSMarcel Holtmann */ 1614d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1615d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1616a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 161712aa4f0aSMarcel Holtmann 1618cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1619cbed0ca1SJohan Hedberg 1620fee746b0SMarcel Holtmann done: 1621cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1622cbed0ca1SJohan Hedberg return err; 1623cbed0ca1SJohan Hedberg } 1624cbed0ca1SJohan Hedberg 1625d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1626d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1627d7347f3cSJohan Hedberg { 1628d7347f3cSJohan Hedberg struct hci_conn_params *p; 1629d7347f3cSJohan Hedberg 1630f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1631f161dd41SJohan Hedberg if (p->conn) { 1632f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1633f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1634f161dd41SJohan Hedberg p->conn = NULL; 1635f161dd41SJohan Hedberg } 1636d7347f3cSJohan Hedberg list_del_init(&p->action); 1637f161dd41SJohan Hedberg } 1638d7347f3cSJohan Hedberg 1639d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1640d7347f3cSJohan Hedberg } 1641d7347f3cSJohan Hedberg 16426b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 16431da177e4SLinus Torvalds { 1644acc649c6SMarcel Holtmann bool auto_off; 1645acc649c6SMarcel Holtmann 16461da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 16471da177e4SLinus Torvalds 1648d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1649867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1650d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1651a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1652a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1653a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1654a44fecbdSTedd Ho-Jeong An } 1655a44fecbdSTedd Ho-Jeong An 165678c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 165778c04c0bSVinicius Costa Gomes 16581da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 16591da177e4SLinus Torvalds hci_req_lock(hdev); 16601da177e4SLinus Torvalds 16611da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 166265cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16631da177e4SLinus Torvalds hci_req_unlock(hdev); 16641da177e4SLinus Torvalds return 0; 16651da177e4SLinus Torvalds } 16661da177e4SLinus Torvalds 16673eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16683eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1669b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16701da177e4SLinus Torvalds 167116ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1672e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 167316ab91abSJohan Hedberg hdev->discov_timeout = 0; 1674a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1675a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 167616ab91abSJohan Hedberg } 167716ab91abSJohan Hedberg 1678a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 16797d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 16807d78525dSJohan Hedberg 16817ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 16822d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 16834518bb0fSJohan Hedberg 1684d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_MGMT)) 1685d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 16867ba8b4beSAndre Guedes 16875d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 16885d900e46SFlorian Grandel cancel_delayed_work_sync(&hdev->adv_instance_expire); 16895d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 16905d900e46SFlorian Grandel } 16915d900e46SFlorian Grandel 169276727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 169376727c02SJohan Hedberg * ensuring the workqueue is empty up front. 169476727c02SJohan Hedberg */ 169576727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 169676727c02SJohan Hedberg 169709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16981aeb9c65SJohan Hedberg 16998f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 17008f502f84SJohan Hedberg 1701acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1702acc649c6SMarcel Holtmann 1703acc649c6SMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_BREDR) 17041aeb9c65SJohan Hedberg mgmt_powered(hdev, 0); 17051aeb9c65SJohan Hedberg 17061f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1707d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1708f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 170909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17101da177e4SLinus Torvalds 171164dae967SMarcel Holtmann smp_unregister(hdev); 171264dae967SMarcel Holtmann 171305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 17141da177e4SLinus Torvalds 17151da177e4SLinus Torvalds if (hdev->flush) 17161da177e4SLinus Torvalds hdev->flush(hdev); 17171da177e4SLinus Torvalds 17181da177e4SLinus Torvalds /* Reset device */ 17191da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17201da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1721acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1722acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17231da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 172401178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 17251da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 17261da177e4SLinus Torvalds } 17271da177e4SLinus Torvalds 1728c347b765SGustavo F. Padovan /* flush cmd work */ 1729c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds /* Drop queues */ 17321da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17331da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17341da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 17351da177e4SLinus Torvalds 17361da177e4SLinus Torvalds /* Drop last sent command */ 17371da177e4SLinus Torvalds if (hdev->sent_cmd) { 173865cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 17391da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 17401da177e4SLinus Torvalds hdev->sent_cmd = NULL; 17411da177e4SLinus Torvalds } 17421da177e4SLinus Torvalds 1743e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 174405fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 17454a3f95b7SMarcel Holtmann 17461da177e4SLinus Torvalds /* After this point our queues are empty 17471da177e4SLinus Torvalds * and no tasks are scheduled. */ 17481da177e4SLinus Torvalds hdev->close(hdev); 17491da177e4SLinus Torvalds 175035b973c9SJohan Hedberg /* Clear flags */ 1751fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1752eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 175335b973c9SJohan Hedberg 1754ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1755536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1756ced5c338SAndrei Emeltchenko 1757e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 175809b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 17597a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1760e59fda8dSJohan Hedberg 17611da177e4SLinus Torvalds hci_req_unlock(hdev); 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds hci_dev_put(hdev); 17641da177e4SLinus Torvalds return 0; 17651da177e4SLinus Torvalds } 17661da177e4SLinus Torvalds 17671da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 17681da177e4SLinus Torvalds { 17691da177e4SLinus Torvalds struct hci_dev *hdev; 17701da177e4SLinus Torvalds int err; 17711da177e4SLinus Torvalds 177270f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 177370f23020SAndrei Emeltchenko if (!hdev) 17741da177e4SLinus Torvalds return -ENODEV; 17758ee56540SMarcel Holtmann 1776d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17770736cfa8SMarcel Holtmann err = -EBUSY; 17780736cfa8SMarcel Holtmann goto done; 17790736cfa8SMarcel Holtmann } 17800736cfa8SMarcel Holtmann 1781a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 17828ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 17838ee56540SMarcel Holtmann 17841da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 17858ee56540SMarcel Holtmann 17860736cfa8SMarcel Holtmann done: 17871da177e4SLinus Torvalds hci_dev_put(hdev); 17881da177e4SLinus Torvalds return err; 17891da177e4SLinus Torvalds } 17901da177e4SLinus Torvalds 17915c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 17921da177e4SLinus Torvalds { 17935c912495SMarcel Holtmann int ret; 17941da177e4SLinus Torvalds 17955c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 17961da177e4SLinus Torvalds 17971da177e4SLinus Torvalds hci_req_lock(hdev); 17981da177e4SLinus Torvalds 17991da177e4SLinus Torvalds /* Drop queues */ 18001da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18011da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18021da177e4SLinus Torvalds 180376727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 180476727c02SJohan Hedberg * ensuring the workqueue is empty up front. 180576727c02SJohan Hedberg */ 180676727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 180776727c02SJohan Hedberg 180809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 18091f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 18101da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 181109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18121da177e4SLinus Torvalds 18131da177e4SLinus Torvalds if (hdev->flush) 18141da177e4SLinus Torvalds hdev->flush(hdev); 18151da177e4SLinus Torvalds 18161da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18176ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 18181da177e4SLinus Torvalds 181901178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds hci_req_unlock(hdev); 18221da177e4SLinus Torvalds return ret; 18231da177e4SLinus Torvalds } 18241da177e4SLinus Torvalds 18255c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 18265c912495SMarcel Holtmann { 18275c912495SMarcel Holtmann struct hci_dev *hdev; 18285c912495SMarcel Holtmann int err; 18295c912495SMarcel Holtmann 18305c912495SMarcel Holtmann hdev = hci_dev_get(dev); 18315c912495SMarcel Holtmann if (!hdev) 18325c912495SMarcel Holtmann return -ENODEV; 18335c912495SMarcel Holtmann 18345c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 18355c912495SMarcel Holtmann err = -ENETDOWN; 18365c912495SMarcel Holtmann goto done; 18375c912495SMarcel Holtmann } 18385c912495SMarcel Holtmann 1839d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18405c912495SMarcel Holtmann err = -EBUSY; 18415c912495SMarcel Holtmann goto done; 18425c912495SMarcel Holtmann } 18435c912495SMarcel Holtmann 1844d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 18455c912495SMarcel Holtmann err = -EOPNOTSUPP; 18465c912495SMarcel Holtmann goto done; 18475c912495SMarcel Holtmann } 18485c912495SMarcel Holtmann 18495c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 18505c912495SMarcel Holtmann 18515c912495SMarcel Holtmann done: 18525c912495SMarcel Holtmann hci_dev_put(hdev); 18535c912495SMarcel Holtmann return err; 18545c912495SMarcel Holtmann } 18555c912495SMarcel Holtmann 18561da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 18571da177e4SLinus Torvalds { 18581da177e4SLinus Torvalds struct hci_dev *hdev; 18591da177e4SLinus Torvalds int ret = 0; 18601da177e4SLinus Torvalds 186170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 186270f23020SAndrei Emeltchenko if (!hdev) 18631da177e4SLinus Torvalds return -ENODEV; 18641da177e4SLinus Torvalds 1865d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18660736cfa8SMarcel Holtmann ret = -EBUSY; 18670736cfa8SMarcel Holtmann goto done; 18680736cfa8SMarcel Holtmann } 18690736cfa8SMarcel Holtmann 1870d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1871fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1872fee746b0SMarcel Holtmann goto done; 1873fee746b0SMarcel Holtmann } 1874fee746b0SMarcel Holtmann 18751da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 18761da177e4SLinus Torvalds 18770736cfa8SMarcel Holtmann done: 18781da177e4SLinus Torvalds hci_dev_put(hdev); 18791da177e4SLinus Torvalds return ret; 18801da177e4SLinus Torvalds } 18811da177e4SLinus Torvalds 1882123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1883123abc08SJohan Hedberg { 1884bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1885123abc08SJohan Hedberg 1886123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1887123abc08SJohan Hedberg 1888123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1889238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1890238be788SMarcel Holtmann HCI_CONNECTABLE); 1891123abc08SJohan Hedberg else 1892a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1893a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1894123abc08SJohan Hedberg 1895bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1896238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1897238be788SMarcel Holtmann HCI_DISCOVERABLE); 1898bc6d2d04SJohan Hedberg } else { 1899a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1900a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1901a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1902bc6d2d04SJohan Hedberg } 1903bc6d2d04SJohan Hedberg 1904d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1905123abc08SJohan Hedberg return; 1906123abc08SJohan Hedberg 1907bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1908bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1909a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1910bc6d2d04SJohan Hedberg 1911d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1912bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 1913bc6d2d04SJohan Hedberg 1914123abc08SJohan Hedberg mgmt_new_settings(hdev); 1915123abc08SJohan Hedberg } 1916bc6d2d04SJohan Hedberg } 1917123abc08SJohan Hedberg 19181da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 19191da177e4SLinus Torvalds { 19201da177e4SLinus Torvalds struct hci_dev *hdev; 19211da177e4SLinus Torvalds struct hci_dev_req dr; 19221da177e4SLinus Torvalds int err = 0; 19231da177e4SLinus Torvalds 19241da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 19251da177e4SLinus Torvalds return -EFAULT; 19261da177e4SLinus Torvalds 192770f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 192870f23020SAndrei Emeltchenko if (!hdev) 19291da177e4SLinus Torvalds return -ENODEV; 19301da177e4SLinus Torvalds 1931d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19320736cfa8SMarcel Holtmann err = -EBUSY; 19330736cfa8SMarcel Holtmann goto done; 19340736cfa8SMarcel Holtmann } 19350736cfa8SMarcel Holtmann 1936d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1937fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1938fee746b0SMarcel Holtmann goto done; 1939fee746b0SMarcel Holtmann } 1940fee746b0SMarcel Holtmann 19415b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 19425b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 19435b69bef5SMarcel Holtmann goto done; 19445b69bef5SMarcel Holtmann } 19455b69bef5SMarcel Holtmann 1946d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 194756f87901SJohan Hedberg err = -EOPNOTSUPP; 194856f87901SJohan Hedberg goto done; 194956f87901SJohan Hedberg } 195056f87901SJohan Hedberg 19511da177e4SLinus Torvalds switch (cmd) { 19521da177e4SLinus Torvalds case HCISETAUTH: 195301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19545f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19551da177e4SLinus Torvalds break; 19561da177e4SLinus Torvalds 19571da177e4SLinus Torvalds case HCISETENCRYPT: 19581da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 19591da177e4SLinus Torvalds err = -EOPNOTSUPP; 19601da177e4SLinus Torvalds break; 19611da177e4SLinus Torvalds } 19621da177e4SLinus Torvalds 19631da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 19641da177e4SLinus Torvalds /* Auth must be enabled first */ 196501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19665f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19671da177e4SLinus Torvalds if (err) 19681da177e4SLinus Torvalds break; 19691da177e4SLinus Torvalds } 19701da177e4SLinus Torvalds 197101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19725f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19731da177e4SLinus Torvalds break; 19741da177e4SLinus Torvalds 19751da177e4SLinus Torvalds case HCISETSCAN: 197601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19775f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 197891a668b0SJohan Hedberg 1979bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1980bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 198191a668b0SJohan Hedberg */ 1982123abc08SJohan Hedberg if (!err) 1983123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 19841da177e4SLinus Torvalds break; 19851da177e4SLinus Torvalds 19861da177e4SLinus Torvalds case HCISETLINKPOL: 198701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19885f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19891da177e4SLinus Torvalds break; 19901da177e4SLinus Torvalds 19911da177e4SLinus Torvalds case HCISETLINKMODE: 1992e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1993e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1994e4e8e37cSMarcel Holtmann break; 1995e4e8e37cSMarcel Holtmann 1996e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1997e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 19981da177e4SLinus Torvalds break; 19991da177e4SLinus Torvalds 20001da177e4SLinus Torvalds case HCISETACLMTU: 20011da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 20021da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 20031da177e4SLinus Torvalds break; 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds case HCISETSCOMTU: 20061da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 20071da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 20081da177e4SLinus Torvalds break; 20091da177e4SLinus Torvalds 20101da177e4SLinus Torvalds default: 20111da177e4SLinus Torvalds err = -EINVAL; 20121da177e4SLinus Torvalds break; 20131da177e4SLinus Torvalds } 2014e4e8e37cSMarcel Holtmann 20150736cfa8SMarcel Holtmann done: 20161da177e4SLinus Torvalds hci_dev_put(hdev); 20171da177e4SLinus Torvalds return err; 20181da177e4SLinus Torvalds } 20191da177e4SLinus Torvalds 20201da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 20211da177e4SLinus Torvalds { 20228035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 20231da177e4SLinus Torvalds struct hci_dev_list_req *dl; 20241da177e4SLinus Torvalds struct hci_dev_req *dr; 20251da177e4SLinus Torvalds int n = 0, size, err; 20261da177e4SLinus Torvalds __u16 dev_num; 20271da177e4SLinus Torvalds 20281da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 20291da177e4SLinus Torvalds return -EFAULT; 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 20321da177e4SLinus Torvalds return -EINVAL; 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 20351da177e4SLinus Torvalds 203670f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 203770f23020SAndrei Emeltchenko if (!dl) 20381da177e4SLinus Torvalds return -ENOMEM; 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds dr = dl->dev_req; 20411da177e4SLinus Torvalds 2042f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 20438035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 20442e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2045c542a06cSJohan Hedberg 20462e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20472e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20482e84d8dbSMarcel Holtmann * device is actually down. 20492e84d8dbSMarcel Holtmann */ 2050d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20512e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2052c542a06cSJohan Hedberg 20531da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 20542e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2055c542a06cSJohan Hedberg 20561da177e4SLinus Torvalds if (++n >= dev_num) 20571da177e4SLinus Torvalds break; 20581da177e4SLinus Torvalds } 2059f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 20601da177e4SLinus Torvalds 20611da177e4SLinus Torvalds dl->dev_num = n; 20621da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 20651da177e4SLinus Torvalds kfree(dl); 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds return err ? -EFAULT : 0; 20681da177e4SLinus Torvalds } 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20711da177e4SLinus Torvalds { 20721da177e4SLinus Torvalds struct hci_dev *hdev; 20731da177e4SLinus Torvalds struct hci_dev_info di; 20742e84d8dbSMarcel Holtmann unsigned long flags; 20751da177e4SLinus Torvalds int err = 0; 20761da177e4SLinus Torvalds 20771da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 20781da177e4SLinus Torvalds return -EFAULT; 20791da177e4SLinus Torvalds 208070f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 208170f23020SAndrei Emeltchenko if (!hdev) 20821da177e4SLinus Torvalds return -ENODEV; 20831da177e4SLinus Torvalds 20842e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20852e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20862e84d8dbSMarcel Holtmann * device is actually down. 20872e84d8dbSMarcel Holtmann */ 2088d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20892e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 20902e84d8dbSMarcel Holtmann else 20912e84d8dbSMarcel Holtmann flags = hdev->flags; 2092c542a06cSJohan Hedberg 20931da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20941da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 209560f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20962e84d8dbSMarcel Holtmann di.flags = flags; 20971da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2098572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 20991da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 21001da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 21011da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 21021da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2103572c7f84SJohan Hedberg } else { 2104572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2105572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2106572c7f84SJohan Hedberg di.sco_mtu = 0; 2107572c7f84SJohan Hedberg di.sco_pkts = 0; 2108572c7f84SJohan Hedberg } 21091da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 21101da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 21131da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 21161da177e4SLinus Torvalds err = -EFAULT; 21171da177e4SLinus Torvalds 21181da177e4SLinus Torvalds hci_dev_put(hdev); 21191da177e4SLinus Torvalds 21201da177e4SLinus Torvalds return err; 21211da177e4SLinus Torvalds } 21221da177e4SLinus Torvalds 21231da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 21241da177e4SLinus Torvalds 2125611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2126611b30f7SMarcel Holtmann { 2127611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2128611b30f7SMarcel Holtmann 2129611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2130611b30f7SMarcel Holtmann 2131d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 21320736cfa8SMarcel Holtmann return -EBUSY; 21330736cfa8SMarcel Holtmann 21345e130367SJohan Hedberg if (blocked) { 2135a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2136d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2137d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2138611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 21395e130367SJohan Hedberg } else { 2140a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 21415e130367SJohan Hedberg } 2142611b30f7SMarcel Holtmann 2143611b30f7SMarcel Holtmann return 0; 2144611b30f7SMarcel Holtmann } 2145611b30f7SMarcel Holtmann 2146611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2147611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2148611b30f7SMarcel Holtmann }; 2149611b30f7SMarcel Holtmann 2150ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2151ab81cbf9SJohan Hedberg { 2152ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 215396570ffcSJohan Hedberg int err; 2154ab81cbf9SJohan Hedberg 2155ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2156ab81cbf9SJohan Hedberg 2157cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 215896570ffcSJohan Hedberg if (err < 0) { 21593ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 216096570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 21613ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2162ab81cbf9SJohan Hedberg return; 216396570ffcSJohan Hedberg } 2164ab81cbf9SJohan Hedberg 2165a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2166a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2167a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2168a5c8f270SMarcel Holtmann */ 2169d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2170d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2171a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2172a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2173a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2174a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2175bf543036SJohan Hedberg hci_dev_do_close(hdev); 2176d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 217719202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 217819202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2179bf543036SJohan Hedberg } 2180ab81cbf9SJohan Hedberg 2181a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 21824a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 21834a964404SMarcel Holtmann * so that userspace can easily identify them. 21844a964404SMarcel Holtmann */ 2185d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 21864a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 21870602a8adSMarcel Holtmann 21880602a8adSMarcel Holtmann /* For fully configured devices, this will send 21890602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 21900602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 21910602a8adSMarcel Holtmann * 21920602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 21930602a8adSMarcel Holtmann * and no event will be send. 21940602a8adSMarcel Holtmann */ 2195744cf19eSJohan Hedberg mgmt_index_added(hdev); 2196a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 21975ea234d3SMarcel Holtmann /* When the controller is now configured, then it 21985ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 21995ea234d3SMarcel Holtmann */ 2200d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22015ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 22025ea234d3SMarcel Holtmann 2203d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2204d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2205d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2206d603b76bSMarcel Holtmann */ 2207d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2208ab81cbf9SJohan Hedberg } 2209ab81cbf9SJohan Hedberg } 2210ab81cbf9SJohan Hedberg 2211ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2212ab81cbf9SJohan Hedberg { 22133243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 22143243553fSJohan Hedberg power_off.work); 2215ab81cbf9SJohan Hedberg 2216ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2217ab81cbf9SJohan Hedberg 22188ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2219ab81cbf9SJohan Hedberg } 2220ab81cbf9SJohan Hedberg 2221c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2222c7741d16SMarcel Holtmann { 2223c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2224c7741d16SMarcel Holtmann 2225c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2226c7741d16SMarcel Holtmann 2227c7741d16SMarcel Holtmann if (hdev->hw_error) 2228c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2229c7741d16SMarcel Holtmann else 2230c7741d16SMarcel Holtmann BT_ERR("%s hardware error 0x%2.2x", hdev->name, 2231c7741d16SMarcel Holtmann hdev->hw_error_code); 2232c7741d16SMarcel Holtmann 2233c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2234c7741d16SMarcel Holtmann return; 2235c7741d16SMarcel Holtmann 2236c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2237c7741d16SMarcel Holtmann } 2238c7741d16SMarcel Holtmann 223916ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 224016ab91abSJohan Hedberg { 224116ab91abSJohan Hedberg struct hci_dev *hdev; 224216ab91abSJohan Hedberg 224316ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 224416ab91abSJohan Hedberg 224516ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 224616ab91abSJohan Hedberg 2247d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 224816ab91abSJohan Hedberg } 224916ab91abSJohan Hedberg 22505d900e46SFlorian Grandel static void hci_adv_timeout_expire(struct work_struct *work) 22515d900e46SFlorian Grandel { 22525d900e46SFlorian Grandel struct hci_dev *hdev; 22535d900e46SFlorian Grandel 22545d900e46SFlorian Grandel hdev = container_of(work, struct hci_dev, adv_instance_expire.work); 22555d900e46SFlorian Grandel 22565d900e46SFlorian Grandel BT_DBG("%s", hdev->name); 22575d900e46SFlorian Grandel 22585d900e46SFlorian Grandel mgmt_adv_timeout_expired(hdev); 22595d900e46SFlorian Grandel } 22605d900e46SFlorian Grandel 226135f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 22622aeb9a1aSJohan Hedberg { 22634821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 22642aeb9a1aSJohan Hedberg 22654821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 22664821002cSJohan Hedberg list_del(&uuid->list); 22672aeb9a1aSJohan Hedberg kfree(uuid); 22682aeb9a1aSJohan Hedberg } 22692aeb9a1aSJohan Hedberg } 22702aeb9a1aSJohan Hedberg 227135f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 227255ed8ca1SJohan Hedberg { 227355ed8ca1SJohan Hedberg struct link_key *key; 227455ed8ca1SJohan Hedberg 22750378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 22760378b597SJohan Hedberg list_del_rcu(&key->list); 22770378b597SJohan Hedberg kfree_rcu(key, rcu); 227855ed8ca1SJohan Hedberg } 227955ed8ca1SJohan Hedberg } 228055ed8ca1SJohan Hedberg 228135f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2282b899efafSVinicius Costa Gomes { 2283970d0f1bSJohan Hedberg struct smp_ltk *k; 2284b899efafSVinicius Costa Gomes 2285970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2286970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2287970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2288b899efafSVinicius Costa Gomes } 2289b899efafSVinicius Costa Gomes } 2290b899efafSVinicius Costa Gomes 2291970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2292970c4e46SJohan Hedberg { 2293adae20cbSJohan Hedberg struct smp_irk *k; 2294970c4e46SJohan Hedberg 2295adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2296adae20cbSJohan Hedberg list_del_rcu(&k->list); 2297adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2298970c4e46SJohan Hedberg } 2299970c4e46SJohan Hedberg } 2300970c4e46SJohan Hedberg 230155ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 230255ed8ca1SJohan Hedberg { 230355ed8ca1SJohan Hedberg struct link_key *k; 230455ed8ca1SJohan Hedberg 23050378b597SJohan Hedberg rcu_read_lock(); 23060378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 23070378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 23080378b597SJohan Hedberg rcu_read_unlock(); 230955ed8ca1SJohan Hedberg return k; 23100378b597SJohan Hedberg } 23110378b597SJohan Hedberg } 23120378b597SJohan Hedberg rcu_read_unlock(); 231355ed8ca1SJohan Hedberg 231455ed8ca1SJohan Hedberg return NULL; 231555ed8ca1SJohan Hedberg } 231655ed8ca1SJohan Hedberg 2317745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2318d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2319d25e28abSJohan Hedberg { 2320d25e28abSJohan Hedberg /* Legacy key */ 2321d25e28abSJohan Hedberg if (key_type < 0x03) 2322745c0ce3SVishal Agarwal return true; 2323d25e28abSJohan Hedberg 2324d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2325d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2326745c0ce3SVishal Agarwal return false; 2327d25e28abSJohan Hedberg 2328d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2329d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2330745c0ce3SVishal Agarwal return false; 2331d25e28abSJohan Hedberg 2332d25e28abSJohan Hedberg /* Security mode 3 case */ 2333d25e28abSJohan Hedberg if (!conn) 2334745c0ce3SVishal Agarwal return true; 2335d25e28abSJohan Hedberg 2336e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2337e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2338e3befab9SJohan Hedberg return true; 2339e3befab9SJohan Hedberg 2340d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2341d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2342745c0ce3SVishal Agarwal return true; 2343d25e28abSJohan Hedberg 2344d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2345d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2346745c0ce3SVishal Agarwal return true; 2347d25e28abSJohan Hedberg 2348d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2349d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2350745c0ce3SVishal Agarwal return true; 2351d25e28abSJohan Hedberg 2352d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2353d25e28abSJohan Hedberg * persistently */ 2354745c0ce3SVishal Agarwal return false; 2355d25e28abSJohan Hedberg } 2356d25e28abSJohan Hedberg 2357e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 235898a0b845SJohan Hedberg { 2359e804d25dSJohan Hedberg if (type == SMP_LTK) 2360e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 236198a0b845SJohan Hedberg 2362e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 236398a0b845SJohan Hedberg } 236498a0b845SJohan Hedberg 2365f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2366e804d25dSJohan Hedberg u8 addr_type, u8 role) 236775d262c2SVinicius Costa Gomes { 2368c9839a11SVinicius Costa Gomes struct smp_ltk *k; 236975d262c2SVinicius Costa Gomes 2370970d0f1bSJohan Hedberg rcu_read_lock(); 2371970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 23725378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 23735378bc56SJohan Hedberg continue; 23745378bc56SJohan Hedberg 2375923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2376970d0f1bSJohan Hedberg rcu_read_unlock(); 237775d262c2SVinicius Costa Gomes return k; 2378970d0f1bSJohan Hedberg } 2379970d0f1bSJohan Hedberg } 2380970d0f1bSJohan Hedberg rcu_read_unlock(); 238175d262c2SVinicius Costa Gomes 238275d262c2SVinicius Costa Gomes return NULL; 238375d262c2SVinicius Costa Gomes } 238475d262c2SVinicius Costa Gomes 2385970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2386970c4e46SJohan Hedberg { 2387970c4e46SJohan Hedberg struct smp_irk *irk; 2388970c4e46SJohan Hedberg 2389adae20cbSJohan Hedberg rcu_read_lock(); 2390adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2391adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2392adae20cbSJohan Hedberg rcu_read_unlock(); 2393970c4e46SJohan Hedberg return irk; 2394970c4e46SJohan Hedberg } 2395adae20cbSJohan Hedberg } 2396970c4e46SJohan Hedberg 2397adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2398defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2399970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2400adae20cbSJohan Hedberg rcu_read_unlock(); 2401970c4e46SJohan Hedberg return irk; 2402970c4e46SJohan Hedberg } 2403970c4e46SJohan Hedberg } 2404adae20cbSJohan Hedberg rcu_read_unlock(); 2405970c4e46SJohan Hedberg 2406970c4e46SJohan Hedberg return NULL; 2407970c4e46SJohan Hedberg } 2408970c4e46SJohan Hedberg 2409970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2410970c4e46SJohan Hedberg u8 addr_type) 2411970c4e46SJohan Hedberg { 2412970c4e46SJohan Hedberg struct smp_irk *irk; 2413970c4e46SJohan Hedberg 24146cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 24156cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 24166cfc9988SJohan Hedberg return NULL; 24176cfc9988SJohan Hedberg 2418adae20cbSJohan Hedberg rcu_read_lock(); 2419adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2420970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2421adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2422adae20cbSJohan Hedberg rcu_read_unlock(); 2423970c4e46SJohan Hedberg return irk; 2424970c4e46SJohan Hedberg } 2425adae20cbSJohan Hedberg } 2426adae20cbSJohan Hedberg rcu_read_unlock(); 2427970c4e46SJohan Hedberg 2428970c4e46SJohan Hedberg return NULL; 2429970c4e46SJohan Hedberg } 2430970c4e46SJohan Hedberg 2431567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 24327652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 24337652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 243455ed8ca1SJohan Hedberg { 243555ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2436745c0ce3SVishal Agarwal u8 old_key_type; 243755ed8ca1SJohan Hedberg 243855ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 243955ed8ca1SJohan Hedberg if (old_key) { 244055ed8ca1SJohan Hedberg old_key_type = old_key->type; 244155ed8ca1SJohan Hedberg key = old_key; 244255ed8ca1SJohan Hedberg } else { 244312adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 24440a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 244555ed8ca1SJohan Hedberg if (!key) 2446567fa2aaSJohan Hedberg return NULL; 24470378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 244855ed8ca1SJohan Hedberg } 244955ed8ca1SJohan Hedberg 24506ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 245155ed8ca1SJohan Hedberg 2452d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2453d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2454d25e28abSJohan Hedberg * previous key */ 2455d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2456a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2457d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2458655fe6ecSJohan Hedberg if (conn) 2459655fe6ecSJohan Hedberg conn->key_type = type; 2460655fe6ecSJohan Hedberg } 2461d25e28abSJohan Hedberg 246255ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 24639b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 246455ed8ca1SJohan Hedberg key->pin_len = pin_len; 246555ed8ca1SJohan Hedberg 2466b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 246755ed8ca1SJohan Hedberg key->type = old_key_type; 24684748fed2SJohan Hedberg else 24694748fed2SJohan Hedberg key->type = type; 24704748fed2SJohan Hedberg 24717652ff6aSJohan Hedberg if (persistent) 24727652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 24737652ff6aSJohan Hedberg old_key_type); 24744df378a1SJohan Hedberg 2475567fa2aaSJohan Hedberg return key; 247655ed8ca1SJohan Hedberg } 247755ed8ca1SJohan Hedberg 2478ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 247935d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2480fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 248175d262c2SVinicius Costa Gomes { 2482c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2483e804d25dSJohan Hedberg u8 role = ltk_role(type); 248475d262c2SVinicius Costa Gomes 2485f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2486c9839a11SVinicius Costa Gomes if (old_key) 248775d262c2SVinicius Costa Gomes key = old_key; 2488c9839a11SVinicius Costa Gomes else { 24890a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 249075d262c2SVinicius Costa Gomes if (!key) 2491ca9142b8SJohan Hedberg return NULL; 2492970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 249375d262c2SVinicius Costa Gomes } 249475d262c2SVinicius Costa Gomes 249575d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2496c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2497c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2498c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2499c9839a11SVinicius Costa Gomes key->ediv = ediv; 2500fe39c7b2SMarcel Holtmann key->rand = rand; 2501c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2502c9839a11SVinicius Costa Gomes key->type = type; 250375d262c2SVinicius Costa Gomes 2504ca9142b8SJohan Hedberg return key; 250575d262c2SVinicius Costa Gomes } 250675d262c2SVinicius Costa Gomes 2507ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2508ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2509970c4e46SJohan Hedberg { 2510970c4e46SJohan Hedberg struct smp_irk *irk; 2511970c4e46SJohan Hedberg 2512970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2513970c4e46SJohan Hedberg if (!irk) { 2514970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2515970c4e46SJohan Hedberg if (!irk) 2516ca9142b8SJohan Hedberg return NULL; 2517970c4e46SJohan Hedberg 2518970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2519970c4e46SJohan Hedberg irk->addr_type = addr_type; 2520970c4e46SJohan Hedberg 2521adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2522970c4e46SJohan Hedberg } 2523970c4e46SJohan Hedberg 2524970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2525970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2526970c4e46SJohan Hedberg 2527ca9142b8SJohan Hedberg return irk; 2528970c4e46SJohan Hedberg } 2529970c4e46SJohan Hedberg 253055ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 253155ed8ca1SJohan Hedberg { 253255ed8ca1SJohan Hedberg struct link_key *key; 253355ed8ca1SJohan Hedberg 253455ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 253555ed8ca1SJohan Hedberg if (!key) 253655ed8ca1SJohan Hedberg return -ENOENT; 253755ed8ca1SJohan Hedberg 25386ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 253955ed8ca1SJohan Hedberg 25400378b597SJohan Hedberg list_del_rcu(&key->list); 25410378b597SJohan Hedberg kfree_rcu(key, rcu); 254255ed8ca1SJohan Hedberg 254355ed8ca1SJohan Hedberg return 0; 254455ed8ca1SJohan Hedberg } 254555ed8ca1SJohan Hedberg 2546e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2547b899efafSVinicius Costa Gomes { 2548970d0f1bSJohan Hedberg struct smp_ltk *k; 2549c51ffa0bSJohan Hedberg int removed = 0; 2550b899efafSVinicius Costa Gomes 2551970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2552e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2553b899efafSVinicius Costa Gomes continue; 2554b899efafSVinicius Costa Gomes 25556ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2556b899efafSVinicius Costa Gomes 2557970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2558970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2559c51ffa0bSJohan Hedberg removed++; 2560b899efafSVinicius Costa Gomes } 2561b899efafSVinicius Costa Gomes 2562c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2563b899efafSVinicius Costa Gomes } 2564b899efafSVinicius Costa Gomes 2565a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2566a7ec7338SJohan Hedberg { 2567adae20cbSJohan Hedberg struct smp_irk *k; 2568a7ec7338SJohan Hedberg 2569adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2570a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2571a7ec7338SJohan Hedberg continue; 2572a7ec7338SJohan Hedberg 2573a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2574a7ec7338SJohan Hedberg 2575adae20cbSJohan Hedberg list_del_rcu(&k->list); 2576adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2577a7ec7338SJohan Hedberg } 2578a7ec7338SJohan Hedberg } 2579a7ec7338SJohan Hedberg 258055e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 258155e76b38SJohan Hedberg { 258255e76b38SJohan Hedberg struct smp_ltk *k; 25834ba9faf3SJohan Hedberg struct smp_irk *irk; 258455e76b38SJohan Hedberg u8 addr_type; 258555e76b38SJohan Hedberg 258655e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 258755e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 258855e76b38SJohan Hedberg return true; 258955e76b38SJohan Hedberg return false; 259055e76b38SJohan Hedberg } 259155e76b38SJohan Hedberg 259255e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 259355e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 259455e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 259555e76b38SJohan Hedberg else 259655e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 259755e76b38SJohan Hedberg 25984ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 25994ba9faf3SJohan Hedberg if (irk) { 26004ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 26014ba9faf3SJohan Hedberg addr_type = irk->addr_type; 26024ba9faf3SJohan Hedberg } 26034ba9faf3SJohan Hedberg 260455e76b38SJohan Hedberg rcu_read_lock(); 260555e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 260687c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 260787c8b28dSJohan Hedberg rcu_read_unlock(); 260855e76b38SJohan Hedberg return true; 260955e76b38SJohan Hedberg } 261087c8b28dSJohan Hedberg } 261155e76b38SJohan Hedberg rcu_read_unlock(); 261255e76b38SJohan Hedberg 261355e76b38SJohan Hedberg return false; 261455e76b38SJohan Hedberg } 261555e76b38SJohan Hedberg 26166bd32326SVille Tervo /* HCI command timer function */ 261765cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 26186bd32326SVille Tervo { 261965cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 262065cc2b49SMarcel Holtmann cmd_timer.work); 26216bd32326SVille Tervo 2622bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2623bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2624bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2625bda4f23aSAndrei Emeltchenko 2626bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2627bda4f23aSAndrei Emeltchenko } else { 26286bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2629bda4f23aSAndrei Emeltchenko } 2630bda4f23aSAndrei Emeltchenko 26316bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2632c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 26336bd32326SVille Tervo } 26346bd32326SVille Tervo 26352763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 26366928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 26372763eda6SSzymon Janc { 26382763eda6SSzymon Janc struct oob_data *data; 26392763eda6SSzymon Janc 26406928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 26416928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 26426928a924SJohan Hedberg continue; 26436928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 26446928a924SJohan Hedberg continue; 26452763eda6SSzymon Janc return data; 26466928a924SJohan Hedberg } 26472763eda6SSzymon Janc 26482763eda6SSzymon Janc return NULL; 26492763eda6SSzymon Janc } 26502763eda6SSzymon Janc 26516928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26526928a924SJohan Hedberg u8 bdaddr_type) 26532763eda6SSzymon Janc { 26542763eda6SSzymon Janc struct oob_data *data; 26552763eda6SSzymon Janc 26566928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26572763eda6SSzymon Janc if (!data) 26582763eda6SSzymon Janc return -ENOENT; 26592763eda6SSzymon Janc 26606928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 26612763eda6SSzymon Janc 26622763eda6SSzymon Janc list_del(&data->list); 26632763eda6SSzymon Janc kfree(data); 26642763eda6SSzymon Janc 26652763eda6SSzymon Janc return 0; 26662763eda6SSzymon Janc } 26672763eda6SSzymon Janc 266835f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 26692763eda6SSzymon Janc { 26702763eda6SSzymon Janc struct oob_data *data, *n; 26712763eda6SSzymon Janc 26722763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 26732763eda6SSzymon Janc list_del(&data->list); 26742763eda6SSzymon Janc kfree(data); 26752763eda6SSzymon Janc } 26762763eda6SSzymon Janc } 26772763eda6SSzymon Janc 26780798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26796928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 268038da1703SJohan Hedberg u8 *hash256, u8 *rand256) 26810798872eSMarcel Holtmann { 26820798872eSMarcel Holtmann struct oob_data *data; 26830798872eSMarcel Holtmann 26846928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26850798872eSMarcel Holtmann if (!data) { 26860a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 26870798872eSMarcel Holtmann if (!data) 26880798872eSMarcel Holtmann return -ENOMEM; 26890798872eSMarcel Holtmann 26900798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 26916928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 26920798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 26930798872eSMarcel Holtmann } 26940798872eSMarcel Holtmann 269581328d5cSJohan Hedberg if (hash192 && rand192) { 26960798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 269738da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2698f7697b16SMarcel Holtmann if (hash256 && rand256) 2699f7697b16SMarcel Holtmann data->present = 0x03; 270081328d5cSJohan Hedberg } else { 270181328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 270281328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2703f7697b16SMarcel Holtmann if (hash256 && rand256) 2704f7697b16SMarcel Holtmann data->present = 0x02; 2705f7697b16SMarcel Holtmann else 2706f7697b16SMarcel Holtmann data->present = 0x00; 270781328d5cSJohan Hedberg } 27080798872eSMarcel Holtmann 270981328d5cSJohan Hedberg if (hash256 && rand256) { 27100798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 271138da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 271281328d5cSJohan Hedberg } else { 271381328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 271481328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2715f7697b16SMarcel Holtmann if (hash192 && rand192) 2716f7697b16SMarcel Holtmann data->present = 0x01; 271781328d5cSJohan Hedberg } 27180798872eSMarcel Holtmann 27196ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 27202763eda6SSzymon Janc 27212763eda6SSzymon Janc return 0; 27222763eda6SSzymon Janc } 27232763eda6SSzymon Janc 2724d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2725d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2726d2609b34SFlorian Grandel { 2727d2609b34SFlorian Grandel struct adv_info *adv_instance; 2728d2609b34SFlorian Grandel 2729d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2730d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2731d2609b34SFlorian Grandel return adv_instance; 2732d2609b34SFlorian Grandel } 2733d2609b34SFlorian Grandel 2734d2609b34SFlorian Grandel return NULL; 2735d2609b34SFlorian Grandel } 2736d2609b34SFlorian Grandel 2737d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2738d2609b34SFlorian Grandel struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) { 2739d2609b34SFlorian Grandel struct adv_info *cur_instance; 2740d2609b34SFlorian Grandel 2741d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2742d2609b34SFlorian Grandel if (!cur_instance) 2743d2609b34SFlorian Grandel return NULL; 2744d2609b34SFlorian Grandel 2745d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2746d2609b34SFlorian Grandel struct adv_info, list)) 2747d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2748d2609b34SFlorian Grandel struct adv_info, list); 2749d2609b34SFlorian Grandel else 2750d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2751d2609b34SFlorian Grandel } 2752d2609b34SFlorian Grandel 2753d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2754d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2755d2609b34SFlorian Grandel { 2756d2609b34SFlorian Grandel struct adv_info *adv_instance; 2757d2609b34SFlorian Grandel 2758d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2759d2609b34SFlorian Grandel if (!adv_instance) 2760d2609b34SFlorian Grandel return -ENOENT; 2761d2609b34SFlorian Grandel 2762d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2763d2609b34SFlorian Grandel 27645d900e46SFlorian Grandel if (hdev->cur_adv_instance == instance && hdev->adv_instance_timeout) { 27655d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27665d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27675d900e46SFlorian Grandel } 27685d900e46SFlorian Grandel 2769d2609b34SFlorian Grandel list_del(&adv_instance->list); 2770d2609b34SFlorian Grandel kfree(adv_instance); 2771d2609b34SFlorian Grandel 2772d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2773d2609b34SFlorian Grandel 2774d2609b34SFlorian Grandel return 0; 2775d2609b34SFlorian Grandel } 2776d2609b34SFlorian Grandel 2777d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2778d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2779d2609b34SFlorian Grandel { 2780d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2781d2609b34SFlorian Grandel 27825d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 27835d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27845d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27855d900e46SFlorian Grandel } 27865d900e46SFlorian Grandel 2787d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2788d2609b34SFlorian Grandel list_del(&adv_instance->list); 2789d2609b34SFlorian Grandel kfree(adv_instance); 2790d2609b34SFlorian Grandel } 2791d2609b34SFlorian Grandel 2792d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2793d2609b34SFlorian Grandel } 2794d2609b34SFlorian Grandel 2795d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2796d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2797d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2798d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2799d2609b34SFlorian Grandel u16 timeout, u16 duration) 2800d2609b34SFlorian Grandel { 2801d2609b34SFlorian Grandel struct adv_info *adv_instance; 2802d2609b34SFlorian Grandel 2803d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2804d2609b34SFlorian Grandel if (adv_instance) { 2805d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2806d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2807d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2808d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2809d2609b34SFlorian Grandel } else { 2810d2609b34SFlorian Grandel if (hdev->adv_instance_cnt >= HCI_MAX_ADV_INSTANCES || 2811d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2812d2609b34SFlorian Grandel return -EOVERFLOW; 2813d2609b34SFlorian Grandel 281439ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2815d2609b34SFlorian Grandel if (!adv_instance) 2816d2609b34SFlorian Grandel return -ENOMEM; 2817d2609b34SFlorian Grandel 2818fffd38bcSFlorian Grandel adv_instance->pending = true; 2819d2609b34SFlorian Grandel adv_instance->instance = instance; 2820d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2821d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2822d2609b34SFlorian Grandel } 2823d2609b34SFlorian Grandel 2824d2609b34SFlorian Grandel adv_instance->flags = flags; 2825d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2826d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2827d2609b34SFlorian Grandel 2828d2609b34SFlorian Grandel if (adv_data_len) 2829d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2830d2609b34SFlorian Grandel 2831d2609b34SFlorian Grandel if (scan_rsp_len) 2832d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2833d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2834d2609b34SFlorian Grandel 2835d2609b34SFlorian Grandel adv_instance->timeout = timeout; 28365d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2837d2609b34SFlorian Grandel 2838d2609b34SFlorian Grandel if (duration == 0) 2839d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2840d2609b34SFlorian Grandel else 2841d2609b34SFlorian Grandel adv_instance->duration = duration; 2842d2609b34SFlorian Grandel 2843d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2844d2609b34SFlorian Grandel 2845d2609b34SFlorian Grandel return 0; 2846d2609b34SFlorian Grandel } 2847d2609b34SFlorian Grandel 2848dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2849b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2850b2a66aadSAntti Julku { 2851b2a66aadSAntti Julku struct bdaddr_list *b; 2852b2a66aadSAntti Julku 2853dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2854b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2855b2a66aadSAntti Julku return b; 2856b9ee0a78SMarcel Holtmann } 2857b2a66aadSAntti Julku 2858b2a66aadSAntti Julku return NULL; 2859b2a66aadSAntti Julku } 2860b2a66aadSAntti Julku 2861dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2862b2a66aadSAntti Julku { 2863b2a66aadSAntti Julku struct list_head *p, *n; 2864b2a66aadSAntti Julku 2865dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 2866b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2867b2a66aadSAntti Julku 2868b2a66aadSAntti Julku list_del(p); 2869b2a66aadSAntti Julku kfree(b); 2870b2a66aadSAntti Julku } 2871b2a66aadSAntti Julku } 2872b2a66aadSAntti Julku 2873dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2874b2a66aadSAntti Julku { 2875b2a66aadSAntti Julku struct bdaddr_list *entry; 2876b2a66aadSAntti Julku 2877b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2878b2a66aadSAntti Julku return -EBADF; 2879b2a66aadSAntti Julku 2880dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 28815e762444SAntti Julku return -EEXIST; 2882b2a66aadSAntti Julku 288327f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 28845e762444SAntti Julku if (!entry) 28855e762444SAntti Julku return -ENOMEM; 2886b2a66aadSAntti Julku 2887b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2888b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2889b2a66aadSAntti Julku 2890dcc36c16SJohan Hedberg list_add(&entry->list, list); 2891b2a66aadSAntti Julku 28922a8357f2SJohan Hedberg return 0; 2893b2a66aadSAntti Julku } 2894b2a66aadSAntti Julku 2895dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2896b2a66aadSAntti Julku { 2897b2a66aadSAntti Julku struct bdaddr_list *entry; 2898b2a66aadSAntti Julku 289935f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2900dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 290135f7498aSJohan Hedberg return 0; 290235f7498aSJohan Hedberg } 2903b2a66aadSAntti Julku 2904dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2905d2ab0ac1SMarcel Holtmann if (!entry) 2906d2ab0ac1SMarcel Holtmann return -ENOENT; 2907d2ab0ac1SMarcel Holtmann 2908d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2909d2ab0ac1SMarcel Holtmann kfree(entry); 2910d2ab0ac1SMarcel Holtmann 2911d2ab0ac1SMarcel Holtmann return 0; 2912d2ab0ac1SMarcel Holtmann } 2913d2ab0ac1SMarcel Holtmann 291415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 291515819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 291615819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 291715819a70SAndre Guedes { 291815819a70SAndre Guedes struct hci_conn_params *params; 291915819a70SAndre Guedes 292015819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 292115819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 292215819a70SAndre Guedes params->addr_type == addr_type) { 292315819a70SAndre Guedes return params; 292415819a70SAndre Guedes } 292515819a70SAndre Guedes } 292615819a70SAndre Guedes 292715819a70SAndre Guedes return NULL; 292815819a70SAndre Guedes } 292915819a70SAndre Guedes 293015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2931501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 29324b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 293315819a70SAndre Guedes { 2934912b42efSJohan Hedberg struct hci_conn_params *param; 293515819a70SAndre Guedes 2936501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2937912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2938912b42efSJohan Hedberg param->addr_type == addr_type) 2939912b42efSJohan Hedberg return param; 29404b10966fSMarcel Holtmann } 29414b10966fSMarcel Holtmann 29424b10966fSMarcel Holtmann return NULL; 294315819a70SAndre Guedes } 294415819a70SAndre Guedes 294515819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 294651d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 294751d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 294815819a70SAndre Guedes { 294915819a70SAndre Guedes struct hci_conn_params *params; 295015819a70SAndre Guedes 295115819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2952cef952ceSAndre Guedes if (params) 295351d167c0SMarcel Holtmann return params; 295415819a70SAndre Guedes 295515819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 295615819a70SAndre Guedes if (!params) { 295715819a70SAndre Guedes BT_ERR("Out of memory"); 295851d167c0SMarcel Holtmann return NULL; 295915819a70SAndre Guedes } 296015819a70SAndre Guedes 296115819a70SAndre Guedes bacpy(¶ms->addr, addr); 296215819a70SAndre Guedes params->addr_type = addr_type; 2963cef952ceSAndre Guedes 2964cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 296593450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2966cef952ceSAndre Guedes 2967bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2968bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2969bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2970bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2971bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2972bf5b3c8bSMarcel Holtmann 2973bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2974bf5b3c8bSMarcel Holtmann 297551d167c0SMarcel Holtmann return params; 2976bf5b3c8bSMarcel Holtmann } 2977bf5b3c8bSMarcel Holtmann 2978f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2979f6c63249SJohan Hedberg { 2980f6c63249SJohan Hedberg if (params->conn) { 2981f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2982f6c63249SJohan Hedberg hci_conn_put(params->conn); 2983f6c63249SJohan Hedberg } 2984f6c63249SJohan Hedberg 2985f6c63249SJohan Hedberg list_del(¶ms->action); 2986f6c63249SJohan Hedberg list_del(¶ms->list); 2987f6c63249SJohan Hedberg kfree(params); 2988f6c63249SJohan Hedberg } 2989f6c63249SJohan Hedberg 299015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 299115819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 299215819a70SAndre Guedes { 299315819a70SAndre Guedes struct hci_conn_params *params; 299415819a70SAndre Guedes 299515819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 299615819a70SAndre Guedes if (!params) 299715819a70SAndre Guedes return; 299815819a70SAndre Guedes 2999f6c63249SJohan Hedberg hci_conn_params_free(params); 300015819a70SAndre Guedes 300195305baaSJohan Hedberg hci_update_background_scan(hdev); 300295305baaSJohan Hedberg 300315819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 300415819a70SAndre Guedes } 300515819a70SAndre Guedes 300615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 300755af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 300815819a70SAndre Guedes { 300915819a70SAndre Guedes struct hci_conn_params *params, *tmp; 301015819a70SAndre Guedes 301115819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 301255af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 301355af49a8SJohan Hedberg continue; 3014f75113a2SJakub Pawlowski 3015f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 3016f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 3017f75113a2SJakub Pawlowski */ 3018f75113a2SJakub Pawlowski if (params->explicit_connect) { 3019f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 3020f75113a2SJakub Pawlowski continue; 3021f75113a2SJakub Pawlowski } 3022f75113a2SJakub Pawlowski 302315819a70SAndre Guedes list_del(¶ms->list); 302415819a70SAndre Guedes kfree(params); 302515819a70SAndre Guedes } 302615819a70SAndre Guedes 302755af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 302855af49a8SJohan Hedberg } 302955af49a8SJohan Hedberg 303055af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3031373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 303215819a70SAndre Guedes { 303315819a70SAndre Guedes struct hci_conn_params *params, *tmp; 303415819a70SAndre Guedes 3035f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3036f6c63249SJohan Hedberg hci_conn_params_free(params); 303715819a70SAndre Guedes 3038a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 30391089b67dSMarcel Holtmann 304015819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 304115819a70SAndre Guedes } 304215819a70SAndre Guedes 30431904a853SMarcel Holtmann static void inquiry_complete(struct hci_dev *hdev, u8 status, u16 opcode) 30447ba8b4beSAndre Guedes { 30454c87eaabSAndre Guedes if (status) { 30464c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 30477ba8b4beSAndre Guedes 30484c87eaabSAndre Guedes hci_dev_lock(hdev); 30494c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 30504c87eaabSAndre Guedes hci_dev_unlock(hdev); 30514c87eaabSAndre Guedes return; 30524c87eaabSAndre Guedes } 30537ba8b4beSAndre Guedes } 30547ba8b4beSAndre Guedes 30551904a853SMarcel Holtmann static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status, 30561904a853SMarcel Holtmann u16 opcode) 30577ba8b4beSAndre Guedes { 30584c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 30594c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 30604c87eaabSAndre Guedes struct hci_cp_inquiry cp; 30617ba8b4beSAndre Guedes int err; 30627ba8b4beSAndre Guedes 30634c87eaabSAndre Guedes if (status) { 30644c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 30654c87eaabSAndre Guedes return; 30667ba8b4beSAndre Guedes } 30677ba8b4beSAndre Guedes 30682d28cfe7SJakub Pawlowski hdev->discovery.scan_start = 0; 30692d28cfe7SJakub Pawlowski 30704c87eaabSAndre Guedes switch (hdev->discovery.type) { 30714c87eaabSAndre Guedes case DISCOV_TYPE_LE: 30724c87eaabSAndre Guedes hci_dev_lock(hdev); 30734c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 30744c87eaabSAndre Guedes hci_dev_unlock(hdev); 30754c87eaabSAndre Guedes break; 30767dbfac1dSAndre Guedes 30774c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 30784c87eaabSAndre Guedes hci_dev_lock(hdev); 30794c87eaabSAndre Guedes 308007d2334aSJakub Pawlowski if (test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, 308107d2334aSJakub Pawlowski &hdev->quirks)) { 308207d2334aSJakub Pawlowski /* If we were running LE only scan, change discovery 308307d2334aSJakub Pawlowski * state. If we were running both LE and BR/EDR inquiry 308407d2334aSJakub Pawlowski * simultaneously, and BR/EDR inquiry is already 308507d2334aSJakub Pawlowski * finished, stop discovery, otherwise BR/EDR inquiry 3086177d0506SWesley Kuo * will stop discovery when finished. If we will resolve 3087177d0506SWesley Kuo * remote device name, do not change discovery state. 308807d2334aSJakub Pawlowski */ 3089177d0506SWesley Kuo if (!test_bit(HCI_INQUIRY, &hdev->flags) && 3090177d0506SWesley Kuo hdev->discovery.state != DISCOVERY_RESOLVING) 309107d2334aSJakub Pawlowski hci_discovery_set_state(hdev, 309207d2334aSJakub Pawlowski DISCOVERY_STOPPED); 309307d2334aSJakub Pawlowski } else { 3094baf880a9SJohan Hedberg struct hci_request req; 3095baf880a9SJohan Hedberg 30964c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 30974c87eaabSAndre Guedes 3098baf880a9SJohan Hedberg hci_req_init(&req, hdev); 3099baf880a9SJohan Hedberg 3100baf880a9SJohan Hedberg memset(&cp, 0, sizeof(cp)); 3101baf880a9SJohan Hedberg memcpy(&cp.lap, lap, sizeof(cp.lap)); 3102baf880a9SJohan Hedberg cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 3103baf880a9SJohan Hedberg hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 3104baf880a9SJohan Hedberg 31054c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 31064c87eaabSAndre Guedes if (err) { 31074c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 310807d2334aSJakub Pawlowski hci_discovery_set_state(hdev, 310907d2334aSJakub Pawlowski DISCOVERY_STOPPED); 311007d2334aSJakub Pawlowski } 31117dbfac1dSAndre Guedes } 31127dbfac1dSAndre Guedes 31134c87eaabSAndre Guedes hci_dev_unlock(hdev); 31144c87eaabSAndre Guedes break; 31154c87eaabSAndre Guedes } 31167dbfac1dSAndre Guedes } 31177dbfac1dSAndre Guedes 31187ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 31197ba8b4beSAndre Guedes { 31207ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 31217ba8b4beSAndre Guedes le_scan_disable.work); 31224c87eaabSAndre Guedes struct hci_request req; 31234c87eaabSAndre Guedes int err; 31247ba8b4beSAndre Guedes 31257ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 31267ba8b4beSAndre Guedes 31272d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 31282d28cfe7SJakub Pawlowski 31294c87eaabSAndre Guedes hci_req_init(&req, hdev); 31307ba8b4beSAndre Guedes 3131b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 31327ba8b4beSAndre Guedes 31334c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 31344c87eaabSAndre Guedes if (err) 31354c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 313628b75a89SAndre Guedes } 313728b75a89SAndre Guedes 31382d28cfe7SJakub Pawlowski static void le_scan_restart_work_complete(struct hci_dev *hdev, u8 status, 31392d28cfe7SJakub Pawlowski u16 opcode) 31402d28cfe7SJakub Pawlowski { 31412d28cfe7SJakub Pawlowski unsigned long timeout, duration, scan_start, now; 31422d28cfe7SJakub Pawlowski 31432d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 31442d28cfe7SJakub Pawlowski 31452d28cfe7SJakub Pawlowski if (status) { 31462d28cfe7SJakub Pawlowski BT_ERR("Failed to restart LE scan: status %d", status); 31472d28cfe7SJakub Pawlowski return; 31482d28cfe7SJakub Pawlowski } 31492d28cfe7SJakub Pawlowski 31502d28cfe7SJakub Pawlowski if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) || 31512d28cfe7SJakub Pawlowski !hdev->discovery.scan_start) 31522d28cfe7SJakub Pawlowski return; 31532d28cfe7SJakub Pawlowski 31542d28cfe7SJakub Pawlowski /* When the scan was started, hdev->le_scan_disable has been queued 31552d28cfe7SJakub Pawlowski * after duration from scan_start. During scan restart this job 31562d28cfe7SJakub Pawlowski * has been canceled, and we need to queue it again after proper 31572d28cfe7SJakub Pawlowski * timeout, to make sure that scan does not run indefinitely. 31582d28cfe7SJakub Pawlowski */ 31592d28cfe7SJakub Pawlowski duration = hdev->discovery.scan_duration; 31602d28cfe7SJakub Pawlowski scan_start = hdev->discovery.scan_start; 31612d28cfe7SJakub Pawlowski now = jiffies; 31622d28cfe7SJakub Pawlowski if (now - scan_start <= duration) { 31632d28cfe7SJakub Pawlowski int elapsed; 31642d28cfe7SJakub Pawlowski 31652d28cfe7SJakub Pawlowski if (now >= scan_start) 31662d28cfe7SJakub Pawlowski elapsed = now - scan_start; 31672d28cfe7SJakub Pawlowski else 31682d28cfe7SJakub Pawlowski elapsed = ULONG_MAX - scan_start + now; 31692d28cfe7SJakub Pawlowski 31702d28cfe7SJakub Pawlowski timeout = duration - elapsed; 31712d28cfe7SJakub Pawlowski } else { 31722d28cfe7SJakub Pawlowski timeout = 0; 31732d28cfe7SJakub Pawlowski } 31742d28cfe7SJakub Pawlowski queue_delayed_work(hdev->workqueue, 31752d28cfe7SJakub Pawlowski &hdev->le_scan_disable, timeout); 31762d28cfe7SJakub Pawlowski } 31772d28cfe7SJakub Pawlowski 31782d28cfe7SJakub Pawlowski static void le_scan_restart_work(struct work_struct *work) 31792d28cfe7SJakub Pawlowski { 31802d28cfe7SJakub Pawlowski struct hci_dev *hdev = container_of(work, struct hci_dev, 31812d28cfe7SJakub Pawlowski le_scan_restart.work); 31822d28cfe7SJakub Pawlowski struct hci_request req; 31832d28cfe7SJakub Pawlowski struct hci_cp_le_set_scan_enable cp; 31842d28cfe7SJakub Pawlowski int err; 31852d28cfe7SJakub Pawlowski 31862d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 31872d28cfe7SJakub Pawlowski 31882d28cfe7SJakub Pawlowski /* If controller is not scanning we are done. */ 3189d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_LE_SCAN)) 31902d28cfe7SJakub Pawlowski return; 31912d28cfe7SJakub Pawlowski 31922d28cfe7SJakub Pawlowski hci_req_init(&req, hdev); 31932d28cfe7SJakub Pawlowski 31942d28cfe7SJakub Pawlowski hci_req_add_le_scan_disable(&req); 31952d28cfe7SJakub Pawlowski 31962d28cfe7SJakub Pawlowski memset(&cp, 0, sizeof(cp)); 31972d28cfe7SJakub Pawlowski cp.enable = LE_SCAN_ENABLE; 31982d28cfe7SJakub Pawlowski cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 31992d28cfe7SJakub Pawlowski hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 32002d28cfe7SJakub Pawlowski 32012d28cfe7SJakub Pawlowski err = hci_req_run(&req, le_scan_restart_work_complete); 32022d28cfe7SJakub Pawlowski if (err) 32032d28cfe7SJakub Pawlowski BT_ERR("Restart LE scan request failed: err %d", err); 32042d28cfe7SJakub Pawlowski } 32052d28cfe7SJakub Pawlowski 3206a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3207a1f4c318SJohan Hedberg * 3208a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3209a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3210a1f4c318SJohan Hedberg * the static random address. 3211a1f4c318SJohan Hedberg * 3212a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3213a1f4c318SJohan Hedberg * public address to use the static random address instead. 321450b5b952SMarcel Holtmann * 321550b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 321650b5b952SMarcel Holtmann * userspace has configured a static address, then that address 321750b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 3218a1f4c318SJohan Hedberg */ 3219a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3220a1f4c318SJohan Hedberg u8 *bdaddr_type) 3221a1f4c318SJohan Hedberg { 3222b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 322350b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 3224d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 322550b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 3226a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3227a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3228a1f4c318SJohan Hedberg } else { 3229a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3230a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3231a1f4c318SJohan Hedberg } 3232a1f4c318SJohan Hedberg } 3233a1f4c318SJohan Hedberg 32349be0dab7SDavid Herrmann /* Alloc HCI device */ 32359be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 32369be0dab7SDavid Herrmann { 32379be0dab7SDavid Herrmann struct hci_dev *hdev; 32389be0dab7SDavid Herrmann 323927f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 32409be0dab7SDavid Herrmann if (!hdev) 32419be0dab7SDavid Herrmann return NULL; 32429be0dab7SDavid Herrmann 3243b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3244b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3245b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3246b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3247b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 324896c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3249bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3250bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3251d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 3252d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 32535d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 3254b1b813d4SDavid Herrmann 3255b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3256b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3257b1b813d4SDavid Herrmann 32583f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3259628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3260628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3261bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3262bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 32634e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 32644e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 326504fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 326604fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3267a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3268a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3269a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3270a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3271a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3272a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 3273bef64738SMarcel Holtmann 3274d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3275b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 327631ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 327731ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3278d6bfd59cSJohan Hedberg 3279b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3280b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3281b1b813d4SDavid Herrmann 3282b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3283b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 32846659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3285b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3286b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3287b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3288970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3289b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3290d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 329115819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 329277a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 329366f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 32946b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3295d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3296b1b813d4SDavid Herrmann 3297b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3298b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3299b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3300b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3301c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3302b1b813d4SDavid Herrmann 3303b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3304b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3305b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 33062d28cfe7SJakub Pawlowski INIT_DELAYED_WORK(&hdev->le_scan_restart, le_scan_restart_work); 33075d900e46SFlorian Grandel INIT_DELAYED_WORK(&hdev->adv_instance_expire, hci_adv_timeout_expire); 3308b1b813d4SDavid Herrmann 3309b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3310b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3311b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3312b1b813d4SDavid Herrmann 3313b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3314b1b813d4SDavid Herrmann 331565cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3316b1b813d4SDavid Herrmann 3317b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3318b1b813d4SDavid Herrmann discovery_init(hdev); 33199be0dab7SDavid Herrmann 33209be0dab7SDavid Herrmann return hdev; 33219be0dab7SDavid Herrmann } 33229be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 33239be0dab7SDavid Herrmann 33249be0dab7SDavid Herrmann /* Free HCI device */ 33259be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 33269be0dab7SDavid Herrmann { 33279be0dab7SDavid Herrmann /* will free via device release */ 33289be0dab7SDavid Herrmann put_device(&hdev->dev); 33299be0dab7SDavid Herrmann } 33309be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 33319be0dab7SDavid Herrmann 33321da177e4SLinus Torvalds /* Register HCI device */ 33331da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 33341da177e4SLinus Torvalds { 3335b1b813d4SDavid Herrmann int id, error; 33361da177e4SLinus Torvalds 333774292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 33381da177e4SLinus Torvalds return -EINVAL; 33391da177e4SLinus Torvalds 334008add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 334108add513SMat Martineau * so the index can be used as the AMP controller ID. 334208add513SMat Martineau */ 33433df92b31SSasha Levin switch (hdev->dev_type) { 33443df92b31SSasha Levin case HCI_BREDR: 33453df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 33461da177e4SLinus Torvalds break; 33473df92b31SSasha Levin case HCI_AMP: 33483df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 33493df92b31SSasha Levin break; 33503df92b31SSasha Levin default: 33513df92b31SSasha Levin return -EINVAL; 33521da177e4SLinus Torvalds } 33531da177e4SLinus Torvalds 33543df92b31SSasha Levin if (id < 0) 33553df92b31SSasha Levin return id; 33563df92b31SSasha Levin 33571da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 33581da177e4SLinus Torvalds hdev->id = id; 33592d8b3a11SAndrei Emeltchenko 33602d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 33612d8b3a11SAndrei Emeltchenko 3362d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3363d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 336433ca954dSDavid Herrmann if (!hdev->workqueue) { 336533ca954dSDavid Herrmann error = -ENOMEM; 336633ca954dSDavid Herrmann goto err; 336733ca954dSDavid Herrmann } 3368f48fd9c8SMarcel Holtmann 3369d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3370d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 33716ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 33726ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 33736ead1bbcSJohan Hedberg error = -ENOMEM; 33746ead1bbcSJohan Hedberg goto err; 33756ead1bbcSJohan Hedberg } 33766ead1bbcSJohan Hedberg 33770153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 33780153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 33790153e2ecSMarcel Holtmann 3380bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3381bdc3e0f1SMarcel Holtmann 3382bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 338333ca954dSDavid Herrmann if (error < 0) 338454506918SJohan Hedberg goto err_wqueue; 33851da177e4SLinus Torvalds 3386611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3387a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3388a8c5fb1aSGustavo Padovan hdev); 3389611b30f7SMarcel Holtmann if (hdev->rfkill) { 3390611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3391611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3392611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3393611b30f7SMarcel Holtmann } 3394611b30f7SMarcel Holtmann } 3395611b30f7SMarcel Holtmann 33965e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3397a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 33985e130367SJohan Hedberg 3399a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3400a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3401ce2be9acSAndrei Emeltchenko 340201cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 340356f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 340456f87901SJohan Hedberg * through reading supported features during init. 340556f87901SJohan Hedberg */ 3406a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 340756f87901SJohan Hedberg } 3408ce2be9acSAndrei Emeltchenko 3409fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3410fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3411fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3412fcee3377SGustavo Padovan 34134a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 34144a964404SMarcel Holtmann * and should not be included in normal operation. 3415fee746b0SMarcel Holtmann */ 3416fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3417a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3418fee746b0SMarcel Holtmann 341905fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3420dc946bd8SDavid Herrmann hci_dev_hold(hdev); 34211da177e4SLinus Torvalds 342219202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3423fbe96d6fSMarcel Holtmann 34241da177e4SLinus Torvalds return id; 3425f48fd9c8SMarcel Holtmann 342633ca954dSDavid Herrmann err_wqueue: 342733ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 34286ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 342933ca954dSDavid Herrmann err: 34303df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3431f48fd9c8SMarcel Holtmann 343233ca954dSDavid Herrmann return error; 34331da177e4SLinus Torvalds } 34341da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 34351da177e4SLinus Torvalds 34361da177e4SLinus Torvalds /* Unregister HCI device */ 343759735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 34381da177e4SLinus Torvalds { 34392d7cc19eSMarcel Holtmann int id; 3440ef222013SMarcel Holtmann 3441c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 34421da177e4SLinus Torvalds 3443a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 344494324962SJohan Hovold 34453df92b31SSasha Levin id = hdev->id; 34463df92b31SSasha Levin 3447f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 34481da177e4SLinus Torvalds list_del(&hdev->list); 3449f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 34501da177e4SLinus Torvalds 34511da177e4SLinus Torvalds hci_dev_do_close(hdev); 34521da177e4SLinus Torvalds 3453b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3454b9b5ef18SGustavo Padovan 3455ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3456d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3457d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 345809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3459744cf19eSJohan Hedberg mgmt_index_removed(hdev); 346009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 346156e5cb86SJohan Hedberg } 3462ab81cbf9SJohan Hedberg 34632e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 34642e58ef3eSJohan Hedberg * pending list */ 34652e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 34662e58ef3eSJohan Hedberg 346705fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 34681da177e4SLinus Torvalds 3469611b30f7SMarcel Holtmann if (hdev->rfkill) { 3470611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3471611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3472611b30f7SMarcel Holtmann } 3473611b30f7SMarcel Holtmann 3474bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3475147e2d59SDave Young 34760153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 34770153e2ecSMarcel Holtmann 3478f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 34796ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3480f48fd9c8SMarcel Holtmann 348109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3482dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 34836659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 34842aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 348555ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3486b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3487970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 34882763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3489d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3490dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3491373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 349222078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 349309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3494e2e0cacbSJohan Hedberg 3495dc946bd8SDavid Herrmann hci_dev_put(hdev); 34963df92b31SSasha Levin 34973df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 34981da177e4SLinus Torvalds } 34991da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 35001da177e4SLinus Torvalds 35011da177e4SLinus Torvalds /* Suspend HCI device */ 35021da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 35031da177e4SLinus Torvalds { 350405fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 35051da177e4SLinus Torvalds return 0; 35061da177e4SLinus Torvalds } 35071da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 35081da177e4SLinus Torvalds 35091da177e4SLinus Torvalds /* Resume HCI device */ 35101da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 35111da177e4SLinus Torvalds { 351205fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 35131da177e4SLinus Torvalds return 0; 35141da177e4SLinus Torvalds } 35151da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 35161da177e4SLinus Torvalds 351775e0569fSMarcel Holtmann /* Reset HCI device */ 351875e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 351975e0569fSMarcel Holtmann { 352075e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 352175e0569fSMarcel Holtmann struct sk_buff *skb; 352275e0569fSMarcel Holtmann 352375e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 352475e0569fSMarcel Holtmann if (!skb) 352575e0569fSMarcel Holtmann return -ENOMEM; 352675e0569fSMarcel Holtmann 352775e0569fSMarcel Holtmann bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 352875e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 352975e0569fSMarcel Holtmann 353075e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 353175e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 353275e0569fSMarcel Holtmann } 353375e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 353475e0569fSMarcel Holtmann 353576bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3536e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 353776bca880SMarcel Holtmann { 353876bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 353976bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 354076bca880SMarcel Holtmann kfree_skb(skb); 354176bca880SMarcel Holtmann return -ENXIO; 354276bca880SMarcel Holtmann } 354376bca880SMarcel Holtmann 3544fe806dceSMarcel Holtmann if (bt_cb(skb)->pkt_type != HCI_EVENT_PKT && 3545fe806dceSMarcel Holtmann bt_cb(skb)->pkt_type != HCI_ACLDATA_PKT && 3546fe806dceSMarcel Holtmann bt_cb(skb)->pkt_type != HCI_SCODATA_PKT) { 3547fe806dceSMarcel Holtmann kfree_skb(skb); 3548fe806dceSMarcel Holtmann return -EINVAL; 3549fe806dceSMarcel Holtmann } 3550fe806dceSMarcel Holtmann 3551d82603c6SJorrit Schippers /* Incoming skb */ 355276bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 355376bca880SMarcel Holtmann 355476bca880SMarcel Holtmann /* Time stamp */ 355576bca880SMarcel Holtmann __net_timestamp(skb); 355676bca880SMarcel Holtmann 355776bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3558b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3559c78ae283SMarcel Holtmann 356076bca880SMarcel Holtmann return 0; 356176bca880SMarcel Holtmann } 356276bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 356376bca880SMarcel Holtmann 3564e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3565e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3566e875ff84SMarcel Holtmann { 3567581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3568581d6fd6SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_DIAG_PKT; 3569581d6fd6SMarcel Holtmann 3570e875ff84SMarcel Holtmann /* Time stamp */ 3571e875ff84SMarcel Holtmann __net_timestamp(skb); 3572e875ff84SMarcel Holtmann 3573581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3574581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3575e875ff84SMarcel Holtmann 3576e875ff84SMarcel Holtmann return 0; 3577e875ff84SMarcel Holtmann } 3578e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3579e875ff84SMarcel Holtmann 35801da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 35811da177e4SLinus Torvalds 35821da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 35831da177e4SLinus Torvalds { 35841da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35851da177e4SLinus Torvalds 3586fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 358700629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3588fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 35891da177e4SLinus Torvalds 35901da177e4SLinus Torvalds return 0; 35911da177e4SLinus Torvalds } 35921da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 35931da177e4SLinus Torvalds 35941da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 35951da177e4SLinus Torvalds { 35961da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35971da177e4SLinus Torvalds 3598fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 35991da177e4SLinus Torvalds list_del(&cb->list); 3600fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 36011da177e4SLinus Torvalds 36021da177e4SLinus Torvalds return 0; 36031da177e4SLinus Torvalds } 36041da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 36051da177e4SLinus Torvalds 360651086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 36071da177e4SLinus Torvalds { 3608cdc52faaSMarcel Holtmann int err; 3609cdc52faaSMarcel Holtmann 36100d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 36111da177e4SLinus Torvalds 36121da177e4SLinus Torvalds /* Time stamp */ 3613a61bbcf2SPatrick McHardy __net_timestamp(skb); 36141da177e4SLinus Torvalds 3615cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3616cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3617cd82e61cSMarcel Holtmann 3618cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3619cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3620470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 36211da177e4SLinus Torvalds } 36221da177e4SLinus Torvalds 36231da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 36241da177e4SLinus Torvalds skb_orphan(skb); 36251da177e4SLinus Torvalds 362673d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 362773d0d3c8SMarcel Holtmann kfree_skb(skb); 362873d0d3c8SMarcel Holtmann return; 362973d0d3c8SMarcel Holtmann } 363073d0d3c8SMarcel Holtmann 3631cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3632cdc52faaSMarcel Holtmann if (err < 0) { 3633cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3634cdc52faaSMarcel Holtmann kfree_skb(skb); 3635cdc52faaSMarcel Holtmann } 36361da177e4SLinus Torvalds } 36371da177e4SLinus Torvalds 36381ca3a9d0SJohan Hedberg /* Send HCI command */ 363907dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 364007dc93ddSJohan Hedberg const void *param) 36411ca3a9d0SJohan Hedberg { 36421ca3a9d0SJohan Hedberg struct sk_buff *skb; 36431ca3a9d0SJohan Hedberg 36441ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 36451ca3a9d0SJohan Hedberg 36461ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 36471ca3a9d0SJohan Hedberg if (!skb) { 36481ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 36491ca3a9d0SJohan Hedberg return -ENOMEM; 36501ca3a9d0SJohan Hedberg } 36511ca3a9d0SJohan Hedberg 365249c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 365311714b3dSJohan Hedberg * single-command requests. 365411714b3dSJohan Hedberg */ 3655242c0ebdSMarcel Holtmann bt_cb(skb)->hci.req_start = true; 365611714b3dSJohan Hedberg 36571da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3658c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 36591da177e4SLinus Torvalds 36601da177e4SLinus Torvalds return 0; 36611da177e4SLinus Torvalds } 36621da177e4SLinus Torvalds 36631da177e4SLinus Torvalds /* Get data from the previously sent command */ 3664a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 36651da177e4SLinus Torvalds { 36661da177e4SLinus Torvalds struct hci_command_hdr *hdr; 36671da177e4SLinus Torvalds 36681da177e4SLinus Torvalds if (!hdev->sent_cmd) 36691da177e4SLinus Torvalds return NULL; 36701da177e4SLinus Torvalds 36711da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 36721da177e4SLinus Torvalds 3673a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 36741da177e4SLinus Torvalds return NULL; 36751da177e4SLinus Torvalds 3676f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 36771da177e4SLinus Torvalds 36781da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 36791da177e4SLinus Torvalds } 36801da177e4SLinus Torvalds 3681fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3682fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3683fbef168fSLoic Poulain const void *param, u32 timeout) 3684fbef168fSLoic Poulain { 3685fbef168fSLoic Poulain struct sk_buff *skb; 3686fbef168fSLoic Poulain 3687fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3688fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3689fbef168fSLoic Poulain 3690fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3691fbef168fSLoic Poulain 3692fbef168fSLoic Poulain hci_req_lock(hdev); 3693fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3694fbef168fSLoic Poulain hci_req_unlock(hdev); 3695fbef168fSLoic Poulain 3696fbef168fSLoic Poulain return skb; 3697fbef168fSLoic Poulain } 3698fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3699fbef168fSLoic Poulain 37001da177e4SLinus Torvalds /* Send ACL data */ 37011da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 37021da177e4SLinus Torvalds { 37031da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 37041da177e4SLinus Torvalds int len = skb->len; 37051da177e4SLinus Torvalds 3706badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3707badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 37089c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3709aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3710aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 37111da177e4SLinus Torvalds } 37121da177e4SLinus Torvalds 3713ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 371473d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 37151da177e4SLinus Torvalds { 3716ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 37171da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37181da177e4SLinus Torvalds struct sk_buff *list; 37191da177e4SLinus Torvalds 3720087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3721087bfd99SGustavo Padovan skb->data_len = 0; 3722087bfd99SGustavo Padovan 3723087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3724204a6e54SAndrei Emeltchenko 3725204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3726204a6e54SAndrei Emeltchenko case HCI_BREDR: 3727087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3728204a6e54SAndrei Emeltchenko break; 3729204a6e54SAndrei Emeltchenko case HCI_AMP: 3730204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3731204a6e54SAndrei Emeltchenko break; 3732204a6e54SAndrei Emeltchenko default: 3733204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3734204a6e54SAndrei Emeltchenko return; 3735204a6e54SAndrei Emeltchenko } 3736087bfd99SGustavo Padovan 373770f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 373870f23020SAndrei Emeltchenko if (!list) { 37391da177e4SLinus Torvalds /* Non fragmented */ 37401da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 37411da177e4SLinus Torvalds 374273d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 37431da177e4SLinus Torvalds } else { 37441da177e4SLinus Torvalds /* Fragmented */ 37451da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37461da177e4SLinus Torvalds 37471da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 37481da177e4SLinus Torvalds 37499cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 37509cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 37519cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 37529cfd5a23SJukka Rissanen * deadlocks. 37539cfd5a23SJukka Rissanen */ 37549cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 37551da177e4SLinus Torvalds 375673d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3757e702112fSAndrei Emeltchenko 3758e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3759e702112fSAndrei Emeltchenko flags |= ACL_CONT; 37601da177e4SLinus Torvalds do { 37611da177e4SLinus Torvalds skb = list; list = list->next; 37621da177e4SLinus Torvalds 37630d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3764e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 37651da177e4SLinus Torvalds 37661da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37671da177e4SLinus Torvalds 376873d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 37691da177e4SLinus Torvalds } while (list); 37701da177e4SLinus Torvalds 37719cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 37721da177e4SLinus Torvalds } 377373d80debSLuiz Augusto von Dentz } 377473d80debSLuiz Augusto von Dentz 377573d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 377673d80debSLuiz Augusto von Dentz { 3777ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 377873d80debSLuiz Augusto von Dentz 3779f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 378073d80debSLuiz Augusto von Dentz 3781ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 37821da177e4SLinus Torvalds 37833eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 37841da177e4SLinus Torvalds } 37851da177e4SLinus Torvalds 37861da177e4SLinus Torvalds /* Send SCO data */ 37870d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 37881da177e4SLinus Torvalds { 37891da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37901da177e4SLinus Torvalds struct hci_sco_hdr hdr; 37911da177e4SLinus Torvalds 37921da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 37931da177e4SLinus Torvalds 3794aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 37951da177e4SLinus Torvalds hdr.dlen = skb->len; 37961da177e4SLinus Torvalds 3797badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3798badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 37999c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 38001da177e4SLinus Torvalds 38010d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3802c78ae283SMarcel Holtmann 38031da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 38043eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 38051da177e4SLinus Torvalds } 38061da177e4SLinus Torvalds 38071da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 38081da177e4SLinus Torvalds 38091da177e4SLinus Torvalds /* HCI Connection scheduler */ 38106039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3811a8c5fb1aSGustavo Padovan int *quote) 38121da177e4SLinus Torvalds { 38131da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38148035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3815abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 38161da177e4SLinus Torvalds 38171da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 38181da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3819bf4c6325SGustavo F. Padovan 3820bf4c6325SGustavo F. Padovan rcu_read_lock(); 3821bf4c6325SGustavo F. Padovan 3822bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3823769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 38241da177e4SLinus Torvalds continue; 3825769be974SMarcel Holtmann 3826769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3827769be974SMarcel Holtmann continue; 3828769be974SMarcel Holtmann 38291da177e4SLinus Torvalds num++; 38301da177e4SLinus Torvalds 38311da177e4SLinus Torvalds if (c->sent < min) { 38321da177e4SLinus Torvalds min = c->sent; 38331da177e4SLinus Torvalds conn = c; 38341da177e4SLinus Torvalds } 383552087a79SLuiz Augusto von Dentz 383652087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 383752087a79SLuiz Augusto von Dentz break; 38381da177e4SLinus Torvalds } 38391da177e4SLinus Torvalds 3840bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3841bf4c6325SGustavo F. Padovan 38421da177e4SLinus Torvalds if (conn) { 38436ed58ec5SVille Tervo int cnt, q; 38446ed58ec5SVille Tervo 38456ed58ec5SVille Tervo switch (conn->type) { 38466ed58ec5SVille Tervo case ACL_LINK: 38476ed58ec5SVille Tervo cnt = hdev->acl_cnt; 38486ed58ec5SVille Tervo break; 38496ed58ec5SVille Tervo case SCO_LINK: 38506ed58ec5SVille Tervo case ESCO_LINK: 38516ed58ec5SVille Tervo cnt = hdev->sco_cnt; 38526ed58ec5SVille Tervo break; 38536ed58ec5SVille Tervo case LE_LINK: 38546ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 38556ed58ec5SVille Tervo break; 38566ed58ec5SVille Tervo default: 38576ed58ec5SVille Tervo cnt = 0; 38586ed58ec5SVille Tervo BT_ERR("Unknown link type"); 38596ed58ec5SVille Tervo } 38606ed58ec5SVille Tervo 38616ed58ec5SVille Tervo q = cnt / num; 38621da177e4SLinus Torvalds *quote = q ? q : 1; 38631da177e4SLinus Torvalds } else 38641da177e4SLinus Torvalds *quote = 0; 38651da177e4SLinus Torvalds 38661da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 38671da177e4SLinus Torvalds return conn; 38681da177e4SLinus Torvalds } 38691da177e4SLinus Torvalds 38706039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 38711da177e4SLinus Torvalds { 38721da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38731da177e4SLinus Torvalds struct hci_conn *c; 38741da177e4SLinus Torvalds 3875bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 38761da177e4SLinus Torvalds 3877bf4c6325SGustavo F. Padovan rcu_read_lock(); 3878bf4c6325SGustavo F. Padovan 38791da177e4SLinus Torvalds /* Kill stalled connections */ 3880bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3881bae1f5d9SVille Tervo if (c->type == type && c->sent) { 38826ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 38836ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3884bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 38851da177e4SLinus Torvalds } 38861da177e4SLinus Torvalds } 3887bf4c6325SGustavo F. Padovan 3888bf4c6325SGustavo F. Padovan rcu_read_unlock(); 38891da177e4SLinus Torvalds } 38901da177e4SLinus Torvalds 38916039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 389273d80debSLuiz Augusto von Dentz int *quote) 389373d80debSLuiz Augusto von Dentz { 389473d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 389573d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3896abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 389773d80debSLuiz Augusto von Dentz struct hci_conn *conn; 389873d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 389973d80debSLuiz Augusto von Dentz 390073d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 390173d80debSLuiz Augusto von Dentz 3902bf4c6325SGustavo F. Padovan rcu_read_lock(); 3903bf4c6325SGustavo F. Padovan 3904bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 390573d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 390673d80debSLuiz Augusto von Dentz 390773d80debSLuiz Augusto von Dentz if (conn->type != type) 390873d80debSLuiz Augusto von Dentz continue; 390973d80debSLuiz Augusto von Dentz 391073d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 391173d80debSLuiz Augusto von Dentz continue; 391273d80debSLuiz Augusto von Dentz 391373d80debSLuiz Augusto von Dentz conn_num++; 391473d80debSLuiz Augusto von Dentz 39158192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 391673d80debSLuiz Augusto von Dentz struct sk_buff *skb; 391773d80debSLuiz Augusto von Dentz 391873d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 391973d80debSLuiz Augusto von Dentz continue; 392073d80debSLuiz Augusto von Dentz 392173d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 392273d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 392373d80debSLuiz Augusto von Dentz continue; 392473d80debSLuiz Augusto von Dentz 392573d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 392673d80debSLuiz Augusto von Dentz num = 0; 392773d80debSLuiz Augusto von Dentz min = ~0; 392873d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 392973d80debSLuiz Augusto von Dentz } 393073d80debSLuiz Augusto von Dentz 393173d80debSLuiz Augusto von Dentz num++; 393273d80debSLuiz Augusto von Dentz 393373d80debSLuiz Augusto von Dentz if (conn->sent < min) { 393473d80debSLuiz Augusto von Dentz min = conn->sent; 393573d80debSLuiz Augusto von Dentz chan = tmp; 393673d80debSLuiz Augusto von Dentz } 393773d80debSLuiz Augusto von Dentz } 393873d80debSLuiz Augusto von Dentz 393973d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 394073d80debSLuiz Augusto von Dentz break; 394173d80debSLuiz Augusto von Dentz } 394273d80debSLuiz Augusto von Dentz 3943bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3944bf4c6325SGustavo F. Padovan 394573d80debSLuiz Augusto von Dentz if (!chan) 394673d80debSLuiz Augusto von Dentz return NULL; 394773d80debSLuiz Augusto von Dentz 394873d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 394973d80debSLuiz Augusto von Dentz case ACL_LINK: 395073d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 395173d80debSLuiz Augusto von Dentz break; 3952bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3953bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3954bd1eb66bSAndrei Emeltchenko break; 395573d80debSLuiz Augusto von Dentz case SCO_LINK: 395673d80debSLuiz Augusto von Dentz case ESCO_LINK: 395773d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 395873d80debSLuiz Augusto von Dentz break; 395973d80debSLuiz Augusto von Dentz case LE_LINK: 396073d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 396173d80debSLuiz Augusto von Dentz break; 396273d80debSLuiz Augusto von Dentz default: 396373d80debSLuiz Augusto von Dentz cnt = 0; 396473d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 396573d80debSLuiz Augusto von Dentz } 396673d80debSLuiz Augusto von Dentz 396773d80debSLuiz Augusto von Dentz q = cnt / num; 396873d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 396973d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 397073d80debSLuiz Augusto von Dentz return chan; 397173d80debSLuiz Augusto von Dentz } 397273d80debSLuiz Augusto von Dentz 397302b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 397402b20f0bSLuiz Augusto von Dentz { 397502b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 397602b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 397702b20f0bSLuiz Augusto von Dentz int num = 0; 397802b20f0bSLuiz Augusto von Dentz 397902b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 398002b20f0bSLuiz Augusto von Dentz 3981bf4c6325SGustavo F. Padovan rcu_read_lock(); 3982bf4c6325SGustavo F. Padovan 3983bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 398402b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 398502b20f0bSLuiz Augusto von Dentz 398602b20f0bSLuiz Augusto von Dentz if (conn->type != type) 398702b20f0bSLuiz Augusto von Dentz continue; 398802b20f0bSLuiz Augusto von Dentz 398902b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 399002b20f0bSLuiz Augusto von Dentz continue; 399102b20f0bSLuiz Augusto von Dentz 399202b20f0bSLuiz Augusto von Dentz num++; 399302b20f0bSLuiz Augusto von Dentz 39948192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 399502b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 399602b20f0bSLuiz Augusto von Dentz 399702b20f0bSLuiz Augusto von Dentz if (chan->sent) { 399802b20f0bSLuiz Augusto von Dentz chan->sent = 0; 399902b20f0bSLuiz Augusto von Dentz continue; 400002b20f0bSLuiz Augusto von Dentz } 400102b20f0bSLuiz Augusto von Dentz 400202b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 400302b20f0bSLuiz Augusto von Dentz continue; 400402b20f0bSLuiz Augusto von Dentz 400502b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 400602b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 400702b20f0bSLuiz Augusto von Dentz continue; 400802b20f0bSLuiz Augusto von Dentz 400902b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 401002b20f0bSLuiz Augusto von Dentz 401102b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 401202b20f0bSLuiz Augusto von Dentz skb->priority); 401302b20f0bSLuiz Augusto von Dentz } 401402b20f0bSLuiz Augusto von Dentz 401502b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 401602b20f0bSLuiz Augusto von Dentz break; 401702b20f0bSLuiz Augusto von Dentz } 4018bf4c6325SGustavo F. Padovan 4019bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4020bf4c6325SGustavo F. Padovan 402102b20f0bSLuiz Augusto von Dentz } 402202b20f0bSLuiz Augusto von Dentz 4023b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4024b71d385aSAndrei Emeltchenko { 4025b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4026b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4027b71d385aSAndrei Emeltchenko } 4028b71d385aSAndrei Emeltchenko 40296039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 40301da177e4SLinus Torvalds { 4031d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 40321da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 40331da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 403463d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 40355f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4036bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 40371da177e4SLinus Torvalds } 403863d2bc1bSAndrei Emeltchenko } 40391da177e4SLinus Torvalds 40406039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 404163d2bc1bSAndrei Emeltchenko { 404263d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 404363d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 404463d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 404563d2bc1bSAndrei Emeltchenko int quote; 404663d2bc1bSAndrei Emeltchenko 404763d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 404804837f64SMarcel Holtmann 404973d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 405073d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4051ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4052ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 405373d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 405473d80debSLuiz Augusto von Dentz skb->len, skb->priority); 405573d80debSLuiz Augusto von Dentz 4056ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4057ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4058ec1cce24SLuiz Augusto von Dentz break; 4059ec1cce24SLuiz Augusto von Dentz 4060ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4061ec1cce24SLuiz Augusto von Dentz 406273d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 406373d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 406404837f64SMarcel Holtmann 406557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40661da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 40671da177e4SLinus Torvalds 40681da177e4SLinus Torvalds hdev->acl_cnt--; 406973d80debSLuiz Augusto von Dentz chan->sent++; 407073d80debSLuiz Augusto von Dentz chan->conn->sent++; 40711da177e4SLinus Torvalds } 40721da177e4SLinus Torvalds } 407302b20f0bSLuiz Augusto von Dentz 407402b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 407502b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 40761da177e4SLinus Torvalds } 40771da177e4SLinus Torvalds 40786039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4079b71d385aSAndrei Emeltchenko { 408063d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4081b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4082b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4083b71d385aSAndrei Emeltchenko int quote; 4084bd1eb66bSAndrei Emeltchenko u8 type; 4085b71d385aSAndrei Emeltchenko 408663d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4087b71d385aSAndrei Emeltchenko 4088bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4089bd1eb66bSAndrei Emeltchenko 4090bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4091bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4092bd1eb66bSAndrei Emeltchenko else 4093bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4094bd1eb66bSAndrei Emeltchenko 4095b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4096bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4097b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4098b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4099b71d385aSAndrei Emeltchenko int blocks; 4100b71d385aSAndrei Emeltchenko 4101b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4102b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4103b71d385aSAndrei Emeltchenko 4104b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4105b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4106b71d385aSAndrei Emeltchenko break; 4107b71d385aSAndrei Emeltchenko 4108b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4109b71d385aSAndrei Emeltchenko 4110b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4111b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4112b71d385aSAndrei Emeltchenko return; 4113b71d385aSAndrei Emeltchenko 4114b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4115b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4116b71d385aSAndrei Emeltchenko 411757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4118b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4119b71d385aSAndrei Emeltchenko 4120b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4121b71d385aSAndrei Emeltchenko quote -= blocks; 4122b71d385aSAndrei Emeltchenko 4123b71d385aSAndrei Emeltchenko chan->sent += blocks; 4124b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4125b71d385aSAndrei Emeltchenko } 4126b71d385aSAndrei Emeltchenko } 4127b71d385aSAndrei Emeltchenko 4128b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4129bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4130b71d385aSAndrei Emeltchenko } 4131b71d385aSAndrei Emeltchenko 41326039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4133b71d385aSAndrei Emeltchenko { 4134b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4135b71d385aSAndrei Emeltchenko 4136bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4137bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 4138bd1eb66bSAndrei Emeltchenko return; 4139bd1eb66bSAndrei Emeltchenko 4140bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4141bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4142b71d385aSAndrei Emeltchenko return; 4143b71d385aSAndrei Emeltchenko 4144b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4145b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4146b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4147b71d385aSAndrei Emeltchenko break; 4148b71d385aSAndrei Emeltchenko 4149b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4150b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4151b71d385aSAndrei Emeltchenko break; 4152b71d385aSAndrei Emeltchenko } 4153b71d385aSAndrei Emeltchenko } 4154b71d385aSAndrei Emeltchenko 41551da177e4SLinus Torvalds /* Schedule SCO */ 41566039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 41571da177e4SLinus Torvalds { 41581da177e4SLinus Torvalds struct hci_conn *conn; 41591da177e4SLinus Torvalds struct sk_buff *skb; 41601da177e4SLinus Torvalds int quote; 41611da177e4SLinus Torvalds 41621da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 41631da177e4SLinus Torvalds 416452087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 416552087a79SLuiz Augusto von Dentz return; 416652087a79SLuiz Augusto von Dentz 41671da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 41681da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 41691da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 417057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41711da177e4SLinus Torvalds 41721da177e4SLinus Torvalds conn->sent++; 41731da177e4SLinus Torvalds if (conn->sent == ~0) 41741da177e4SLinus Torvalds conn->sent = 0; 41751da177e4SLinus Torvalds } 41761da177e4SLinus Torvalds } 41771da177e4SLinus Torvalds } 41781da177e4SLinus Torvalds 41796039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4180b6a0dc82SMarcel Holtmann { 4181b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4182b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4183b6a0dc82SMarcel Holtmann int quote; 4184b6a0dc82SMarcel Holtmann 4185b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4186b6a0dc82SMarcel Holtmann 418752087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 418852087a79SLuiz Augusto von Dentz return; 418952087a79SLuiz Augusto von Dentz 41908fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 41918fc9ced3SGustavo Padovan "e))) { 4192b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4193b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 419457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4195b6a0dc82SMarcel Holtmann 4196b6a0dc82SMarcel Holtmann conn->sent++; 4197b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4198b6a0dc82SMarcel Holtmann conn->sent = 0; 4199b6a0dc82SMarcel Holtmann } 4200b6a0dc82SMarcel Holtmann } 4201b6a0dc82SMarcel Holtmann } 4202b6a0dc82SMarcel Holtmann 42036039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 42046ed58ec5SVille Tervo { 420573d80debSLuiz Augusto von Dentz struct hci_chan *chan; 42066ed58ec5SVille Tervo struct sk_buff *skb; 420702b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 42086ed58ec5SVille Tervo 42096ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 42106ed58ec5SVille Tervo 421152087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 421252087a79SLuiz Augusto von Dentz return; 421352087a79SLuiz Augusto von Dentz 4214d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 42156ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 42166ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4217bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 42186ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4219bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 42206ed58ec5SVille Tervo } 42216ed58ec5SVille Tervo 42226ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 422302b20f0bSLuiz Augusto von Dentz tmp = cnt; 422473d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4225ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4226ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 422773d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 422873d80debSLuiz Augusto von Dentz skb->len, skb->priority); 42296ed58ec5SVille Tervo 4230ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4231ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4232ec1cce24SLuiz Augusto von Dentz break; 4233ec1cce24SLuiz Augusto von Dentz 4234ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4235ec1cce24SLuiz Augusto von Dentz 423657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42376ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 42386ed58ec5SVille Tervo 42396ed58ec5SVille Tervo cnt--; 424073d80debSLuiz Augusto von Dentz chan->sent++; 424173d80debSLuiz Augusto von Dentz chan->conn->sent++; 42426ed58ec5SVille Tervo } 42436ed58ec5SVille Tervo } 424473d80debSLuiz Augusto von Dentz 42456ed58ec5SVille Tervo if (hdev->le_pkts) 42466ed58ec5SVille Tervo hdev->le_cnt = cnt; 42476ed58ec5SVille Tervo else 42486ed58ec5SVille Tervo hdev->acl_cnt = cnt; 424902b20f0bSLuiz Augusto von Dentz 425002b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 425102b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 42526ed58ec5SVille Tervo } 42536ed58ec5SVille Tervo 42543eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 42551da177e4SLinus Torvalds { 42563eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 42571da177e4SLinus Torvalds struct sk_buff *skb; 42581da177e4SLinus Torvalds 42596ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 42606ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 42611da177e4SLinus Torvalds 4262d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 42631da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 42641da177e4SLinus Torvalds hci_sched_acl(hdev); 42651da177e4SLinus Torvalds hci_sched_sco(hdev); 4266b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 42676ed58ec5SVille Tervo hci_sched_le(hdev); 426852de599eSMarcel Holtmann } 42696ed58ec5SVille Tervo 42701da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 42711da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 427257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42731da177e4SLinus Torvalds } 42741da177e4SLinus Torvalds 427525985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 42761da177e4SLinus Torvalds 42771da177e4SLinus Torvalds /* ACL data packet */ 42786039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 42791da177e4SLinus Torvalds { 42801da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 42811da177e4SLinus Torvalds struct hci_conn *conn; 42821da177e4SLinus Torvalds __u16 handle, flags; 42831da177e4SLinus Torvalds 42841da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 42851da177e4SLinus Torvalds 42861da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 42871da177e4SLinus Torvalds flags = hci_flags(handle); 42881da177e4SLinus Torvalds handle = hci_handle(handle); 42891da177e4SLinus Torvalds 4290f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4291a8c5fb1aSGustavo Padovan handle, flags); 42921da177e4SLinus Torvalds 42931da177e4SLinus Torvalds hdev->stat.acl_rx++; 42941da177e4SLinus Torvalds 42951da177e4SLinus Torvalds hci_dev_lock(hdev); 42961da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 42971da177e4SLinus Torvalds hci_dev_unlock(hdev); 42981da177e4SLinus Torvalds 42991da177e4SLinus Torvalds if (conn) { 430065983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 430104837f64SMarcel Holtmann 43021da177e4SLinus Torvalds /* Send to upper protocol */ 4303686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 43041da177e4SLinus Torvalds return; 43051da177e4SLinus Torvalds } else { 43061da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 43071da177e4SLinus Torvalds hdev->name, handle); 43081da177e4SLinus Torvalds } 43091da177e4SLinus Torvalds 43101da177e4SLinus Torvalds kfree_skb(skb); 43111da177e4SLinus Torvalds } 43121da177e4SLinus Torvalds 43131da177e4SLinus Torvalds /* SCO data packet */ 43146039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 43151da177e4SLinus Torvalds { 43161da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 43171da177e4SLinus Torvalds struct hci_conn *conn; 43181da177e4SLinus Torvalds __u16 handle; 43191da177e4SLinus Torvalds 43201da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 43211da177e4SLinus Torvalds 43221da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 43231da177e4SLinus Torvalds 4324f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 43251da177e4SLinus Torvalds 43261da177e4SLinus Torvalds hdev->stat.sco_rx++; 43271da177e4SLinus Torvalds 43281da177e4SLinus Torvalds hci_dev_lock(hdev); 43291da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 43301da177e4SLinus Torvalds hci_dev_unlock(hdev); 43311da177e4SLinus Torvalds 43321da177e4SLinus Torvalds if (conn) { 43331da177e4SLinus Torvalds /* Send to upper protocol */ 4334686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 43351da177e4SLinus Torvalds return; 43361da177e4SLinus Torvalds } else { 43371da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 43381da177e4SLinus Torvalds hdev->name, handle); 43391da177e4SLinus Torvalds } 43401da177e4SLinus Torvalds 43411da177e4SLinus Torvalds kfree_skb(skb); 43421da177e4SLinus Torvalds } 43431da177e4SLinus Torvalds 43449238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 43459238f36aSJohan Hedberg { 43469238f36aSJohan Hedberg struct sk_buff *skb; 43479238f36aSJohan Hedberg 43489238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 43499238f36aSJohan Hedberg if (!skb) 43509238f36aSJohan Hedberg return true; 43519238f36aSJohan Hedberg 4352242c0ebdSMarcel Holtmann return bt_cb(skb)->hci.req_start; 43539238f36aSJohan Hedberg } 43549238f36aSJohan Hedberg 435542c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 435642c6b129SJohan Hedberg { 435742c6b129SJohan Hedberg struct hci_command_hdr *sent; 435842c6b129SJohan Hedberg struct sk_buff *skb; 435942c6b129SJohan Hedberg u16 opcode; 436042c6b129SJohan Hedberg 436142c6b129SJohan Hedberg if (!hdev->sent_cmd) 436242c6b129SJohan Hedberg return; 436342c6b129SJohan Hedberg 436442c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 436542c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 436642c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 436742c6b129SJohan Hedberg return; 436842c6b129SJohan Hedberg 436942c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 437042c6b129SJohan Hedberg if (!skb) 437142c6b129SJohan Hedberg return; 437242c6b129SJohan Hedberg 437342c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 437442c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 437542c6b129SJohan Hedberg } 437642c6b129SJohan Hedberg 4377e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4378e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4379e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 43809238f36aSJohan Hedberg { 43819238f36aSJohan Hedberg struct sk_buff *skb; 43829238f36aSJohan Hedberg unsigned long flags; 43839238f36aSJohan Hedberg 43849238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 43859238f36aSJohan Hedberg 438642c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 438742c6b129SJohan Hedberg * sent we need to do special handling of it. 43889238f36aSJohan Hedberg */ 438942c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 439042c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 439142c6b129SJohan Hedberg * reset complete event during init and any pending 439242c6b129SJohan Hedberg * command will never be completed. In such a case we 439342c6b129SJohan Hedberg * need to resend whatever was the last sent 439442c6b129SJohan Hedberg * command. 439542c6b129SJohan Hedberg */ 439642c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 439742c6b129SJohan Hedberg hci_resend_last(hdev); 439842c6b129SJohan Hedberg 43999238f36aSJohan Hedberg return; 440042c6b129SJohan Hedberg } 44019238f36aSJohan Hedberg 44029238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 44039238f36aSJohan Hedberg * this request the request is not yet complete. 44049238f36aSJohan Hedberg */ 44059238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 44069238f36aSJohan Hedberg return; 44079238f36aSJohan Hedberg 44089238f36aSJohan Hedberg /* If this was the last command in a request the complete 44099238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 44109238f36aSJohan Hedberg * command queue (hdev->cmd_q). 44119238f36aSJohan Hedberg */ 4412242c0ebdSMarcel Holtmann if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 4413242c0ebdSMarcel Holtmann *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4414e6214487SJohan Hedberg return; 44159238f36aSJohan Hedberg } 4416e6214487SJohan Hedberg 4417242c0ebdSMarcel Holtmann if (bt_cb(hdev->sent_cmd)->hci.req_complete_skb) { 4418242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4419e6214487SJohan Hedberg return; 442053e21fbcSJohan Hedberg } 44219238f36aSJohan Hedberg 44229238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 44239238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44249238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 4425242c0ebdSMarcel Holtmann if (bt_cb(skb)->hci.req_start) { 44269238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 44279238f36aSJohan Hedberg break; 44289238f36aSJohan Hedberg } 44299238f36aSJohan Hedberg 4430242c0ebdSMarcel Holtmann *req_complete = bt_cb(skb)->hci.req_complete; 4431242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 44329238f36aSJohan Hedberg kfree_skb(skb); 44339238f36aSJohan Hedberg } 44349238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44359238f36aSJohan Hedberg } 44369238f36aSJohan Hedberg 4437b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 44381da177e4SLinus Torvalds { 4439b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 44401da177e4SLinus Torvalds struct sk_buff *skb; 44411da177e4SLinus Torvalds 44421da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 44431da177e4SLinus Torvalds 44441da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4445cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4446cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4447cd82e61cSMarcel Holtmann 44481da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 44491da177e4SLinus Torvalds /* Send copy to the sockets */ 4450470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44511da177e4SLinus Torvalds } 44521da177e4SLinus Torvalds 4453d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 44541da177e4SLinus Torvalds kfree_skb(skb); 44551da177e4SLinus Torvalds continue; 44561da177e4SLinus Torvalds } 44571da177e4SLinus Torvalds 44581da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 44591da177e4SLinus Torvalds /* Don't process data packets in this states. */ 44600d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 44611da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44621da177e4SLinus Torvalds case HCI_SCODATA_PKT: 44631da177e4SLinus Torvalds kfree_skb(skb); 44641da177e4SLinus Torvalds continue; 44653ff50b79SStephen Hemminger } 44661da177e4SLinus Torvalds } 44671da177e4SLinus Torvalds 44681da177e4SLinus Torvalds /* Process frame */ 44690d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 44701da177e4SLinus Torvalds case HCI_EVENT_PKT: 4471b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 44721da177e4SLinus Torvalds hci_event_packet(hdev, skb); 44731da177e4SLinus Torvalds break; 44741da177e4SLinus Torvalds 44751da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44761da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 44771da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 44781da177e4SLinus Torvalds break; 44791da177e4SLinus Torvalds 44801da177e4SLinus Torvalds case HCI_SCODATA_PKT: 44811da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 44821da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 44831da177e4SLinus Torvalds break; 44841da177e4SLinus Torvalds 44851da177e4SLinus Torvalds default: 44861da177e4SLinus Torvalds kfree_skb(skb); 44871da177e4SLinus Torvalds break; 44881da177e4SLinus Torvalds } 44891da177e4SLinus Torvalds } 44901da177e4SLinus Torvalds } 44911da177e4SLinus Torvalds 4492c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 44931da177e4SLinus Torvalds { 4494c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 44951da177e4SLinus Torvalds struct sk_buff *skb; 44961da177e4SLinus Torvalds 44972104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 44982104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 44991da177e4SLinus Torvalds 45001da177e4SLinus Torvalds /* Send queued commands */ 45015a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 45025a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 45035a08ecceSAndrei Emeltchenko if (!skb) 45045a08ecceSAndrei Emeltchenko return; 45055a08ecceSAndrei Emeltchenko 45061da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 45071da177e4SLinus Torvalds 4508a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 450970f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 45101da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 451157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 45127bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 451365cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 45147bdb8a5cSSzymon Janc else 451565cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 451665cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 45171da177e4SLinus Torvalds } else { 45181da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4519c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45201da177e4SLinus Torvalds } 45211da177e4SLinus Torvalds } 45221da177e4SLinus Torvalds } 4523