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> 337a0e5b15SMatthias Kaehlcke #include <linux/property.h> 3447219839SMarcel Holtmann #include <asm/unaligned.h> 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 371da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 384bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 39af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 401da177e4SLinus Torvalds 410857dd3bSJohan Hedberg #include "hci_request.h" 4260c5f5fbSMarcel Holtmann #include "hci_debugfs.h" 43970c4e46SJohan Hedberg #include "smp.h" 446d5d2ee6SHeiner Kallweit #include "leds.h" 45970c4e46SJohan Hedberg 46b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 47c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 483eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds /* HCI device list */ 511da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 521da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds /* HCI callback list */ 551da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 56fba7ecf0SJohan Hedberg DEFINE_MUTEX(hci_cb_list_lock); 571da177e4SLinus Torvalds 583df92b31SSasha Levin /* HCI ID Numbering */ 593df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 603df92b31SSasha Levin 61baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 62baf27f6eSMarcel Holtmann 634b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 644b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 654b4148e9SMarcel Holtmann { 664b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 674b4148e9SMarcel Holtmann char buf[3]; 684b4148e9SMarcel Holtmann 69b7cb93e5SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y' : 'N'; 704b4148e9SMarcel Holtmann buf[1] = '\n'; 714b4148e9SMarcel Holtmann buf[2] = '\0'; 724b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 734b4148e9SMarcel Holtmann } 744b4148e9SMarcel Holtmann 754b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 764b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 774b4148e9SMarcel Holtmann { 784b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 794b4148e9SMarcel Holtmann struct sk_buff *skb; 804b4148e9SMarcel Holtmann bool enable; 813bf5e97dSAndy Shevchenko int err; 824b4148e9SMarcel Holtmann 834b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 844b4148e9SMarcel Holtmann return -ENETDOWN; 854b4148e9SMarcel Holtmann 863bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 873bf5e97dSAndy Shevchenko if (err) 883bf5e97dSAndy Shevchenko return err; 894b4148e9SMarcel Holtmann 90b7cb93e5SMarcel Holtmann if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE)) 914b4148e9SMarcel Holtmann return -EALREADY; 924b4148e9SMarcel Holtmann 93b504430cSJohan Hedberg hci_req_sync_lock(hdev); 944b4148e9SMarcel Holtmann if (enable) 954b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 964b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 974b4148e9SMarcel Holtmann else 984b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 994b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 100b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1014b4148e9SMarcel Holtmann 1024b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1034b4148e9SMarcel Holtmann return PTR_ERR(skb); 1044b4148e9SMarcel Holtmann 1054b4148e9SMarcel Holtmann kfree_skb(skb); 1064b4148e9SMarcel Holtmann 107b7cb93e5SMarcel Holtmann hci_dev_change_flag(hdev, HCI_DUT_MODE); 1084b4148e9SMarcel Holtmann 1094b4148e9SMarcel Holtmann return count; 1104b4148e9SMarcel Holtmann } 1114b4148e9SMarcel Holtmann 1124b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1134b4148e9SMarcel Holtmann .open = simple_open, 1144b4148e9SMarcel Holtmann .read = dut_mode_read, 1154b4148e9SMarcel Holtmann .write = dut_mode_write, 1164b4148e9SMarcel Holtmann .llseek = default_llseek, 1174b4148e9SMarcel Holtmann }; 1184b4148e9SMarcel Holtmann 1194b4113d6SMarcel Holtmann static ssize_t vendor_diag_read(struct file *file, char __user *user_buf, 1204b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1214b4113d6SMarcel Holtmann { 1224b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1234b4113d6SMarcel Holtmann char buf[3]; 1244b4113d6SMarcel Holtmann 1254b4113d6SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y' : 'N'; 1264b4113d6SMarcel Holtmann buf[1] = '\n'; 1274b4113d6SMarcel Holtmann buf[2] = '\0'; 1284b4113d6SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 1294b4113d6SMarcel Holtmann } 1304b4113d6SMarcel Holtmann 1314b4113d6SMarcel Holtmann static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf, 1324b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1334b4113d6SMarcel Holtmann { 1344b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1354b4113d6SMarcel Holtmann bool enable; 1364b4113d6SMarcel Holtmann int err; 1374b4113d6SMarcel Holtmann 1383bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 1393bf5e97dSAndy Shevchenko if (err) 1403bf5e97dSAndy Shevchenko return err; 1414b4113d6SMarcel Holtmann 1427e995b9eSMarcel Holtmann /* When the diagnostic flags are not persistent and the transport 143b56c7b25SMarcel Holtmann * is not active or in user channel operation, then there is no need 144b56c7b25SMarcel Holtmann * for the vendor callback. Instead just store the desired value and 145b56c7b25SMarcel Holtmann * the setting will be programmed when the controller gets powered on. 1467e995b9eSMarcel Holtmann */ 1477e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 148b56c7b25SMarcel Holtmann (!test_bit(HCI_RUNNING, &hdev->flags) || 149b56c7b25SMarcel Holtmann hci_dev_test_flag(hdev, HCI_USER_CHANNEL))) 1507e995b9eSMarcel Holtmann goto done; 1517e995b9eSMarcel Holtmann 152b504430cSJohan Hedberg hci_req_sync_lock(hdev); 1534b4113d6SMarcel Holtmann err = hdev->set_diag(hdev, enable); 154b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1554b4113d6SMarcel Holtmann 1564b4113d6SMarcel Holtmann if (err < 0) 1574b4113d6SMarcel Holtmann return err; 1584b4113d6SMarcel Holtmann 1597e995b9eSMarcel Holtmann done: 1604b4113d6SMarcel Holtmann if (enable) 1614b4113d6SMarcel Holtmann hci_dev_set_flag(hdev, HCI_VENDOR_DIAG); 1624b4113d6SMarcel Holtmann else 1634b4113d6SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG); 1644b4113d6SMarcel Holtmann 1654b4113d6SMarcel Holtmann return count; 1664b4113d6SMarcel Holtmann } 1674b4113d6SMarcel Holtmann 1684b4113d6SMarcel Holtmann static const struct file_operations vendor_diag_fops = { 1694b4113d6SMarcel Holtmann .open = simple_open, 1704b4113d6SMarcel Holtmann .read = vendor_diag_read, 1714b4113d6SMarcel Holtmann .write = vendor_diag_write, 1724b4113d6SMarcel Holtmann .llseek = default_llseek, 1734b4113d6SMarcel Holtmann }; 1744b4113d6SMarcel Holtmann 175f640ee98SMarcel Holtmann static void hci_debugfs_create_basic(struct hci_dev *hdev) 176f640ee98SMarcel Holtmann { 177f640ee98SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 178f640ee98SMarcel Holtmann &dut_mode_fops); 179f640ee98SMarcel Holtmann 180f640ee98SMarcel Holtmann if (hdev->set_diag) 181f640ee98SMarcel Holtmann debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev, 182f640ee98SMarcel Holtmann &vendor_diag_fops); 183f640ee98SMarcel Holtmann } 184f640ee98SMarcel Holtmann 185a1d01db1SJohan Hedberg static int hci_reset_req(struct hci_request *req, unsigned long opt) 1861da177e4SLinus Torvalds { 18742c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds /* Reset device */ 19042c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 19142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 192a1d01db1SJohan Hedberg return 0; 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds 19542c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 1961da177e4SLinus Torvalds { 19742c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 1982455a3eaSAndrei Emeltchenko 1991da177e4SLinus Torvalds /* Read Local Supported Features */ 20042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2011da177e4SLinus Torvalds 2021143e5a6SMarcel Holtmann /* Read Local Version */ 20342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2042177bab5SJohan Hedberg 2052177bab5SJohan Hedberg /* Read BD Address */ 20642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2090af801b9SJohan Hedberg static void amp_init1(struct hci_request *req) 210e61ef499SAndrei Emeltchenko { 21142c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 2122455a3eaSAndrei Emeltchenko 213e61ef499SAndrei Emeltchenko /* Read Local Version */ 21442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2156bcbc489SAndrei Emeltchenko 216f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 217f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 218f6996cfeSMarcel Holtmann 2196bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 22042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 221e71dfabaSAndrei Emeltchenko 222e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 22342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 2247528ca1cSMarcel Holtmann 225f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 226f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 227f38ba941SMarcel Holtmann 2287528ca1cSMarcel Holtmann /* Read Location Data */ 2297528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 230e61ef499SAndrei Emeltchenko } 231e61ef499SAndrei Emeltchenko 232a1d01db1SJohan Hedberg static int amp_init2(struct hci_request *req) 2330af801b9SJohan Hedberg { 2340af801b9SJohan Hedberg /* Read Local Supported Features. Not all AMP controllers 2350af801b9SJohan Hedberg * support this so it's placed conditionally in the second 2360af801b9SJohan Hedberg * stage init. 2370af801b9SJohan Hedberg */ 2380af801b9SJohan Hedberg if (req->hdev->commands[14] & 0x20) 2390af801b9SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 240a1d01db1SJohan Hedberg 241a1d01db1SJohan Hedberg return 0; 2420af801b9SJohan Hedberg } 2430af801b9SJohan Hedberg 244a1d01db1SJohan Hedberg static int hci_init1_req(struct hci_request *req, unsigned long opt) 245e61ef499SAndrei Emeltchenko { 24642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 247e61ef499SAndrei Emeltchenko 248e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 249e61ef499SAndrei Emeltchenko 25011778716SAndrei Emeltchenko /* Reset */ 25111778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 25242c6b129SJohan Hedberg hci_reset_req(req, 0); 25311778716SAndrei Emeltchenko 254e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 255ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 25642c6b129SJohan Hedberg bredr_init(req); 257e61ef499SAndrei Emeltchenko break; 258e61ef499SAndrei Emeltchenko case HCI_AMP: 2590af801b9SJohan Hedberg amp_init1(req); 260e61ef499SAndrei Emeltchenko break; 261e61ef499SAndrei Emeltchenko default: 2622064ee33SMarcel Holtmann bt_dev_err(hdev, "Unknown device type %d", hdev->dev_type); 263e61ef499SAndrei Emeltchenko break; 264e61ef499SAndrei Emeltchenko } 265a1d01db1SJohan Hedberg 266a1d01db1SJohan Hedberg return 0; 267e61ef499SAndrei Emeltchenko } 268e61ef499SAndrei Emeltchenko 26942c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 2702177bab5SJohan Hedberg { 2712177bab5SJohan Hedberg __le16 param; 2722177bab5SJohan Hedberg __u8 flt_type; 2732177bab5SJohan Hedberg 2742177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 27542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2762177bab5SJohan Hedberg 2772177bab5SJohan Hedberg /* Read Class of Device */ 27842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 2792177bab5SJohan Hedberg 2802177bab5SJohan Hedberg /* Read Local Name */ 28142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2822177bab5SJohan Hedberg 2832177bab5SJohan Hedberg /* Read Voice Setting */ 28442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2852177bab5SJohan Hedberg 286b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 287b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 288b4cb9fb2SMarcel Holtmann 2894b836f39SMarcel Holtmann /* Read Current IAC LAP */ 2904b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 2914b836f39SMarcel Holtmann 2922177bab5SJohan Hedberg /* Clear Event Filters */ 2932177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 29442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2952177bab5SJohan Hedberg 2962177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 297dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 29842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 2992177bab5SJohan Hedberg } 3002177bab5SJohan Hedberg 30142c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 3022177bab5SJohan Hedberg { 303c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 304c73eee91SJohan Hedberg 3052177bab5SJohan Hedberg /* Read LE Buffer Size */ 30642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 3072177bab5SJohan Hedberg 3082177bab5SJohan Hedberg /* Read LE Local Supported Features */ 30942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 3102177bab5SJohan Hedberg 311747d3f03SMarcel Holtmann /* Read LE Supported States */ 312747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 313747d3f03SMarcel Holtmann 314c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 315c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 316a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_LE_ENABLED); 3172177bab5SJohan Hedberg } 3182177bab5SJohan Hedberg 31942c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 3202177bab5SJohan Hedberg { 32142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 32242c6b129SJohan Hedberg 3232177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 3242177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 3252177bab5SJohan Hedberg * command otherwise. 3262177bab5SJohan Hedberg */ 3272177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 3282177bab5SJohan Hedberg 3292177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 3302177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 3312177bab5SJohan Hedberg */ 3322177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 3332177bab5SJohan Hedberg return; 3342177bab5SJohan Hedberg 3352177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 3362177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 337c7882cbdSMarcel Holtmann } else { 338c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 339c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 340c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 341c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 342c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 3435c3d3b4cSMarcel Holtmann 3445c3d3b4cSMarcel Holtmann /* If the controller supports the Disconnect command, enable 3455c3d3b4cSMarcel Holtmann * the corresponding event. In addition enable packet flow 3465c3d3b4cSMarcel Holtmann * control related events. 3475c3d3b4cSMarcel Holtmann */ 3485c3d3b4cSMarcel Holtmann if (hdev->commands[0] & 0x20) { 3495c3d3b4cSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 350c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 351c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 3525c3d3b4cSMarcel Holtmann } 3535c3d3b4cSMarcel Holtmann 3545c3d3b4cSMarcel Holtmann /* If the controller supports the Read Remote Version 3555c3d3b4cSMarcel Holtmann * Information command, enable the corresponding event. 3565c3d3b4cSMarcel Holtmann */ 3575c3d3b4cSMarcel Holtmann if (hdev->commands[2] & 0x80) 3585c3d3b4cSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information 3595c3d3b4cSMarcel Holtmann * Complete 3605c3d3b4cSMarcel Holtmann */ 3610da71f1bSMarcel Holtmann 3620da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 3630da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 364c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3652177bab5SJohan Hedberg } 3660da71f1bSMarcel Holtmann } 3672177bab5SJohan Hedberg 3689fe759ceSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 3699fe759ceSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) 3702177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 3712177bab5SJohan Hedberg 37270f56aa2SMarcel Holtmann if (lmp_ext_feat_capable(hdev)) 37370f56aa2SMarcel Holtmann events[4] |= 0x04; /* Read Remote Extended Features Complete */ 37470f56aa2SMarcel Holtmann 37570f56aa2SMarcel Holtmann if (lmp_esco_capable(hdev)) { 37670f56aa2SMarcel Holtmann events[5] |= 0x08; /* Synchronous Connection Complete */ 37770f56aa2SMarcel Holtmann events[5] |= 0x10; /* Synchronous Connection Changed */ 37870f56aa2SMarcel Holtmann } 37970f56aa2SMarcel Holtmann 3802177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 3812177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 3822177bab5SJohan Hedberg 3832177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 3842177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3852177bab5SJohan Hedberg 3862177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 3872177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 3882177bab5SJohan Hedberg 3892177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 3902177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 3912177bab5SJohan Hedberg 3922177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 3932177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 3942177bab5SJohan Hedberg 3952177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 3962177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 3972177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 3982177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 3992177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 4002177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 4012177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 4022177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 4032177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 4042177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 4052177bab5SJohan Hedberg * Features Notification 4062177bab5SJohan Hedberg */ 4072177bab5SJohan Hedberg } 4082177bab5SJohan Hedberg 4092177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 4102177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 4112177bab5SJohan Hedberg 41242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 4132177bab5SJohan Hedberg } 4142177bab5SJohan Hedberg 415a1d01db1SJohan Hedberg static int hci_init2_req(struct hci_request *req, unsigned long opt) 4162177bab5SJohan Hedberg { 41742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 41842c6b129SJohan Hedberg 4190af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 4200af801b9SJohan Hedberg return amp_init2(req); 4210af801b9SJohan Hedberg 4222177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 42342c6b129SJohan Hedberg bredr_setup(req); 42456f87901SJohan Hedberg else 425a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 4262177bab5SJohan Hedberg 4272177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 42842c6b129SJohan Hedberg le_setup(req); 4292177bab5SJohan Hedberg 4300f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 4310f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 4320f3adeaeSMarcel Holtmann * 4330f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 4340f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 4350f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 4360f3adeaeSMarcel Holtmann * supported commands. 4373f8e2d75SJohan Hedberg */ 4380f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 4390f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 44042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 4412177bab5SJohan Hedberg 4422177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 44357af75a8SMarcel Holtmann /* When SSP is available, then the host features page 44457af75a8SMarcel Holtmann * should also be available as well. However some 44557af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 44657af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 44757af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 44857af75a8SMarcel Holtmann */ 44957af75a8SMarcel Holtmann hdev->max_page = 0x01; 45057af75a8SMarcel Holtmann 451d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 4522177bab5SJohan Hedberg u8 mode = 0x01; 453574ea3c7SMarcel Holtmann 45442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 4552177bab5SJohan Hedberg sizeof(mode), &mode); 4562177bab5SJohan Hedberg } else { 4572177bab5SJohan Hedberg struct hci_cp_write_eir cp; 4582177bab5SJohan Hedberg 4592177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 4602177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 4612177bab5SJohan Hedberg 46242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 4632177bab5SJohan Hedberg } 4642177bab5SJohan Hedberg } 4652177bab5SJohan Hedberg 466043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 467043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 46804422da9SMarcel Holtmann u8 mode; 46904422da9SMarcel Holtmann 47004422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 47104422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 47204422da9SMarcel Holtmann * events. 47304422da9SMarcel Holtmann */ 47404422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 47504422da9SMarcel Holtmann 47604422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 47704422da9SMarcel Holtmann } 4782177bab5SJohan Hedberg 4792177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 48042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 4812177bab5SJohan Hedberg 4822177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 4832177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 4842177bab5SJohan Hedberg 4852177bab5SJohan Hedberg cp.page = 0x01; 48642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 48742c6b129SJohan Hedberg sizeof(cp), &cp); 4882177bab5SJohan Hedberg } 4892177bab5SJohan Hedberg 490d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 4912177bab5SJohan Hedberg u8 enable = 1; 49242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 4932177bab5SJohan Hedberg &enable); 4942177bab5SJohan Hedberg } 495a1d01db1SJohan Hedberg 496a1d01db1SJohan Hedberg return 0; 4972177bab5SJohan Hedberg } 4982177bab5SJohan Hedberg 49942c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 5002177bab5SJohan Hedberg { 50142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5022177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 5032177bab5SJohan Hedberg u16 link_policy = 0; 5042177bab5SJohan Hedberg 5052177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 5062177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 5072177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 5082177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 5092177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 5102177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 5112177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 5122177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 5132177bab5SJohan Hedberg 5142177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 51542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 5162177bab5SJohan Hedberg } 5172177bab5SJohan Hedberg 51842c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 5192177bab5SJohan Hedberg { 52042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5212177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 5222177bab5SJohan Hedberg 523c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 524c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 525c73eee91SJohan Hedberg return; 526c73eee91SJohan Hedberg 5272177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 5282177bab5SJohan Hedberg 529d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 5302177bab5SJohan Hedberg cp.le = 0x01; 53132226e4fSMarcel Holtmann cp.simul = 0x00; 5322177bab5SJohan Hedberg } 5332177bab5SJohan Hedberg 5342177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 53542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 5362177bab5SJohan Hedberg &cp); 5372177bab5SJohan Hedberg } 5382177bab5SJohan Hedberg 539d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 540d62e6d67SJohan Hedberg { 541d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 542d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 543313f6888SMarcel Holtmann bool changed = false; 544d62e6d67SJohan Hedberg 545d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 546d62e6d67SJohan Hedberg * enable all necessary events for it. 547d62e6d67SJohan Hedberg */ 54853b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 549d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 550d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 551d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 552d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 553313f6888SMarcel Holtmann changed = true; 554d62e6d67SJohan Hedberg } 555d62e6d67SJohan Hedberg 556d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 557d62e6d67SJohan Hedberg * enable all necessary events for it. 558d62e6d67SJohan Hedberg */ 55953b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 560d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 561d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 562d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 563d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 564313f6888SMarcel Holtmann changed = true; 565d62e6d67SJohan Hedberg } 566d62e6d67SJohan Hedberg 56740c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 568313f6888SMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) { 56940c59fcbSMarcel Holtmann events[2] |= 0x80; 570313f6888SMarcel Holtmann changed = true; 571313f6888SMarcel Holtmann } 57240c59fcbSMarcel Holtmann 573313f6888SMarcel Holtmann /* Some Broadcom based controllers indicate support for Set Event 574313f6888SMarcel Holtmann * Mask Page 2 command, but then actually do not support it. Since 575313f6888SMarcel Holtmann * the default value is all bits set to zero, the command is only 576313f6888SMarcel Holtmann * required if the event mask has to be changed. In case no change 577313f6888SMarcel Holtmann * to the event mask is needed, skip this command. 578313f6888SMarcel Holtmann */ 579313f6888SMarcel Holtmann if (changed) 580313f6888SMarcel Holtmann hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, 581313f6888SMarcel Holtmann sizeof(events), events); 582d62e6d67SJohan Hedberg } 583d62e6d67SJohan Hedberg 584a1d01db1SJohan Hedberg static int hci_init3_req(struct hci_request *req, unsigned long opt) 5852177bab5SJohan Hedberg { 58642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 587d2c5d77fSJohan Hedberg u8 p; 58842c6b129SJohan Hedberg 5890da71f1bSMarcel Holtmann hci_setup_event_mask(req); 5900da71f1bSMarcel Holtmann 591e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 592e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 59348ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 59448ce62c4SMarcel Holtmann 59548ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 59648ce62c4SMarcel Holtmann cp.read_all = 0x01; 59748ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 59848ce62c4SMarcel Holtmann } 59948ce62c4SMarcel Holtmann 6002177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 60142c6b129SJohan Hedberg hci_setup_link_policy(req); 6022177bab5SJohan Hedberg 603417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 604417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 605417287deSMarcel Holtmann 606417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 607417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 608417287deSMarcel Holtmann * this command in the bit mask of supported commands. 609417287deSMarcel Holtmann */ 610417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 611417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 612417287deSMarcel Holtmann 6139193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 6149193c6e8SAndre Guedes u8 events[8]; 6159193c6e8SAndre Guedes 6169193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 6174d6c705bSMarcel Holtmann 6184d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 6194d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 620662bc2e6SAndre Guedes 621662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 622662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 623662bc2e6SAndre Guedes */ 624662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 625662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 626662bc2e6SAndre Guedes * Parameter Request 627662bc2e6SAndre Guedes */ 628662bc2e6SAndre Guedes 629a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 630a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 631a9f6068eSMarcel Holtmann */ 632a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 633a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 634a9f6068eSMarcel Holtmann 6354b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 6364b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 6374b71bba4SMarcel Holtmann */ 6384b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 6394b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 6404b71bba4SMarcel Holtmann * Report 6414b71bba4SMarcel Holtmann */ 6424b71bba4SMarcel Holtmann 6439756d33bSMarcel Holtmann /* If the controller supports Channel Selection Algorithm #2 6449756d33bSMarcel Holtmann * feature, enable the corresponding event. 6459756d33bSMarcel Holtmann */ 6469756d33bSMarcel Holtmann if (hdev->le_features[1] & HCI_LE_CHAN_SEL_ALG2) 6479756d33bSMarcel Holtmann events[2] |= 0x08; /* LE Channel Selection 6489756d33bSMarcel Holtmann * Algorithm 6499756d33bSMarcel Holtmann */ 6509756d33bSMarcel Holtmann 6517d26f5c4SMarcel Holtmann /* If the controller supports the LE Set Scan Enable command, 6527d26f5c4SMarcel Holtmann * enable the corresponding advertising report event. 6537d26f5c4SMarcel Holtmann */ 6547d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x08) 6557d26f5c4SMarcel Holtmann events[0] |= 0x02; /* LE Advertising Report */ 6567d26f5c4SMarcel Holtmann 6577d26f5c4SMarcel Holtmann /* If the controller supports the LE Create Connection 6587d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6597d26f5c4SMarcel Holtmann */ 6607d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x10) 6617d26f5c4SMarcel Holtmann events[0] |= 0x01; /* LE Connection Complete */ 6627d26f5c4SMarcel Holtmann 6637d26f5c4SMarcel Holtmann /* If the controller supports the LE Connection Update 6647d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6657d26f5c4SMarcel Holtmann */ 6667d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x04) 6677d26f5c4SMarcel Holtmann events[0] |= 0x04; /* LE Connection Update 6687d26f5c4SMarcel Holtmann * Complete 6697d26f5c4SMarcel Holtmann */ 6707d26f5c4SMarcel Holtmann 6717d26f5c4SMarcel Holtmann /* If the controller supports the LE Read Remote Used Features 6727d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6737d26f5c4SMarcel Holtmann */ 6747d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x20) 6757d26f5c4SMarcel Holtmann events[0] |= 0x08; /* LE Read Remote Used 6767d26f5c4SMarcel Holtmann * Features Complete 6777d26f5c4SMarcel Holtmann */ 6787d26f5c4SMarcel Holtmann 6795a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 6805a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 6815a34bd5fSMarcel Holtmann */ 6825a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 6835a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 6845a34bd5fSMarcel Holtmann * Public Key Complete 6855a34bd5fSMarcel Holtmann */ 6865a34bd5fSMarcel Holtmann 6875a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 6885a34bd5fSMarcel Holtmann * command, enable the corresponding event. 6895a34bd5fSMarcel Holtmann */ 6905a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 6915a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 6925a34bd5fSMarcel Holtmann 69327bbca44SMarcel Holtmann /* If the controller supports the LE Set Default PHY or 69427bbca44SMarcel Holtmann * LE Set PHY commands, enable the corresponding event. 69527bbca44SMarcel Holtmann */ 69627bbca44SMarcel Holtmann if (hdev->commands[35] & (0x20 | 0x40)) 69727bbca44SMarcel Holtmann events[1] |= 0x08; /* LE PHY Update Complete */ 69827bbca44SMarcel Holtmann 699c215e939SJaganath Kanakkassery /* If the controller supports LE Set Extended Scan Parameters 700c215e939SJaganath Kanakkassery * and LE Set Extended Scan Enable commands, enable the 701c215e939SJaganath Kanakkassery * corresponding event. 702c215e939SJaganath Kanakkassery */ 703c215e939SJaganath Kanakkassery if (use_ext_scan(hdev)) 704c215e939SJaganath Kanakkassery events[1] |= 0x10; /* LE Extended Advertising 705c215e939SJaganath Kanakkassery * Report 706c215e939SJaganath Kanakkassery */ 707c215e939SJaganath Kanakkassery 7084d94f95dSJaganath Kanakkassery /* If the controller supports the LE Extended Create Connection 7094d94f95dSJaganath Kanakkassery * command, enable the corresponding event. 7104d94f95dSJaganath Kanakkassery */ 7114d94f95dSJaganath Kanakkassery if (use_ext_conn(hdev)) 7124d94f95dSJaganath Kanakkassery events[1] |= 0x02; /* LE Enhanced Connection 7134d94f95dSJaganath Kanakkassery * Complete 7144d94f95dSJaganath Kanakkassery */ 7154d94f95dSJaganath Kanakkassery 716acf0aeaeSJaganath Kanakkassery /* If the controller supports the LE Extended Advertising 717acf0aeaeSJaganath Kanakkassery * command, enable the corresponding event. 718acf0aeaeSJaganath Kanakkassery */ 719acf0aeaeSJaganath Kanakkassery if (ext_adv_capable(hdev)) 720acf0aeaeSJaganath Kanakkassery events[2] |= 0x02; /* LE Advertising Set 721acf0aeaeSJaganath Kanakkassery * Terminated 722acf0aeaeSJaganath Kanakkassery */ 723acf0aeaeSJaganath Kanakkassery 7249193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 7259193c6e8SAndre Guedes events); 7269193c6e8SAndre Guedes 72715a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 7286b49bcb4SJaganath Kanakkassery if ((hdev->commands[25] & 0x40) && !ext_adv_capable(hdev)) { 7296b49bcb4SJaganath Kanakkassery /* HCI TS spec forbids mixing of legacy and extended 7306b49bcb4SJaganath Kanakkassery * advertising commands wherein READ_ADV_TX_POWER is 7316b49bcb4SJaganath Kanakkassery * also included. So do not call it if extended adv 7326b49bcb4SJaganath Kanakkassery * is supported otherwise controller will return 7336b49bcb4SJaganath Kanakkassery * COMMAND_DISALLOWED for extended commands. 7346b49bcb4SJaganath Kanakkassery */ 73515a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 73615a49ccaSMarcel Holtmann } 73715a49ccaSMarcel Holtmann 7382ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 7392ab216a7SMarcel Holtmann /* Read LE White List Size */ 7402ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 7412ab216a7SMarcel Holtmann 0, NULL); 7422ab216a7SMarcel Holtmann } 7432ab216a7SMarcel Holtmann 7442ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 7452ab216a7SMarcel Holtmann /* Clear LE White List */ 7462ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 7472ab216a7SMarcel Holtmann } 7482ab216a7SMarcel Holtmann 749cfdb0c2dSAnkit Navik if (hdev->commands[34] & 0x40) { 750cfdb0c2dSAnkit Navik /* Read LE Resolving List Size */ 751cfdb0c2dSAnkit Navik hci_req_add(req, HCI_OP_LE_READ_RESOLV_LIST_SIZE, 752cfdb0c2dSAnkit Navik 0, NULL); 753cfdb0c2dSAnkit Navik } 754cfdb0c2dSAnkit Navik 755545f2596SAnkit Navik if (hdev->commands[34] & 0x20) { 756545f2596SAnkit Navik /* Clear LE Resolving List */ 757545f2596SAnkit Navik hci_req_add(req, HCI_OP_LE_CLEAR_RESOLV_LIST, 0, NULL); 758545f2596SAnkit Navik } 759545f2596SAnkit Navik 760a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 761a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 762a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 763a9f6068eSMarcel Holtmann 764a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 765a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 766a9f6068eSMarcel Holtmann } 767a9f6068eSMarcel Holtmann 7686b49bcb4SJaganath Kanakkassery if (ext_adv_capable(hdev)) { 7696b49bcb4SJaganath Kanakkassery /* Read LE Number of Supported Advertising Sets */ 7706b49bcb4SJaganath Kanakkassery hci_req_add(req, HCI_OP_LE_READ_NUM_SUPPORTED_ADV_SETS, 7716b49bcb4SJaganath Kanakkassery 0, NULL); 7726b49bcb4SJaganath Kanakkassery } 7736b49bcb4SJaganath Kanakkassery 77442c6b129SJohan Hedberg hci_set_le_support(req); 7759193c6e8SAndre Guedes } 776d2c5d77fSJohan Hedberg 777d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 778d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 779d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 780d2c5d77fSJohan Hedberg 781d2c5d77fSJohan Hedberg cp.page = p; 782d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 783d2c5d77fSJohan Hedberg sizeof(cp), &cp); 784d2c5d77fSJohan Hedberg } 785a1d01db1SJohan Hedberg 786a1d01db1SJohan Hedberg return 0; 7872177bab5SJohan Hedberg } 7882177bab5SJohan Hedberg 789a1d01db1SJohan Hedberg static int hci_init4_req(struct hci_request *req, unsigned long opt) 7905d4e7e8dSJohan Hedberg { 7915d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 7925d4e7e8dSJohan Hedberg 79336f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 79436f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 79536f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 79636f260ceSMarcel Holtmann * 79736f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 79836f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 79936f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 80036f260ceSMarcel Holtmann * command redundant anyway. 80136f260ceSMarcel Holtmann * 80236f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 80336f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 80436f260ceSMarcel Holtmann * just disable this command. 80536f260ceSMarcel Holtmann */ 80636f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 80736f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 80836f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 80936f260ceSMarcel Holtmann 81036f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 81136f260ceSMarcel Holtmann cp.delete_all = 0x01; 81236f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 81336f260ceSMarcel Holtmann sizeof(cp), &cp); 81436f260ceSMarcel Holtmann } 81536f260ceSMarcel Holtmann 816d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 817d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 818d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 819d62e6d67SJohan Hedberg 820109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 821109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 822109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 823109e3191SMarcel Holtmann 824f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 825f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 826f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 827f4fe73edSMarcel Holtmann 8285d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 82953b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 8305d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 831a6d0d690SMarcel Holtmann 832a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 833d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 834574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 835a6d0d690SMarcel Holtmann u8 support = 0x01; 836574ea3c7SMarcel Holtmann 837a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 838a6d0d690SMarcel Holtmann sizeof(support), &support); 839a6d0d690SMarcel Holtmann } 840a1d01db1SJohan Hedberg 84112204875SMarcel Holtmann /* Set Suggested Default Data Length to maximum if supported */ 84212204875SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 84312204875SMarcel Holtmann struct hci_cp_le_write_def_data_len cp; 84412204875SMarcel Holtmann 845727ea61aSBen Dooks (Codethink) cp.tx_len = cpu_to_le16(hdev->le_max_tx_len); 846727ea61aSBen Dooks (Codethink) cp.tx_time = cpu_to_le16(hdev->le_max_tx_time); 84712204875SMarcel Holtmann hci_req_add(req, HCI_OP_LE_WRITE_DEF_DATA_LEN, sizeof(cp), &cp); 84812204875SMarcel Holtmann } 84912204875SMarcel Holtmann 850de2ba303SMarcel Holtmann /* Set Default PHY parameters if command is supported */ 851de2ba303SMarcel Holtmann if (hdev->commands[35] & 0x20) { 852de2ba303SMarcel Holtmann struct hci_cp_le_set_default_phy cp; 853de2ba303SMarcel Holtmann 8546decb5b4SJaganath Kanakkassery cp.all_phys = 0x00; 8556decb5b4SJaganath Kanakkassery cp.tx_phys = hdev->le_tx_def_phys; 8566decb5b4SJaganath Kanakkassery cp.rx_phys = hdev->le_rx_def_phys; 857de2ba303SMarcel Holtmann 858de2ba303SMarcel Holtmann hci_req_add(req, HCI_OP_LE_SET_DEFAULT_PHY, sizeof(cp), &cp); 859de2ba303SMarcel Holtmann } 860de2ba303SMarcel Holtmann 861a1d01db1SJohan Hedberg return 0; 8625d4e7e8dSJohan Hedberg } 8635d4e7e8dSJohan Hedberg 8642177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8652177bab5SJohan Hedberg { 8662177bab5SJohan Hedberg int err; 8672177bab5SJohan Hedberg 8684ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT, NULL); 8692177bab5SJohan Hedberg if (err < 0) 8702177bab5SJohan Hedberg return err; 8712177bab5SJohan Hedberg 872f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 873f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 8744b4148e9SMarcel Holtmann 8754ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT, NULL); 8762177bab5SJohan Hedberg if (err < 0) 8772177bab5SJohan Hedberg return err; 8782177bab5SJohan Hedberg 879ca8bee5dSMarcel Holtmann /* HCI_PRIMARY covers both single-mode LE, BR/EDR and dual-mode 8800af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8810af801b9SJohan Hedberg * first two stages of init. 8820af801b9SJohan Hedberg */ 883ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) 8840af801b9SJohan Hedberg return 0; 8850af801b9SJohan Hedberg 8864ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT, NULL); 8875d4e7e8dSJohan Hedberg if (err < 0) 8885d4e7e8dSJohan Hedberg return err; 8895d4e7e8dSJohan Hedberg 8904ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT, NULL); 891baf27f6eSMarcel Holtmann if (err < 0) 892baf27f6eSMarcel Holtmann return err; 893baf27f6eSMarcel Holtmann 894ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 895ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 896ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 897ec6cef9cSMarcel Holtmann * 898ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 899ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 900ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 901ec6cef9cSMarcel Holtmann * be called during the config phase. 902ec6cef9cSMarcel Holtmann * 903ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 904ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 905baf27f6eSMarcel Holtmann */ 906d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 907d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 908baf27f6eSMarcel Holtmann return 0; 909baf27f6eSMarcel Holtmann 91060c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 91160c5f5fbSMarcel Holtmann 91271c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 91360c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9142bfa3531SMarcel Holtmann 915162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 91660c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 917e7b8fc92SMarcel Holtmann 918baf27f6eSMarcel Holtmann return 0; 9192177bab5SJohan Hedberg } 9202177bab5SJohan Hedberg 921a1d01db1SJohan Hedberg static int hci_init0_req(struct hci_request *req, unsigned long opt) 9220ebca7d6SMarcel Holtmann { 9230ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9240ebca7d6SMarcel Holtmann 9250ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9260ebca7d6SMarcel Holtmann 9270ebca7d6SMarcel Holtmann /* Reset */ 9280ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9290ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9300ebca7d6SMarcel Holtmann 9310ebca7d6SMarcel Holtmann /* Read Local Version */ 9320ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9330ebca7d6SMarcel Holtmann 9340ebca7d6SMarcel Holtmann /* Read BD Address */ 9350ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9360ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 937a1d01db1SJohan Hedberg 938a1d01db1SJohan Hedberg return 0; 9390ebca7d6SMarcel Holtmann } 9400ebca7d6SMarcel Holtmann 9410ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9420ebca7d6SMarcel Holtmann { 9430ebca7d6SMarcel Holtmann int err; 9440ebca7d6SMarcel Holtmann 945cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 946cc78b44bSMarcel Holtmann return 0; 947cc78b44bSMarcel Holtmann 9484ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT, NULL); 9490ebca7d6SMarcel Holtmann if (err < 0) 9500ebca7d6SMarcel Holtmann return err; 9510ebca7d6SMarcel Holtmann 952f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 953f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 954f640ee98SMarcel Holtmann 9550ebca7d6SMarcel Holtmann return 0; 9560ebca7d6SMarcel Holtmann } 9570ebca7d6SMarcel Holtmann 958a1d01db1SJohan Hedberg static int hci_scan_req(struct hci_request *req, unsigned long opt) 9591da177e4SLinus Torvalds { 9601da177e4SLinus Torvalds __u8 scan = opt; 9611da177e4SLinus Torvalds 96242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9631da177e4SLinus Torvalds 9641da177e4SLinus Torvalds /* Inquiry and Page scans */ 96542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 966a1d01db1SJohan Hedberg return 0; 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds 969a1d01db1SJohan Hedberg static int hci_auth_req(struct hci_request *req, unsigned long opt) 9701da177e4SLinus Torvalds { 9711da177e4SLinus Torvalds __u8 auth = opt; 9721da177e4SLinus Torvalds 97342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9741da177e4SLinus Torvalds 9751da177e4SLinus Torvalds /* Authentication */ 97642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 977a1d01db1SJohan Hedberg return 0; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds 980a1d01db1SJohan Hedberg static int hci_encrypt_req(struct hci_request *req, unsigned long opt) 9811da177e4SLinus Torvalds { 9821da177e4SLinus Torvalds __u8 encrypt = opt; 9831da177e4SLinus Torvalds 98442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 9851da177e4SLinus Torvalds 986e4e8e37cSMarcel Holtmann /* Encryption */ 98742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 988a1d01db1SJohan Hedberg return 0; 9891da177e4SLinus Torvalds } 9901da177e4SLinus Torvalds 991a1d01db1SJohan Hedberg static int hci_linkpol_req(struct hci_request *req, unsigned long opt) 992e4e8e37cSMarcel Holtmann { 993e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 994e4e8e37cSMarcel Holtmann 99542c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 996e4e8e37cSMarcel Holtmann 997e4e8e37cSMarcel Holtmann /* Default link policy */ 99842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 999a1d01db1SJohan Hedberg return 0; 1000e4e8e37cSMarcel Holtmann } 1001e4e8e37cSMarcel Holtmann 10021da177e4SLinus Torvalds /* Get HCI device by index. 10031da177e4SLinus Torvalds * Device is held on return. */ 10041da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10051da177e4SLinus Torvalds { 10068035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds BT_DBG("%d", index); 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds if (index < 0) 10111da177e4SLinus Torvalds return NULL; 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10148035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10151da177e4SLinus Torvalds if (d->id == index) { 10161da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10171da177e4SLinus Torvalds break; 10181da177e4SLinus Torvalds } 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10211da177e4SLinus Torvalds return hdev; 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds 10241da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1025ff9ef578SJohan Hedberg 102630dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 102730dc78e1SJohan Hedberg { 102830dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 102930dc78e1SJohan Hedberg 10306fbe195dSAndre Guedes switch (discov->state) { 1031343f935bSAndre Guedes case DISCOVERY_FINDING: 10326fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 103330dc78e1SJohan Hedberg return true; 103430dc78e1SJohan Hedberg 10356fbe195dSAndre Guedes default: 103630dc78e1SJohan Hedberg return false; 103730dc78e1SJohan Hedberg } 10386fbe195dSAndre Guedes } 103930dc78e1SJohan Hedberg 1040ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1041ff9ef578SJohan Hedberg { 1042bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1043bb3e0a33SJohan Hedberg 1044ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1045ff9ef578SJohan Hedberg 1046bb3e0a33SJohan Hedberg if (old_state == state) 1047ff9ef578SJohan Hedberg return; 1048ff9ef578SJohan Hedberg 1049bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1050bb3e0a33SJohan Hedberg 1051ff9ef578SJohan Hedberg switch (state) { 1052ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1053c54c3860SAndre Guedes hci_update_background_scan(hdev); 1054c54c3860SAndre Guedes 1055bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1056ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1057ff9ef578SJohan Hedberg break; 1058ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1059ff9ef578SJohan Hedberg break; 1060343f935bSAndre Guedes case DISCOVERY_FINDING: 1061ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1062ff9ef578SJohan Hedberg break; 106330dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 106430dc78e1SJohan Hedberg break; 1065ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1066ff9ef578SJohan Hedberg break; 1067ff9ef578SJohan Hedberg } 1068ff9ef578SJohan Hedberg } 1069ff9ef578SJohan Hedberg 10701f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 10711da177e4SLinus Torvalds { 107230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1073b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10741da177e4SLinus Torvalds 1075561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1076561aafbcSJohan Hedberg list_del(&p->all); 1077b57c1a56SJohan Hedberg kfree(p); 10781da177e4SLinus Torvalds } 1079561aafbcSJohan Hedberg 1080561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1081561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds 1084a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1085a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 10861da177e4SLinus Torvalds { 108730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 10881da177e4SLinus Torvalds struct inquiry_entry *e; 10891da177e4SLinus Torvalds 10906ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 10911da177e4SLinus Torvalds 1092561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 10931da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 10941da177e4SLinus Torvalds return e; 10951da177e4SLinus Torvalds } 10961da177e4SLinus Torvalds 1097b57c1a56SJohan Hedberg return NULL; 1098b57c1a56SJohan Hedberg } 1099b57c1a56SJohan Hedberg 1100561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1101561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1102561aafbcSJohan Hedberg { 110330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1104561aafbcSJohan Hedberg struct inquiry_entry *e; 1105561aafbcSJohan Hedberg 11066ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1107561aafbcSJohan Hedberg 1108561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1109561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1110561aafbcSJohan Hedberg return e; 1111561aafbcSJohan Hedberg } 1112561aafbcSJohan Hedberg 1113561aafbcSJohan Hedberg return NULL; 1114561aafbcSJohan Hedberg } 1115561aafbcSJohan Hedberg 111630dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 111730dc78e1SJohan Hedberg bdaddr_t *bdaddr, 111830dc78e1SJohan Hedberg int state) 111930dc78e1SJohan Hedberg { 112030dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 112130dc78e1SJohan Hedberg struct inquiry_entry *e; 112230dc78e1SJohan Hedberg 11236ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 112430dc78e1SJohan Hedberg 112530dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 112630dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 112730dc78e1SJohan Hedberg return e; 112830dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 112930dc78e1SJohan Hedberg return e; 113030dc78e1SJohan Hedberg } 113130dc78e1SJohan Hedberg 113230dc78e1SJohan Hedberg return NULL; 113330dc78e1SJohan Hedberg } 113430dc78e1SJohan Hedberg 1135a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1136a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1137a3d4e20aSJohan Hedberg { 1138a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1139a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1140a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1141a3d4e20aSJohan Hedberg 1142a3d4e20aSJohan Hedberg list_del(&ie->list); 1143a3d4e20aSJohan Hedberg 1144a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1145a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1146a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1147a3d4e20aSJohan Hedberg break; 1148a3d4e20aSJohan Hedberg pos = &p->list; 1149a3d4e20aSJohan Hedberg } 1150a3d4e20aSJohan Hedberg 1151a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1152a3d4e20aSJohan Hedberg } 1153a3d4e20aSJohan Hedberg 1154af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1155af58925cSMarcel Holtmann bool name_known) 11561da177e4SLinus Torvalds { 115730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 115870f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1159af58925cSMarcel Holtmann u32 flags = 0; 11601da177e4SLinus Torvalds 11616ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11621da177e4SLinus Torvalds 11636928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11642b2fec4dSSzymon Janc 1165af58925cSMarcel Holtmann if (!data->ssp_mode) 1166af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1167388fc8faSJohan Hedberg 116870f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1169a3d4e20aSJohan Hedberg if (ie) { 1170af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1171af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1172388fc8faSJohan Hedberg 1173a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1174a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1175a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1176a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1177a3d4e20aSJohan Hedberg } 1178a3d4e20aSJohan Hedberg 1179561aafbcSJohan Hedberg goto update; 1180a3d4e20aSJohan Hedberg } 1181561aafbcSJohan Hedberg 11821da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 118327f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1184af58925cSMarcel Holtmann if (!ie) { 1185af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1186af58925cSMarcel Holtmann goto done; 1187af58925cSMarcel Holtmann } 118870f23020SAndrei Emeltchenko 1189561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1190561aafbcSJohan Hedberg 1191561aafbcSJohan Hedberg if (name_known) { 1192561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1193561aafbcSJohan Hedberg } else { 1194561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1195561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1196561aafbcSJohan Hedberg } 1197561aafbcSJohan Hedberg 1198561aafbcSJohan Hedberg update: 1199561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1200561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1201561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1202561aafbcSJohan Hedberg list_del(&ie->list); 12031da177e4SLinus Torvalds } 12041da177e4SLinus Torvalds 120570f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 120670f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12071da177e4SLinus Torvalds cache->timestamp = jiffies; 12083175405bSJohan Hedberg 12093175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1210af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12113175405bSJohan Hedberg 1212af58925cSMarcel Holtmann done: 1213af58925cSMarcel Holtmann return flags; 12141da177e4SLinus Torvalds } 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12171da177e4SLinus Torvalds { 121830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12191da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12201da177e4SLinus Torvalds struct inquiry_entry *e; 12211da177e4SLinus Torvalds int copied = 0; 12221da177e4SLinus Torvalds 1223561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12241da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1225b57c1a56SJohan Hedberg 1226b57c1a56SJohan Hedberg if (copied >= num) 1227b57c1a56SJohan Hedberg break; 1228b57c1a56SJohan Hedberg 12291da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12301da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12311da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12321da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12331da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12341da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1235b57c1a56SJohan Hedberg 12361da177e4SLinus Torvalds info++; 1237b57c1a56SJohan Hedberg copied++; 12381da177e4SLinus Torvalds } 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12411da177e4SLinus Torvalds return copied; 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds 1244a1d01db1SJohan Hedberg static int hci_inq_req(struct hci_request *req, unsigned long opt) 12451da177e4SLinus Torvalds { 12461da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 124742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12481da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12491da177e4SLinus Torvalds 12501da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12511da177e4SLinus Torvalds 12521da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 1253a1d01db1SJohan Hedberg return 0; 12541da177e4SLinus Torvalds 12551da177e4SLinus Torvalds /* Start Inquiry */ 12561da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12571da177e4SLinus Torvalds cp.length = ir->length; 12581da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 125942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 1260a1d01db1SJohan Hedberg 1261a1d01db1SJohan Hedberg return 0; 12621da177e4SLinus Torvalds } 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12651da177e4SLinus Torvalds { 12661da177e4SLinus Torvalds __u8 __user *ptr = arg; 12671da177e4SLinus Torvalds struct hci_inquiry_req ir; 12681da177e4SLinus Torvalds struct hci_dev *hdev; 12691da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 12701da177e4SLinus Torvalds long timeo; 12711da177e4SLinus Torvalds __u8 *buf; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12741da177e4SLinus Torvalds return -EFAULT; 12751da177e4SLinus Torvalds 12765a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12775a08ecceSAndrei Emeltchenko if (!hdev) 12781da177e4SLinus Torvalds return -ENODEV; 12791da177e4SLinus Torvalds 1280d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 12810736cfa8SMarcel Holtmann err = -EBUSY; 12820736cfa8SMarcel Holtmann goto done; 12830736cfa8SMarcel Holtmann } 12840736cfa8SMarcel Holtmann 1285d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1286fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1287fee746b0SMarcel Holtmann goto done; 1288fee746b0SMarcel Holtmann } 1289fee746b0SMarcel Holtmann 1290ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 12915b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 12925b69bef5SMarcel Holtmann goto done; 12935b69bef5SMarcel Holtmann } 12945b69bef5SMarcel Holtmann 1295d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 129656f87901SJohan Hedberg err = -EOPNOTSUPP; 129756f87901SJohan Hedberg goto done; 129856f87901SJohan Hedberg } 129956f87901SJohan Hedberg 130009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13011da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1302a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13031f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13041da177e4SLinus Torvalds do_inquiry = 1; 13051da177e4SLinus Torvalds } 130609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13071da177e4SLinus Torvalds 130804837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 130970f23020SAndrei Emeltchenko 131070f23020SAndrei Emeltchenko if (do_inquiry) { 131101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 13124ebeee2dSJohan Hedberg timeo, NULL); 131370f23020SAndrei Emeltchenko if (err < 0) 13141da177e4SLinus Torvalds goto done; 13153e13fa1eSAndre Guedes 13163e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13173e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13183e13fa1eSAndre Guedes */ 131974316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13203e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13213e13fa1eSAndre Guedes return -EINTR; 132270f23020SAndrei Emeltchenko } 13231da177e4SLinus Torvalds 13248fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13258fc9ced3SGustavo Padovan * 255 entries 13268fc9ced3SGustavo Padovan */ 13271da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13301da177e4SLinus Torvalds * copy it to the user space. 13311da177e4SLinus Torvalds */ 13326da2ec56SKees Cook buf = kmalloc_array(max_rsp, sizeof(struct inquiry_info), GFP_KERNEL); 133370f23020SAndrei Emeltchenko if (!buf) { 13341da177e4SLinus Torvalds err = -ENOMEM; 13351da177e4SLinus Torvalds goto done; 13361da177e4SLinus Torvalds } 13371da177e4SLinus Torvalds 133809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13391da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 134009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13411da177e4SLinus Torvalds 13421da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13431da177e4SLinus Torvalds 13441da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13451da177e4SLinus Torvalds ptr += sizeof(ir); 13461da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13471da177e4SLinus Torvalds ir.num_rsp)) 13481da177e4SLinus Torvalds err = -EFAULT; 13491da177e4SLinus Torvalds } else 13501da177e4SLinus Torvalds err = -EFAULT; 13511da177e4SLinus Torvalds 13521da177e4SLinus Torvalds kfree(buf); 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds done: 13551da177e4SLinus Torvalds hci_dev_put(hdev); 13561da177e4SLinus Torvalds return err; 13571da177e4SLinus Torvalds } 13581da177e4SLinus Torvalds 13597a0e5b15SMatthias Kaehlcke /** 13607a0e5b15SMatthias Kaehlcke * hci_dev_get_bd_addr_from_property - Get the Bluetooth Device Address 13617a0e5b15SMatthias Kaehlcke * (BD_ADDR) for a HCI device from 13627a0e5b15SMatthias Kaehlcke * a firmware node property. 13637a0e5b15SMatthias Kaehlcke * @hdev: The HCI device 13647a0e5b15SMatthias Kaehlcke * 13657a0e5b15SMatthias Kaehlcke * Search the firmware node for 'local-bd-address'. 13667a0e5b15SMatthias Kaehlcke * 13677a0e5b15SMatthias Kaehlcke * All-zero BD addresses are rejected, because those could be properties 13687a0e5b15SMatthias Kaehlcke * that exist in the firmware tables, but were not updated by the firmware. For 13697a0e5b15SMatthias Kaehlcke * example, the DTS could define 'local-bd-address', with zero BD addresses. 13707a0e5b15SMatthias Kaehlcke */ 13717a0e5b15SMatthias Kaehlcke static void hci_dev_get_bd_addr_from_property(struct hci_dev *hdev) 13727a0e5b15SMatthias Kaehlcke { 13737a0e5b15SMatthias Kaehlcke struct fwnode_handle *fwnode = dev_fwnode(hdev->dev.parent); 13747a0e5b15SMatthias Kaehlcke bdaddr_t ba; 13757a0e5b15SMatthias Kaehlcke int ret; 13767a0e5b15SMatthias Kaehlcke 13777a0e5b15SMatthias Kaehlcke ret = fwnode_property_read_u8_array(fwnode, "local-bd-address", 13787a0e5b15SMatthias Kaehlcke (u8 *)&ba, sizeof(ba)); 13797a0e5b15SMatthias Kaehlcke if (ret < 0 || !bacmp(&ba, BDADDR_ANY)) 13807a0e5b15SMatthias Kaehlcke return; 13817a0e5b15SMatthias Kaehlcke 13827a0e5b15SMatthias Kaehlcke bacpy(&hdev->public_addr, &ba); 13837a0e5b15SMatthias Kaehlcke } 13847a0e5b15SMatthias Kaehlcke 1385cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13861da177e4SLinus Torvalds { 13871da177e4SLinus Torvalds int ret = 0; 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13901da177e4SLinus Torvalds 1391b504430cSJohan Hedberg hci_req_sync_lock(hdev); 13921da177e4SLinus Torvalds 1393d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 139494324962SJohan Hovold ret = -ENODEV; 139594324962SJohan Hovold goto done; 139694324962SJohan Hovold } 139794324962SJohan Hovold 1398d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1399d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1400a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1401a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1402bf543036SJohan Hedberg */ 1403d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1404611b30f7SMarcel Holtmann ret = -ERFKILL; 1405611b30f7SMarcel Holtmann goto done; 1406611b30f7SMarcel Holtmann } 1407611b30f7SMarcel Holtmann 1408a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1409a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1410a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1411a5c8f270SMarcel Holtmann * or not. 1412a5c8f270SMarcel Holtmann * 1413c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1414c6beca0eSMarcel Holtmann * if a public address or static random address is 1415c6beca0eSMarcel Holtmann * available. 1416c6beca0eSMarcel Holtmann * 1417a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1418a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1419a5c8f270SMarcel Holtmann */ 1420d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1421ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY && 1422a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1423a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1424a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1425a5c8f270SMarcel Holtmann goto done; 1426a5c8f270SMarcel Holtmann } 1427a5c8f270SMarcel Holtmann } 1428a5c8f270SMarcel Holtmann 14291da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14301da177e4SLinus Torvalds ret = -EALREADY; 14311da177e4SLinus Torvalds goto done; 14321da177e4SLinus Torvalds } 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds if (hdev->open(hdev)) { 14351da177e4SLinus Torvalds ret = -EIO; 14361da177e4SLinus Torvalds goto done; 14371da177e4SLinus Torvalds } 14381da177e4SLinus Torvalds 1439e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 144005fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 14414a3f95b7SMarcel Holtmann 14421da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14431da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1444f41c70c4SMarcel Holtmann 1445740011cfSSean Wang if (hci_dev_test_flag(hdev, HCI_SETUP) || 1446740011cfSSean Wang test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks)) { 14477fdf6c6aSMarcel Holtmann bool invalid_bdaddr; 14487fdf6c6aSMarcel Holtmann 1449e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1450e131d74aSMarcel Holtmann 1451af202f84SMarcel Holtmann if (hdev->setup) 1452f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1453f41c70c4SMarcel Holtmann 14547fdf6c6aSMarcel Holtmann /* The transport driver can set the quirk to mark the 14557fdf6c6aSMarcel Holtmann * BD_ADDR invalid before creating the HCI device or in 14567fdf6c6aSMarcel Holtmann * its setup callback. 14577fdf6c6aSMarcel Holtmann */ 14587fdf6c6aSMarcel Holtmann invalid_bdaddr = test_bit(HCI_QUIRK_INVALID_BDADDR, 14597fdf6c6aSMarcel Holtmann &hdev->quirks); 14607fdf6c6aSMarcel Holtmann 14617a0e5b15SMatthias Kaehlcke if (ret) 14627a0e5b15SMatthias Kaehlcke goto setup_failed; 14637a0e5b15SMatthias Kaehlcke 14647a0e5b15SMatthias Kaehlcke if (test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) { 14657a0e5b15SMatthias Kaehlcke if (!bacmp(&hdev->public_addr, BDADDR_ANY)) 14667a0e5b15SMatthias Kaehlcke hci_dev_get_bd_addr_from_property(hdev); 14677a0e5b15SMatthias Kaehlcke 14687a0e5b15SMatthias Kaehlcke if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14697fdf6c6aSMarcel Holtmann hdev->set_bdaddr) { 14707a0e5b15SMatthias Kaehlcke ret = hdev->set_bdaddr(hdev, 14717a0e5b15SMatthias Kaehlcke &hdev->public_addr); 14727fdf6c6aSMarcel Holtmann 14737fdf6c6aSMarcel Holtmann /* If setting of the BD_ADDR from the device 14747fdf6c6aSMarcel Holtmann * property succeeds, then treat the address 14757fdf6c6aSMarcel Holtmann * as valid even if the invalid BD_ADDR 14767fdf6c6aSMarcel Holtmann * quirk indicates otherwise. 14777fdf6c6aSMarcel Holtmann */ 14787fdf6c6aSMarcel Holtmann if (!ret) 14797fdf6c6aSMarcel Holtmann invalid_bdaddr = false; 14807fdf6c6aSMarcel Holtmann } 14817a0e5b15SMatthias Kaehlcke } 14827a0e5b15SMatthias Kaehlcke 14837a0e5b15SMatthias Kaehlcke setup_failed: 1484af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1485af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1486af202f84SMarcel Holtmann * 14877fdf6c6aSMarcel Holtmann * For the invalid BD_ADDR quirk it is possible that 14887fdf6c6aSMarcel Holtmann * it becomes a valid address if the bootloader does 14897fdf6c6aSMarcel Holtmann * provide it (see above). 14907fdf6c6aSMarcel Holtmann * 1491af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1492af202f84SMarcel Holtmann * start up as unconfigured. 1493af202f84SMarcel Holtmann */ 1494eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 14957fdf6c6aSMarcel Holtmann invalid_bdaddr) 1496a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1497f41c70c4SMarcel Holtmann 14980ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 14990ebca7d6SMarcel Holtmann * read at least the version information provided by 15000ebca7d6SMarcel Holtmann * the Read Local Version Information command. 15010ebca7d6SMarcel Holtmann * 15020ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 15030ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 15040ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 15050ebca7d6SMarcel Holtmann */ 1506d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 15070ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 150889bc22d2SMarcel Holtmann } 150989bc22d2SMarcel Holtmann 1510d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 15119713c17bSMarcel Holtmann /* If public address change is configured, ensure that 15129713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 15139713c17bSMarcel Holtmann * support changing the public address, fail the power 15149713c17bSMarcel Holtmann * on procedure. 151524c457e2SMarcel Holtmann */ 15169713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 15179713c17bSMarcel Holtmann hdev->set_bdaddr) 151824c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 151924c457e2SMarcel Holtmann else 152024c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 152124c457e2SMarcel Holtmann } 152224c457e2SMarcel Holtmann 1523f41c70c4SMarcel Holtmann if (!ret) { 1524d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 152598a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 15262177bab5SJohan Hedberg ret = __hci_init(hdev); 152798a63aafSMarcel Holtmann if (!ret && hdev->post_init) 152898a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 152998a63aafSMarcel Holtmann } 15301da177e4SLinus Torvalds } 15311da177e4SLinus Torvalds 15327e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 15337e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 15347e995b9eSMarcel Holtmann * completed. 15357e995b9eSMarcel Holtmann */ 15367e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1537b56c7b25SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15387e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 15397e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 15407e995b9eSMarcel Holtmann 1541f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1542f41c70c4SMarcel Holtmann 15431da177e4SLinus Torvalds if (!ret) { 15441da177e4SLinus Torvalds hci_dev_hold(hdev); 1545a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 1546a73c046aSJaganath Kanakkassery hci_adv_instances_set_rpa_expired(hdev, true); 15471da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 154805fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 15496d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, true); 1550d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1551d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1552d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1553d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15542ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 1555ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY) { 15562ff13894SJohan Hedberg ret = __hci_req_hci_power_on(hdev); 15572ff13894SJohan Hedberg mgmt_power_on(hdev, ret); 155856e5cb86SJohan Hedberg } 15591da177e4SLinus Torvalds } else { 15601da177e4SLinus Torvalds /* Init failed, cleanup */ 15613eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1562c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1563b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15641da177e4SLinus Torvalds 15651da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15661da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15671da177e4SLinus Torvalds 15681da177e4SLinus Torvalds if (hdev->flush) 15691da177e4SLinus Torvalds hdev->flush(hdev); 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds if (hdev->sent_cmd) { 15721da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15731da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvalds 1576e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 157705fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 15784a3f95b7SMarcel Holtmann 15791da177e4SLinus Torvalds hdev->close(hdev); 1580fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 15811da177e4SLinus Torvalds } 15821da177e4SLinus Torvalds 15831da177e4SLinus Torvalds done: 1584b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 15851da177e4SLinus Torvalds return ret; 15861da177e4SLinus Torvalds } 15871da177e4SLinus Torvalds 1588cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1589cbed0ca1SJohan Hedberg 1590cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1591cbed0ca1SJohan Hedberg { 1592cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1593cbed0ca1SJohan Hedberg int err; 1594cbed0ca1SJohan Hedberg 1595cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1596cbed0ca1SJohan Hedberg if (!hdev) 1597cbed0ca1SJohan Hedberg return -ENODEV; 1598cbed0ca1SJohan Hedberg 15994a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1600fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1601fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1602fee746b0SMarcel Holtmann * possible. 1603fee746b0SMarcel Holtmann * 1604fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1605fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1606fee746b0SMarcel Holtmann * open the device. 1607fee746b0SMarcel Holtmann */ 1608d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1609d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1610fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1611fee746b0SMarcel Holtmann goto done; 1612fee746b0SMarcel Holtmann } 1613fee746b0SMarcel Holtmann 1614e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1615e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1616e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1617e1d08f40SJohan Hedberg * completed. 1618e1d08f40SJohan Hedberg */ 1619a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1620e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1621e1d08f40SJohan Hedberg 1622a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1623a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1624a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1625a5c8f270SMarcel Holtmann */ 1626e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1627e1d08f40SJohan Hedberg 162812aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1629b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 163012aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 163112aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 163212aa4f0aSMarcel Holtmann * to explicitly enable it. 163312aa4f0aSMarcel Holtmann */ 1634d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1635d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1636a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 163712aa4f0aSMarcel Holtmann 1638cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1639cbed0ca1SJohan Hedberg 1640fee746b0SMarcel Holtmann done: 1641cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1642cbed0ca1SJohan Hedberg return err; 1643cbed0ca1SJohan Hedberg } 1644cbed0ca1SJohan Hedberg 1645d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1646d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1647d7347f3cSJohan Hedberg { 1648d7347f3cSJohan Hedberg struct hci_conn_params *p; 1649d7347f3cSJohan Hedberg 1650f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1651f161dd41SJohan Hedberg if (p->conn) { 1652f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1653f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1654f161dd41SJohan Hedberg p->conn = NULL; 1655f161dd41SJohan Hedberg } 1656d7347f3cSJohan Hedberg list_del_init(&p->action); 1657f161dd41SJohan Hedberg } 1658d7347f3cSJohan Hedberg 1659d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1660d7347f3cSJohan Hedberg } 1661d7347f3cSJohan Hedberg 16626b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 16631da177e4SLinus Torvalds { 1664acc649c6SMarcel Holtmann bool auto_off; 1665acc649c6SMarcel Holtmann 16661da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 16671da177e4SLinus Torvalds 1668d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1669867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1670d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1671a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1672a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1673a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1674a44fecbdSTedd Ho-Jeong An } 1675a44fecbdSTedd Ho-Jeong An 167678c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 167778c04c0bSVinicius Costa Gomes 16787df0f73eSJohan Hedberg hci_request_cancel_all(hdev); 1679b504430cSJohan Hedberg hci_req_sync_lock(hdev); 16801da177e4SLinus Torvalds 16811da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 168265cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 1683b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 16841da177e4SLinus Torvalds return 0; 16851da177e4SLinus Torvalds } 16861da177e4SLinus Torvalds 16876d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, false); 16886d5d2ee6SHeiner Kallweit 16893eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16903eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1691b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16921da177e4SLinus Torvalds 169316ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 169416ab91abSJohan Hedberg hdev->discov_timeout = 0; 1695a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1696a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 169716ab91abSJohan Hedberg } 169816ab91abSJohan Hedberg 1699a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 17007d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 17017d78525dSJohan Hedberg 1702a73c046aSJaganath Kanakkassery if (hci_dev_test_flag(hdev, HCI_MGMT)) { 1703a73c046aSJaganath Kanakkassery struct adv_info *adv_instance; 1704a73c046aSJaganath Kanakkassery 1705d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 17067ba8b4beSAndre Guedes 1707a73c046aSJaganath Kanakkassery list_for_each_entry(adv_instance, &hdev->adv_instances, list) 1708a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 1709a73c046aSJaganath Kanakkassery } 1710a73c046aSJaganath Kanakkassery 171176727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 171276727c02SJohan Hedberg * ensuring the workqueue is empty up front. 171376727c02SJohan Hedberg */ 171476727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 171576727c02SJohan Hedberg 171609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17171aeb9c65SJohan Hedberg 17188f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 17198f502f84SJohan Hedberg 1720acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1721acc649c6SMarcel Holtmann 1722ca8bee5dSMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_PRIMARY && 1723baab7932SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 17242ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT)) 17252ff13894SJohan Hedberg __mgmt_power_off(hdev); 17261aeb9c65SJohan Hedberg 17271f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1728d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1729f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 173009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17311da177e4SLinus Torvalds 173264dae967SMarcel Holtmann smp_unregister(hdev); 173364dae967SMarcel Holtmann 173405fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 17351da177e4SLinus Torvalds 17361da177e4SLinus Torvalds if (hdev->flush) 17371da177e4SLinus Torvalds hdev->flush(hdev); 17381da177e4SLinus Torvalds 17391da177e4SLinus Torvalds /* Reset device */ 17401da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17411da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1742acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1743acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17441da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 17454ebeee2dSJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT, NULL); 17461da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 17471da177e4SLinus Torvalds } 17481da177e4SLinus Torvalds 1749c347b765SGustavo F. Padovan /* flush cmd work */ 1750c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 17511da177e4SLinus Torvalds 17521da177e4SLinus Torvalds /* Drop queues */ 17531da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17541da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17551da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds /* Drop last sent command */ 17581da177e4SLinus Torvalds if (hdev->sent_cmd) { 175965cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 17601da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 17611da177e4SLinus Torvalds hdev->sent_cmd = NULL; 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds 1764e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 176505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 17664a3f95b7SMarcel Holtmann 17671da177e4SLinus Torvalds /* After this point our queues are empty 17681da177e4SLinus Torvalds * and no tasks are scheduled. */ 17691da177e4SLinus Torvalds hdev->close(hdev); 17701da177e4SLinus Torvalds 177135b973c9SJohan Hedberg /* Clear flags */ 1772fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1773eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 177435b973c9SJohan Hedberg 1775ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1776536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1777ced5c338SAndrei Emeltchenko 1778e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 177909b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 17807a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1781e59fda8dSJohan Hedberg 1782b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 17831da177e4SLinus Torvalds 17841da177e4SLinus Torvalds hci_dev_put(hdev); 17851da177e4SLinus Torvalds return 0; 17861da177e4SLinus Torvalds } 17871da177e4SLinus Torvalds 17881da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 17891da177e4SLinus Torvalds { 17901da177e4SLinus Torvalds struct hci_dev *hdev; 17911da177e4SLinus Torvalds int err; 17921da177e4SLinus Torvalds 179370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 179470f23020SAndrei Emeltchenko if (!hdev) 17951da177e4SLinus Torvalds return -ENODEV; 17968ee56540SMarcel Holtmann 1797d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17980736cfa8SMarcel Holtmann err = -EBUSY; 17990736cfa8SMarcel Holtmann goto done; 18000736cfa8SMarcel Holtmann } 18010736cfa8SMarcel Holtmann 1802a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 18038ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 18048ee56540SMarcel Holtmann 18051da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 18068ee56540SMarcel Holtmann 18070736cfa8SMarcel Holtmann done: 18081da177e4SLinus Torvalds hci_dev_put(hdev); 18091da177e4SLinus Torvalds return err; 18101da177e4SLinus Torvalds } 18111da177e4SLinus Torvalds 18125c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 18131da177e4SLinus Torvalds { 18145c912495SMarcel Holtmann int ret; 18151da177e4SLinus Torvalds 18165c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 18171da177e4SLinus Torvalds 1818b504430cSJohan Hedberg hci_req_sync_lock(hdev); 18191da177e4SLinus Torvalds 18201da177e4SLinus Torvalds /* Drop queues */ 18211da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18221da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18231da177e4SLinus Torvalds 182476727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 182576727c02SJohan Hedberg * ensuring the workqueue is empty up front. 182676727c02SJohan Hedberg */ 182776727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 182876727c02SJohan Hedberg 182909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 18301f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 18311da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 183209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18331da177e4SLinus Torvalds 18341da177e4SLinus Torvalds if (hdev->flush) 18351da177e4SLinus Torvalds hdev->flush(hdev); 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18386ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 18391da177e4SLinus Torvalds 18404ebeee2dSJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT, NULL); 18411da177e4SLinus Torvalds 1842b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 18431da177e4SLinus Torvalds return ret; 18441da177e4SLinus Torvalds } 18451da177e4SLinus Torvalds 18465c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 18475c912495SMarcel Holtmann { 18485c912495SMarcel Holtmann struct hci_dev *hdev; 18495c912495SMarcel Holtmann int err; 18505c912495SMarcel Holtmann 18515c912495SMarcel Holtmann hdev = hci_dev_get(dev); 18525c912495SMarcel Holtmann if (!hdev) 18535c912495SMarcel Holtmann return -ENODEV; 18545c912495SMarcel Holtmann 18555c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 18565c912495SMarcel Holtmann err = -ENETDOWN; 18575c912495SMarcel Holtmann goto done; 18585c912495SMarcel Holtmann } 18595c912495SMarcel Holtmann 1860d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18615c912495SMarcel Holtmann err = -EBUSY; 18625c912495SMarcel Holtmann goto done; 18635c912495SMarcel Holtmann } 18645c912495SMarcel Holtmann 1865d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 18665c912495SMarcel Holtmann err = -EOPNOTSUPP; 18675c912495SMarcel Holtmann goto done; 18685c912495SMarcel Holtmann } 18695c912495SMarcel Holtmann 18705c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 18715c912495SMarcel Holtmann 18725c912495SMarcel Holtmann done: 18735c912495SMarcel Holtmann hci_dev_put(hdev); 18745c912495SMarcel Holtmann return err; 18755c912495SMarcel Holtmann } 18765c912495SMarcel Holtmann 18771da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 18781da177e4SLinus Torvalds { 18791da177e4SLinus Torvalds struct hci_dev *hdev; 18801da177e4SLinus Torvalds int ret = 0; 18811da177e4SLinus Torvalds 188270f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 188370f23020SAndrei Emeltchenko if (!hdev) 18841da177e4SLinus Torvalds return -ENODEV; 18851da177e4SLinus Torvalds 1886d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18870736cfa8SMarcel Holtmann ret = -EBUSY; 18880736cfa8SMarcel Holtmann goto done; 18890736cfa8SMarcel Holtmann } 18900736cfa8SMarcel Holtmann 1891d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1892fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1893fee746b0SMarcel Holtmann goto done; 1894fee746b0SMarcel Holtmann } 1895fee746b0SMarcel Holtmann 18961da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 18971da177e4SLinus Torvalds 18980736cfa8SMarcel Holtmann done: 18991da177e4SLinus Torvalds hci_dev_put(hdev); 19001da177e4SLinus Torvalds return ret; 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 1903123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1904123abc08SJohan Hedberg { 1905bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1906123abc08SJohan Hedberg 1907123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1908123abc08SJohan Hedberg 1909123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1910238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1911238be788SMarcel Holtmann HCI_CONNECTABLE); 1912123abc08SJohan Hedberg else 1913a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1914a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1915123abc08SJohan Hedberg 1916bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1917238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1918238be788SMarcel Holtmann HCI_DISCOVERABLE); 1919bc6d2d04SJohan Hedberg } else { 1920a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1921a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1922a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1923bc6d2d04SJohan Hedberg } 1924bc6d2d04SJohan Hedberg 1925d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1926123abc08SJohan Hedberg return; 1927123abc08SJohan Hedberg 1928bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1929bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1930a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1931bc6d2d04SJohan Hedberg 1932d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1933cab054abSJohan Hedberg hci_req_update_adv_data(hdev, hdev->cur_adv_instance); 1934bc6d2d04SJohan Hedberg 1935123abc08SJohan Hedberg mgmt_new_settings(hdev); 1936123abc08SJohan Hedberg } 1937bc6d2d04SJohan Hedberg } 1938123abc08SJohan Hedberg 19391da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 19401da177e4SLinus Torvalds { 19411da177e4SLinus Torvalds struct hci_dev *hdev; 19421da177e4SLinus Torvalds struct hci_dev_req dr; 19431da177e4SLinus Torvalds int err = 0; 19441da177e4SLinus Torvalds 19451da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 19461da177e4SLinus Torvalds return -EFAULT; 19471da177e4SLinus Torvalds 194870f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 194970f23020SAndrei Emeltchenko if (!hdev) 19501da177e4SLinus Torvalds return -ENODEV; 19511da177e4SLinus Torvalds 1952d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19530736cfa8SMarcel Holtmann err = -EBUSY; 19540736cfa8SMarcel Holtmann goto done; 19550736cfa8SMarcel Holtmann } 19560736cfa8SMarcel Holtmann 1957d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1958fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1959fee746b0SMarcel Holtmann goto done; 1960fee746b0SMarcel Holtmann } 1961fee746b0SMarcel Holtmann 1962ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 19635b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 19645b69bef5SMarcel Holtmann goto done; 19655b69bef5SMarcel Holtmann } 19665b69bef5SMarcel Holtmann 1967d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 196856f87901SJohan Hedberg err = -EOPNOTSUPP; 196956f87901SJohan Hedberg goto done; 197056f87901SJohan Hedberg } 197156f87901SJohan Hedberg 19721da177e4SLinus Torvalds switch (cmd) { 19731da177e4SLinus Torvalds case HCISETAUTH: 197401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19754ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19761da177e4SLinus Torvalds break; 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds case HCISETENCRYPT: 19791da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 19801da177e4SLinus Torvalds err = -EOPNOTSUPP; 19811da177e4SLinus Torvalds break; 19821da177e4SLinus Torvalds } 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 19851da177e4SLinus Torvalds /* Auth must be enabled first */ 198601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19874ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19881da177e4SLinus Torvalds if (err) 19891da177e4SLinus Torvalds break; 19901da177e4SLinus Torvalds } 19911da177e4SLinus Torvalds 199201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19934ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19941da177e4SLinus Torvalds break; 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvalds case HCISETSCAN: 199701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19984ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 199991a668b0SJohan Hedberg 2000bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2001bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 200291a668b0SJohan Hedberg */ 2003123abc08SJohan Hedberg if (!err) 2004123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 20051da177e4SLinus Torvalds break; 20061da177e4SLinus Torvalds 20071da177e4SLinus Torvalds case HCISETLINKPOL: 200801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 20094ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 20101da177e4SLinus Torvalds break; 20111da177e4SLinus Torvalds 20121da177e4SLinus Torvalds case HCISETLINKMODE: 2013e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2014e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2015e4e8e37cSMarcel Holtmann break; 2016e4e8e37cSMarcel Holtmann 2017e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2018b7c23df8SJaganath Kanakkassery if (hdev->pkt_type == (__u16) dr.dev_opt) 2019b7c23df8SJaganath Kanakkassery break; 2020b7c23df8SJaganath Kanakkassery 2021e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 2022b7c23df8SJaganath Kanakkassery mgmt_phy_configuration_changed(hdev, NULL); 20231da177e4SLinus Torvalds break; 20241da177e4SLinus Torvalds 20251da177e4SLinus Torvalds case HCISETACLMTU: 20261da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 20271da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 20281da177e4SLinus Torvalds break; 20291da177e4SLinus Torvalds 20301da177e4SLinus Torvalds case HCISETSCOMTU: 20311da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 20321da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 20331da177e4SLinus Torvalds break; 20341da177e4SLinus Torvalds 20351da177e4SLinus Torvalds default: 20361da177e4SLinus Torvalds err = -EINVAL; 20371da177e4SLinus Torvalds break; 20381da177e4SLinus Torvalds } 2039e4e8e37cSMarcel Holtmann 20400736cfa8SMarcel Holtmann done: 20411da177e4SLinus Torvalds hci_dev_put(hdev); 20421da177e4SLinus Torvalds return err; 20431da177e4SLinus Torvalds } 20441da177e4SLinus Torvalds 20451da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 20461da177e4SLinus Torvalds { 20478035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 20481da177e4SLinus Torvalds struct hci_dev_list_req *dl; 20491da177e4SLinus Torvalds struct hci_dev_req *dr; 20501da177e4SLinus Torvalds int n = 0, size, err; 20511da177e4SLinus Torvalds __u16 dev_num; 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 20541da177e4SLinus Torvalds return -EFAULT; 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 20571da177e4SLinus Torvalds return -EINVAL; 20581da177e4SLinus Torvalds 20591da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 20601da177e4SLinus Torvalds 206170f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 206270f23020SAndrei Emeltchenko if (!dl) 20631da177e4SLinus Torvalds return -ENOMEM; 20641da177e4SLinus Torvalds 20651da177e4SLinus Torvalds dr = dl->dev_req; 20661da177e4SLinus Torvalds 2067f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 20688035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 20692e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2070c542a06cSJohan Hedberg 20712e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20722e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20732e84d8dbSMarcel Holtmann * device is actually down. 20742e84d8dbSMarcel Holtmann */ 2075d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20762e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2077c542a06cSJohan Hedberg 20781da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 20792e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2080c542a06cSJohan Hedberg 20811da177e4SLinus Torvalds if (++n >= dev_num) 20821da177e4SLinus Torvalds break; 20831da177e4SLinus Torvalds } 2084f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 20851da177e4SLinus Torvalds 20861da177e4SLinus Torvalds dl->dev_num = n; 20871da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 20881da177e4SLinus Torvalds 20891da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 20901da177e4SLinus Torvalds kfree(dl); 20911da177e4SLinus Torvalds 20921da177e4SLinus Torvalds return err ? -EFAULT : 0; 20931da177e4SLinus Torvalds } 20941da177e4SLinus Torvalds 20951da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20961da177e4SLinus Torvalds { 20971da177e4SLinus Torvalds struct hci_dev *hdev; 20981da177e4SLinus Torvalds struct hci_dev_info di; 20992e84d8dbSMarcel Holtmann unsigned long flags; 21001da177e4SLinus Torvalds int err = 0; 21011da177e4SLinus Torvalds 21021da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 21031da177e4SLinus Torvalds return -EFAULT; 21041da177e4SLinus Torvalds 210570f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 210670f23020SAndrei Emeltchenko if (!hdev) 21071da177e4SLinus Torvalds return -ENODEV; 21081da177e4SLinus Torvalds 21092e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 21102e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 21112e84d8dbSMarcel Holtmann * device is actually down. 21122e84d8dbSMarcel Holtmann */ 2113d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 21142e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 21152e84d8dbSMarcel Holtmann else 21162e84d8dbSMarcel Holtmann flags = hdev->flags; 2117c542a06cSJohan Hedberg 21181da177e4SLinus Torvalds strcpy(di.name, hdev->name); 21191da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 212060f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 21212e84d8dbSMarcel Holtmann di.flags = flags; 21221da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2123572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 21241da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 21251da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 21261da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 21271da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2128572c7f84SJohan Hedberg } else { 2129572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2130572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2131572c7f84SJohan Hedberg di.sco_mtu = 0; 2132572c7f84SJohan Hedberg di.sco_pkts = 0; 2133572c7f84SJohan Hedberg } 21341da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 21351da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 21361da177e4SLinus Torvalds 21371da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 21381da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 21391da177e4SLinus Torvalds 21401da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 21411da177e4SLinus Torvalds err = -EFAULT; 21421da177e4SLinus Torvalds 21431da177e4SLinus Torvalds hci_dev_put(hdev); 21441da177e4SLinus Torvalds 21451da177e4SLinus Torvalds return err; 21461da177e4SLinus Torvalds } 21471da177e4SLinus Torvalds 21481da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 21491da177e4SLinus Torvalds 2150611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2151611b30f7SMarcel Holtmann { 2152611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2153611b30f7SMarcel Holtmann 2154611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2155611b30f7SMarcel Holtmann 2156d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 21570736cfa8SMarcel Holtmann return -EBUSY; 21580736cfa8SMarcel Holtmann 21595e130367SJohan Hedberg if (blocked) { 2160a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2161d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2162d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2163611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 21645e130367SJohan Hedberg } else { 2165a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 21665e130367SJohan Hedberg } 2167611b30f7SMarcel Holtmann 2168611b30f7SMarcel Holtmann return 0; 2169611b30f7SMarcel Holtmann } 2170611b30f7SMarcel Holtmann 2171611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2172611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2173611b30f7SMarcel Holtmann }; 2174611b30f7SMarcel Holtmann 2175ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2176ab81cbf9SJohan Hedberg { 2177ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 217896570ffcSJohan Hedberg int err; 2179ab81cbf9SJohan Hedberg 2180ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2181ab81cbf9SJohan Hedberg 21822ff13894SJohan Hedberg if (test_bit(HCI_UP, &hdev->flags) && 21832ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 21842ff13894SJohan Hedberg hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) { 2185d82142a8SWei-Ning Huang cancel_delayed_work(&hdev->power_off); 21862ff13894SJohan Hedberg hci_req_sync_lock(hdev); 21872ff13894SJohan Hedberg err = __hci_req_hci_power_on(hdev); 21882ff13894SJohan Hedberg hci_req_sync_unlock(hdev); 21892ff13894SJohan Hedberg mgmt_power_on(hdev, err); 21902ff13894SJohan Hedberg return; 21912ff13894SJohan Hedberg } 21922ff13894SJohan Hedberg 2193cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 219496570ffcSJohan Hedberg if (err < 0) { 21953ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 219696570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 21973ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2198ab81cbf9SJohan Hedberg return; 219996570ffcSJohan Hedberg } 2200ab81cbf9SJohan Hedberg 2201a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2202a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2203a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2204a5c8f270SMarcel Holtmann */ 2205d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2206d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2207ca8bee5dSMarcel Holtmann (hdev->dev_type == HCI_PRIMARY && 2208a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2209a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2210a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2211bf543036SJohan Hedberg hci_dev_do_close(hdev); 2212d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 221319202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 221419202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2215bf543036SJohan Hedberg } 2216ab81cbf9SJohan Hedberg 2217a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 22184a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 22194a964404SMarcel Holtmann * so that userspace can easily identify them. 22204a964404SMarcel Holtmann */ 2221d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22224a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 22230602a8adSMarcel Holtmann 22240602a8adSMarcel Holtmann /* For fully configured devices, this will send 22250602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 22260602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 22270602a8adSMarcel Holtmann * 22280602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 22290602a8adSMarcel Holtmann * and no event will be send. 22300602a8adSMarcel Holtmann */ 2231744cf19eSJohan Hedberg mgmt_index_added(hdev); 2232a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 22335ea234d3SMarcel Holtmann /* When the controller is now configured, then it 22345ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 22355ea234d3SMarcel Holtmann */ 2236d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22375ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 22385ea234d3SMarcel Holtmann 2239d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2240d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2241d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2242d603b76bSMarcel Holtmann */ 2243d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2244ab81cbf9SJohan Hedberg } 2245ab81cbf9SJohan Hedberg } 2246ab81cbf9SJohan Hedberg 2247ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2248ab81cbf9SJohan Hedberg { 22493243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 22503243553fSJohan Hedberg power_off.work); 2251ab81cbf9SJohan Hedberg 2252ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2253ab81cbf9SJohan Hedberg 22548ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2255ab81cbf9SJohan Hedberg } 2256ab81cbf9SJohan Hedberg 2257c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2258c7741d16SMarcel Holtmann { 2259c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2260c7741d16SMarcel Holtmann 2261c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2262c7741d16SMarcel Holtmann 2263c7741d16SMarcel Holtmann if (hdev->hw_error) 2264c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2265c7741d16SMarcel Holtmann else 22662064ee33SMarcel Holtmann bt_dev_err(hdev, "hardware error 0x%2.2x", hdev->hw_error_code); 2267c7741d16SMarcel Holtmann 2268c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2269c7741d16SMarcel Holtmann return; 2270c7741d16SMarcel Holtmann 2271c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2272c7741d16SMarcel Holtmann } 2273c7741d16SMarcel Holtmann 227435f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 22752aeb9a1aSJohan Hedberg { 22764821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 22772aeb9a1aSJohan Hedberg 22784821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 22794821002cSJohan Hedberg list_del(&uuid->list); 22802aeb9a1aSJohan Hedberg kfree(uuid); 22812aeb9a1aSJohan Hedberg } 22822aeb9a1aSJohan Hedberg } 22832aeb9a1aSJohan Hedberg 228435f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 228555ed8ca1SJohan Hedberg { 228655ed8ca1SJohan Hedberg struct link_key *key; 228755ed8ca1SJohan Hedberg 22880378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 22890378b597SJohan Hedberg list_del_rcu(&key->list); 22900378b597SJohan Hedberg kfree_rcu(key, rcu); 229155ed8ca1SJohan Hedberg } 229255ed8ca1SJohan Hedberg } 229355ed8ca1SJohan Hedberg 229435f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2295b899efafSVinicius Costa Gomes { 2296970d0f1bSJohan Hedberg struct smp_ltk *k; 2297b899efafSVinicius Costa Gomes 2298970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2299970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2300970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2301b899efafSVinicius Costa Gomes } 2302b899efafSVinicius Costa Gomes } 2303b899efafSVinicius Costa Gomes 2304970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2305970c4e46SJohan Hedberg { 2306adae20cbSJohan Hedberg struct smp_irk *k; 2307970c4e46SJohan Hedberg 2308adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2309adae20cbSJohan Hedberg list_del_rcu(&k->list); 2310adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2311970c4e46SJohan Hedberg } 2312970c4e46SJohan Hedberg } 2313970c4e46SJohan Hedberg 231455ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 231555ed8ca1SJohan Hedberg { 231655ed8ca1SJohan Hedberg struct link_key *k; 231755ed8ca1SJohan Hedberg 23180378b597SJohan Hedberg rcu_read_lock(); 23190378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 23200378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 23210378b597SJohan Hedberg rcu_read_unlock(); 232255ed8ca1SJohan Hedberg return k; 23230378b597SJohan Hedberg } 23240378b597SJohan Hedberg } 23250378b597SJohan Hedberg rcu_read_unlock(); 232655ed8ca1SJohan Hedberg 232755ed8ca1SJohan Hedberg return NULL; 232855ed8ca1SJohan Hedberg } 232955ed8ca1SJohan Hedberg 2330745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2331d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2332d25e28abSJohan Hedberg { 2333d25e28abSJohan Hedberg /* Legacy key */ 2334d25e28abSJohan Hedberg if (key_type < 0x03) 2335745c0ce3SVishal Agarwal return true; 2336d25e28abSJohan Hedberg 2337d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2338d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2339745c0ce3SVishal Agarwal return false; 2340d25e28abSJohan Hedberg 2341d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2342d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2343745c0ce3SVishal Agarwal return false; 2344d25e28abSJohan Hedberg 2345d25e28abSJohan Hedberg /* Security mode 3 case */ 2346d25e28abSJohan Hedberg if (!conn) 2347745c0ce3SVishal Agarwal return true; 2348d25e28abSJohan Hedberg 2349e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2350e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2351e3befab9SJohan Hedberg return true; 2352e3befab9SJohan Hedberg 2353d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2354d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2355745c0ce3SVishal Agarwal return true; 2356d25e28abSJohan Hedberg 2357d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2358d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2359745c0ce3SVishal Agarwal return true; 2360d25e28abSJohan Hedberg 2361d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2362d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2363745c0ce3SVishal Agarwal return true; 2364d25e28abSJohan Hedberg 2365d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2366d25e28abSJohan Hedberg * persistently */ 2367745c0ce3SVishal Agarwal return false; 2368d25e28abSJohan Hedberg } 2369d25e28abSJohan Hedberg 2370e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 237198a0b845SJohan Hedberg { 2372e804d25dSJohan Hedberg if (type == SMP_LTK) 2373e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 237498a0b845SJohan Hedberg 2375e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 237698a0b845SJohan Hedberg } 237798a0b845SJohan Hedberg 2378f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2379e804d25dSJohan Hedberg u8 addr_type, u8 role) 238075d262c2SVinicius Costa Gomes { 2381c9839a11SVinicius Costa Gomes struct smp_ltk *k; 238275d262c2SVinicius Costa Gomes 2383970d0f1bSJohan Hedberg rcu_read_lock(); 2384970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 23855378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 23865378bc56SJohan Hedberg continue; 23875378bc56SJohan Hedberg 2388923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2389970d0f1bSJohan Hedberg rcu_read_unlock(); 239075d262c2SVinicius Costa Gomes return k; 2391970d0f1bSJohan Hedberg } 2392970d0f1bSJohan Hedberg } 2393970d0f1bSJohan Hedberg rcu_read_unlock(); 239475d262c2SVinicius Costa Gomes 239575d262c2SVinicius Costa Gomes return NULL; 239675d262c2SVinicius Costa Gomes } 239775d262c2SVinicius Costa Gomes 2398970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2399970c4e46SJohan Hedberg { 2400970c4e46SJohan Hedberg struct smp_irk *irk; 2401970c4e46SJohan Hedberg 2402adae20cbSJohan Hedberg rcu_read_lock(); 2403adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2404adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2405adae20cbSJohan Hedberg rcu_read_unlock(); 2406970c4e46SJohan Hedberg return irk; 2407970c4e46SJohan Hedberg } 2408adae20cbSJohan Hedberg } 2409970c4e46SJohan Hedberg 2410adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2411defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2412970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2413adae20cbSJohan Hedberg rcu_read_unlock(); 2414970c4e46SJohan Hedberg return irk; 2415970c4e46SJohan Hedberg } 2416970c4e46SJohan Hedberg } 2417adae20cbSJohan Hedberg rcu_read_unlock(); 2418970c4e46SJohan Hedberg 2419970c4e46SJohan Hedberg return NULL; 2420970c4e46SJohan Hedberg } 2421970c4e46SJohan Hedberg 2422970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2423970c4e46SJohan Hedberg u8 addr_type) 2424970c4e46SJohan Hedberg { 2425970c4e46SJohan Hedberg struct smp_irk *irk; 2426970c4e46SJohan Hedberg 24276cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 24286cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 24296cfc9988SJohan Hedberg return NULL; 24306cfc9988SJohan Hedberg 2431adae20cbSJohan Hedberg rcu_read_lock(); 2432adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2433970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2434adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2435adae20cbSJohan Hedberg rcu_read_unlock(); 2436970c4e46SJohan Hedberg return irk; 2437970c4e46SJohan Hedberg } 2438adae20cbSJohan Hedberg } 2439adae20cbSJohan Hedberg rcu_read_unlock(); 2440970c4e46SJohan Hedberg 2441970c4e46SJohan Hedberg return NULL; 2442970c4e46SJohan Hedberg } 2443970c4e46SJohan Hedberg 2444567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 24457652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 24467652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 244755ed8ca1SJohan Hedberg { 244855ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2449745c0ce3SVishal Agarwal u8 old_key_type; 245055ed8ca1SJohan Hedberg 245155ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 245255ed8ca1SJohan Hedberg if (old_key) { 245355ed8ca1SJohan Hedberg old_key_type = old_key->type; 245455ed8ca1SJohan Hedberg key = old_key; 245555ed8ca1SJohan Hedberg } else { 245612adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 24570a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 245855ed8ca1SJohan Hedberg if (!key) 2459567fa2aaSJohan Hedberg return NULL; 24600378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 246155ed8ca1SJohan Hedberg } 246255ed8ca1SJohan Hedberg 24636ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 246455ed8ca1SJohan Hedberg 2465d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2466d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2467d25e28abSJohan Hedberg * previous key */ 2468d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2469a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2470d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2471655fe6ecSJohan Hedberg if (conn) 2472655fe6ecSJohan Hedberg conn->key_type = type; 2473655fe6ecSJohan Hedberg } 2474d25e28abSJohan Hedberg 247555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 24769b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 247755ed8ca1SJohan Hedberg key->pin_len = pin_len; 247855ed8ca1SJohan Hedberg 2479b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 248055ed8ca1SJohan Hedberg key->type = old_key_type; 24814748fed2SJohan Hedberg else 24824748fed2SJohan Hedberg key->type = type; 24834748fed2SJohan Hedberg 24847652ff6aSJohan Hedberg if (persistent) 24857652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 24867652ff6aSJohan Hedberg old_key_type); 24874df378a1SJohan Hedberg 2488567fa2aaSJohan Hedberg return key; 248955ed8ca1SJohan Hedberg } 249055ed8ca1SJohan Hedberg 2491ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 249235d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2493fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 249475d262c2SVinicius Costa Gomes { 2495c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2496e804d25dSJohan Hedberg u8 role = ltk_role(type); 249775d262c2SVinicius Costa Gomes 2498f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2499c9839a11SVinicius Costa Gomes if (old_key) 250075d262c2SVinicius Costa Gomes key = old_key; 2501c9839a11SVinicius Costa Gomes else { 25020a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 250375d262c2SVinicius Costa Gomes if (!key) 2504ca9142b8SJohan Hedberg return NULL; 2505970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 250675d262c2SVinicius Costa Gomes } 250775d262c2SVinicius Costa Gomes 250875d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2509c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2510c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2511c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2512c9839a11SVinicius Costa Gomes key->ediv = ediv; 2513fe39c7b2SMarcel Holtmann key->rand = rand; 2514c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2515c9839a11SVinicius Costa Gomes key->type = type; 251675d262c2SVinicius Costa Gomes 2517ca9142b8SJohan Hedberg return key; 251875d262c2SVinicius Costa Gomes } 251975d262c2SVinicius Costa Gomes 2520ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2521ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2522970c4e46SJohan Hedberg { 2523970c4e46SJohan Hedberg struct smp_irk *irk; 2524970c4e46SJohan Hedberg 2525970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2526970c4e46SJohan Hedberg if (!irk) { 2527970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2528970c4e46SJohan Hedberg if (!irk) 2529ca9142b8SJohan Hedberg return NULL; 2530970c4e46SJohan Hedberg 2531970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2532970c4e46SJohan Hedberg irk->addr_type = addr_type; 2533970c4e46SJohan Hedberg 2534adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2535970c4e46SJohan Hedberg } 2536970c4e46SJohan Hedberg 2537970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2538970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2539970c4e46SJohan Hedberg 2540ca9142b8SJohan Hedberg return irk; 2541970c4e46SJohan Hedberg } 2542970c4e46SJohan Hedberg 254355ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 254455ed8ca1SJohan Hedberg { 254555ed8ca1SJohan Hedberg struct link_key *key; 254655ed8ca1SJohan Hedberg 254755ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 254855ed8ca1SJohan Hedberg if (!key) 254955ed8ca1SJohan Hedberg return -ENOENT; 255055ed8ca1SJohan Hedberg 25516ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 255255ed8ca1SJohan Hedberg 25530378b597SJohan Hedberg list_del_rcu(&key->list); 25540378b597SJohan Hedberg kfree_rcu(key, rcu); 255555ed8ca1SJohan Hedberg 255655ed8ca1SJohan Hedberg return 0; 255755ed8ca1SJohan Hedberg } 255855ed8ca1SJohan Hedberg 2559e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2560b899efafSVinicius Costa Gomes { 2561970d0f1bSJohan Hedberg struct smp_ltk *k; 2562c51ffa0bSJohan Hedberg int removed = 0; 2563b899efafSVinicius Costa Gomes 2564970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2565e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2566b899efafSVinicius Costa Gomes continue; 2567b899efafSVinicius Costa Gomes 25686ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2569b899efafSVinicius Costa Gomes 2570970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2571970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2572c51ffa0bSJohan Hedberg removed++; 2573b899efafSVinicius Costa Gomes } 2574b899efafSVinicius Costa Gomes 2575c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2576b899efafSVinicius Costa Gomes } 2577b899efafSVinicius Costa Gomes 2578a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2579a7ec7338SJohan Hedberg { 2580adae20cbSJohan Hedberg struct smp_irk *k; 2581a7ec7338SJohan Hedberg 2582adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2583a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2584a7ec7338SJohan Hedberg continue; 2585a7ec7338SJohan Hedberg 2586a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2587a7ec7338SJohan Hedberg 2588adae20cbSJohan Hedberg list_del_rcu(&k->list); 2589adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2590a7ec7338SJohan Hedberg } 2591a7ec7338SJohan Hedberg } 2592a7ec7338SJohan Hedberg 259355e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 259455e76b38SJohan Hedberg { 259555e76b38SJohan Hedberg struct smp_ltk *k; 25964ba9faf3SJohan Hedberg struct smp_irk *irk; 259755e76b38SJohan Hedberg u8 addr_type; 259855e76b38SJohan Hedberg 259955e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 260055e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 260155e76b38SJohan Hedberg return true; 260255e76b38SJohan Hedberg return false; 260355e76b38SJohan Hedberg } 260455e76b38SJohan Hedberg 260555e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 260655e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 260755e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 260855e76b38SJohan Hedberg else 260955e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 261055e76b38SJohan Hedberg 26114ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 26124ba9faf3SJohan Hedberg if (irk) { 26134ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 26144ba9faf3SJohan Hedberg addr_type = irk->addr_type; 26154ba9faf3SJohan Hedberg } 26164ba9faf3SJohan Hedberg 261755e76b38SJohan Hedberg rcu_read_lock(); 261855e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 261987c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 262087c8b28dSJohan Hedberg rcu_read_unlock(); 262155e76b38SJohan Hedberg return true; 262255e76b38SJohan Hedberg } 262387c8b28dSJohan Hedberg } 262455e76b38SJohan Hedberg rcu_read_unlock(); 262555e76b38SJohan Hedberg 262655e76b38SJohan Hedberg return false; 262755e76b38SJohan Hedberg } 262855e76b38SJohan Hedberg 26296bd32326SVille Tervo /* HCI command timer function */ 263065cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 26316bd32326SVille Tervo { 263265cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 263365cc2b49SMarcel Holtmann cmd_timer.work); 26346bd32326SVille Tervo 2635bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2636bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2637bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2638bda4f23aSAndrei Emeltchenko 26392064ee33SMarcel Holtmann bt_dev_err(hdev, "command 0x%4.4x tx timeout", opcode); 2640bda4f23aSAndrei Emeltchenko } else { 26412064ee33SMarcel Holtmann bt_dev_err(hdev, "command tx timeout"); 2642bda4f23aSAndrei Emeltchenko } 2643bda4f23aSAndrei Emeltchenko 2644e2bef384SRajat Jain if (hdev->cmd_timeout) 2645e2bef384SRajat Jain hdev->cmd_timeout(hdev); 2646e2bef384SRajat Jain 26476bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2648c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 26496bd32326SVille Tervo } 26506bd32326SVille Tervo 26512763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 26526928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 26532763eda6SSzymon Janc { 26542763eda6SSzymon Janc struct oob_data *data; 26552763eda6SSzymon Janc 26566928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 26576928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 26586928a924SJohan Hedberg continue; 26596928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 26606928a924SJohan Hedberg continue; 26612763eda6SSzymon Janc return data; 26626928a924SJohan Hedberg } 26632763eda6SSzymon Janc 26642763eda6SSzymon Janc return NULL; 26652763eda6SSzymon Janc } 26662763eda6SSzymon Janc 26676928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26686928a924SJohan Hedberg u8 bdaddr_type) 26692763eda6SSzymon Janc { 26702763eda6SSzymon Janc struct oob_data *data; 26712763eda6SSzymon Janc 26726928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26732763eda6SSzymon Janc if (!data) 26742763eda6SSzymon Janc return -ENOENT; 26752763eda6SSzymon Janc 26766928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 26772763eda6SSzymon Janc 26782763eda6SSzymon Janc list_del(&data->list); 26792763eda6SSzymon Janc kfree(data); 26802763eda6SSzymon Janc 26812763eda6SSzymon Janc return 0; 26822763eda6SSzymon Janc } 26832763eda6SSzymon Janc 268435f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 26852763eda6SSzymon Janc { 26862763eda6SSzymon Janc struct oob_data *data, *n; 26872763eda6SSzymon Janc 26882763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 26892763eda6SSzymon Janc list_del(&data->list); 26902763eda6SSzymon Janc kfree(data); 26912763eda6SSzymon Janc } 26922763eda6SSzymon Janc } 26932763eda6SSzymon Janc 26940798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26956928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 269638da1703SJohan Hedberg u8 *hash256, u8 *rand256) 26970798872eSMarcel Holtmann { 26980798872eSMarcel Holtmann struct oob_data *data; 26990798872eSMarcel Holtmann 27006928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 27010798872eSMarcel Holtmann if (!data) { 27020a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 27030798872eSMarcel Holtmann if (!data) 27040798872eSMarcel Holtmann return -ENOMEM; 27050798872eSMarcel Holtmann 27060798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 27076928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 27080798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 27090798872eSMarcel Holtmann } 27100798872eSMarcel Holtmann 271181328d5cSJohan Hedberg if (hash192 && rand192) { 27120798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 271338da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2714f7697b16SMarcel Holtmann if (hash256 && rand256) 2715f7697b16SMarcel Holtmann data->present = 0x03; 271681328d5cSJohan Hedberg } else { 271781328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 271881328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2719f7697b16SMarcel Holtmann if (hash256 && rand256) 2720f7697b16SMarcel Holtmann data->present = 0x02; 2721f7697b16SMarcel Holtmann else 2722f7697b16SMarcel Holtmann data->present = 0x00; 272381328d5cSJohan Hedberg } 27240798872eSMarcel Holtmann 272581328d5cSJohan Hedberg if (hash256 && rand256) { 27260798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 272738da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 272881328d5cSJohan Hedberg } else { 272981328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 273081328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2731f7697b16SMarcel Holtmann if (hash192 && rand192) 2732f7697b16SMarcel Holtmann data->present = 0x01; 273381328d5cSJohan Hedberg } 27340798872eSMarcel Holtmann 27356ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 27362763eda6SSzymon Janc 27372763eda6SSzymon Janc return 0; 27382763eda6SSzymon Janc } 27392763eda6SSzymon Janc 2740d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2741d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2742d2609b34SFlorian Grandel { 2743d2609b34SFlorian Grandel struct adv_info *adv_instance; 2744d2609b34SFlorian Grandel 2745d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2746d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2747d2609b34SFlorian Grandel return adv_instance; 2748d2609b34SFlorian Grandel } 2749d2609b34SFlorian Grandel 2750d2609b34SFlorian Grandel return NULL; 2751d2609b34SFlorian Grandel } 2752d2609b34SFlorian Grandel 2753d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 275474b93e9fSPrasanna Karthik struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) 275574b93e9fSPrasanna Karthik { 2756d2609b34SFlorian Grandel struct adv_info *cur_instance; 2757d2609b34SFlorian Grandel 2758d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2759d2609b34SFlorian Grandel if (!cur_instance) 2760d2609b34SFlorian Grandel return NULL; 2761d2609b34SFlorian Grandel 2762d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2763d2609b34SFlorian Grandel struct adv_info, list)) 2764d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2765d2609b34SFlorian Grandel struct adv_info, list); 2766d2609b34SFlorian Grandel else 2767d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2768d2609b34SFlorian Grandel } 2769d2609b34SFlorian Grandel 2770d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2771d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2772d2609b34SFlorian Grandel { 2773d2609b34SFlorian Grandel struct adv_info *adv_instance; 2774d2609b34SFlorian Grandel 2775d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2776d2609b34SFlorian Grandel if (!adv_instance) 2777d2609b34SFlorian Grandel return -ENOENT; 2778d2609b34SFlorian Grandel 2779d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2780d2609b34SFlorian Grandel 2781cab054abSJohan Hedberg if (hdev->cur_adv_instance == instance) { 2782cab054abSJohan Hedberg if (hdev->adv_instance_timeout) { 27835d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27845d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27855d900e46SFlorian Grandel } 2786cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2787cab054abSJohan Hedberg } 27885d900e46SFlorian Grandel 2789a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 2790a73c046aSJaganath Kanakkassery 2791d2609b34SFlorian Grandel list_del(&adv_instance->list); 2792d2609b34SFlorian Grandel kfree(adv_instance); 2793d2609b34SFlorian Grandel 2794d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2795d2609b34SFlorian Grandel 2796d2609b34SFlorian Grandel return 0; 2797d2609b34SFlorian Grandel } 2798d2609b34SFlorian Grandel 2799a73c046aSJaganath Kanakkassery void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired) 2800a73c046aSJaganath Kanakkassery { 2801a73c046aSJaganath Kanakkassery struct adv_info *adv_instance, *n; 2802a73c046aSJaganath Kanakkassery 2803a73c046aSJaganath Kanakkassery list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) 2804a73c046aSJaganath Kanakkassery adv_instance->rpa_expired = rpa_expired; 2805a73c046aSJaganath Kanakkassery } 2806a73c046aSJaganath Kanakkassery 2807d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2808d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2809d2609b34SFlorian Grandel { 2810d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2811d2609b34SFlorian Grandel 28125d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 28135d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 28145d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 28155d900e46SFlorian Grandel } 28165d900e46SFlorian Grandel 2817d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2818a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 2819d2609b34SFlorian Grandel list_del(&adv_instance->list); 2820d2609b34SFlorian Grandel kfree(adv_instance); 2821d2609b34SFlorian Grandel } 2822d2609b34SFlorian Grandel 2823d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2824cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2825d2609b34SFlorian Grandel } 2826d2609b34SFlorian Grandel 2827a73c046aSJaganath Kanakkassery static void adv_instance_rpa_expired(struct work_struct *work) 2828a73c046aSJaganath Kanakkassery { 2829a73c046aSJaganath Kanakkassery struct adv_info *adv_instance = container_of(work, struct adv_info, 2830a73c046aSJaganath Kanakkassery rpa_expired_cb.work); 2831a73c046aSJaganath Kanakkassery 2832a73c046aSJaganath Kanakkassery BT_DBG(""); 2833a73c046aSJaganath Kanakkassery 2834a73c046aSJaganath Kanakkassery adv_instance->rpa_expired = true; 2835a73c046aSJaganath Kanakkassery } 2836a73c046aSJaganath Kanakkassery 2837d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2838d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2839d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2840d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2841d2609b34SFlorian Grandel u16 timeout, u16 duration) 2842d2609b34SFlorian Grandel { 2843d2609b34SFlorian Grandel struct adv_info *adv_instance; 2844d2609b34SFlorian Grandel 2845d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2846d2609b34SFlorian Grandel if (adv_instance) { 2847d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2848d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2849d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2850d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2851d2609b34SFlorian Grandel } else { 28521d0fac2cSLuiz Augusto von Dentz if (hdev->adv_instance_cnt >= hdev->le_num_of_adv_sets || 2853d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2854d2609b34SFlorian Grandel return -EOVERFLOW; 2855d2609b34SFlorian Grandel 285639ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2857d2609b34SFlorian Grandel if (!adv_instance) 2858d2609b34SFlorian Grandel return -ENOMEM; 2859d2609b34SFlorian Grandel 2860fffd38bcSFlorian Grandel adv_instance->pending = true; 2861d2609b34SFlorian Grandel adv_instance->instance = instance; 2862d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2863d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2864d2609b34SFlorian Grandel } 2865d2609b34SFlorian Grandel 2866d2609b34SFlorian Grandel adv_instance->flags = flags; 2867d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2868d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2869d2609b34SFlorian Grandel 2870d2609b34SFlorian Grandel if (adv_data_len) 2871d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2872d2609b34SFlorian Grandel 2873d2609b34SFlorian Grandel if (scan_rsp_len) 2874d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2875d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2876d2609b34SFlorian Grandel 2877d2609b34SFlorian Grandel adv_instance->timeout = timeout; 28785d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2879d2609b34SFlorian Grandel 2880d2609b34SFlorian Grandel if (duration == 0) 2881d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2882d2609b34SFlorian Grandel else 2883d2609b34SFlorian Grandel adv_instance->duration = duration; 2884d2609b34SFlorian Grandel 2885de181e88SJaganath Kanakkassery adv_instance->tx_power = HCI_TX_POWER_INVALID; 2886de181e88SJaganath Kanakkassery 2887a73c046aSJaganath Kanakkassery INIT_DELAYED_WORK(&adv_instance->rpa_expired_cb, 2888a73c046aSJaganath Kanakkassery adv_instance_rpa_expired); 2889a73c046aSJaganath Kanakkassery 2890d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2891d2609b34SFlorian Grandel 2892d2609b34SFlorian Grandel return 0; 2893d2609b34SFlorian Grandel } 2894d2609b34SFlorian Grandel 2895dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2896b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2897b2a66aadSAntti Julku { 2898b2a66aadSAntti Julku struct bdaddr_list *b; 2899b2a66aadSAntti Julku 2900dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2901b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2902b2a66aadSAntti Julku return b; 2903b9ee0a78SMarcel Holtmann } 2904b2a66aadSAntti Julku 2905b2a66aadSAntti Julku return NULL; 2906b2a66aadSAntti Julku } 2907b2a66aadSAntti Julku 2908b950aa88SAnkit Navik struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk( 2909b950aa88SAnkit Navik struct list_head *bdaddr_list, bdaddr_t *bdaddr, 2910b950aa88SAnkit Navik u8 type) 2911b950aa88SAnkit Navik { 2912b950aa88SAnkit Navik struct bdaddr_list_with_irk *b; 2913b950aa88SAnkit Navik 2914b950aa88SAnkit Navik list_for_each_entry(b, bdaddr_list, list) { 2915b950aa88SAnkit Navik if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2916b950aa88SAnkit Navik return b; 2917b950aa88SAnkit Navik } 2918b950aa88SAnkit Navik 2919b950aa88SAnkit Navik return NULL; 2920b950aa88SAnkit Navik } 2921b950aa88SAnkit Navik 2922dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2923b2a66aadSAntti Julku { 29247eb7404fSGeliang Tang struct bdaddr_list *b, *n; 2925b2a66aadSAntti Julku 29267eb7404fSGeliang Tang list_for_each_entry_safe(b, n, bdaddr_list, list) { 29277eb7404fSGeliang Tang list_del(&b->list); 2928b2a66aadSAntti Julku kfree(b); 2929b2a66aadSAntti Julku } 2930b2a66aadSAntti Julku } 2931b2a66aadSAntti Julku 2932dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2933b2a66aadSAntti Julku { 2934b2a66aadSAntti Julku struct bdaddr_list *entry; 2935b2a66aadSAntti Julku 2936b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2937b2a66aadSAntti Julku return -EBADF; 2938b2a66aadSAntti Julku 2939dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 29405e762444SAntti Julku return -EEXIST; 2941b2a66aadSAntti Julku 294227f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 29435e762444SAntti Julku if (!entry) 29445e762444SAntti Julku return -ENOMEM; 2945b2a66aadSAntti Julku 2946b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2947b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2948b2a66aadSAntti Julku 2949dcc36c16SJohan Hedberg list_add(&entry->list, list); 2950b2a66aadSAntti Julku 29512a8357f2SJohan Hedberg return 0; 2952b2a66aadSAntti Julku } 2953b2a66aadSAntti Julku 2954b950aa88SAnkit Navik int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr, 2955b950aa88SAnkit Navik u8 type, u8 *peer_irk, u8 *local_irk) 2956b950aa88SAnkit Navik { 2957b950aa88SAnkit Navik struct bdaddr_list_with_irk *entry; 2958b950aa88SAnkit Navik 2959b950aa88SAnkit Navik if (!bacmp(bdaddr, BDADDR_ANY)) 2960b950aa88SAnkit Navik return -EBADF; 2961b950aa88SAnkit Navik 2962b950aa88SAnkit Navik if (hci_bdaddr_list_lookup(list, bdaddr, type)) 2963b950aa88SAnkit Navik return -EEXIST; 2964b950aa88SAnkit Navik 2965b950aa88SAnkit Navik entry = kzalloc(sizeof(*entry), GFP_KERNEL); 2966b950aa88SAnkit Navik if (!entry) 2967b950aa88SAnkit Navik return -ENOMEM; 2968b950aa88SAnkit Navik 2969b950aa88SAnkit Navik bacpy(&entry->bdaddr, bdaddr); 2970b950aa88SAnkit Navik entry->bdaddr_type = type; 2971b950aa88SAnkit Navik 2972b950aa88SAnkit Navik if (peer_irk) 2973b950aa88SAnkit Navik memcpy(entry->peer_irk, peer_irk, 16); 2974b950aa88SAnkit Navik 2975b950aa88SAnkit Navik if (local_irk) 2976b950aa88SAnkit Navik memcpy(entry->local_irk, local_irk, 16); 2977b950aa88SAnkit Navik 2978b950aa88SAnkit Navik list_add(&entry->list, list); 2979b950aa88SAnkit Navik 2980b950aa88SAnkit Navik return 0; 2981b950aa88SAnkit Navik } 2982b950aa88SAnkit Navik 2983dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2984b2a66aadSAntti Julku { 2985b2a66aadSAntti Julku struct bdaddr_list *entry; 2986b2a66aadSAntti Julku 298735f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2988dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 298935f7498aSJohan Hedberg return 0; 299035f7498aSJohan Hedberg } 2991b2a66aadSAntti Julku 2992dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2993d2ab0ac1SMarcel Holtmann if (!entry) 2994d2ab0ac1SMarcel Holtmann return -ENOENT; 2995d2ab0ac1SMarcel Holtmann 2996d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2997d2ab0ac1SMarcel Holtmann kfree(entry); 2998d2ab0ac1SMarcel Holtmann 2999d2ab0ac1SMarcel Holtmann return 0; 3000d2ab0ac1SMarcel Holtmann } 3001d2ab0ac1SMarcel Holtmann 3002b950aa88SAnkit Navik int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr, 3003b950aa88SAnkit Navik u8 type) 3004b950aa88SAnkit Navik { 3005b950aa88SAnkit Navik struct bdaddr_list_with_irk *entry; 3006b950aa88SAnkit Navik 3007b950aa88SAnkit Navik if (!bacmp(bdaddr, BDADDR_ANY)) { 3008b950aa88SAnkit Navik hci_bdaddr_list_clear(list); 3009b950aa88SAnkit Navik return 0; 3010b950aa88SAnkit Navik } 3011b950aa88SAnkit Navik 3012b950aa88SAnkit Navik entry = hci_bdaddr_list_lookup_with_irk(list, bdaddr, type); 3013b950aa88SAnkit Navik if (!entry) 3014b950aa88SAnkit Navik return -ENOENT; 3015b950aa88SAnkit Navik 3016b950aa88SAnkit Navik list_del(&entry->list); 3017b950aa88SAnkit Navik kfree(entry); 3018b950aa88SAnkit Navik 3019b950aa88SAnkit Navik return 0; 3020b950aa88SAnkit Navik } 3021b950aa88SAnkit Navik 302215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 302315819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 302415819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 302515819a70SAndre Guedes { 302615819a70SAndre Guedes struct hci_conn_params *params; 302715819a70SAndre Guedes 302815819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 302915819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 303015819a70SAndre Guedes params->addr_type == addr_type) { 303115819a70SAndre Guedes return params; 303215819a70SAndre Guedes } 303315819a70SAndre Guedes } 303415819a70SAndre Guedes 303515819a70SAndre Guedes return NULL; 303615819a70SAndre Guedes } 303715819a70SAndre Guedes 303815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3039501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 30404b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 304115819a70SAndre Guedes { 3042912b42efSJohan Hedberg struct hci_conn_params *param; 304315819a70SAndre Guedes 3044501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3045912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3046912b42efSJohan Hedberg param->addr_type == addr_type) 3047912b42efSJohan Hedberg return param; 30484b10966fSMarcel Holtmann } 30494b10966fSMarcel Holtmann 30504b10966fSMarcel Holtmann return NULL; 305115819a70SAndre Guedes } 305215819a70SAndre Guedes 305315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 305451d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 305551d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 305615819a70SAndre Guedes { 305715819a70SAndre Guedes struct hci_conn_params *params; 305815819a70SAndre Guedes 305915819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 3060cef952ceSAndre Guedes if (params) 306151d167c0SMarcel Holtmann return params; 306215819a70SAndre Guedes 306315819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 306415819a70SAndre Guedes if (!params) { 30652064ee33SMarcel Holtmann bt_dev_err(hdev, "out of memory"); 306651d167c0SMarcel Holtmann return NULL; 306715819a70SAndre Guedes } 306815819a70SAndre Guedes 306915819a70SAndre Guedes bacpy(¶ms->addr, addr); 307015819a70SAndre Guedes params->addr_type = addr_type; 3071cef952ceSAndre Guedes 3072cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 307393450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3074cef952ceSAndre Guedes 3075bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3076bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3077bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3078bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3079bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3080bf5b3c8bSMarcel Holtmann 3081bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3082bf5b3c8bSMarcel Holtmann 308351d167c0SMarcel Holtmann return params; 3084bf5b3c8bSMarcel Holtmann } 3085bf5b3c8bSMarcel Holtmann 3086f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 3087f6c63249SJohan Hedberg { 3088f6c63249SJohan Hedberg if (params->conn) { 3089f6c63249SJohan Hedberg hci_conn_drop(params->conn); 3090f6c63249SJohan Hedberg hci_conn_put(params->conn); 3091f6c63249SJohan Hedberg } 3092f6c63249SJohan Hedberg 3093f6c63249SJohan Hedberg list_del(¶ms->action); 3094f6c63249SJohan Hedberg list_del(¶ms->list); 3095f6c63249SJohan Hedberg kfree(params); 3096f6c63249SJohan Hedberg } 3097f6c63249SJohan Hedberg 309815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 309915819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 310015819a70SAndre Guedes { 310115819a70SAndre Guedes struct hci_conn_params *params; 310215819a70SAndre Guedes 310315819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 310415819a70SAndre Guedes if (!params) 310515819a70SAndre Guedes return; 310615819a70SAndre Guedes 3107f6c63249SJohan Hedberg hci_conn_params_free(params); 310815819a70SAndre Guedes 310995305baaSJohan Hedberg hci_update_background_scan(hdev); 311095305baaSJohan Hedberg 311115819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 311215819a70SAndre Guedes } 311315819a70SAndre Guedes 311415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 311555af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 311615819a70SAndre Guedes { 311715819a70SAndre Guedes struct hci_conn_params *params, *tmp; 311815819a70SAndre Guedes 311915819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 312055af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 312155af49a8SJohan Hedberg continue; 3122f75113a2SJakub Pawlowski 3123f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 3124f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 3125f75113a2SJakub Pawlowski */ 3126f75113a2SJakub Pawlowski if (params->explicit_connect) { 3127f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 3128f75113a2SJakub Pawlowski continue; 3129f75113a2SJakub Pawlowski } 3130f75113a2SJakub Pawlowski 313115819a70SAndre Guedes list_del(¶ms->list); 313215819a70SAndre Guedes kfree(params); 313315819a70SAndre Guedes } 313415819a70SAndre Guedes 313555af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 313655af49a8SJohan Hedberg } 313755af49a8SJohan Hedberg 313855af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3139030e7f81SJohan Hedberg static void hci_conn_params_clear_all(struct hci_dev *hdev) 314015819a70SAndre Guedes { 314115819a70SAndre Guedes struct hci_conn_params *params, *tmp; 314215819a70SAndre Guedes 3143f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3144f6c63249SJohan Hedberg hci_conn_params_free(params); 314515819a70SAndre Guedes 314615819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 314715819a70SAndre Guedes } 314815819a70SAndre Guedes 3149a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3150a1f4c318SJohan Hedberg * 3151a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3152a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3153a1f4c318SJohan Hedberg * the static random address. 3154a1f4c318SJohan Hedberg * 3155a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3156a1f4c318SJohan Hedberg * public address to use the static random address instead. 315750b5b952SMarcel Holtmann * 315850b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 315950b5b952SMarcel Holtmann * userspace has configured a static address, then that address 316050b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 3161a1f4c318SJohan Hedberg */ 3162a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3163a1f4c318SJohan Hedberg u8 *bdaddr_type) 3164a1f4c318SJohan Hedberg { 3165b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 316650b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 3167d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 316850b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 3169a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3170a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3171a1f4c318SJohan Hedberg } else { 3172a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3173a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3174a1f4c318SJohan Hedberg } 3175a1f4c318SJohan Hedberg } 3176a1f4c318SJohan Hedberg 31779be0dab7SDavid Herrmann /* Alloc HCI device */ 31789be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 31799be0dab7SDavid Herrmann { 31809be0dab7SDavid Herrmann struct hci_dev *hdev; 31819be0dab7SDavid Herrmann 318227f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 31839be0dab7SDavid Herrmann if (!hdev) 31849be0dab7SDavid Herrmann return NULL; 31859be0dab7SDavid Herrmann 3186b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3187b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3188b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3189b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3190b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 319196c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3192bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3193bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3194d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 3195d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 31965d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 3197b1b813d4SDavid Herrmann 3198b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3199b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3200b1b813d4SDavid Herrmann 32013f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3202628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3203628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3204bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3205bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 3206b48c3b59SJonas Holmberg hdev->le_conn_min_interval = 0x0018; 3207b48c3b59SJonas Holmberg hdev->le_conn_max_interval = 0x0028; 320804fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 320904fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3210a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3211a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3212a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3213a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3214a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3215a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 321630d65e08SMatias Karhumaa hdev->le_max_key_size = SMP_MAX_ENC_KEY_SIZE; 321730d65e08SMatias Karhumaa hdev->le_min_key_size = SMP_MIN_ENC_KEY_SIZE; 32186decb5b4SJaganath Kanakkassery hdev->le_tx_def_phys = HCI_LE_SET_PHY_1M; 32196decb5b4SJaganath Kanakkassery hdev->le_rx_def_phys = HCI_LE_SET_PHY_1M; 32201d0fac2cSLuiz Augusto von Dentz hdev->le_num_of_adv_sets = HCI_MAX_ADV_INSTANCES; 3221bef64738SMarcel Holtmann 3222d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3223b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 322431ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 322531ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3226302975cbSSpoorthi Ravishankar Koppad hdev->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT; 322758a96fc3SMarcel Holtmann hdev->min_enc_key_size = HCI_MIN_ENC_KEY_SIZE; 3228d6bfd59cSJohan Hedberg 3229b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3230b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3231b1b813d4SDavid Herrmann 3232b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3233b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 32346659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3235b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3236b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3237b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3238970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3239b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3240d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 3241cfdb0c2dSAnkit Navik INIT_LIST_HEAD(&hdev->le_resolv_list); 324215819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 324377a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 324466f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 32456b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3246d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3247b1b813d4SDavid Herrmann 3248b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3249b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3250b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3251b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3252c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3253b1b813d4SDavid Herrmann 3254b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3255b1b813d4SDavid Herrmann 3256b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3257b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3258b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3259b1b813d4SDavid Herrmann 3260b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3261b1b813d4SDavid Herrmann 326265cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3263b1b813d4SDavid Herrmann 32645fc16cc4SJohan Hedberg hci_request_setup(hdev); 32655fc16cc4SJohan Hedberg 3266b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3267b1b813d4SDavid Herrmann discovery_init(hdev); 32689be0dab7SDavid Herrmann 32699be0dab7SDavid Herrmann return hdev; 32709be0dab7SDavid Herrmann } 32719be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 32729be0dab7SDavid Herrmann 32739be0dab7SDavid Herrmann /* Free HCI device */ 32749be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 32759be0dab7SDavid Herrmann { 32769be0dab7SDavid Herrmann /* will free via device release */ 32779be0dab7SDavid Herrmann put_device(&hdev->dev); 32789be0dab7SDavid Herrmann } 32799be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 32809be0dab7SDavid Herrmann 32811da177e4SLinus Torvalds /* Register HCI device */ 32821da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 32831da177e4SLinus Torvalds { 3284b1b813d4SDavid Herrmann int id, error; 32851da177e4SLinus Torvalds 328674292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 32871da177e4SLinus Torvalds return -EINVAL; 32881da177e4SLinus Torvalds 328908add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 329008add513SMat Martineau * so the index can be used as the AMP controller ID. 329108add513SMat Martineau */ 32923df92b31SSasha Levin switch (hdev->dev_type) { 3293ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 32943df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 32951da177e4SLinus Torvalds break; 32963df92b31SSasha Levin case HCI_AMP: 32973df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 32983df92b31SSasha Levin break; 32993df92b31SSasha Levin default: 33003df92b31SSasha Levin return -EINVAL; 33011da177e4SLinus Torvalds } 33021da177e4SLinus Torvalds 33033df92b31SSasha Levin if (id < 0) 33043df92b31SSasha Levin return id; 33053df92b31SSasha Levin 33061da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 33071da177e4SLinus Torvalds hdev->id = id; 33082d8b3a11SAndrei Emeltchenko 33092d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 33102d8b3a11SAndrei Emeltchenko 331129e2dd0dSTejun Heo hdev->workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, hdev->name); 331233ca954dSDavid Herrmann if (!hdev->workqueue) { 331333ca954dSDavid Herrmann error = -ENOMEM; 331433ca954dSDavid Herrmann goto err; 331533ca954dSDavid Herrmann } 3316f48fd9c8SMarcel Holtmann 331729e2dd0dSTejun Heo hdev->req_workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, 331829e2dd0dSTejun Heo hdev->name); 33196ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 33206ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 33216ead1bbcSJohan Hedberg error = -ENOMEM; 33226ead1bbcSJohan Hedberg goto err; 33236ead1bbcSJohan Hedberg } 33246ead1bbcSJohan Hedberg 33250153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 33260153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 33270153e2ecSMarcel Holtmann 3328bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3329bdc3e0f1SMarcel Holtmann 3330bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 333133ca954dSDavid Herrmann if (error < 0) 333254506918SJohan Hedberg goto err_wqueue; 33331da177e4SLinus Torvalds 33346d5d2ee6SHeiner Kallweit hci_leds_init(hdev); 33356d5d2ee6SHeiner Kallweit 3336611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3337a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3338a8c5fb1aSGustavo Padovan hdev); 3339611b30f7SMarcel Holtmann if (hdev->rfkill) { 3340611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3341611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3342611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3343611b30f7SMarcel Holtmann } 3344611b30f7SMarcel Holtmann } 3345611b30f7SMarcel Holtmann 33465e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3347a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 33485e130367SJohan Hedberg 3349a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3350a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3351ce2be9acSAndrei Emeltchenko 3352ca8bee5dSMarcel Holtmann if (hdev->dev_type == HCI_PRIMARY) { 335356f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 335456f87901SJohan Hedberg * through reading supported features during init. 335556f87901SJohan Hedberg */ 3356a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 335756f87901SJohan Hedberg } 3358ce2be9acSAndrei Emeltchenko 3359fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3360fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3361fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3362fcee3377SGustavo Padovan 33634a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 33644a964404SMarcel Holtmann * and should not be included in normal operation. 3365fee746b0SMarcel Holtmann */ 3366fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3367a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3368fee746b0SMarcel Holtmann 336905fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3370dc946bd8SDavid Herrmann hci_dev_hold(hdev); 33711da177e4SLinus Torvalds 337219202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3373fbe96d6fSMarcel Holtmann 33741da177e4SLinus Torvalds return id; 3375f48fd9c8SMarcel Holtmann 337633ca954dSDavid Herrmann err_wqueue: 337733ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 33786ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 337933ca954dSDavid Herrmann err: 33803df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3381f48fd9c8SMarcel Holtmann 338233ca954dSDavid Herrmann return error; 33831da177e4SLinus Torvalds } 33841da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 33851da177e4SLinus Torvalds 33861da177e4SLinus Torvalds /* Unregister HCI device */ 338759735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 33881da177e4SLinus Torvalds { 33892d7cc19eSMarcel Holtmann int id; 3390ef222013SMarcel Holtmann 3391c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 33921da177e4SLinus Torvalds 3393a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 339494324962SJohan Hovold 33953df92b31SSasha Levin id = hdev->id; 33963df92b31SSasha Levin 3397f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 33981da177e4SLinus Torvalds list_del(&hdev->list); 3399f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 34001da177e4SLinus Torvalds 3401b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3402b9b5ef18SGustavo Padovan 3403bf389cabSJiri Slaby hci_dev_do_close(hdev); 3404bf389cabSJiri Slaby 3405ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3406d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3407d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 340809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3409744cf19eSJohan Hedberg mgmt_index_removed(hdev); 341009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 341156e5cb86SJohan Hedberg } 3412ab81cbf9SJohan Hedberg 34132e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 34142e58ef3eSJohan Hedberg * pending list */ 34152e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 34162e58ef3eSJohan Hedberg 341705fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 34181da177e4SLinus Torvalds 3419611b30f7SMarcel Holtmann if (hdev->rfkill) { 3420611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3421611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3422611b30f7SMarcel Holtmann } 3423611b30f7SMarcel Holtmann 3424bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3425147e2d59SDave Young 34260153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 34275177a838SMarcel Holtmann kfree_const(hdev->hw_info); 34285177a838SMarcel Holtmann kfree_const(hdev->fw_info); 34290153e2ecSMarcel Holtmann 3430f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 34316ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3432f48fd9c8SMarcel Holtmann 343309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3434dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 34356659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 34362aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 343755ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3438b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3439970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 34402763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3441d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3442dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3443cfdb0c2dSAnkit Navik hci_bdaddr_list_clear(&hdev->le_resolv_list); 3444373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 344522078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 344609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3447e2e0cacbSJohan Hedberg 3448dc946bd8SDavid Herrmann hci_dev_put(hdev); 34493df92b31SSasha Levin 34503df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 34511da177e4SLinus Torvalds } 34521da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 34531da177e4SLinus Torvalds 34541da177e4SLinus Torvalds /* Suspend HCI device */ 34551da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 34561da177e4SLinus Torvalds { 345705fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 34581da177e4SLinus Torvalds return 0; 34591da177e4SLinus Torvalds } 34601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 34611da177e4SLinus Torvalds 34621da177e4SLinus Torvalds /* Resume HCI device */ 34631da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 34641da177e4SLinus Torvalds { 346505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 34661da177e4SLinus Torvalds return 0; 34671da177e4SLinus Torvalds } 34681da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 34691da177e4SLinus Torvalds 347075e0569fSMarcel Holtmann /* Reset HCI device */ 347175e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 347275e0569fSMarcel Holtmann { 34731e4b6e91SColin Ian King static const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 347475e0569fSMarcel Holtmann struct sk_buff *skb; 347575e0569fSMarcel Holtmann 347675e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 347775e0569fSMarcel Holtmann if (!skb) 347875e0569fSMarcel Holtmann return -ENOMEM; 347975e0569fSMarcel Holtmann 3480d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 348159ae1d12SJohannes Berg skb_put_data(skb, hw_err, 3); 348275e0569fSMarcel Holtmann 348375e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 348475e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 348575e0569fSMarcel Holtmann } 348675e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 348775e0569fSMarcel Holtmann 348876bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3489e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 349076bca880SMarcel Holtmann { 349176bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 349276bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 349376bca880SMarcel Holtmann kfree_skb(skb); 349476bca880SMarcel Holtmann return -ENXIO; 349576bca880SMarcel Holtmann } 349676bca880SMarcel Holtmann 3497d79f34e3SMarcel Holtmann if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT && 3498d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT && 3499d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_SCODATA_PKT) { 3500fe806dceSMarcel Holtmann kfree_skb(skb); 3501fe806dceSMarcel Holtmann return -EINVAL; 3502fe806dceSMarcel Holtmann } 3503fe806dceSMarcel Holtmann 3504d82603c6SJorrit Schippers /* Incoming skb */ 350576bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 350676bca880SMarcel Holtmann 350776bca880SMarcel Holtmann /* Time stamp */ 350876bca880SMarcel Holtmann __net_timestamp(skb); 350976bca880SMarcel Holtmann 351076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3511b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3512c78ae283SMarcel Holtmann 351376bca880SMarcel Holtmann return 0; 351476bca880SMarcel Holtmann } 351576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 351676bca880SMarcel Holtmann 3517e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3518e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3519e875ff84SMarcel Holtmann { 3520581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3521d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_DIAG_PKT; 3522581d6fd6SMarcel Holtmann 3523e875ff84SMarcel Holtmann /* Time stamp */ 3524e875ff84SMarcel Holtmann __net_timestamp(skb); 3525e875ff84SMarcel Holtmann 3526581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3527581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3528e875ff84SMarcel Holtmann 3529e875ff84SMarcel Holtmann return 0; 3530e875ff84SMarcel Holtmann } 3531e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3532e875ff84SMarcel Holtmann 35335177a838SMarcel Holtmann void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...) 35345177a838SMarcel Holtmann { 35355177a838SMarcel Holtmann va_list vargs; 35365177a838SMarcel Holtmann 35375177a838SMarcel Holtmann va_start(vargs, fmt); 35385177a838SMarcel Holtmann kfree_const(hdev->hw_info); 35395177a838SMarcel Holtmann hdev->hw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 35405177a838SMarcel Holtmann va_end(vargs); 35415177a838SMarcel Holtmann } 35425177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_hw_info); 35435177a838SMarcel Holtmann 35445177a838SMarcel Holtmann void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...) 35455177a838SMarcel Holtmann { 35465177a838SMarcel Holtmann va_list vargs; 35475177a838SMarcel Holtmann 35485177a838SMarcel Holtmann va_start(vargs, fmt); 35495177a838SMarcel Holtmann kfree_const(hdev->fw_info); 35505177a838SMarcel Holtmann hdev->fw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 35515177a838SMarcel Holtmann va_end(vargs); 35525177a838SMarcel Holtmann } 35535177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_fw_info); 35545177a838SMarcel Holtmann 35551da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 35561da177e4SLinus Torvalds 35571da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 35581da177e4SLinus Torvalds { 35591da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35601da177e4SLinus Torvalds 3561fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 356200629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3563fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 35641da177e4SLinus Torvalds 35651da177e4SLinus Torvalds return 0; 35661da177e4SLinus Torvalds } 35671da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 35681da177e4SLinus Torvalds 35691da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 35701da177e4SLinus Torvalds { 35711da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35721da177e4SLinus Torvalds 3573fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 35741da177e4SLinus Torvalds list_del(&cb->list); 3575fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 35761da177e4SLinus Torvalds 35771da177e4SLinus Torvalds return 0; 35781da177e4SLinus Torvalds } 35791da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 35801da177e4SLinus Torvalds 358151086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 35821da177e4SLinus Torvalds { 3583cdc52faaSMarcel Holtmann int err; 3584cdc52faaSMarcel Holtmann 3585d79f34e3SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb), 3586d79f34e3SMarcel Holtmann skb->len); 35871da177e4SLinus Torvalds 35881da177e4SLinus Torvalds /* Time stamp */ 3589a61bbcf2SPatrick McHardy __net_timestamp(skb); 35901da177e4SLinus Torvalds 3591cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3592cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3593cd82e61cSMarcel Holtmann 3594cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3595cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3596470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 35971da177e4SLinus Torvalds } 35981da177e4SLinus Torvalds 35991da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 36001da177e4SLinus Torvalds skb_orphan(skb); 36011da177e4SLinus Torvalds 360273d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 360373d0d3c8SMarcel Holtmann kfree_skb(skb); 360473d0d3c8SMarcel Holtmann return; 360573d0d3c8SMarcel Holtmann } 360673d0d3c8SMarcel Holtmann 3607cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3608cdc52faaSMarcel Holtmann if (err < 0) { 36092064ee33SMarcel Holtmann bt_dev_err(hdev, "sending frame failed (%d)", err); 3610cdc52faaSMarcel Holtmann kfree_skb(skb); 3611cdc52faaSMarcel Holtmann } 36121da177e4SLinus Torvalds } 36131da177e4SLinus Torvalds 36141ca3a9d0SJohan Hedberg /* Send HCI command */ 361507dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 361607dc93ddSJohan Hedberg const void *param) 36171ca3a9d0SJohan Hedberg { 36181ca3a9d0SJohan Hedberg struct sk_buff *skb; 36191ca3a9d0SJohan Hedberg 36201ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 36211ca3a9d0SJohan Hedberg 36221ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 36231ca3a9d0SJohan Hedberg if (!skb) { 36242064ee33SMarcel Holtmann bt_dev_err(hdev, "no memory for command"); 36251ca3a9d0SJohan Hedberg return -ENOMEM; 36261ca3a9d0SJohan Hedberg } 36271ca3a9d0SJohan Hedberg 362849c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 362911714b3dSJohan Hedberg * single-command requests. 363011714b3dSJohan Hedberg */ 363144d27137SJohan Hedberg bt_cb(skb)->hci.req_flags |= HCI_REQ_START; 363211714b3dSJohan Hedberg 36331da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3634c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 36351da177e4SLinus Torvalds 36361da177e4SLinus Torvalds return 0; 36371da177e4SLinus Torvalds } 36381da177e4SLinus Torvalds 3639d6ee6ad7SLoic Poulain int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen, 3640d6ee6ad7SLoic Poulain const void *param) 3641d6ee6ad7SLoic Poulain { 3642d6ee6ad7SLoic Poulain struct sk_buff *skb; 3643d6ee6ad7SLoic Poulain 3644d6ee6ad7SLoic Poulain if (hci_opcode_ogf(opcode) != 0x3f) { 3645d6ee6ad7SLoic Poulain /* A controller receiving a command shall respond with either 3646d6ee6ad7SLoic Poulain * a Command Status Event or a Command Complete Event. 3647d6ee6ad7SLoic Poulain * Therefore, all standard HCI commands must be sent via the 3648d6ee6ad7SLoic Poulain * standard API, using hci_send_cmd or hci_cmd_sync helpers. 3649d6ee6ad7SLoic Poulain * Some vendors do not comply with this rule for vendor-specific 3650d6ee6ad7SLoic Poulain * commands and do not return any event. We want to support 3651d6ee6ad7SLoic Poulain * unresponded commands for such cases only. 3652d6ee6ad7SLoic Poulain */ 3653d6ee6ad7SLoic Poulain bt_dev_err(hdev, "unresponded command not supported"); 3654d6ee6ad7SLoic Poulain return -EINVAL; 3655d6ee6ad7SLoic Poulain } 3656d6ee6ad7SLoic Poulain 3657d6ee6ad7SLoic Poulain skb = hci_prepare_cmd(hdev, opcode, plen, param); 3658d6ee6ad7SLoic Poulain if (!skb) { 3659d6ee6ad7SLoic Poulain bt_dev_err(hdev, "no memory for command (opcode 0x%4.4x)", 3660d6ee6ad7SLoic Poulain opcode); 3661d6ee6ad7SLoic Poulain return -ENOMEM; 3662d6ee6ad7SLoic Poulain } 3663d6ee6ad7SLoic Poulain 3664d6ee6ad7SLoic Poulain hci_send_frame(hdev, skb); 3665d6ee6ad7SLoic Poulain 3666d6ee6ad7SLoic Poulain return 0; 3667d6ee6ad7SLoic Poulain } 3668d6ee6ad7SLoic Poulain EXPORT_SYMBOL(__hci_cmd_send); 3669d6ee6ad7SLoic Poulain 36701da177e4SLinus Torvalds /* Get data from the previously sent command */ 3671a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 36721da177e4SLinus Torvalds { 36731da177e4SLinus Torvalds struct hci_command_hdr *hdr; 36741da177e4SLinus Torvalds 36751da177e4SLinus Torvalds if (!hdev->sent_cmd) 36761da177e4SLinus Torvalds return NULL; 36771da177e4SLinus Torvalds 36781da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 36791da177e4SLinus Torvalds 3680a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 36811da177e4SLinus Torvalds return NULL; 36821da177e4SLinus Torvalds 3683f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 36841da177e4SLinus Torvalds 36851da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 36861da177e4SLinus Torvalds } 36871da177e4SLinus Torvalds 3688fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3689fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3690fbef168fSLoic Poulain const void *param, u32 timeout) 3691fbef168fSLoic Poulain { 3692fbef168fSLoic Poulain struct sk_buff *skb; 3693fbef168fSLoic Poulain 3694fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3695fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3696fbef168fSLoic Poulain 3697fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3698fbef168fSLoic Poulain 3699b504430cSJohan Hedberg hci_req_sync_lock(hdev); 3700fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3701b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 3702fbef168fSLoic Poulain 3703fbef168fSLoic Poulain return skb; 3704fbef168fSLoic Poulain } 3705fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3706fbef168fSLoic Poulain 37071da177e4SLinus Torvalds /* Send ACL data */ 37081da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 37091da177e4SLinus Torvalds { 37101da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 37111da177e4SLinus Torvalds int len = skb->len; 37121da177e4SLinus Torvalds 3713badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3714badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 37159c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3716aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3717aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 37181da177e4SLinus Torvalds } 37191da177e4SLinus Torvalds 3720ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 372173d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 37221da177e4SLinus Torvalds { 3723ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 37241da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37251da177e4SLinus Torvalds struct sk_buff *list; 37261da177e4SLinus Torvalds 3727087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3728087bfd99SGustavo Padovan skb->data_len = 0; 3729087bfd99SGustavo Padovan 3730d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3731204a6e54SAndrei Emeltchenko 3732204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3733ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 3734087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3735204a6e54SAndrei Emeltchenko break; 3736204a6e54SAndrei Emeltchenko case HCI_AMP: 3737204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3738204a6e54SAndrei Emeltchenko break; 3739204a6e54SAndrei Emeltchenko default: 37402064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown dev_type %d", hdev->dev_type); 3741204a6e54SAndrei Emeltchenko return; 3742204a6e54SAndrei Emeltchenko } 3743087bfd99SGustavo Padovan 374470f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 374570f23020SAndrei Emeltchenko if (!list) { 37461da177e4SLinus Torvalds /* Non fragmented */ 37471da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 37481da177e4SLinus Torvalds 374973d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 37501da177e4SLinus Torvalds } else { 37511da177e4SLinus Torvalds /* Fragmented */ 37521da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37531da177e4SLinus Torvalds 37541da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 37551da177e4SLinus Torvalds 37569cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 37579cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 37589cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 37599cfd5a23SJukka Rissanen * deadlocks. 37609cfd5a23SJukka Rissanen */ 37619cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 37621da177e4SLinus Torvalds 376373d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3764e702112fSAndrei Emeltchenko 3765e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3766e702112fSAndrei Emeltchenko flags |= ACL_CONT; 37671da177e4SLinus Torvalds do { 37681da177e4SLinus Torvalds skb = list; list = list->next; 37691da177e4SLinus Torvalds 3770d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3771e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 37721da177e4SLinus Torvalds 37731da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37741da177e4SLinus Torvalds 377573d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 37761da177e4SLinus Torvalds } while (list); 37771da177e4SLinus Torvalds 37789cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 37791da177e4SLinus Torvalds } 378073d80debSLuiz Augusto von Dentz } 378173d80debSLuiz Augusto von Dentz 378273d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 378373d80debSLuiz Augusto von Dentz { 3784ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 378573d80debSLuiz Augusto von Dentz 3786f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 378773d80debSLuiz Augusto von Dentz 3788ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 37891da177e4SLinus Torvalds 37903eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 37911da177e4SLinus Torvalds } 37921da177e4SLinus Torvalds 37931da177e4SLinus Torvalds /* Send SCO data */ 37940d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 37951da177e4SLinus Torvalds { 37961da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37971da177e4SLinus Torvalds struct hci_sco_hdr hdr; 37981da177e4SLinus Torvalds 37991da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 38001da177e4SLinus Torvalds 3801aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 38021da177e4SLinus Torvalds hdr.dlen = skb->len; 38031da177e4SLinus Torvalds 3804badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3805badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 38069c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 38071da177e4SLinus Torvalds 3808d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 3809c78ae283SMarcel Holtmann 38101da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 38113eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 38121da177e4SLinus Torvalds } 38131da177e4SLinus Torvalds 38141da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 38151da177e4SLinus Torvalds 38161da177e4SLinus Torvalds /* HCI Connection scheduler */ 38176039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3818a8c5fb1aSGustavo Padovan int *quote) 38191da177e4SLinus Torvalds { 38201da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38218035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3822abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 38231da177e4SLinus Torvalds 38241da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 38251da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3826bf4c6325SGustavo F. Padovan 3827bf4c6325SGustavo F. Padovan rcu_read_lock(); 3828bf4c6325SGustavo F. Padovan 3829bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3830769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 38311da177e4SLinus Torvalds continue; 3832769be974SMarcel Holtmann 3833769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3834769be974SMarcel Holtmann continue; 3835769be974SMarcel Holtmann 38361da177e4SLinus Torvalds num++; 38371da177e4SLinus Torvalds 38381da177e4SLinus Torvalds if (c->sent < min) { 38391da177e4SLinus Torvalds min = c->sent; 38401da177e4SLinus Torvalds conn = c; 38411da177e4SLinus Torvalds } 384252087a79SLuiz Augusto von Dentz 384352087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 384452087a79SLuiz Augusto von Dentz break; 38451da177e4SLinus Torvalds } 38461da177e4SLinus Torvalds 3847bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3848bf4c6325SGustavo F. Padovan 38491da177e4SLinus Torvalds if (conn) { 38506ed58ec5SVille Tervo int cnt, q; 38516ed58ec5SVille Tervo 38526ed58ec5SVille Tervo switch (conn->type) { 38536ed58ec5SVille Tervo case ACL_LINK: 38546ed58ec5SVille Tervo cnt = hdev->acl_cnt; 38556ed58ec5SVille Tervo break; 38566ed58ec5SVille Tervo case SCO_LINK: 38576ed58ec5SVille Tervo case ESCO_LINK: 38586ed58ec5SVille Tervo cnt = hdev->sco_cnt; 38596ed58ec5SVille Tervo break; 38606ed58ec5SVille Tervo case LE_LINK: 38616ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 38626ed58ec5SVille Tervo break; 38636ed58ec5SVille Tervo default: 38646ed58ec5SVille Tervo cnt = 0; 38652064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", conn->type); 38666ed58ec5SVille Tervo } 38676ed58ec5SVille Tervo 38686ed58ec5SVille Tervo q = cnt / num; 38691da177e4SLinus Torvalds *quote = q ? q : 1; 38701da177e4SLinus Torvalds } else 38711da177e4SLinus Torvalds *quote = 0; 38721da177e4SLinus Torvalds 38731da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 38741da177e4SLinus Torvalds return conn; 38751da177e4SLinus Torvalds } 38761da177e4SLinus Torvalds 38776039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 38781da177e4SLinus Torvalds { 38791da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38801da177e4SLinus Torvalds struct hci_conn *c; 38811da177e4SLinus Torvalds 38822064ee33SMarcel Holtmann bt_dev_err(hdev, "link tx timeout"); 38831da177e4SLinus Torvalds 3884bf4c6325SGustavo F. Padovan rcu_read_lock(); 3885bf4c6325SGustavo F. Padovan 38861da177e4SLinus Torvalds /* Kill stalled connections */ 3887bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3888bae1f5d9SVille Tervo if (c->type == type && c->sent) { 38892064ee33SMarcel Holtmann bt_dev_err(hdev, "killing stalled connection %pMR", 38902064ee33SMarcel Holtmann &c->dst); 3891bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 38921da177e4SLinus Torvalds } 38931da177e4SLinus Torvalds } 3894bf4c6325SGustavo F. Padovan 3895bf4c6325SGustavo F. Padovan rcu_read_unlock(); 38961da177e4SLinus Torvalds } 38971da177e4SLinus Torvalds 38986039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 389973d80debSLuiz Augusto von Dentz int *quote) 390073d80debSLuiz Augusto von Dentz { 390173d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 390273d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3903abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 390473d80debSLuiz Augusto von Dentz struct hci_conn *conn; 390573d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 390673d80debSLuiz Augusto von Dentz 390773d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 390873d80debSLuiz Augusto von Dentz 3909bf4c6325SGustavo F. Padovan rcu_read_lock(); 3910bf4c6325SGustavo F. Padovan 3911bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 391273d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 391373d80debSLuiz Augusto von Dentz 391473d80debSLuiz Augusto von Dentz if (conn->type != type) 391573d80debSLuiz Augusto von Dentz continue; 391673d80debSLuiz Augusto von Dentz 391773d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 391873d80debSLuiz Augusto von Dentz continue; 391973d80debSLuiz Augusto von Dentz 392073d80debSLuiz Augusto von Dentz conn_num++; 392173d80debSLuiz Augusto von Dentz 39228192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 392373d80debSLuiz Augusto von Dentz struct sk_buff *skb; 392473d80debSLuiz Augusto von Dentz 392573d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 392673d80debSLuiz Augusto von Dentz continue; 392773d80debSLuiz Augusto von Dentz 392873d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 392973d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 393073d80debSLuiz Augusto von Dentz continue; 393173d80debSLuiz Augusto von Dentz 393273d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 393373d80debSLuiz Augusto von Dentz num = 0; 393473d80debSLuiz Augusto von Dentz min = ~0; 393573d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 393673d80debSLuiz Augusto von Dentz } 393773d80debSLuiz Augusto von Dentz 393873d80debSLuiz Augusto von Dentz num++; 393973d80debSLuiz Augusto von Dentz 394073d80debSLuiz Augusto von Dentz if (conn->sent < min) { 394173d80debSLuiz Augusto von Dentz min = conn->sent; 394273d80debSLuiz Augusto von Dentz chan = tmp; 394373d80debSLuiz Augusto von Dentz } 394473d80debSLuiz Augusto von Dentz } 394573d80debSLuiz Augusto von Dentz 394673d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 394773d80debSLuiz Augusto von Dentz break; 394873d80debSLuiz Augusto von Dentz } 394973d80debSLuiz Augusto von Dentz 3950bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3951bf4c6325SGustavo F. Padovan 395273d80debSLuiz Augusto von Dentz if (!chan) 395373d80debSLuiz Augusto von Dentz return NULL; 395473d80debSLuiz Augusto von Dentz 395573d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 395673d80debSLuiz Augusto von Dentz case ACL_LINK: 395773d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 395873d80debSLuiz Augusto von Dentz break; 3959bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3960bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3961bd1eb66bSAndrei Emeltchenko break; 396273d80debSLuiz Augusto von Dentz case SCO_LINK: 396373d80debSLuiz Augusto von Dentz case ESCO_LINK: 396473d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 396573d80debSLuiz Augusto von Dentz break; 396673d80debSLuiz Augusto von Dentz case LE_LINK: 396773d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 396873d80debSLuiz Augusto von Dentz break; 396973d80debSLuiz Augusto von Dentz default: 397073d80debSLuiz Augusto von Dentz cnt = 0; 39712064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", chan->conn->type); 397273d80debSLuiz Augusto von Dentz } 397373d80debSLuiz Augusto von Dentz 397473d80debSLuiz Augusto von Dentz q = cnt / num; 397573d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 397673d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 397773d80debSLuiz Augusto von Dentz return chan; 397873d80debSLuiz Augusto von Dentz } 397973d80debSLuiz Augusto von Dentz 398002b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 398102b20f0bSLuiz Augusto von Dentz { 398202b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 398302b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 398402b20f0bSLuiz Augusto von Dentz int num = 0; 398502b20f0bSLuiz Augusto von Dentz 398602b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 398702b20f0bSLuiz Augusto von Dentz 3988bf4c6325SGustavo F. Padovan rcu_read_lock(); 3989bf4c6325SGustavo F. Padovan 3990bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 399102b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 399202b20f0bSLuiz Augusto von Dentz 399302b20f0bSLuiz Augusto von Dentz if (conn->type != type) 399402b20f0bSLuiz Augusto von Dentz continue; 399502b20f0bSLuiz Augusto von Dentz 399602b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 399702b20f0bSLuiz Augusto von Dentz continue; 399802b20f0bSLuiz Augusto von Dentz 399902b20f0bSLuiz Augusto von Dentz num++; 400002b20f0bSLuiz Augusto von Dentz 40018192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 400202b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 400302b20f0bSLuiz Augusto von Dentz 400402b20f0bSLuiz Augusto von Dentz if (chan->sent) { 400502b20f0bSLuiz Augusto von Dentz chan->sent = 0; 400602b20f0bSLuiz Augusto von Dentz continue; 400702b20f0bSLuiz Augusto von Dentz } 400802b20f0bSLuiz Augusto von Dentz 400902b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 401002b20f0bSLuiz Augusto von Dentz continue; 401102b20f0bSLuiz Augusto von Dentz 401202b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 401302b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 401402b20f0bSLuiz Augusto von Dentz continue; 401502b20f0bSLuiz Augusto von Dentz 401602b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 401702b20f0bSLuiz Augusto von Dentz 401802b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 401902b20f0bSLuiz Augusto von Dentz skb->priority); 402002b20f0bSLuiz Augusto von Dentz } 402102b20f0bSLuiz Augusto von Dentz 402202b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 402302b20f0bSLuiz Augusto von Dentz break; 402402b20f0bSLuiz Augusto von Dentz } 4025bf4c6325SGustavo F. Padovan 4026bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4027bf4c6325SGustavo F. Padovan 402802b20f0bSLuiz Augusto von Dentz } 402902b20f0bSLuiz Augusto von Dentz 4030b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4031b71d385aSAndrei Emeltchenko { 4032b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4033b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4034b71d385aSAndrei Emeltchenko } 4035b71d385aSAndrei Emeltchenko 40366039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 40371da177e4SLinus Torvalds { 4038d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 40391da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 40401da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 404163d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 40425f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4043bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 40441da177e4SLinus Torvalds } 404563d2bc1bSAndrei Emeltchenko } 40461da177e4SLinus Torvalds 40476039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 404863d2bc1bSAndrei Emeltchenko { 404963d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 405063d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 405163d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 405263d2bc1bSAndrei Emeltchenko int quote; 405363d2bc1bSAndrei Emeltchenko 405463d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 405504837f64SMarcel Holtmann 405673d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 405773d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4058ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4059ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 406073d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 406173d80debSLuiz Augusto von Dentz skb->len, skb->priority); 406273d80debSLuiz Augusto von Dentz 4063ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4064ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4065ec1cce24SLuiz Augusto von Dentz break; 4066ec1cce24SLuiz Augusto von Dentz 4067ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4068ec1cce24SLuiz Augusto von Dentz 406973d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 407073d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 407104837f64SMarcel Holtmann 407257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40731da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 40741da177e4SLinus Torvalds 40751da177e4SLinus Torvalds hdev->acl_cnt--; 407673d80debSLuiz Augusto von Dentz chan->sent++; 407773d80debSLuiz Augusto von Dentz chan->conn->sent++; 40781da177e4SLinus Torvalds } 40791da177e4SLinus Torvalds } 408002b20f0bSLuiz Augusto von Dentz 408102b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 408202b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 40831da177e4SLinus Torvalds } 40841da177e4SLinus Torvalds 40856039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4086b71d385aSAndrei Emeltchenko { 408763d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4088b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4089b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4090b71d385aSAndrei Emeltchenko int quote; 4091bd1eb66bSAndrei Emeltchenko u8 type; 4092b71d385aSAndrei Emeltchenko 409363d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4094b71d385aSAndrei Emeltchenko 4095bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4096bd1eb66bSAndrei Emeltchenko 4097bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4098bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4099bd1eb66bSAndrei Emeltchenko else 4100bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4101bd1eb66bSAndrei Emeltchenko 4102b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4103bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4104b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4105b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4106b71d385aSAndrei Emeltchenko int blocks; 4107b71d385aSAndrei Emeltchenko 4108b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4109b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4110b71d385aSAndrei Emeltchenko 4111b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4112b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4113b71d385aSAndrei Emeltchenko break; 4114b71d385aSAndrei Emeltchenko 4115b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4116b71d385aSAndrei Emeltchenko 4117b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4118b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4119b71d385aSAndrei Emeltchenko return; 4120b71d385aSAndrei Emeltchenko 4121b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4122b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4123b71d385aSAndrei Emeltchenko 412457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4125b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4126b71d385aSAndrei Emeltchenko 4127b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4128b71d385aSAndrei Emeltchenko quote -= blocks; 4129b71d385aSAndrei Emeltchenko 4130b71d385aSAndrei Emeltchenko chan->sent += blocks; 4131b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4132b71d385aSAndrei Emeltchenko } 4133b71d385aSAndrei Emeltchenko } 4134b71d385aSAndrei Emeltchenko 4135b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4136bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4137b71d385aSAndrei Emeltchenko } 4138b71d385aSAndrei Emeltchenko 41396039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4140b71d385aSAndrei Emeltchenko { 4141b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4142b71d385aSAndrei Emeltchenko 4143bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4144ca8bee5dSMarcel Holtmann if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_PRIMARY) 4145bd1eb66bSAndrei Emeltchenko return; 4146bd1eb66bSAndrei Emeltchenko 4147bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4148bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4149b71d385aSAndrei Emeltchenko return; 4150b71d385aSAndrei Emeltchenko 4151b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4152b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4153b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4154b71d385aSAndrei Emeltchenko break; 4155b71d385aSAndrei Emeltchenko 4156b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4157b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4158b71d385aSAndrei Emeltchenko break; 4159b71d385aSAndrei Emeltchenko } 4160b71d385aSAndrei Emeltchenko } 4161b71d385aSAndrei Emeltchenko 41621da177e4SLinus Torvalds /* Schedule SCO */ 41636039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 41641da177e4SLinus Torvalds { 41651da177e4SLinus Torvalds struct hci_conn *conn; 41661da177e4SLinus Torvalds struct sk_buff *skb; 41671da177e4SLinus Torvalds int quote; 41681da177e4SLinus Torvalds 41691da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 41701da177e4SLinus Torvalds 417152087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 417252087a79SLuiz Augusto von Dentz return; 417352087a79SLuiz Augusto von Dentz 41741da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 41751da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 41761da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 417757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41781da177e4SLinus Torvalds 41791da177e4SLinus Torvalds conn->sent++; 41801da177e4SLinus Torvalds if (conn->sent == ~0) 41811da177e4SLinus Torvalds conn->sent = 0; 41821da177e4SLinus Torvalds } 41831da177e4SLinus Torvalds } 41841da177e4SLinus Torvalds } 41851da177e4SLinus Torvalds 41866039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4187b6a0dc82SMarcel Holtmann { 4188b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4189b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4190b6a0dc82SMarcel Holtmann int quote; 4191b6a0dc82SMarcel Holtmann 4192b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4193b6a0dc82SMarcel Holtmann 419452087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 419552087a79SLuiz Augusto von Dentz return; 419652087a79SLuiz Augusto von Dentz 41978fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 41988fc9ced3SGustavo Padovan "e))) { 4199b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4200b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 420157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4202b6a0dc82SMarcel Holtmann 4203b6a0dc82SMarcel Holtmann conn->sent++; 4204b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4205b6a0dc82SMarcel Holtmann conn->sent = 0; 4206b6a0dc82SMarcel Holtmann } 4207b6a0dc82SMarcel Holtmann } 4208b6a0dc82SMarcel Holtmann } 4209b6a0dc82SMarcel Holtmann 42106039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 42116ed58ec5SVille Tervo { 421273d80debSLuiz Augusto von Dentz struct hci_chan *chan; 42136ed58ec5SVille Tervo struct sk_buff *skb; 421402b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 42156ed58ec5SVille Tervo 42166ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 42176ed58ec5SVille Tervo 421852087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 421952087a79SLuiz Augusto von Dentz return; 422052087a79SLuiz Augusto von Dentz 4221d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 42226ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 42236ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4224bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 42256ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4226bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 42276ed58ec5SVille Tervo } 42286ed58ec5SVille Tervo 42296ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 423002b20f0bSLuiz Augusto von Dentz tmp = cnt; 423173d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4232ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4233ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 423473d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 423573d80debSLuiz Augusto von Dentz skb->len, skb->priority); 42366ed58ec5SVille Tervo 4237ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4238ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4239ec1cce24SLuiz Augusto von Dentz break; 4240ec1cce24SLuiz Augusto von Dentz 4241ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4242ec1cce24SLuiz Augusto von Dentz 424357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42446ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 42456ed58ec5SVille Tervo 42466ed58ec5SVille Tervo cnt--; 424773d80debSLuiz Augusto von Dentz chan->sent++; 424873d80debSLuiz Augusto von Dentz chan->conn->sent++; 42496ed58ec5SVille Tervo } 42506ed58ec5SVille Tervo } 425173d80debSLuiz Augusto von Dentz 42526ed58ec5SVille Tervo if (hdev->le_pkts) 42536ed58ec5SVille Tervo hdev->le_cnt = cnt; 42546ed58ec5SVille Tervo else 42556ed58ec5SVille Tervo hdev->acl_cnt = cnt; 425602b20f0bSLuiz Augusto von Dentz 425702b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 425802b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 42596ed58ec5SVille Tervo } 42606ed58ec5SVille Tervo 42613eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 42621da177e4SLinus Torvalds { 42633eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 42641da177e4SLinus Torvalds struct sk_buff *skb; 42651da177e4SLinus Torvalds 42666ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 42676ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 42681da177e4SLinus Torvalds 4269d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 42701da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 42711da177e4SLinus Torvalds hci_sched_acl(hdev); 42721da177e4SLinus Torvalds hci_sched_sco(hdev); 4273b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 42746ed58ec5SVille Tervo hci_sched_le(hdev); 427552de599eSMarcel Holtmann } 42766ed58ec5SVille Tervo 42771da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 42781da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 427957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42801da177e4SLinus Torvalds } 42811da177e4SLinus Torvalds 428225985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 42831da177e4SLinus Torvalds 42841da177e4SLinus Torvalds /* ACL data packet */ 42856039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 42861da177e4SLinus Torvalds { 42871da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 42881da177e4SLinus Torvalds struct hci_conn *conn; 42891da177e4SLinus Torvalds __u16 handle, flags; 42901da177e4SLinus Torvalds 42911da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 42921da177e4SLinus Torvalds 42931da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 42941da177e4SLinus Torvalds flags = hci_flags(handle); 42951da177e4SLinus Torvalds handle = hci_handle(handle); 42961da177e4SLinus Torvalds 4297f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4298a8c5fb1aSGustavo Padovan handle, flags); 42991da177e4SLinus Torvalds 43001da177e4SLinus Torvalds hdev->stat.acl_rx++; 43011da177e4SLinus Torvalds 43021da177e4SLinus Torvalds hci_dev_lock(hdev); 43031da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 43041da177e4SLinus Torvalds hci_dev_unlock(hdev); 43051da177e4SLinus Torvalds 43061da177e4SLinus Torvalds if (conn) { 430765983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 430804837f64SMarcel Holtmann 43091da177e4SLinus Torvalds /* Send to upper protocol */ 4310686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 43111da177e4SLinus Torvalds return; 43121da177e4SLinus Torvalds } else { 43132064ee33SMarcel Holtmann bt_dev_err(hdev, "ACL packet for unknown connection handle %d", 43142064ee33SMarcel Holtmann handle); 43151da177e4SLinus Torvalds } 43161da177e4SLinus Torvalds 43171da177e4SLinus Torvalds kfree_skb(skb); 43181da177e4SLinus Torvalds } 43191da177e4SLinus Torvalds 43201da177e4SLinus Torvalds /* SCO data packet */ 43216039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 43221da177e4SLinus Torvalds { 43231da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 43241da177e4SLinus Torvalds struct hci_conn *conn; 43251da177e4SLinus Torvalds __u16 handle; 43261da177e4SLinus Torvalds 43271da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 43281da177e4SLinus Torvalds 43291da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 43301da177e4SLinus Torvalds 4331f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 43321da177e4SLinus Torvalds 43331da177e4SLinus Torvalds hdev->stat.sco_rx++; 43341da177e4SLinus Torvalds 43351da177e4SLinus Torvalds hci_dev_lock(hdev); 43361da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 43371da177e4SLinus Torvalds hci_dev_unlock(hdev); 43381da177e4SLinus Torvalds 43391da177e4SLinus Torvalds if (conn) { 43401da177e4SLinus Torvalds /* Send to upper protocol */ 4341686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 43421da177e4SLinus Torvalds return; 43431da177e4SLinus Torvalds } else { 43442064ee33SMarcel Holtmann bt_dev_err(hdev, "SCO packet for unknown connection handle %d", 43452064ee33SMarcel Holtmann handle); 43461da177e4SLinus Torvalds } 43471da177e4SLinus Torvalds 43481da177e4SLinus Torvalds kfree_skb(skb); 43491da177e4SLinus Torvalds } 43501da177e4SLinus Torvalds 43519238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 43529238f36aSJohan Hedberg { 43539238f36aSJohan Hedberg struct sk_buff *skb; 43549238f36aSJohan Hedberg 43559238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 43569238f36aSJohan Hedberg if (!skb) 43579238f36aSJohan Hedberg return true; 43589238f36aSJohan Hedberg 435944d27137SJohan Hedberg return (bt_cb(skb)->hci.req_flags & HCI_REQ_START); 43609238f36aSJohan Hedberg } 43619238f36aSJohan Hedberg 436242c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 436342c6b129SJohan Hedberg { 436442c6b129SJohan Hedberg struct hci_command_hdr *sent; 436542c6b129SJohan Hedberg struct sk_buff *skb; 436642c6b129SJohan Hedberg u16 opcode; 436742c6b129SJohan Hedberg 436842c6b129SJohan Hedberg if (!hdev->sent_cmd) 436942c6b129SJohan Hedberg return; 437042c6b129SJohan Hedberg 437142c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 437242c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 437342c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 437442c6b129SJohan Hedberg return; 437542c6b129SJohan Hedberg 437642c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 437742c6b129SJohan Hedberg if (!skb) 437842c6b129SJohan Hedberg return; 437942c6b129SJohan Hedberg 438042c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 438142c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 438242c6b129SJohan Hedberg } 438342c6b129SJohan Hedberg 4384e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4385e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4386e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 43879238f36aSJohan Hedberg { 43889238f36aSJohan Hedberg struct sk_buff *skb; 43899238f36aSJohan Hedberg unsigned long flags; 43909238f36aSJohan Hedberg 43919238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 43929238f36aSJohan Hedberg 439342c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 439442c6b129SJohan Hedberg * sent we need to do special handling of it. 43959238f36aSJohan Hedberg */ 439642c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 439742c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 439842c6b129SJohan Hedberg * reset complete event during init and any pending 439942c6b129SJohan Hedberg * command will never be completed. In such a case we 440042c6b129SJohan Hedberg * need to resend whatever was the last sent 440142c6b129SJohan Hedberg * command. 440242c6b129SJohan Hedberg */ 440342c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 440442c6b129SJohan Hedberg hci_resend_last(hdev); 440542c6b129SJohan Hedberg 44069238f36aSJohan Hedberg return; 440742c6b129SJohan Hedberg } 44089238f36aSJohan Hedberg 4409f80c5dadSJoão Paulo Rechi Vita /* If we reach this point this event matches the last command sent */ 4410f80c5dadSJoão Paulo Rechi Vita hci_dev_clear_flag(hdev, HCI_CMD_PENDING); 4411f80c5dadSJoão Paulo Rechi Vita 44129238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 44139238f36aSJohan Hedberg * this request the request is not yet complete. 44149238f36aSJohan Hedberg */ 44159238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 44169238f36aSJohan Hedberg return; 44179238f36aSJohan Hedberg 44189238f36aSJohan Hedberg /* If this was the last command in a request the complete 44199238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 44209238f36aSJohan Hedberg * command queue (hdev->cmd_q). 44219238f36aSJohan Hedberg */ 442244d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_flags & HCI_REQ_SKB) { 442344d27137SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4424e6214487SJohan Hedberg return; 44259238f36aSJohan Hedberg } 4426e6214487SJohan Hedberg 442744d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 442844d27137SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4429e6214487SJohan Hedberg return; 443053e21fbcSJohan Hedberg } 44319238f36aSJohan Hedberg 44329238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 44339238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44349238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 443544d27137SJohan Hedberg if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) { 44369238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 44379238f36aSJohan Hedberg break; 44389238f36aSJohan Hedberg } 44399238f36aSJohan Hedberg 44403bd7594eSDouglas Anderson if (bt_cb(skb)->hci.req_flags & HCI_REQ_SKB) 4441242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 44423bd7594eSDouglas Anderson else 44433bd7594eSDouglas Anderson *req_complete = bt_cb(skb)->hci.req_complete; 44449238f36aSJohan Hedberg kfree_skb(skb); 44459238f36aSJohan Hedberg } 44469238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44479238f36aSJohan Hedberg } 44489238f36aSJohan Hedberg 4449b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 44501da177e4SLinus Torvalds { 4451b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 44521da177e4SLinus Torvalds struct sk_buff *skb; 44531da177e4SLinus Torvalds 44541da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 44551da177e4SLinus Torvalds 44561da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4457cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4458cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4459cd82e61cSMarcel Holtmann 44601da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 44611da177e4SLinus Torvalds /* Send copy to the sockets */ 4462470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44631da177e4SLinus Torvalds } 44641da177e4SLinus Torvalds 4465eb8c101eSMattijs Korpershoek /* If the device has been opened in HCI_USER_CHANNEL, 4466eb8c101eSMattijs Korpershoek * the userspace has exclusive access to device. 4467eb8c101eSMattijs Korpershoek * When device is HCI_INIT, we still need to process 4468eb8c101eSMattijs Korpershoek * the data packets to the driver in order 4469eb8c101eSMattijs Korpershoek * to complete its setup(). 4470eb8c101eSMattijs Korpershoek */ 4471eb8c101eSMattijs Korpershoek if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 4472eb8c101eSMattijs Korpershoek !test_bit(HCI_INIT, &hdev->flags)) { 44731da177e4SLinus Torvalds kfree_skb(skb); 44741da177e4SLinus Torvalds continue; 44751da177e4SLinus Torvalds } 44761da177e4SLinus Torvalds 44771da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 44781da177e4SLinus Torvalds /* Don't process data packets in this states. */ 4479d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 44801da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44811da177e4SLinus Torvalds case HCI_SCODATA_PKT: 44821da177e4SLinus Torvalds kfree_skb(skb); 44831da177e4SLinus Torvalds continue; 44843ff50b79SStephen Hemminger } 44851da177e4SLinus Torvalds } 44861da177e4SLinus Torvalds 44871da177e4SLinus Torvalds /* Process frame */ 4488d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 44891da177e4SLinus Torvalds case HCI_EVENT_PKT: 4490b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 44911da177e4SLinus Torvalds hci_event_packet(hdev, skb); 44921da177e4SLinus Torvalds break; 44931da177e4SLinus Torvalds 44941da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44951da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 44961da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 44971da177e4SLinus Torvalds break; 44981da177e4SLinus Torvalds 44991da177e4SLinus Torvalds case HCI_SCODATA_PKT: 45001da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 45011da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 45021da177e4SLinus Torvalds break; 45031da177e4SLinus Torvalds 45041da177e4SLinus Torvalds default: 45051da177e4SLinus Torvalds kfree_skb(skb); 45061da177e4SLinus Torvalds break; 45071da177e4SLinus Torvalds } 45081da177e4SLinus Torvalds } 45091da177e4SLinus Torvalds } 45101da177e4SLinus Torvalds 4511c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 45121da177e4SLinus Torvalds { 4513c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 45141da177e4SLinus Torvalds struct sk_buff *skb; 45151da177e4SLinus Torvalds 45162104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 45172104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 45181da177e4SLinus Torvalds 45191da177e4SLinus Torvalds /* Send queued commands */ 45205a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 45215a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 45225a08ecceSAndrei Emeltchenko if (!skb) 45235a08ecceSAndrei Emeltchenko return; 45245a08ecceSAndrei Emeltchenko 45251da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 45261da177e4SLinus Torvalds 4527a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 452870f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 4529f80c5dadSJoão Paulo Rechi Vita if (hci_req_status_pend(hdev)) 4530f80c5dadSJoão Paulo Rechi Vita hci_dev_set_flag(hdev, HCI_CMD_PENDING); 45311da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 453257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 45337bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 453465cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 45357bdb8a5cSSzymon Janc else 453665cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 453765cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 45381da177e4SLinus Torvalds } else { 45391da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4540c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45411da177e4SLinus Torvalds } 45421da177e4SLinus Torvalds } 45431da177e4SLinus Torvalds } 4544