11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 4590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 51da177e4SLinus Torvalds 61da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 101da177e4SLinus Torvalds published by the Free Software Foundation; 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 131da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 141da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 151da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 161da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 171da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 181da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 191da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 221da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 231da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds /* Bluetooth HCI core. */ 271da177e4SLinus Torvalds 288c520a59SGustavo Padovan #include <linux/export.h> 293df92b31SSasha Levin #include <linux/idr.h> 30611b30f7SMarcel Holtmann #include <linux/rfkill.h> 31baf27f6eSMarcel Holtmann #include <linux/debugfs.h> 3299780a7bSJohan Hedberg #include <linux/crypto.h> 3347219839SMarcel Holtmann #include <asm/unaligned.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 361da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 374bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 38af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 391da177e4SLinus Torvalds 400857dd3bSJohan Hedberg #include "hci_request.h" 4160c5f5fbSMarcel Holtmann #include "hci_debugfs.h" 42970c4e46SJohan Hedberg #include "smp.h" 436d5d2ee6SHeiner Kallweit #include "leds.h" 44970c4e46SJohan Hedberg 45b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 46c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 473eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds /* HCI device list */ 501da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 511da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds /* HCI callback list */ 541da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 55fba7ecf0SJohan Hedberg DEFINE_MUTEX(hci_cb_list_lock); 561da177e4SLinus Torvalds 573df92b31SSasha Levin /* HCI ID Numbering */ 583df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 593df92b31SSasha Levin 60baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 61baf27f6eSMarcel Holtmann 624b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 634b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 644b4148e9SMarcel Holtmann { 654b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 664b4148e9SMarcel Holtmann char buf[3]; 674b4148e9SMarcel Holtmann 68b7cb93e5SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y' : 'N'; 694b4148e9SMarcel Holtmann buf[1] = '\n'; 704b4148e9SMarcel Holtmann buf[2] = '\0'; 714b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 724b4148e9SMarcel Holtmann } 734b4148e9SMarcel Holtmann 744b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 754b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 764b4148e9SMarcel Holtmann { 774b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 784b4148e9SMarcel Holtmann struct sk_buff *skb; 794b4148e9SMarcel Holtmann bool enable; 803bf5e97dSAndy Shevchenko int err; 814b4148e9SMarcel Holtmann 824b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 834b4148e9SMarcel Holtmann return -ENETDOWN; 844b4148e9SMarcel Holtmann 853bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 863bf5e97dSAndy Shevchenko if (err) 873bf5e97dSAndy Shevchenko return err; 884b4148e9SMarcel Holtmann 89b7cb93e5SMarcel Holtmann if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE)) 904b4148e9SMarcel Holtmann return -EALREADY; 914b4148e9SMarcel Holtmann 92b504430cSJohan Hedberg hci_req_sync_lock(hdev); 934b4148e9SMarcel Holtmann if (enable) 944b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 954b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 964b4148e9SMarcel Holtmann else 974b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 984b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 99b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1004b4148e9SMarcel Holtmann 1014b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1024b4148e9SMarcel Holtmann return PTR_ERR(skb); 1034b4148e9SMarcel Holtmann 1044b4148e9SMarcel Holtmann kfree_skb(skb); 1054b4148e9SMarcel Holtmann 106b7cb93e5SMarcel Holtmann hci_dev_change_flag(hdev, HCI_DUT_MODE); 1074b4148e9SMarcel Holtmann 1084b4148e9SMarcel Holtmann return count; 1094b4148e9SMarcel Holtmann } 1104b4148e9SMarcel Holtmann 1114b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1124b4148e9SMarcel Holtmann .open = simple_open, 1134b4148e9SMarcel Holtmann .read = dut_mode_read, 1144b4148e9SMarcel Holtmann .write = dut_mode_write, 1154b4148e9SMarcel Holtmann .llseek = default_llseek, 1164b4148e9SMarcel Holtmann }; 1174b4148e9SMarcel Holtmann 1184b4113d6SMarcel Holtmann static ssize_t vendor_diag_read(struct file *file, char __user *user_buf, 1194b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1204b4113d6SMarcel Holtmann { 1214b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1224b4113d6SMarcel Holtmann char buf[3]; 1234b4113d6SMarcel Holtmann 1244b4113d6SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y' : 'N'; 1254b4113d6SMarcel Holtmann buf[1] = '\n'; 1264b4113d6SMarcel Holtmann buf[2] = '\0'; 1274b4113d6SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 1284b4113d6SMarcel Holtmann } 1294b4113d6SMarcel Holtmann 1304b4113d6SMarcel Holtmann static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf, 1314b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1324b4113d6SMarcel Holtmann { 1334b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1344b4113d6SMarcel Holtmann bool enable; 1354b4113d6SMarcel Holtmann int err; 1364b4113d6SMarcel Holtmann 1373bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 1383bf5e97dSAndy Shevchenko if (err) 1393bf5e97dSAndy Shevchenko return err; 1404b4113d6SMarcel Holtmann 1417e995b9eSMarcel Holtmann /* When the diagnostic flags are not persistent and the transport 142b56c7b25SMarcel Holtmann * is not active or in user channel operation, then there is no need 143b56c7b25SMarcel Holtmann * for the vendor callback. Instead just store the desired value and 144b56c7b25SMarcel Holtmann * the setting will be programmed when the controller gets powered on. 1457e995b9eSMarcel Holtmann */ 1467e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 147b56c7b25SMarcel Holtmann (!test_bit(HCI_RUNNING, &hdev->flags) || 148b56c7b25SMarcel Holtmann hci_dev_test_flag(hdev, HCI_USER_CHANNEL))) 1497e995b9eSMarcel Holtmann goto done; 1507e995b9eSMarcel Holtmann 151b504430cSJohan Hedberg hci_req_sync_lock(hdev); 1524b4113d6SMarcel Holtmann err = hdev->set_diag(hdev, enable); 153b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1544b4113d6SMarcel Holtmann 1554b4113d6SMarcel Holtmann if (err < 0) 1564b4113d6SMarcel Holtmann return err; 1574b4113d6SMarcel Holtmann 1587e995b9eSMarcel Holtmann done: 1594b4113d6SMarcel Holtmann if (enable) 1604b4113d6SMarcel Holtmann hci_dev_set_flag(hdev, HCI_VENDOR_DIAG); 1614b4113d6SMarcel Holtmann else 1624b4113d6SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG); 1634b4113d6SMarcel Holtmann 1644b4113d6SMarcel Holtmann return count; 1654b4113d6SMarcel Holtmann } 1664b4113d6SMarcel Holtmann 1674b4113d6SMarcel Holtmann static const struct file_operations vendor_diag_fops = { 1684b4113d6SMarcel Holtmann .open = simple_open, 1694b4113d6SMarcel Holtmann .read = vendor_diag_read, 1704b4113d6SMarcel Holtmann .write = vendor_diag_write, 1714b4113d6SMarcel Holtmann .llseek = default_llseek, 1724b4113d6SMarcel Holtmann }; 1734b4113d6SMarcel Holtmann 174f640ee98SMarcel Holtmann static void hci_debugfs_create_basic(struct hci_dev *hdev) 175f640ee98SMarcel Holtmann { 176f640ee98SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 177f640ee98SMarcel Holtmann &dut_mode_fops); 178f640ee98SMarcel Holtmann 179f640ee98SMarcel Holtmann if (hdev->set_diag) 180f640ee98SMarcel Holtmann debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev, 181f640ee98SMarcel Holtmann &vendor_diag_fops); 182f640ee98SMarcel Holtmann } 183f640ee98SMarcel Holtmann 184a1d01db1SJohan Hedberg static int hci_reset_req(struct hci_request *req, unsigned long opt) 1851da177e4SLinus Torvalds { 18642c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds /* Reset device */ 18942c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 19042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 191a1d01db1SJohan Hedberg return 0; 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds 19442c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 1951da177e4SLinus Torvalds { 19642c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 1972455a3eaSAndrei Emeltchenko 1981da177e4SLinus Torvalds /* Read Local Supported Features */ 19942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2001da177e4SLinus Torvalds 2011143e5a6SMarcel Holtmann /* Read Local Version */ 20242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2032177bab5SJohan Hedberg 2042177bab5SJohan Hedberg /* Read BD Address */ 20542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 2061da177e4SLinus Torvalds } 2071da177e4SLinus Torvalds 2080af801b9SJohan Hedberg static void amp_init1(struct hci_request *req) 209e61ef499SAndrei Emeltchenko { 21042c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 2112455a3eaSAndrei Emeltchenko 212e61ef499SAndrei Emeltchenko /* Read Local Version */ 21342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2146bcbc489SAndrei Emeltchenko 215f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 216f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 217f6996cfeSMarcel Holtmann 2186bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 21942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 220e71dfabaSAndrei Emeltchenko 221e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 22242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 2237528ca1cSMarcel Holtmann 224f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 225f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 226f38ba941SMarcel Holtmann 2277528ca1cSMarcel Holtmann /* Read Location Data */ 2287528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 229e61ef499SAndrei Emeltchenko } 230e61ef499SAndrei Emeltchenko 231a1d01db1SJohan Hedberg static int amp_init2(struct hci_request *req) 2320af801b9SJohan Hedberg { 2330af801b9SJohan Hedberg /* Read Local Supported Features. Not all AMP controllers 2340af801b9SJohan Hedberg * support this so it's placed conditionally in the second 2350af801b9SJohan Hedberg * stage init. 2360af801b9SJohan Hedberg */ 2370af801b9SJohan Hedberg if (req->hdev->commands[14] & 0x20) 2380af801b9SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 239a1d01db1SJohan Hedberg 240a1d01db1SJohan Hedberg return 0; 2410af801b9SJohan Hedberg } 2420af801b9SJohan Hedberg 243a1d01db1SJohan Hedberg static int hci_init1_req(struct hci_request *req, unsigned long opt) 244e61ef499SAndrei Emeltchenko { 24542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 246e61ef499SAndrei Emeltchenko 247e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 248e61ef499SAndrei Emeltchenko 24911778716SAndrei Emeltchenko /* Reset */ 25011778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 25142c6b129SJohan Hedberg hci_reset_req(req, 0); 25211778716SAndrei Emeltchenko 253e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 254ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 25542c6b129SJohan Hedberg bredr_init(req); 256e61ef499SAndrei Emeltchenko break; 257e61ef499SAndrei Emeltchenko case HCI_AMP: 2580af801b9SJohan Hedberg amp_init1(req); 259e61ef499SAndrei Emeltchenko break; 260e61ef499SAndrei Emeltchenko default: 2612064ee33SMarcel Holtmann bt_dev_err(hdev, "Unknown device type %d", hdev->dev_type); 262e61ef499SAndrei Emeltchenko break; 263e61ef499SAndrei Emeltchenko } 264a1d01db1SJohan Hedberg 265a1d01db1SJohan Hedberg return 0; 266e61ef499SAndrei Emeltchenko } 267e61ef499SAndrei Emeltchenko 26842c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 2692177bab5SJohan Hedberg { 2702177bab5SJohan Hedberg __le16 param; 2712177bab5SJohan Hedberg __u8 flt_type; 2722177bab5SJohan Hedberg 2732177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 27442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2752177bab5SJohan Hedberg 2762177bab5SJohan Hedberg /* Read Class of Device */ 27742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 2782177bab5SJohan Hedberg 2792177bab5SJohan Hedberg /* Read Local Name */ 28042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2812177bab5SJohan Hedberg 2822177bab5SJohan Hedberg /* Read Voice Setting */ 28342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2842177bab5SJohan Hedberg 285b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 286b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 287b4cb9fb2SMarcel Holtmann 2884b836f39SMarcel Holtmann /* Read Current IAC LAP */ 2894b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 2904b836f39SMarcel Holtmann 2912177bab5SJohan Hedberg /* Clear Event Filters */ 2922177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 29342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2942177bab5SJohan Hedberg 2952177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 296dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 29742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 2982177bab5SJohan Hedberg } 2992177bab5SJohan Hedberg 30042c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 3012177bab5SJohan Hedberg { 302c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 303c73eee91SJohan Hedberg 3042177bab5SJohan Hedberg /* Read LE Buffer Size */ 30542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 3062177bab5SJohan Hedberg 3072177bab5SJohan Hedberg /* Read LE Local Supported Features */ 30842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 3092177bab5SJohan Hedberg 310747d3f03SMarcel Holtmann /* Read LE Supported States */ 311747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 312747d3f03SMarcel Holtmann 313c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 314c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 315a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_LE_ENABLED); 3162177bab5SJohan Hedberg } 3172177bab5SJohan Hedberg 31842c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 3192177bab5SJohan Hedberg { 32042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 32142c6b129SJohan Hedberg 3222177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 3232177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 3242177bab5SJohan Hedberg * command otherwise. 3252177bab5SJohan Hedberg */ 3262177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 3272177bab5SJohan Hedberg 3282177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 3292177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 3302177bab5SJohan Hedberg */ 3312177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 3322177bab5SJohan Hedberg return; 3332177bab5SJohan Hedberg 3342177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 3352177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 336c7882cbdSMarcel Holtmann } else { 337c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 338c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 339c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 340c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 341c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 3425c3d3b4cSMarcel Holtmann 3435c3d3b4cSMarcel Holtmann /* If the controller supports the Disconnect command, enable 3445c3d3b4cSMarcel Holtmann * the corresponding event. In addition enable packet flow 3455c3d3b4cSMarcel Holtmann * control related events. 3465c3d3b4cSMarcel Holtmann */ 3475c3d3b4cSMarcel Holtmann if (hdev->commands[0] & 0x20) { 3485c3d3b4cSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 349c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 350c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 3515c3d3b4cSMarcel Holtmann } 3525c3d3b4cSMarcel Holtmann 3535c3d3b4cSMarcel Holtmann /* If the controller supports the Read Remote Version 3545c3d3b4cSMarcel Holtmann * Information command, enable the corresponding event. 3555c3d3b4cSMarcel Holtmann */ 3565c3d3b4cSMarcel Holtmann if (hdev->commands[2] & 0x80) 3575c3d3b4cSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information 3585c3d3b4cSMarcel Holtmann * Complete 3595c3d3b4cSMarcel Holtmann */ 3600da71f1bSMarcel Holtmann 3610da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 3620da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 363c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3642177bab5SJohan Hedberg } 3650da71f1bSMarcel Holtmann } 3662177bab5SJohan Hedberg 3679fe759ceSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 3689fe759ceSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) 3692177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 3702177bab5SJohan Hedberg 37170f56aa2SMarcel Holtmann if (lmp_ext_feat_capable(hdev)) 37270f56aa2SMarcel Holtmann events[4] |= 0x04; /* Read Remote Extended Features Complete */ 37370f56aa2SMarcel Holtmann 37470f56aa2SMarcel Holtmann if (lmp_esco_capable(hdev)) { 37570f56aa2SMarcel Holtmann events[5] |= 0x08; /* Synchronous Connection Complete */ 37670f56aa2SMarcel Holtmann events[5] |= 0x10; /* Synchronous Connection Changed */ 37770f56aa2SMarcel Holtmann } 37870f56aa2SMarcel Holtmann 3792177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 3802177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 3812177bab5SJohan Hedberg 3822177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 3832177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3842177bab5SJohan Hedberg 3852177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 3862177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 3872177bab5SJohan Hedberg 3882177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 3892177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 3902177bab5SJohan Hedberg 3912177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 3922177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 3932177bab5SJohan Hedberg 3942177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 3952177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 3962177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 3972177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 3982177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 3992177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 4002177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 4012177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 4022177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 4032177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 4042177bab5SJohan Hedberg * Features Notification 4052177bab5SJohan Hedberg */ 4062177bab5SJohan Hedberg } 4072177bab5SJohan Hedberg 4082177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 4092177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 4102177bab5SJohan Hedberg 41142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 4122177bab5SJohan Hedberg } 4132177bab5SJohan Hedberg 414a1d01db1SJohan Hedberg static int hci_init2_req(struct hci_request *req, unsigned long opt) 4152177bab5SJohan Hedberg { 41642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 41742c6b129SJohan Hedberg 4180af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 4190af801b9SJohan Hedberg return amp_init2(req); 4200af801b9SJohan Hedberg 4212177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 42242c6b129SJohan Hedberg bredr_setup(req); 42356f87901SJohan Hedberg else 424a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 4252177bab5SJohan Hedberg 4262177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 42742c6b129SJohan Hedberg le_setup(req); 4282177bab5SJohan Hedberg 4290f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 4300f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 4310f3adeaeSMarcel Holtmann * 4320f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 4330f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 4340f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 4350f3adeaeSMarcel Holtmann * supported commands. 4363f8e2d75SJohan Hedberg */ 4370f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 4380f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 43942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 4402177bab5SJohan Hedberg 4412177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 44257af75a8SMarcel Holtmann /* When SSP is available, then the host features page 44357af75a8SMarcel Holtmann * should also be available as well. However some 44457af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 44557af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 44657af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 44757af75a8SMarcel Holtmann */ 44857af75a8SMarcel Holtmann hdev->max_page = 0x01; 44957af75a8SMarcel Holtmann 450d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 4512177bab5SJohan Hedberg u8 mode = 0x01; 452574ea3c7SMarcel Holtmann 45342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 4542177bab5SJohan Hedberg sizeof(mode), &mode); 4552177bab5SJohan Hedberg } else { 4562177bab5SJohan Hedberg struct hci_cp_write_eir cp; 4572177bab5SJohan Hedberg 4582177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 4592177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 4602177bab5SJohan Hedberg 46142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 4622177bab5SJohan Hedberg } 4632177bab5SJohan Hedberg } 4642177bab5SJohan Hedberg 465043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 466043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 46704422da9SMarcel Holtmann u8 mode; 46804422da9SMarcel Holtmann 46904422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 47004422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 47104422da9SMarcel Holtmann * events. 47204422da9SMarcel Holtmann */ 47304422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 47404422da9SMarcel Holtmann 47504422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 47604422da9SMarcel Holtmann } 4772177bab5SJohan Hedberg 4782177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 47942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 4802177bab5SJohan Hedberg 4812177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 4822177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 4832177bab5SJohan Hedberg 4842177bab5SJohan Hedberg cp.page = 0x01; 48542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 48642c6b129SJohan Hedberg sizeof(cp), &cp); 4872177bab5SJohan Hedberg } 4882177bab5SJohan Hedberg 489d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 4902177bab5SJohan Hedberg u8 enable = 1; 49142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 4922177bab5SJohan Hedberg &enable); 4932177bab5SJohan Hedberg } 494a1d01db1SJohan Hedberg 495a1d01db1SJohan Hedberg return 0; 4962177bab5SJohan Hedberg } 4972177bab5SJohan Hedberg 49842c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 4992177bab5SJohan Hedberg { 50042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5012177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 5022177bab5SJohan Hedberg u16 link_policy = 0; 5032177bab5SJohan Hedberg 5042177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 5052177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 5062177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 5072177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 5082177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 5092177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 5102177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 5112177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 5122177bab5SJohan Hedberg 5132177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 51442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 5152177bab5SJohan Hedberg } 5162177bab5SJohan Hedberg 51742c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 5182177bab5SJohan Hedberg { 51942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5202177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 5212177bab5SJohan Hedberg 522c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 523c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 524c73eee91SJohan Hedberg return; 525c73eee91SJohan Hedberg 5262177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 5272177bab5SJohan Hedberg 528d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 5292177bab5SJohan Hedberg cp.le = 0x01; 53032226e4fSMarcel Holtmann cp.simul = 0x00; 5312177bab5SJohan Hedberg } 5322177bab5SJohan Hedberg 5332177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 53442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 5352177bab5SJohan Hedberg &cp); 5362177bab5SJohan Hedberg } 5372177bab5SJohan Hedberg 538d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 539d62e6d67SJohan Hedberg { 540d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 541d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 542313f6888SMarcel Holtmann bool changed = false; 543d62e6d67SJohan Hedberg 544d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 545d62e6d67SJohan Hedberg * enable all necessary events for it. 546d62e6d67SJohan Hedberg */ 54753b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 548d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 549d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 550d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 551d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 552313f6888SMarcel Holtmann changed = true; 553d62e6d67SJohan Hedberg } 554d62e6d67SJohan Hedberg 555d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 556d62e6d67SJohan Hedberg * enable all necessary events for it. 557d62e6d67SJohan Hedberg */ 55853b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 559d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 560d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 561d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 562d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 563313f6888SMarcel Holtmann changed = true; 564d62e6d67SJohan Hedberg } 565d62e6d67SJohan Hedberg 56640c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 567313f6888SMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) { 56840c59fcbSMarcel Holtmann events[2] |= 0x80; 569313f6888SMarcel Holtmann changed = true; 570313f6888SMarcel Holtmann } 57140c59fcbSMarcel Holtmann 572313f6888SMarcel Holtmann /* Some Broadcom based controllers indicate support for Set Event 573313f6888SMarcel Holtmann * Mask Page 2 command, but then actually do not support it. Since 574313f6888SMarcel Holtmann * the default value is all bits set to zero, the command is only 575313f6888SMarcel Holtmann * required if the event mask has to be changed. In case no change 576313f6888SMarcel Holtmann * to the event mask is needed, skip this command. 577313f6888SMarcel Holtmann */ 578313f6888SMarcel Holtmann if (changed) 579313f6888SMarcel Holtmann hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, 580313f6888SMarcel Holtmann sizeof(events), events); 581d62e6d67SJohan Hedberg } 582d62e6d67SJohan Hedberg 583a1d01db1SJohan Hedberg static int hci_init3_req(struct hci_request *req, unsigned long opt) 5842177bab5SJohan Hedberg { 58542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 586d2c5d77fSJohan Hedberg u8 p; 58742c6b129SJohan Hedberg 5880da71f1bSMarcel Holtmann hci_setup_event_mask(req); 5890da71f1bSMarcel Holtmann 590e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 591e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 59248ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 59348ce62c4SMarcel Holtmann 59448ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 59548ce62c4SMarcel Holtmann cp.read_all = 0x01; 59648ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 59748ce62c4SMarcel Holtmann } 59848ce62c4SMarcel Holtmann 5992177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 60042c6b129SJohan Hedberg hci_setup_link_policy(req); 6012177bab5SJohan Hedberg 602417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 603417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 604417287deSMarcel Holtmann 605417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 606417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 607417287deSMarcel Holtmann * this command in the bit mask of supported commands. 608417287deSMarcel Holtmann */ 609417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 610417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 611417287deSMarcel Holtmann 6129193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 6139193c6e8SAndre Guedes u8 events[8]; 6149193c6e8SAndre Guedes 6159193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 6164d6c705bSMarcel Holtmann 6174d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 6184d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 619662bc2e6SAndre Guedes 620662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 621662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 622662bc2e6SAndre Guedes */ 623662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 624662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 625662bc2e6SAndre Guedes * Parameter Request 626662bc2e6SAndre Guedes */ 627662bc2e6SAndre Guedes 628a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 629a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 630a9f6068eSMarcel Holtmann */ 631a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 632a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 633a9f6068eSMarcel Holtmann 6344b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 6354b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 6364b71bba4SMarcel Holtmann */ 6374b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 6384b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 6394b71bba4SMarcel Holtmann * Report 6404b71bba4SMarcel Holtmann */ 6414b71bba4SMarcel Holtmann 6429756d33bSMarcel Holtmann /* If the controller supports Channel Selection Algorithm #2 6439756d33bSMarcel Holtmann * feature, enable the corresponding event. 6449756d33bSMarcel Holtmann */ 6459756d33bSMarcel Holtmann if (hdev->le_features[1] & HCI_LE_CHAN_SEL_ALG2) 6469756d33bSMarcel Holtmann events[2] |= 0x08; /* LE Channel Selection 6479756d33bSMarcel Holtmann * Algorithm 6489756d33bSMarcel Holtmann */ 6499756d33bSMarcel Holtmann 6507d26f5c4SMarcel Holtmann /* If the controller supports the LE Set Scan Enable command, 6517d26f5c4SMarcel Holtmann * enable the corresponding advertising report event. 6527d26f5c4SMarcel Holtmann */ 6537d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x08) 6547d26f5c4SMarcel Holtmann events[0] |= 0x02; /* LE Advertising Report */ 6557d26f5c4SMarcel Holtmann 6567d26f5c4SMarcel Holtmann /* If the controller supports the LE Create Connection 6577d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6587d26f5c4SMarcel Holtmann */ 6597d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x10) 6607d26f5c4SMarcel Holtmann events[0] |= 0x01; /* LE Connection Complete */ 6617d26f5c4SMarcel Holtmann 6627d26f5c4SMarcel Holtmann /* If the controller supports the LE Connection Update 6637d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6647d26f5c4SMarcel Holtmann */ 6657d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x04) 6667d26f5c4SMarcel Holtmann events[0] |= 0x04; /* LE Connection Update 6677d26f5c4SMarcel Holtmann * Complete 6687d26f5c4SMarcel Holtmann */ 6697d26f5c4SMarcel Holtmann 6707d26f5c4SMarcel Holtmann /* If the controller supports the LE Read Remote Used Features 6717d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6727d26f5c4SMarcel Holtmann */ 6737d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x20) 6747d26f5c4SMarcel Holtmann events[0] |= 0x08; /* LE Read Remote Used 6757d26f5c4SMarcel Holtmann * Features Complete 6767d26f5c4SMarcel Holtmann */ 6777d26f5c4SMarcel Holtmann 6785a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 6795a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 6805a34bd5fSMarcel Holtmann */ 6815a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 6825a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 6835a34bd5fSMarcel Holtmann * Public Key Complete 6845a34bd5fSMarcel Holtmann */ 6855a34bd5fSMarcel Holtmann 6865a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 6875a34bd5fSMarcel Holtmann * command, enable the corresponding event. 6885a34bd5fSMarcel Holtmann */ 6895a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 6905a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 6915a34bd5fSMarcel Holtmann 69227bbca44SMarcel Holtmann /* If the controller supports the LE Set Default PHY or 69327bbca44SMarcel Holtmann * LE Set PHY commands, enable the corresponding event. 69427bbca44SMarcel Holtmann */ 69527bbca44SMarcel Holtmann if (hdev->commands[35] & (0x20 | 0x40)) 69627bbca44SMarcel Holtmann events[1] |= 0x08; /* LE PHY Update Complete */ 69727bbca44SMarcel Holtmann 698c215e939SJaganath Kanakkassery /* If the controller supports LE Set Extended Scan Parameters 699c215e939SJaganath Kanakkassery * and LE Set Extended Scan Enable commands, enable the 700c215e939SJaganath Kanakkassery * corresponding event. 701c215e939SJaganath Kanakkassery */ 702c215e939SJaganath Kanakkassery if (use_ext_scan(hdev)) 703c215e939SJaganath Kanakkassery events[1] |= 0x10; /* LE Extended Advertising 704c215e939SJaganath Kanakkassery * Report 705c215e939SJaganath Kanakkassery */ 706c215e939SJaganath Kanakkassery 7074d94f95dSJaganath Kanakkassery /* If the controller supports the LE Extended Create Connection 7084d94f95dSJaganath Kanakkassery * command, enable the corresponding event. 7094d94f95dSJaganath Kanakkassery */ 7104d94f95dSJaganath Kanakkassery if (use_ext_conn(hdev)) 7114d94f95dSJaganath Kanakkassery events[1] |= 0x02; /* LE Enhanced Connection 7124d94f95dSJaganath Kanakkassery * Complete 7134d94f95dSJaganath Kanakkassery */ 7144d94f95dSJaganath Kanakkassery 7159193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 7169193c6e8SAndre Guedes events); 7179193c6e8SAndre Guedes 71815a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 7196b49bcb4SJaganath Kanakkassery if ((hdev->commands[25] & 0x40) && !ext_adv_capable(hdev)) { 7206b49bcb4SJaganath Kanakkassery /* HCI TS spec forbids mixing of legacy and extended 7216b49bcb4SJaganath Kanakkassery * advertising commands wherein READ_ADV_TX_POWER is 7226b49bcb4SJaganath Kanakkassery * also included. So do not call it if extended adv 7236b49bcb4SJaganath Kanakkassery * is supported otherwise controller will return 7246b49bcb4SJaganath Kanakkassery * COMMAND_DISALLOWED for extended commands. 7256b49bcb4SJaganath Kanakkassery */ 72615a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 72715a49ccaSMarcel Holtmann } 72815a49ccaSMarcel Holtmann 7292ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 7302ab216a7SMarcel Holtmann /* Read LE White List Size */ 7312ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 7322ab216a7SMarcel Holtmann 0, NULL); 7332ab216a7SMarcel Holtmann } 7342ab216a7SMarcel Holtmann 7352ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 7362ab216a7SMarcel Holtmann /* Clear LE White List */ 7372ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 7382ab216a7SMarcel Holtmann } 7392ab216a7SMarcel Holtmann 740cfdb0c2dSAnkit Navik if (hdev->commands[34] & 0x40) { 741cfdb0c2dSAnkit Navik /* Read LE Resolving List Size */ 742cfdb0c2dSAnkit Navik hci_req_add(req, HCI_OP_LE_READ_RESOLV_LIST_SIZE, 743cfdb0c2dSAnkit Navik 0, NULL); 744cfdb0c2dSAnkit Navik } 745cfdb0c2dSAnkit Navik 746545f2596SAnkit Navik if (hdev->commands[34] & 0x20) { 747545f2596SAnkit Navik /* Clear LE Resolving List */ 748545f2596SAnkit Navik hci_req_add(req, HCI_OP_LE_CLEAR_RESOLV_LIST, 0, NULL); 749545f2596SAnkit Navik } 750545f2596SAnkit Navik 751a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 752a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 753a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 754a9f6068eSMarcel Holtmann 755a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 756a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 757a9f6068eSMarcel Holtmann } 758a9f6068eSMarcel Holtmann 7596b49bcb4SJaganath Kanakkassery if (ext_adv_capable(hdev)) { 7606b49bcb4SJaganath Kanakkassery /* Read LE Number of Supported Advertising Sets */ 7616b49bcb4SJaganath Kanakkassery hci_req_add(req, HCI_OP_LE_READ_NUM_SUPPORTED_ADV_SETS, 7626b49bcb4SJaganath Kanakkassery 0, NULL); 7636b49bcb4SJaganath Kanakkassery } 7646b49bcb4SJaganath Kanakkassery 76542c6b129SJohan Hedberg hci_set_le_support(req); 7669193c6e8SAndre Guedes } 767d2c5d77fSJohan Hedberg 768d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 769d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 770d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 771d2c5d77fSJohan Hedberg 772d2c5d77fSJohan Hedberg cp.page = p; 773d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 774d2c5d77fSJohan Hedberg sizeof(cp), &cp); 775d2c5d77fSJohan Hedberg } 776a1d01db1SJohan Hedberg 777a1d01db1SJohan Hedberg return 0; 7782177bab5SJohan Hedberg } 7792177bab5SJohan Hedberg 780a1d01db1SJohan Hedberg static int hci_init4_req(struct hci_request *req, unsigned long opt) 7815d4e7e8dSJohan Hedberg { 7825d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 7835d4e7e8dSJohan Hedberg 78436f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 78536f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 78636f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 78736f260ceSMarcel Holtmann * 78836f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 78936f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 79036f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 79136f260ceSMarcel Holtmann * command redundant anyway. 79236f260ceSMarcel Holtmann * 79336f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 79436f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 79536f260ceSMarcel Holtmann * just disable this command. 79636f260ceSMarcel Holtmann */ 79736f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 79836f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 79936f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 80036f260ceSMarcel Holtmann 80136f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 80236f260ceSMarcel Holtmann cp.delete_all = 0x01; 80336f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 80436f260ceSMarcel Holtmann sizeof(cp), &cp); 80536f260ceSMarcel Holtmann } 80636f260ceSMarcel Holtmann 807d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 808d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 809d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 810d62e6d67SJohan Hedberg 811109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 812109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 813109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 814109e3191SMarcel Holtmann 815f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 816f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 817f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 818f4fe73edSMarcel Holtmann 8195d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 82053b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 8215d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 822a6d0d690SMarcel Holtmann 823a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 824d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 825574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 826a6d0d690SMarcel Holtmann u8 support = 0x01; 827574ea3c7SMarcel Holtmann 828a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 829a6d0d690SMarcel Holtmann sizeof(support), &support); 830a6d0d690SMarcel Holtmann } 831a1d01db1SJohan Hedberg 83212204875SMarcel Holtmann /* Set Suggested Default Data Length to maximum if supported */ 83312204875SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 83412204875SMarcel Holtmann struct hci_cp_le_write_def_data_len cp; 83512204875SMarcel Holtmann 83612204875SMarcel Holtmann cp.tx_len = hdev->le_max_tx_len; 83712204875SMarcel Holtmann cp.tx_time = hdev->le_max_tx_time; 83812204875SMarcel Holtmann hci_req_add(req, HCI_OP_LE_WRITE_DEF_DATA_LEN, sizeof(cp), &cp); 83912204875SMarcel Holtmann } 84012204875SMarcel Holtmann 841de2ba303SMarcel Holtmann /* Set Default PHY parameters if command is supported */ 842de2ba303SMarcel Holtmann if (hdev->commands[35] & 0x20) { 843de2ba303SMarcel Holtmann struct hci_cp_le_set_default_phy cp; 844de2ba303SMarcel Holtmann 8456decb5b4SJaganath Kanakkassery cp.all_phys = 0x00; 8466decb5b4SJaganath Kanakkassery cp.tx_phys = hdev->le_tx_def_phys; 8476decb5b4SJaganath Kanakkassery cp.rx_phys = hdev->le_rx_def_phys; 848de2ba303SMarcel Holtmann 849de2ba303SMarcel Holtmann hci_req_add(req, HCI_OP_LE_SET_DEFAULT_PHY, sizeof(cp), &cp); 850de2ba303SMarcel Holtmann } 851de2ba303SMarcel Holtmann 852a1d01db1SJohan Hedberg return 0; 8535d4e7e8dSJohan Hedberg } 8545d4e7e8dSJohan Hedberg 8552177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8562177bab5SJohan Hedberg { 8572177bab5SJohan Hedberg int err; 8582177bab5SJohan Hedberg 8594ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT, NULL); 8602177bab5SJohan Hedberg if (err < 0) 8612177bab5SJohan Hedberg return err; 8622177bab5SJohan Hedberg 863f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 864f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 8654b4148e9SMarcel Holtmann 8664ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT, NULL); 8672177bab5SJohan Hedberg if (err < 0) 8682177bab5SJohan Hedberg return err; 8692177bab5SJohan Hedberg 870ca8bee5dSMarcel Holtmann /* HCI_PRIMARY covers both single-mode LE, BR/EDR and dual-mode 8710af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8720af801b9SJohan Hedberg * first two stages of init. 8730af801b9SJohan Hedberg */ 874ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) 8750af801b9SJohan Hedberg return 0; 8760af801b9SJohan Hedberg 8774ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT, NULL); 8785d4e7e8dSJohan Hedberg if (err < 0) 8795d4e7e8dSJohan Hedberg return err; 8805d4e7e8dSJohan Hedberg 8814ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT, NULL); 882baf27f6eSMarcel Holtmann if (err < 0) 883baf27f6eSMarcel Holtmann return err; 884baf27f6eSMarcel Holtmann 885ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 886ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 887ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 888ec6cef9cSMarcel Holtmann * 889ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 890ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 891ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 892ec6cef9cSMarcel Holtmann * be called during the config phase. 893ec6cef9cSMarcel Holtmann * 894ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 895ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 896baf27f6eSMarcel Holtmann */ 897d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 898d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 899baf27f6eSMarcel Holtmann return 0; 900baf27f6eSMarcel Holtmann 90160c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 90260c5f5fbSMarcel Holtmann 90371c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 90460c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9052bfa3531SMarcel Holtmann 906162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 90760c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 908e7b8fc92SMarcel Holtmann 909baf27f6eSMarcel Holtmann return 0; 9102177bab5SJohan Hedberg } 9112177bab5SJohan Hedberg 912a1d01db1SJohan Hedberg static int hci_init0_req(struct hci_request *req, unsigned long opt) 9130ebca7d6SMarcel Holtmann { 9140ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9150ebca7d6SMarcel Holtmann 9160ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9170ebca7d6SMarcel Holtmann 9180ebca7d6SMarcel Holtmann /* Reset */ 9190ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9200ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9210ebca7d6SMarcel Holtmann 9220ebca7d6SMarcel Holtmann /* Read Local Version */ 9230ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9240ebca7d6SMarcel Holtmann 9250ebca7d6SMarcel Holtmann /* Read BD Address */ 9260ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9270ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 928a1d01db1SJohan Hedberg 929a1d01db1SJohan Hedberg return 0; 9300ebca7d6SMarcel Holtmann } 9310ebca7d6SMarcel Holtmann 9320ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9330ebca7d6SMarcel Holtmann { 9340ebca7d6SMarcel Holtmann int err; 9350ebca7d6SMarcel Holtmann 936cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 937cc78b44bSMarcel Holtmann return 0; 938cc78b44bSMarcel Holtmann 9394ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT, NULL); 9400ebca7d6SMarcel Holtmann if (err < 0) 9410ebca7d6SMarcel Holtmann return err; 9420ebca7d6SMarcel Holtmann 943f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 944f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 945f640ee98SMarcel Holtmann 9460ebca7d6SMarcel Holtmann return 0; 9470ebca7d6SMarcel Holtmann } 9480ebca7d6SMarcel Holtmann 949a1d01db1SJohan Hedberg static int hci_scan_req(struct hci_request *req, unsigned long opt) 9501da177e4SLinus Torvalds { 9511da177e4SLinus Torvalds __u8 scan = opt; 9521da177e4SLinus Torvalds 95342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9541da177e4SLinus Torvalds 9551da177e4SLinus Torvalds /* Inquiry and Page scans */ 95642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 957a1d01db1SJohan Hedberg return 0; 9581da177e4SLinus Torvalds } 9591da177e4SLinus Torvalds 960a1d01db1SJohan Hedberg static int hci_auth_req(struct hci_request *req, unsigned long opt) 9611da177e4SLinus Torvalds { 9621da177e4SLinus Torvalds __u8 auth = opt; 9631da177e4SLinus Torvalds 96442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9651da177e4SLinus Torvalds 9661da177e4SLinus Torvalds /* Authentication */ 96742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 968a1d01db1SJohan Hedberg return 0; 9691da177e4SLinus Torvalds } 9701da177e4SLinus Torvalds 971a1d01db1SJohan Hedberg static int hci_encrypt_req(struct hci_request *req, unsigned long opt) 9721da177e4SLinus Torvalds { 9731da177e4SLinus Torvalds __u8 encrypt = opt; 9741da177e4SLinus Torvalds 97542c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 9761da177e4SLinus Torvalds 977e4e8e37cSMarcel Holtmann /* Encryption */ 97842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 979a1d01db1SJohan Hedberg return 0; 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds 982a1d01db1SJohan Hedberg static int hci_linkpol_req(struct hci_request *req, unsigned long opt) 983e4e8e37cSMarcel Holtmann { 984e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 985e4e8e37cSMarcel Holtmann 98642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 987e4e8e37cSMarcel Holtmann 988e4e8e37cSMarcel Holtmann /* Default link policy */ 98942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 990a1d01db1SJohan Hedberg return 0; 991e4e8e37cSMarcel Holtmann } 992e4e8e37cSMarcel Holtmann 9931da177e4SLinus Torvalds /* Get HCI device by index. 9941da177e4SLinus Torvalds * Device is held on return. */ 9951da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 9961da177e4SLinus Torvalds { 9978035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds BT_DBG("%d", index); 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds if (index < 0) 10021da177e4SLinus Torvalds return NULL; 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10058035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10061da177e4SLinus Torvalds if (d->id == index) { 10071da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10081da177e4SLinus Torvalds break; 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10121da177e4SLinus Torvalds return hdev; 10131da177e4SLinus Torvalds } 10141da177e4SLinus Torvalds 10151da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1016ff9ef578SJohan Hedberg 101730dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 101830dc78e1SJohan Hedberg { 101930dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 102030dc78e1SJohan Hedberg 10216fbe195dSAndre Guedes switch (discov->state) { 1022343f935bSAndre Guedes case DISCOVERY_FINDING: 10236fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 102430dc78e1SJohan Hedberg return true; 102530dc78e1SJohan Hedberg 10266fbe195dSAndre Guedes default: 102730dc78e1SJohan Hedberg return false; 102830dc78e1SJohan Hedberg } 10296fbe195dSAndre Guedes } 103030dc78e1SJohan Hedberg 1031ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1032ff9ef578SJohan Hedberg { 1033bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1034bb3e0a33SJohan Hedberg 1035ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1036ff9ef578SJohan Hedberg 1037bb3e0a33SJohan Hedberg if (old_state == state) 1038ff9ef578SJohan Hedberg return; 1039ff9ef578SJohan Hedberg 1040bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1041bb3e0a33SJohan Hedberg 1042ff9ef578SJohan Hedberg switch (state) { 1043ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1044c54c3860SAndre Guedes hci_update_background_scan(hdev); 1045c54c3860SAndre Guedes 1046bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1047ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1048ff9ef578SJohan Hedberg break; 1049ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1050ff9ef578SJohan Hedberg break; 1051343f935bSAndre Guedes case DISCOVERY_FINDING: 1052ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1053ff9ef578SJohan Hedberg break; 105430dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 105530dc78e1SJohan Hedberg break; 1056ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1057ff9ef578SJohan Hedberg break; 1058ff9ef578SJohan Hedberg } 1059ff9ef578SJohan Hedberg } 1060ff9ef578SJohan Hedberg 10611f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 10621da177e4SLinus Torvalds { 106330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1064b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10651da177e4SLinus Torvalds 1066561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1067561aafbcSJohan Hedberg list_del(&p->all); 1068b57c1a56SJohan Hedberg kfree(p); 10691da177e4SLinus Torvalds } 1070561aafbcSJohan Hedberg 1071561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1072561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10731da177e4SLinus Torvalds } 10741da177e4SLinus Torvalds 1075a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1076a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 10771da177e4SLinus Torvalds { 107830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 10791da177e4SLinus Torvalds struct inquiry_entry *e; 10801da177e4SLinus Torvalds 10816ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 10821da177e4SLinus Torvalds 1083561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 10841da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 10851da177e4SLinus Torvalds return e; 10861da177e4SLinus Torvalds } 10871da177e4SLinus Torvalds 1088b57c1a56SJohan Hedberg return NULL; 1089b57c1a56SJohan Hedberg } 1090b57c1a56SJohan Hedberg 1091561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1092561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1093561aafbcSJohan Hedberg { 109430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1095561aafbcSJohan Hedberg struct inquiry_entry *e; 1096561aafbcSJohan Hedberg 10976ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1098561aafbcSJohan Hedberg 1099561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1100561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1101561aafbcSJohan Hedberg return e; 1102561aafbcSJohan Hedberg } 1103561aafbcSJohan Hedberg 1104561aafbcSJohan Hedberg return NULL; 1105561aafbcSJohan Hedberg } 1106561aafbcSJohan Hedberg 110730dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 110830dc78e1SJohan Hedberg bdaddr_t *bdaddr, 110930dc78e1SJohan Hedberg int state) 111030dc78e1SJohan Hedberg { 111130dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 111230dc78e1SJohan Hedberg struct inquiry_entry *e; 111330dc78e1SJohan Hedberg 11146ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 111530dc78e1SJohan Hedberg 111630dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 111730dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 111830dc78e1SJohan Hedberg return e; 111930dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 112030dc78e1SJohan Hedberg return e; 112130dc78e1SJohan Hedberg } 112230dc78e1SJohan Hedberg 112330dc78e1SJohan Hedberg return NULL; 112430dc78e1SJohan Hedberg } 112530dc78e1SJohan Hedberg 1126a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1127a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1128a3d4e20aSJohan Hedberg { 1129a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1130a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1131a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1132a3d4e20aSJohan Hedberg 1133a3d4e20aSJohan Hedberg list_del(&ie->list); 1134a3d4e20aSJohan Hedberg 1135a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1136a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1137a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1138a3d4e20aSJohan Hedberg break; 1139a3d4e20aSJohan Hedberg pos = &p->list; 1140a3d4e20aSJohan Hedberg } 1141a3d4e20aSJohan Hedberg 1142a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1143a3d4e20aSJohan Hedberg } 1144a3d4e20aSJohan Hedberg 1145af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1146af58925cSMarcel Holtmann bool name_known) 11471da177e4SLinus Torvalds { 114830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 114970f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1150af58925cSMarcel Holtmann u32 flags = 0; 11511da177e4SLinus Torvalds 11526ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11531da177e4SLinus Torvalds 11546928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11552b2fec4dSSzymon Janc 1156af58925cSMarcel Holtmann if (!data->ssp_mode) 1157af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1158388fc8faSJohan Hedberg 115970f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1160a3d4e20aSJohan Hedberg if (ie) { 1161af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1162af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1163388fc8faSJohan Hedberg 1164a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1165a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1166a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1167a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1168a3d4e20aSJohan Hedberg } 1169a3d4e20aSJohan Hedberg 1170561aafbcSJohan Hedberg goto update; 1171a3d4e20aSJohan Hedberg } 1172561aafbcSJohan Hedberg 11731da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 117427f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1175af58925cSMarcel Holtmann if (!ie) { 1176af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1177af58925cSMarcel Holtmann goto done; 1178af58925cSMarcel Holtmann } 117970f23020SAndrei Emeltchenko 1180561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1181561aafbcSJohan Hedberg 1182561aafbcSJohan Hedberg if (name_known) { 1183561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1184561aafbcSJohan Hedberg } else { 1185561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1186561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1187561aafbcSJohan Hedberg } 1188561aafbcSJohan Hedberg 1189561aafbcSJohan Hedberg update: 1190561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1191561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1192561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1193561aafbcSJohan Hedberg list_del(&ie->list); 11941da177e4SLinus Torvalds } 11951da177e4SLinus Torvalds 119670f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 119770f23020SAndrei Emeltchenko ie->timestamp = jiffies; 11981da177e4SLinus Torvalds cache->timestamp = jiffies; 11993175405bSJohan Hedberg 12003175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1201af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12023175405bSJohan Hedberg 1203af58925cSMarcel Holtmann done: 1204af58925cSMarcel Holtmann return flags; 12051da177e4SLinus Torvalds } 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12081da177e4SLinus Torvalds { 120930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12101da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12111da177e4SLinus Torvalds struct inquiry_entry *e; 12121da177e4SLinus Torvalds int copied = 0; 12131da177e4SLinus Torvalds 1214561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12151da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1216b57c1a56SJohan Hedberg 1217b57c1a56SJohan Hedberg if (copied >= num) 1218b57c1a56SJohan Hedberg break; 1219b57c1a56SJohan Hedberg 12201da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12211da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12221da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12231da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12241da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12251da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1226b57c1a56SJohan Hedberg 12271da177e4SLinus Torvalds info++; 1228b57c1a56SJohan Hedberg copied++; 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12321da177e4SLinus Torvalds return copied; 12331da177e4SLinus Torvalds } 12341da177e4SLinus Torvalds 1235a1d01db1SJohan Hedberg static int hci_inq_req(struct hci_request *req, unsigned long opt) 12361da177e4SLinus Torvalds { 12371da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 123842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12391da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12401da177e4SLinus Torvalds 12411da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12421da177e4SLinus Torvalds 12431da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 1244a1d01db1SJohan Hedberg return 0; 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds /* Start Inquiry */ 12471da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12481da177e4SLinus Torvalds cp.length = ir->length; 12491da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 125042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 1251a1d01db1SJohan Hedberg 1252a1d01db1SJohan Hedberg return 0; 12531da177e4SLinus Torvalds } 12541da177e4SLinus Torvalds 12551da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12561da177e4SLinus Torvalds { 12571da177e4SLinus Torvalds __u8 __user *ptr = arg; 12581da177e4SLinus Torvalds struct hci_inquiry_req ir; 12591da177e4SLinus Torvalds struct hci_dev *hdev; 12601da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 12611da177e4SLinus Torvalds long timeo; 12621da177e4SLinus Torvalds __u8 *buf; 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12651da177e4SLinus Torvalds return -EFAULT; 12661da177e4SLinus Torvalds 12675a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12685a08ecceSAndrei Emeltchenko if (!hdev) 12691da177e4SLinus Torvalds return -ENODEV; 12701da177e4SLinus Torvalds 1271d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 12720736cfa8SMarcel Holtmann err = -EBUSY; 12730736cfa8SMarcel Holtmann goto done; 12740736cfa8SMarcel Holtmann } 12750736cfa8SMarcel Holtmann 1276d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1277fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1278fee746b0SMarcel Holtmann goto done; 1279fee746b0SMarcel Holtmann } 1280fee746b0SMarcel Holtmann 1281ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 12825b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 12835b69bef5SMarcel Holtmann goto done; 12845b69bef5SMarcel Holtmann } 12855b69bef5SMarcel Holtmann 1286d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 128756f87901SJohan Hedberg err = -EOPNOTSUPP; 128856f87901SJohan Hedberg goto done; 128956f87901SJohan Hedberg } 129056f87901SJohan Hedberg 129109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12921da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1293a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 12941f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 12951da177e4SLinus Torvalds do_inquiry = 1; 12961da177e4SLinus Torvalds } 129709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12981da177e4SLinus Torvalds 129904837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 130070f23020SAndrei Emeltchenko 130170f23020SAndrei Emeltchenko if (do_inquiry) { 130201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 13034ebeee2dSJohan Hedberg timeo, NULL); 130470f23020SAndrei Emeltchenko if (err < 0) 13051da177e4SLinus Torvalds goto done; 13063e13fa1eSAndre Guedes 13073e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13083e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13093e13fa1eSAndre Guedes */ 131074316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13113e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13123e13fa1eSAndre Guedes return -EINTR; 131370f23020SAndrei Emeltchenko } 13141da177e4SLinus Torvalds 13158fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13168fc9ced3SGustavo Padovan * 255 entries 13178fc9ced3SGustavo Padovan */ 13181da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13191da177e4SLinus Torvalds 13201da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13211da177e4SLinus Torvalds * copy it to the user space. 13221da177e4SLinus Torvalds */ 13236da2ec56SKees Cook buf = kmalloc_array(max_rsp, sizeof(struct inquiry_info), GFP_KERNEL); 132470f23020SAndrei Emeltchenko if (!buf) { 13251da177e4SLinus Torvalds err = -ENOMEM; 13261da177e4SLinus Torvalds goto done; 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds 132909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13301da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 133109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13321da177e4SLinus Torvalds 13331da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13361da177e4SLinus Torvalds ptr += sizeof(ir); 13371da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13381da177e4SLinus Torvalds ir.num_rsp)) 13391da177e4SLinus Torvalds err = -EFAULT; 13401da177e4SLinus Torvalds } else 13411da177e4SLinus Torvalds err = -EFAULT; 13421da177e4SLinus Torvalds 13431da177e4SLinus Torvalds kfree(buf); 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds done: 13461da177e4SLinus Torvalds hci_dev_put(hdev); 13471da177e4SLinus Torvalds return err; 13481da177e4SLinus Torvalds } 13491da177e4SLinus Torvalds 1350cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13511da177e4SLinus Torvalds { 13521da177e4SLinus Torvalds int ret = 0; 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13551da177e4SLinus Torvalds 1356b504430cSJohan Hedberg hci_req_sync_lock(hdev); 13571da177e4SLinus Torvalds 1358d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 135994324962SJohan Hovold ret = -ENODEV; 136094324962SJohan Hovold goto done; 136194324962SJohan Hovold } 136294324962SJohan Hovold 1363d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1364d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1365a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1366a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1367bf543036SJohan Hedberg */ 1368d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1369611b30f7SMarcel Holtmann ret = -ERFKILL; 1370611b30f7SMarcel Holtmann goto done; 1371611b30f7SMarcel Holtmann } 1372611b30f7SMarcel Holtmann 1373a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1374a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1375a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1376a5c8f270SMarcel Holtmann * or not. 1377a5c8f270SMarcel Holtmann * 1378c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1379c6beca0eSMarcel Holtmann * if a public address or static random address is 1380c6beca0eSMarcel Holtmann * available. 1381c6beca0eSMarcel Holtmann * 1382a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1383a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1384a5c8f270SMarcel Holtmann */ 1385d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1386ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY && 1387a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1388a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1389a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1390a5c8f270SMarcel Holtmann goto done; 1391a5c8f270SMarcel Holtmann } 1392a5c8f270SMarcel Holtmann } 1393a5c8f270SMarcel Holtmann 13941da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 13951da177e4SLinus Torvalds ret = -EALREADY; 13961da177e4SLinus Torvalds goto done; 13971da177e4SLinus Torvalds } 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds if (hdev->open(hdev)) { 14001da177e4SLinus Torvalds ret = -EIO; 14011da177e4SLinus Torvalds goto done; 14021da177e4SLinus Torvalds } 14031da177e4SLinus Torvalds 1404e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 140505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 14064a3f95b7SMarcel Holtmann 14071da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14081da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1409f41c70c4SMarcel Holtmann 1410d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) { 1411e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1412e131d74aSMarcel Holtmann 1413af202f84SMarcel Holtmann if (hdev->setup) 1414f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1415f41c70c4SMarcel Holtmann 1416af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1417af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1418af202f84SMarcel Holtmann * 1419af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1420af202f84SMarcel Holtmann * start up as unconfigured. 1421af202f84SMarcel Holtmann */ 1422eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1423eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 1424a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1425f41c70c4SMarcel Holtmann 14260ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 14270ebca7d6SMarcel Holtmann * read at least the version information provided by 14280ebca7d6SMarcel Holtmann * the Read Local Version Information command. 14290ebca7d6SMarcel Holtmann * 14300ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 14310ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 14320ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 14330ebca7d6SMarcel Holtmann */ 1434d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 14350ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 143689bc22d2SMarcel Holtmann } 143789bc22d2SMarcel Holtmann 1438d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 14399713c17bSMarcel Holtmann /* If public address change is configured, ensure that 14409713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 14419713c17bSMarcel Holtmann * support changing the public address, fail the power 14429713c17bSMarcel Holtmann * on procedure. 144324c457e2SMarcel Holtmann */ 14449713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14459713c17bSMarcel Holtmann hdev->set_bdaddr) 144624c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 144724c457e2SMarcel Holtmann else 144824c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 144924c457e2SMarcel Holtmann } 145024c457e2SMarcel Holtmann 1451f41c70c4SMarcel Holtmann if (!ret) { 1452d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 145398a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 14542177bab5SJohan Hedberg ret = __hci_init(hdev); 145598a63aafSMarcel Holtmann if (!ret && hdev->post_init) 145698a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 145798a63aafSMarcel Holtmann } 14581da177e4SLinus Torvalds } 14591da177e4SLinus Torvalds 14607e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 14617e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 14627e995b9eSMarcel Holtmann * completed. 14637e995b9eSMarcel Holtmann */ 14647e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1465b56c7b25SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 14667e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 14677e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 14687e995b9eSMarcel Holtmann 1469f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1470f41c70c4SMarcel Holtmann 14711da177e4SLinus Torvalds if (!ret) { 14721da177e4SLinus Torvalds hci_dev_hold(hdev); 1473a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 14741da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 147505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 14766d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, true); 1477d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1478d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1479d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1480d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 14812ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 1482ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY) { 14832ff13894SJohan Hedberg ret = __hci_req_hci_power_on(hdev); 14842ff13894SJohan Hedberg mgmt_power_on(hdev, ret); 148556e5cb86SJohan Hedberg } 14861da177e4SLinus Torvalds } else { 14871da177e4SLinus Torvalds /* Init failed, cleanup */ 14883eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1489c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1490b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14931da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds if (hdev->flush) 14961da177e4SLinus Torvalds hdev->flush(hdev); 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds if (hdev->sent_cmd) { 14991da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15001da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15011da177e4SLinus Torvalds } 15021da177e4SLinus Torvalds 1503e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 150405fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 15054a3f95b7SMarcel Holtmann 15061da177e4SLinus Torvalds hdev->close(hdev); 1507fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 15081da177e4SLinus Torvalds } 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds done: 1511b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 15121da177e4SLinus Torvalds return ret; 15131da177e4SLinus Torvalds } 15141da177e4SLinus Torvalds 1515cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1516cbed0ca1SJohan Hedberg 1517cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1518cbed0ca1SJohan Hedberg { 1519cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1520cbed0ca1SJohan Hedberg int err; 1521cbed0ca1SJohan Hedberg 1522cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1523cbed0ca1SJohan Hedberg if (!hdev) 1524cbed0ca1SJohan Hedberg return -ENODEV; 1525cbed0ca1SJohan Hedberg 15264a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1527fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1528fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1529fee746b0SMarcel Holtmann * possible. 1530fee746b0SMarcel Holtmann * 1531fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1532fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1533fee746b0SMarcel Holtmann * open the device. 1534fee746b0SMarcel Holtmann */ 1535d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1536d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1537fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1538fee746b0SMarcel Holtmann goto done; 1539fee746b0SMarcel Holtmann } 1540fee746b0SMarcel Holtmann 1541e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1542e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1543e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1544e1d08f40SJohan Hedberg * completed. 1545e1d08f40SJohan Hedberg */ 1546a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1547e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1548e1d08f40SJohan Hedberg 1549a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1550a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1551a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1552a5c8f270SMarcel Holtmann */ 1553e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1554e1d08f40SJohan Hedberg 155512aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1556b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 155712aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 155812aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 155912aa4f0aSMarcel Holtmann * to explicitly enable it. 156012aa4f0aSMarcel Holtmann */ 1561d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1562d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1563a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 156412aa4f0aSMarcel Holtmann 1565cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1566cbed0ca1SJohan Hedberg 1567fee746b0SMarcel Holtmann done: 1568cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1569cbed0ca1SJohan Hedberg return err; 1570cbed0ca1SJohan Hedberg } 1571cbed0ca1SJohan Hedberg 1572d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1573d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1574d7347f3cSJohan Hedberg { 1575d7347f3cSJohan Hedberg struct hci_conn_params *p; 1576d7347f3cSJohan Hedberg 1577f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1578f161dd41SJohan Hedberg if (p->conn) { 1579f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1580f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1581f161dd41SJohan Hedberg p->conn = NULL; 1582f161dd41SJohan Hedberg } 1583d7347f3cSJohan Hedberg list_del_init(&p->action); 1584f161dd41SJohan Hedberg } 1585d7347f3cSJohan Hedberg 1586d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1587d7347f3cSJohan Hedberg } 1588d7347f3cSJohan Hedberg 15896b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 15901da177e4SLinus Torvalds { 1591acc649c6SMarcel Holtmann bool auto_off; 1592acc649c6SMarcel Holtmann 15931da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 15941da177e4SLinus Torvalds 1595d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1596867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1597d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1598a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1599a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1600a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1601a44fecbdSTedd Ho-Jeong An } 1602a44fecbdSTedd Ho-Jeong An 160378c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 160478c04c0bSVinicius Costa Gomes 16057df0f73eSJohan Hedberg hci_request_cancel_all(hdev); 1606b504430cSJohan Hedberg hci_req_sync_lock(hdev); 16071da177e4SLinus Torvalds 16081da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 160965cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 1610b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 16111da177e4SLinus Torvalds return 0; 16121da177e4SLinus Torvalds } 16131da177e4SLinus Torvalds 16146d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, false); 16156d5d2ee6SHeiner Kallweit 16163eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16173eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1618b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16191da177e4SLinus Torvalds 162016ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 162116ab91abSJohan Hedberg hdev->discov_timeout = 0; 1622a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1623a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 162416ab91abSJohan Hedberg } 162516ab91abSJohan Hedberg 1626a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 16277d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 16287d78525dSJohan Hedberg 1629d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_MGMT)) 1630d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 16317ba8b4beSAndre Guedes 163276727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 163376727c02SJohan Hedberg * ensuring the workqueue is empty up front. 163476727c02SJohan Hedberg */ 163576727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 163676727c02SJohan Hedberg 163709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16381aeb9c65SJohan Hedberg 16398f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 16408f502f84SJohan Hedberg 1641acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1642acc649c6SMarcel Holtmann 1643ca8bee5dSMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_PRIMARY && 1644baab7932SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 16452ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT)) 16462ff13894SJohan Hedberg __mgmt_power_off(hdev); 16471aeb9c65SJohan Hedberg 16481f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1649d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1650f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 165109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16521da177e4SLinus Torvalds 165364dae967SMarcel Holtmann smp_unregister(hdev); 165464dae967SMarcel Holtmann 165505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 16561da177e4SLinus Torvalds 16571da177e4SLinus Torvalds if (hdev->flush) 16581da177e4SLinus Torvalds hdev->flush(hdev); 16591da177e4SLinus Torvalds 16601da177e4SLinus Torvalds /* Reset device */ 16611da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16621da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1663acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1664acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 16651da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 16664ebeee2dSJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT, NULL); 16671da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 16681da177e4SLinus Torvalds } 16691da177e4SLinus Torvalds 1670c347b765SGustavo F. Padovan /* flush cmd work */ 1671c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 16721da177e4SLinus Torvalds 16731da177e4SLinus Torvalds /* Drop queues */ 16741da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16751da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16761da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 16771da177e4SLinus Torvalds 16781da177e4SLinus Torvalds /* Drop last sent command */ 16791da177e4SLinus Torvalds if (hdev->sent_cmd) { 168065cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16811da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16821da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16831da177e4SLinus Torvalds } 16841da177e4SLinus Torvalds 1685e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 168605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 16874a3f95b7SMarcel Holtmann 16881da177e4SLinus Torvalds /* After this point our queues are empty 16891da177e4SLinus Torvalds * and no tasks are scheduled. */ 16901da177e4SLinus Torvalds hdev->close(hdev); 16911da177e4SLinus Torvalds 169235b973c9SJohan Hedberg /* Clear flags */ 1693fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1694eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 169535b973c9SJohan Hedberg 1696ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1697536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1698ced5c338SAndrei Emeltchenko 1699e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 170009b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 17017a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1702e59fda8dSJohan Hedberg 1703b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 17041da177e4SLinus Torvalds 17051da177e4SLinus Torvalds hci_dev_put(hdev); 17061da177e4SLinus Torvalds return 0; 17071da177e4SLinus Torvalds } 17081da177e4SLinus Torvalds 17091da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 17101da177e4SLinus Torvalds { 17111da177e4SLinus Torvalds struct hci_dev *hdev; 17121da177e4SLinus Torvalds int err; 17131da177e4SLinus Torvalds 171470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 171570f23020SAndrei Emeltchenko if (!hdev) 17161da177e4SLinus Torvalds return -ENODEV; 17178ee56540SMarcel Holtmann 1718d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17190736cfa8SMarcel Holtmann err = -EBUSY; 17200736cfa8SMarcel Holtmann goto done; 17210736cfa8SMarcel Holtmann } 17220736cfa8SMarcel Holtmann 1723a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 17248ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 17258ee56540SMarcel Holtmann 17261da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 17278ee56540SMarcel Holtmann 17280736cfa8SMarcel Holtmann done: 17291da177e4SLinus Torvalds hci_dev_put(hdev); 17301da177e4SLinus Torvalds return err; 17311da177e4SLinus Torvalds } 17321da177e4SLinus Torvalds 17335c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 17341da177e4SLinus Torvalds { 17355c912495SMarcel Holtmann int ret; 17361da177e4SLinus Torvalds 17375c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 17381da177e4SLinus Torvalds 1739b504430cSJohan Hedberg hci_req_sync_lock(hdev); 17401da177e4SLinus Torvalds 17411da177e4SLinus Torvalds /* Drop queues */ 17421da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17431da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17441da177e4SLinus Torvalds 174576727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 174676727c02SJohan Hedberg * ensuring the workqueue is empty up front. 174776727c02SJohan Hedberg */ 174876727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 174976727c02SJohan Hedberg 175009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17511f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17521da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 175309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17541da177e4SLinus Torvalds 17551da177e4SLinus Torvalds if (hdev->flush) 17561da177e4SLinus Torvalds hdev->flush(hdev); 17571da177e4SLinus Torvalds 17581da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17596ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 17601da177e4SLinus Torvalds 17614ebeee2dSJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT, NULL); 17621da177e4SLinus Torvalds 1763b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 17641da177e4SLinus Torvalds return ret; 17651da177e4SLinus Torvalds } 17661da177e4SLinus Torvalds 17675c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 17685c912495SMarcel Holtmann { 17695c912495SMarcel Holtmann struct hci_dev *hdev; 17705c912495SMarcel Holtmann int err; 17715c912495SMarcel Holtmann 17725c912495SMarcel Holtmann hdev = hci_dev_get(dev); 17735c912495SMarcel Holtmann if (!hdev) 17745c912495SMarcel Holtmann return -ENODEV; 17755c912495SMarcel Holtmann 17765c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 17775c912495SMarcel Holtmann err = -ENETDOWN; 17785c912495SMarcel Holtmann goto done; 17795c912495SMarcel Holtmann } 17805c912495SMarcel Holtmann 1781d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17825c912495SMarcel Holtmann err = -EBUSY; 17835c912495SMarcel Holtmann goto done; 17845c912495SMarcel Holtmann } 17855c912495SMarcel Holtmann 1786d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17875c912495SMarcel Holtmann err = -EOPNOTSUPP; 17885c912495SMarcel Holtmann goto done; 17895c912495SMarcel Holtmann } 17905c912495SMarcel Holtmann 17915c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 17925c912495SMarcel Holtmann 17935c912495SMarcel Holtmann done: 17945c912495SMarcel Holtmann hci_dev_put(hdev); 17955c912495SMarcel Holtmann return err; 17965c912495SMarcel Holtmann } 17975c912495SMarcel Holtmann 17981da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 17991da177e4SLinus Torvalds { 18001da177e4SLinus Torvalds struct hci_dev *hdev; 18011da177e4SLinus Torvalds int ret = 0; 18021da177e4SLinus Torvalds 180370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 180470f23020SAndrei Emeltchenko if (!hdev) 18051da177e4SLinus Torvalds return -ENODEV; 18061da177e4SLinus Torvalds 1807d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18080736cfa8SMarcel Holtmann ret = -EBUSY; 18090736cfa8SMarcel Holtmann goto done; 18100736cfa8SMarcel Holtmann } 18110736cfa8SMarcel Holtmann 1812d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1813fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1814fee746b0SMarcel Holtmann goto done; 1815fee746b0SMarcel Holtmann } 1816fee746b0SMarcel Holtmann 18171da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 18181da177e4SLinus Torvalds 18190736cfa8SMarcel Holtmann done: 18201da177e4SLinus Torvalds hci_dev_put(hdev); 18211da177e4SLinus Torvalds return ret; 18221da177e4SLinus Torvalds } 18231da177e4SLinus Torvalds 1824123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1825123abc08SJohan Hedberg { 1826bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1827123abc08SJohan Hedberg 1828123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1829123abc08SJohan Hedberg 1830123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1831238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1832238be788SMarcel Holtmann HCI_CONNECTABLE); 1833123abc08SJohan Hedberg else 1834a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1835a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1836123abc08SJohan Hedberg 1837bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1838238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1839238be788SMarcel Holtmann HCI_DISCOVERABLE); 1840bc6d2d04SJohan Hedberg } else { 1841a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1842a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1843a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1844bc6d2d04SJohan Hedberg } 1845bc6d2d04SJohan Hedberg 1846d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1847123abc08SJohan Hedberg return; 1848123abc08SJohan Hedberg 1849bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1850bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1851a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1852bc6d2d04SJohan Hedberg 1853d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1854cab054abSJohan Hedberg hci_req_update_adv_data(hdev, hdev->cur_adv_instance); 1855bc6d2d04SJohan Hedberg 1856123abc08SJohan Hedberg mgmt_new_settings(hdev); 1857123abc08SJohan Hedberg } 1858bc6d2d04SJohan Hedberg } 1859123abc08SJohan Hedberg 18601da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 18611da177e4SLinus Torvalds { 18621da177e4SLinus Torvalds struct hci_dev *hdev; 18631da177e4SLinus Torvalds struct hci_dev_req dr; 18641da177e4SLinus Torvalds int err = 0; 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 18671da177e4SLinus Torvalds return -EFAULT; 18681da177e4SLinus Torvalds 186970f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 187070f23020SAndrei Emeltchenko if (!hdev) 18711da177e4SLinus Torvalds return -ENODEV; 18721da177e4SLinus Torvalds 1873d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18740736cfa8SMarcel Holtmann err = -EBUSY; 18750736cfa8SMarcel Holtmann goto done; 18760736cfa8SMarcel Holtmann } 18770736cfa8SMarcel Holtmann 1878d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1879fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1880fee746b0SMarcel Holtmann goto done; 1881fee746b0SMarcel Holtmann } 1882fee746b0SMarcel Holtmann 1883ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 18845b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 18855b69bef5SMarcel Holtmann goto done; 18865b69bef5SMarcel Holtmann } 18875b69bef5SMarcel Holtmann 1888d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 188956f87901SJohan Hedberg err = -EOPNOTSUPP; 189056f87901SJohan Hedberg goto done; 189156f87901SJohan Hedberg } 189256f87901SJohan Hedberg 18931da177e4SLinus Torvalds switch (cmd) { 18941da177e4SLinus Torvalds case HCISETAUTH: 189501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18964ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18971da177e4SLinus Torvalds break; 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds case HCISETENCRYPT: 19001da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 19011da177e4SLinus Torvalds err = -EOPNOTSUPP; 19021da177e4SLinus Torvalds break; 19031da177e4SLinus Torvalds } 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 19061da177e4SLinus Torvalds /* Auth must be enabled first */ 190701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19084ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19091da177e4SLinus Torvalds if (err) 19101da177e4SLinus Torvalds break; 19111da177e4SLinus Torvalds } 19121da177e4SLinus Torvalds 191301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19144ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19151da177e4SLinus Torvalds break; 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds case HCISETSCAN: 191801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19194ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 192091a668b0SJohan Hedberg 1921bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1922bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 192391a668b0SJohan Hedberg */ 1924123abc08SJohan Hedberg if (!err) 1925123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 19261da177e4SLinus Torvalds break; 19271da177e4SLinus Torvalds 19281da177e4SLinus Torvalds case HCISETLINKPOL: 192901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19304ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19311da177e4SLinus Torvalds break; 19321da177e4SLinus Torvalds 19331da177e4SLinus Torvalds case HCISETLINKMODE: 1934e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1935e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1936e4e8e37cSMarcel Holtmann break; 1937e4e8e37cSMarcel Holtmann 1938e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1939b7c23df8SJaganath Kanakkassery if (hdev->pkt_type == (__u16) dr.dev_opt) 1940b7c23df8SJaganath Kanakkassery break; 1941b7c23df8SJaganath Kanakkassery 1942e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 1943b7c23df8SJaganath Kanakkassery mgmt_phy_configuration_changed(hdev, NULL); 19441da177e4SLinus Torvalds break; 19451da177e4SLinus Torvalds 19461da177e4SLinus Torvalds case HCISETACLMTU: 19471da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 19481da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 19491da177e4SLinus Torvalds break; 19501da177e4SLinus Torvalds 19511da177e4SLinus Torvalds case HCISETSCOMTU: 19521da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 19531da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 19541da177e4SLinus Torvalds break; 19551da177e4SLinus Torvalds 19561da177e4SLinus Torvalds default: 19571da177e4SLinus Torvalds err = -EINVAL; 19581da177e4SLinus Torvalds break; 19591da177e4SLinus Torvalds } 1960e4e8e37cSMarcel Holtmann 19610736cfa8SMarcel Holtmann done: 19621da177e4SLinus Torvalds hci_dev_put(hdev); 19631da177e4SLinus Torvalds return err; 19641da177e4SLinus Torvalds } 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 19671da177e4SLinus Torvalds { 19688035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 19691da177e4SLinus Torvalds struct hci_dev_list_req *dl; 19701da177e4SLinus Torvalds struct hci_dev_req *dr; 19711da177e4SLinus Torvalds int n = 0, size, err; 19721da177e4SLinus Torvalds __u16 dev_num; 19731da177e4SLinus Torvalds 19741da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 19751da177e4SLinus Torvalds return -EFAULT; 19761da177e4SLinus Torvalds 19771da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 19781da177e4SLinus Torvalds return -EINVAL; 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 19811da177e4SLinus Torvalds 198270f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 198370f23020SAndrei Emeltchenko if (!dl) 19841da177e4SLinus Torvalds return -ENOMEM; 19851da177e4SLinus Torvalds 19861da177e4SLinus Torvalds dr = dl->dev_req; 19871da177e4SLinus Torvalds 1988f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 19898035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 19902e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 1991c542a06cSJohan Hedberg 19922e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19932e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19942e84d8dbSMarcel Holtmann * device is actually down. 19952e84d8dbSMarcel Holtmann */ 1996d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 19972e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 1998c542a06cSJohan Hedberg 19991da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 20002e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2001c542a06cSJohan Hedberg 20021da177e4SLinus Torvalds if (++n >= dev_num) 20031da177e4SLinus Torvalds break; 20041da177e4SLinus Torvalds } 2005f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 20061da177e4SLinus Torvalds 20071da177e4SLinus Torvalds dl->dev_num = n; 20081da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 20091da177e4SLinus Torvalds 20101da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 20111da177e4SLinus Torvalds kfree(dl); 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds return err ? -EFAULT : 0; 20141da177e4SLinus Torvalds } 20151da177e4SLinus Torvalds 20161da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20171da177e4SLinus Torvalds { 20181da177e4SLinus Torvalds struct hci_dev *hdev; 20191da177e4SLinus Torvalds struct hci_dev_info di; 20202e84d8dbSMarcel Holtmann unsigned long flags; 20211da177e4SLinus Torvalds int err = 0; 20221da177e4SLinus Torvalds 20231da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 20241da177e4SLinus Torvalds return -EFAULT; 20251da177e4SLinus Torvalds 202670f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 202770f23020SAndrei Emeltchenko if (!hdev) 20281da177e4SLinus Torvalds return -ENODEV; 20291da177e4SLinus Torvalds 20302e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20312e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20322e84d8dbSMarcel Holtmann * device is actually down. 20332e84d8dbSMarcel Holtmann */ 2034d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20352e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 20362e84d8dbSMarcel Holtmann else 20372e84d8dbSMarcel Holtmann flags = hdev->flags; 2038c542a06cSJohan Hedberg 20391da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20401da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 204160f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20422e84d8dbSMarcel Holtmann di.flags = flags; 20431da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2044572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 20451da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 20461da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 20471da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 20481da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2049572c7f84SJohan Hedberg } else { 2050572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2051572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2052572c7f84SJohan Hedberg di.sco_mtu = 0; 2053572c7f84SJohan Hedberg di.sco_pkts = 0; 2054572c7f84SJohan Hedberg } 20551da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 20561da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 20591da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 20601da177e4SLinus Torvalds 20611da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 20621da177e4SLinus Torvalds err = -EFAULT; 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds hci_dev_put(hdev); 20651da177e4SLinus Torvalds 20661da177e4SLinus Torvalds return err; 20671da177e4SLinus Torvalds } 20681da177e4SLinus Torvalds 20691da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 20701da177e4SLinus Torvalds 2071611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2072611b30f7SMarcel Holtmann { 2073611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2074611b30f7SMarcel Holtmann 2075611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2076611b30f7SMarcel Holtmann 2077d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 20780736cfa8SMarcel Holtmann return -EBUSY; 20790736cfa8SMarcel Holtmann 20805e130367SJohan Hedberg if (blocked) { 2081a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2082d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2083d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2084611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 20855e130367SJohan Hedberg } else { 2086a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 20875e130367SJohan Hedberg } 2088611b30f7SMarcel Holtmann 2089611b30f7SMarcel Holtmann return 0; 2090611b30f7SMarcel Holtmann } 2091611b30f7SMarcel Holtmann 2092611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2093611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2094611b30f7SMarcel Holtmann }; 2095611b30f7SMarcel Holtmann 2096ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2097ab81cbf9SJohan Hedberg { 2098ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 209996570ffcSJohan Hedberg int err; 2100ab81cbf9SJohan Hedberg 2101ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2102ab81cbf9SJohan Hedberg 21032ff13894SJohan Hedberg if (test_bit(HCI_UP, &hdev->flags) && 21042ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 21052ff13894SJohan Hedberg hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) { 2106d82142a8SWei-Ning Huang cancel_delayed_work(&hdev->power_off); 21072ff13894SJohan Hedberg hci_req_sync_lock(hdev); 21082ff13894SJohan Hedberg err = __hci_req_hci_power_on(hdev); 21092ff13894SJohan Hedberg hci_req_sync_unlock(hdev); 21102ff13894SJohan Hedberg mgmt_power_on(hdev, err); 21112ff13894SJohan Hedberg return; 21122ff13894SJohan Hedberg } 21132ff13894SJohan Hedberg 2114cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 211596570ffcSJohan Hedberg if (err < 0) { 21163ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 211796570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 21183ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2119ab81cbf9SJohan Hedberg return; 212096570ffcSJohan Hedberg } 2121ab81cbf9SJohan Hedberg 2122a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2123a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2124a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2125a5c8f270SMarcel Holtmann */ 2126d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2127d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2128ca8bee5dSMarcel Holtmann (hdev->dev_type == HCI_PRIMARY && 2129a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2130a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2131a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2132bf543036SJohan Hedberg hci_dev_do_close(hdev); 2133d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 213419202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 213519202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2136bf543036SJohan Hedberg } 2137ab81cbf9SJohan Hedberg 2138a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 21394a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 21404a964404SMarcel Holtmann * so that userspace can easily identify them. 21414a964404SMarcel Holtmann */ 2142d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 21434a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 21440602a8adSMarcel Holtmann 21450602a8adSMarcel Holtmann /* For fully configured devices, this will send 21460602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 21470602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 21480602a8adSMarcel Holtmann * 21490602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 21500602a8adSMarcel Holtmann * and no event will be send. 21510602a8adSMarcel Holtmann */ 2152744cf19eSJohan Hedberg mgmt_index_added(hdev); 2153a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 21545ea234d3SMarcel Holtmann /* When the controller is now configured, then it 21555ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 21565ea234d3SMarcel Holtmann */ 2157d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 21585ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 21595ea234d3SMarcel Holtmann 2160d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2161d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2162d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2163d603b76bSMarcel Holtmann */ 2164d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2165ab81cbf9SJohan Hedberg } 2166ab81cbf9SJohan Hedberg } 2167ab81cbf9SJohan Hedberg 2168ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2169ab81cbf9SJohan Hedberg { 21703243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 21713243553fSJohan Hedberg power_off.work); 2172ab81cbf9SJohan Hedberg 2173ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2174ab81cbf9SJohan Hedberg 21758ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2176ab81cbf9SJohan Hedberg } 2177ab81cbf9SJohan Hedberg 2178c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2179c7741d16SMarcel Holtmann { 2180c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2181c7741d16SMarcel Holtmann 2182c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2183c7741d16SMarcel Holtmann 2184c7741d16SMarcel Holtmann if (hdev->hw_error) 2185c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2186c7741d16SMarcel Holtmann else 21872064ee33SMarcel Holtmann bt_dev_err(hdev, "hardware error 0x%2.2x", hdev->hw_error_code); 2188c7741d16SMarcel Holtmann 2189c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2190c7741d16SMarcel Holtmann return; 2191c7741d16SMarcel Holtmann 2192c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2193c7741d16SMarcel Holtmann } 2194c7741d16SMarcel Holtmann 219535f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 21962aeb9a1aSJohan Hedberg { 21974821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 21982aeb9a1aSJohan Hedberg 21994821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 22004821002cSJohan Hedberg list_del(&uuid->list); 22012aeb9a1aSJohan Hedberg kfree(uuid); 22022aeb9a1aSJohan Hedberg } 22032aeb9a1aSJohan Hedberg } 22042aeb9a1aSJohan Hedberg 220535f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 220655ed8ca1SJohan Hedberg { 220755ed8ca1SJohan Hedberg struct link_key *key; 220855ed8ca1SJohan Hedberg 22090378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 22100378b597SJohan Hedberg list_del_rcu(&key->list); 22110378b597SJohan Hedberg kfree_rcu(key, rcu); 221255ed8ca1SJohan Hedberg } 221355ed8ca1SJohan Hedberg } 221455ed8ca1SJohan Hedberg 221535f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2216b899efafSVinicius Costa Gomes { 2217970d0f1bSJohan Hedberg struct smp_ltk *k; 2218b899efafSVinicius Costa Gomes 2219970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2220970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2221970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2222b899efafSVinicius Costa Gomes } 2223b899efafSVinicius Costa Gomes } 2224b899efafSVinicius Costa Gomes 2225970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2226970c4e46SJohan Hedberg { 2227adae20cbSJohan Hedberg struct smp_irk *k; 2228970c4e46SJohan Hedberg 2229adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2230adae20cbSJohan Hedberg list_del_rcu(&k->list); 2231adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2232970c4e46SJohan Hedberg } 2233970c4e46SJohan Hedberg } 2234970c4e46SJohan Hedberg 223555ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 223655ed8ca1SJohan Hedberg { 223755ed8ca1SJohan Hedberg struct link_key *k; 223855ed8ca1SJohan Hedberg 22390378b597SJohan Hedberg rcu_read_lock(); 22400378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 22410378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 22420378b597SJohan Hedberg rcu_read_unlock(); 224355ed8ca1SJohan Hedberg return k; 22440378b597SJohan Hedberg } 22450378b597SJohan Hedberg } 22460378b597SJohan Hedberg rcu_read_unlock(); 224755ed8ca1SJohan Hedberg 224855ed8ca1SJohan Hedberg return NULL; 224955ed8ca1SJohan Hedberg } 225055ed8ca1SJohan Hedberg 2251745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2252d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2253d25e28abSJohan Hedberg { 2254d25e28abSJohan Hedberg /* Legacy key */ 2255d25e28abSJohan Hedberg if (key_type < 0x03) 2256745c0ce3SVishal Agarwal return true; 2257d25e28abSJohan Hedberg 2258d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2259d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2260745c0ce3SVishal Agarwal return false; 2261d25e28abSJohan Hedberg 2262d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2263d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2264745c0ce3SVishal Agarwal return false; 2265d25e28abSJohan Hedberg 2266d25e28abSJohan Hedberg /* Security mode 3 case */ 2267d25e28abSJohan Hedberg if (!conn) 2268745c0ce3SVishal Agarwal return true; 2269d25e28abSJohan Hedberg 2270e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2271e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2272e3befab9SJohan Hedberg return true; 2273e3befab9SJohan Hedberg 2274d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2275d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2276745c0ce3SVishal Agarwal return true; 2277d25e28abSJohan Hedberg 2278d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2279d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2280745c0ce3SVishal Agarwal return true; 2281d25e28abSJohan Hedberg 2282d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2283d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2284745c0ce3SVishal Agarwal return true; 2285d25e28abSJohan Hedberg 2286d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2287d25e28abSJohan Hedberg * persistently */ 2288745c0ce3SVishal Agarwal return false; 2289d25e28abSJohan Hedberg } 2290d25e28abSJohan Hedberg 2291e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 229298a0b845SJohan Hedberg { 2293e804d25dSJohan Hedberg if (type == SMP_LTK) 2294e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 229598a0b845SJohan Hedberg 2296e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 229798a0b845SJohan Hedberg } 229898a0b845SJohan Hedberg 2299f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2300e804d25dSJohan Hedberg u8 addr_type, u8 role) 230175d262c2SVinicius Costa Gomes { 2302c9839a11SVinicius Costa Gomes struct smp_ltk *k; 230375d262c2SVinicius Costa Gomes 2304970d0f1bSJohan Hedberg rcu_read_lock(); 2305970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 23065378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 23075378bc56SJohan Hedberg continue; 23085378bc56SJohan Hedberg 2309923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2310970d0f1bSJohan Hedberg rcu_read_unlock(); 231175d262c2SVinicius Costa Gomes return k; 2312970d0f1bSJohan Hedberg } 2313970d0f1bSJohan Hedberg } 2314970d0f1bSJohan Hedberg rcu_read_unlock(); 231575d262c2SVinicius Costa Gomes 231675d262c2SVinicius Costa Gomes return NULL; 231775d262c2SVinicius Costa Gomes } 231875d262c2SVinicius Costa Gomes 2319970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2320970c4e46SJohan Hedberg { 2321970c4e46SJohan Hedberg struct smp_irk *irk; 2322970c4e46SJohan Hedberg 2323adae20cbSJohan Hedberg rcu_read_lock(); 2324adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2325adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2326adae20cbSJohan Hedberg rcu_read_unlock(); 2327970c4e46SJohan Hedberg return irk; 2328970c4e46SJohan Hedberg } 2329adae20cbSJohan Hedberg } 2330970c4e46SJohan Hedberg 2331adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2332defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2333970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2334adae20cbSJohan Hedberg rcu_read_unlock(); 2335970c4e46SJohan Hedberg return irk; 2336970c4e46SJohan Hedberg } 2337970c4e46SJohan Hedberg } 2338adae20cbSJohan Hedberg rcu_read_unlock(); 2339970c4e46SJohan Hedberg 2340970c4e46SJohan Hedberg return NULL; 2341970c4e46SJohan Hedberg } 2342970c4e46SJohan Hedberg 2343970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2344970c4e46SJohan Hedberg u8 addr_type) 2345970c4e46SJohan Hedberg { 2346970c4e46SJohan Hedberg struct smp_irk *irk; 2347970c4e46SJohan Hedberg 23486cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 23496cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 23506cfc9988SJohan Hedberg return NULL; 23516cfc9988SJohan Hedberg 2352adae20cbSJohan Hedberg rcu_read_lock(); 2353adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2354970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2355adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2356adae20cbSJohan Hedberg rcu_read_unlock(); 2357970c4e46SJohan Hedberg return irk; 2358970c4e46SJohan Hedberg } 2359adae20cbSJohan Hedberg } 2360adae20cbSJohan Hedberg rcu_read_unlock(); 2361970c4e46SJohan Hedberg 2362970c4e46SJohan Hedberg return NULL; 2363970c4e46SJohan Hedberg } 2364970c4e46SJohan Hedberg 2365567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 23667652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 23677652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 236855ed8ca1SJohan Hedberg { 236955ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2370745c0ce3SVishal Agarwal u8 old_key_type; 237155ed8ca1SJohan Hedberg 237255ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 237355ed8ca1SJohan Hedberg if (old_key) { 237455ed8ca1SJohan Hedberg old_key_type = old_key->type; 237555ed8ca1SJohan Hedberg key = old_key; 237655ed8ca1SJohan Hedberg } else { 237712adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 23780a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 237955ed8ca1SJohan Hedberg if (!key) 2380567fa2aaSJohan Hedberg return NULL; 23810378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 238255ed8ca1SJohan Hedberg } 238355ed8ca1SJohan Hedberg 23846ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 238555ed8ca1SJohan Hedberg 2386d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2387d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2388d25e28abSJohan Hedberg * previous key */ 2389d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2390a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2391d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2392655fe6ecSJohan Hedberg if (conn) 2393655fe6ecSJohan Hedberg conn->key_type = type; 2394655fe6ecSJohan Hedberg } 2395d25e28abSJohan Hedberg 239655ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 23979b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 239855ed8ca1SJohan Hedberg key->pin_len = pin_len; 239955ed8ca1SJohan Hedberg 2400b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 240155ed8ca1SJohan Hedberg key->type = old_key_type; 24024748fed2SJohan Hedberg else 24034748fed2SJohan Hedberg key->type = type; 24044748fed2SJohan Hedberg 24057652ff6aSJohan Hedberg if (persistent) 24067652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 24077652ff6aSJohan Hedberg old_key_type); 24084df378a1SJohan Hedberg 2409567fa2aaSJohan Hedberg return key; 241055ed8ca1SJohan Hedberg } 241155ed8ca1SJohan Hedberg 2412ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 241335d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2414fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 241575d262c2SVinicius Costa Gomes { 2416c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2417e804d25dSJohan Hedberg u8 role = ltk_role(type); 241875d262c2SVinicius Costa Gomes 2419f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2420c9839a11SVinicius Costa Gomes if (old_key) 242175d262c2SVinicius Costa Gomes key = old_key; 2422c9839a11SVinicius Costa Gomes else { 24230a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 242475d262c2SVinicius Costa Gomes if (!key) 2425ca9142b8SJohan Hedberg return NULL; 2426970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 242775d262c2SVinicius Costa Gomes } 242875d262c2SVinicius Costa Gomes 242975d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2430c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2431c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2432c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2433c9839a11SVinicius Costa Gomes key->ediv = ediv; 2434fe39c7b2SMarcel Holtmann key->rand = rand; 2435c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2436c9839a11SVinicius Costa Gomes key->type = type; 243775d262c2SVinicius Costa Gomes 2438ca9142b8SJohan Hedberg return key; 243975d262c2SVinicius Costa Gomes } 244075d262c2SVinicius Costa Gomes 2441ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2442ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2443970c4e46SJohan Hedberg { 2444970c4e46SJohan Hedberg struct smp_irk *irk; 2445970c4e46SJohan Hedberg 2446970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2447970c4e46SJohan Hedberg if (!irk) { 2448970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2449970c4e46SJohan Hedberg if (!irk) 2450ca9142b8SJohan Hedberg return NULL; 2451970c4e46SJohan Hedberg 2452970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2453970c4e46SJohan Hedberg irk->addr_type = addr_type; 2454970c4e46SJohan Hedberg 2455adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2456970c4e46SJohan Hedberg } 2457970c4e46SJohan Hedberg 2458970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2459970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2460970c4e46SJohan Hedberg 2461ca9142b8SJohan Hedberg return irk; 2462970c4e46SJohan Hedberg } 2463970c4e46SJohan Hedberg 246455ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 246555ed8ca1SJohan Hedberg { 246655ed8ca1SJohan Hedberg struct link_key *key; 246755ed8ca1SJohan Hedberg 246855ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 246955ed8ca1SJohan Hedberg if (!key) 247055ed8ca1SJohan Hedberg return -ENOENT; 247155ed8ca1SJohan Hedberg 24726ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 247355ed8ca1SJohan Hedberg 24740378b597SJohan Hedberg list_del_rcu(&key->list); 24750378b597SJohan Hedberg kfree_rcu(key, rcu); 247655ed8ca1SJohan Hedberg 247755ed8ca1SJohan Hedberg return 0; 247855ed8ca1SJohan Hedberg } 247955ed8ca1SJohan Hedberg 2480e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2481b899efafSVinicius Costa Gomes { 2482970d0f1bSJohan Hedberg struct smp_ltk *k; 2483c51ffa0bSJohan Hedberg int removed = 0; 2484b899efafSVinicius Costa Gomes 2485970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2486e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2487b899efafSVinicius Costa Gomes continue; 2488b899efafSVinicius Costa Gomes 24896ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2490b899efafSVinicius Costa Gomes 2491970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2492970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2493c51ffa0bSJohan Hedberg removed++; 2494b899efafSVinicius Costa Gomes } 2495b899efafSVinicius Costa Gomes 2496c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2497b899efafSVinicius Costa Gomes } 2498b899efafSVinicius Costa Gomes 2499a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2500a7ec7338SJohan Hedberg { 2501adae20cbSJohan Hedberg struct smp_irk *k; 2502a7ec7338SJohan Hedberg 2503adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2504a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2505a7ec7338SJohan Hedberg continue; 2506a7ec7338SJohan Hedberg 2507a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2508a7ec7338SJohan Hedberg 2509adae20cbSJohan Hedberg list_del_rcu(&k->list); 2510adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2511a7ec7338SJohan Hedberg } 2512a7ec7338SJohan Hedberg } 2513a7ec7338SJohan Hedberg 251455e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 251555e76b38SJohan Hedberg { 251655e76b38SJohan Hedberg struct smp_ltk *k; 25174ba9faf3SJohan Hedberg struct smp_irk *irk; 251855e76b38SJohan Hedberg u8 addr_type; 251955e76b38SJohan Hedberg 252055e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 252155e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 252255e76b38SJohan Hedberg return true; 252355e76b38SJohan Hedberg return false; 252455e76b38SJohan Hedberg } 252555e76b38SJohan Hedberg 252655e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 252755e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 252855e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 252955e76b38SJohan Hedberg else 253055e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 253155e76b38SJohan Hedberg 25324ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 25334ba9faf3SJohan Hedberg if (irk) { 25344ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 25354ba9faf3SJohan Hedberg addr_type = irk->addr_type; 25364ba9faf3SJohan Hedberg } 25374ba9faf3SJohan Hedberg 253855e76b38SJohan Hedberg rcu_read_lock(); 253955e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 254087c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 254187c8b28dSJohan Hedberg rcu_read_unlock(); 254255e76b38SJohan Hedberg return true; 254355e76b38SJohan Hedberg } 254487c8b28dSJohan Hedberg } 254555e76b38SJohan Hedberg rcu_read_unlock(); 254655e76b38SJohan Hedberg 254755e76b38SJohan Hedberg return false; 254855e76b38SJohan Hedberg } 254955e76b38SJohan Hedberg 25506bd32326SVille Tervo /* HCI command timer function */ 255165cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 25526bd32326SVille Tervo { 255365cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 255465cc2b49SMarcel Holtmann cmd_timer.work); 25556bd32326SVille Tervo 2556bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2557bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2558bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2559bda4f23aSAndrei Emeltchenko 25602064ee33SMarcel Holtmann bt_dev_err(hdev, "command 0x%4.4x tx timeout", opcode); 2561bda4f23aSAndrei Emeltchenko } else { 25622064ee33SMarcel Holtmann bt_dev_err(hdev, "command tx timeout"); 2563bda4f23aSAndrei Emeltchenko } 2564bda4f23aSAndrei Emeltchenko 25656bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2566c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 25676bd32326SVille Tervo } 25686bd32326SVille Tervo 25692763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 25706928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 25712763eda6SSzymon Janc { 25722763eda6SSzymon Janc struct oob_data *data; 25732763eda6SSzymon Janc 25746928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 25756928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 25766928a924SJohan Hedberg continue; 25776928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 25786928a924SJohan Hedberg continue; 25792763eda6SSzymon Janc return data; 25806928a924SJohan Hedberg } 25812763eda6SSzymon Janc 25822763eda6SSzymon Janc return NULL; 25832763eda6SSzymon Janc } 25842763eda6SSzymon Janc 25856928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25866928a924SJohan Hedberg u8 bdaddr_type) 25872763eda6SSzymon Janc { 25882763eda6SSzymon Janc struct oob_data *data; 25892763eda6SSzymon Janc 25906928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25912763eda6SSzymon Janc if (!data) 25922763eda6SSzymon Janc return -ENOENT; 25932763eda6SSzymon Janc 25946928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 25952763eda6SSzymon Janc 25962763eda6SSzymon Janc list_del(&data->list); 25972763eda6SSzymon Janc kfree(data); 25982763eda6SSzymon Janc 25992763eda6SSzymon Janc return 0; 26002763eda6SSzymon Janc } 26012763eda6SSzymon Janc 260235f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 26032763eda6SSzymon Janc { 26042763eda6SSzymon Janc struct oob_data *data, *n; 26052763eda6SSzymon Janc 26062763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 26072763eda6SSzymon Janc list_del(&data->list); 26082763eda6SSzymon Janc kfree(data); 26092763eda6SSzymon Janc } 26102763eda6SSzymon Janc } 26112763eda6SSzymon Janc 26120798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26136928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 261438da1703SJohan Hedberg u8 *hash256, u8 *rand256) 26150798872eSMarcel Holtmann { 26160798872eSMarcel Holtmann struct oob_data *data; 26170798872eSMarcel Holtmann 26186928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26190798872eSMarcel Holtmann if (!data) { 26200a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 26210798872eSMarcel Holtmann if (!data) 26220798872eSMarcel Holtmann return -ENOMEM; 26230798872eSMarcel Holtmann 26240798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 26256928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 26260798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 26270798872eSMarcel Holtmann } 26280798872eSMarcel Holtmann 262981328d5cSJohan Hedberg if (hash192 && rand192) { 26300798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 263138da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2632f7697b16SMarcel Holtmann if (hash256 && rand256) 2633f7697b16SMarcel Holtmann data->present = 0x03; 263481328d5cSJohan Hedberg } else { 263581328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 263681328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2637f7697b16SMarcel Holtmann if (hash256 && rand256) 2638f7697b16SMarcel Holtmann data->present = 0x02; 2639f7697b16SMarcel Holtmann else 2640f7697b16SMarcel Holtmann data->present = 0x00; 264181328d5cSJohan Hedberg } 26420798872eSMarcel Holtmann 264381328d5cSJohan Hedberg if (hash256 && rand256) { 26440798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 264538da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 264681328d5cSJohan Hedberg } else { 264781328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 264881328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2649f7697b16SMarcel Holtmann if (hash192 && rand192) 2650f7697b16SMarcel Holtmann data->present = 0x01; 265181328d5cSJohan Hedberg } 26520798872eSMarcel Holtmann 26536ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 26542763eda6SSzymon Janc 26552763eda6SSzymon Janc return 0; 26562763eda6SSzymon Janc } 26572763eda6SSzymon Janc 2658d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2659d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2660d2609b34SFlorian Grandel { 2661d2609b34SFlorian Grandel struct adv_info *adv_instance; 2662d2609b34SFlorian Grandel 2663d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2664d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2665d2609b34SFlorian Grandel return adv_instance; 2666d2609b34SFlorian Grandel } 2667d2609b34SFlorian Grandel 2668d2609b34SFlorian Grandel return NULL; 2669d2609b34SFlorian Grandel } 2670d2609b34SFlorian Grandel 2671d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 267274b93e9fSPrasanna Karthik struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) 267374b93e9fSPrasanna Karthik { 2674d2609b34SFlorian Grandel struct adv_info *cur_instance; 2675d2609b34SFlorian Grandel 2676d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2677d2609b34SFlorian Grandel if (!cur_instance) 2678d2609b34SFlorian Grandel return NULL; 2679d2609b34SFlorian Grandel 2680d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2681d2609b34SFlorian Grandel struct adv_info, list)) 2682d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2683d2609b34SFlorian Grandel struct adv_info, list); 2684d2609b34SFlorian Grandel else 2685d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2686d2609b34SFlorian Grandel } 2687d2609b34SFlorian Grandel 2688d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2689d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2690d2609b34SFlorian Grandel { 2691d2609b34SFlorian Grandel struct adv_info *adv_instance; 2692d2609b34SFlorian Grandel 2693d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2694d2609b34SFlorian Grandel if (!adv_instance) 2695d2609b34SFlorian Grandel return -ENOENT; 2696d2609b34SFlorian Grandel 2697d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2698d2609b34SFlorian Grandel 2699cab054abSJohan Hedberg if (hdev->cur_adv_instance == instance) { 2700cab054abSJohan Hedberg if (hdev->adv_instance_timeout) { 27015d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27025d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27035d900e46SFlorian Grandel } 2704cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2705cab054abSJohan Hedberg } 27065d900e46SFlorian Grandel 2707d2609b34SFlorian Grandel list_del(&adv_instance->list); 2708d2609b34SFlorian Grandel kfree(adv_instance); 2709d2609b34SFlorian Grandel 2710d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2711d2609b34SFlorian Grandel 2712d2609b34SFlorian Grandel return 0; 2713d2609b34SFlorian Grandel } 2714d2609b34SFlorian Grandel 2715d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2716d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2717d2609b34SFlorian Grandel { 2718d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2719d2609b34SFlorian Grandel 27205d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 27215d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27225d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27235d900e46SFlorian Grandel } 27245d900e46SFlorian Grandel 2725d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2726d2609b34SFlorian Grandel list_del(&adv_instance->list); 2727d2609b34SFlorian Grandel kfree(adv_instance); 2728d2609b34SFlorian Grandel } 2729d2609b34SFlorian Grandel 2730d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2731cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2732d2609b34SFlorian Grandel } 2733d2609b34SFlorian Grandel 2734d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2735d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2736d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2737d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2738d2609b34SFlorian Grandel u16 timeout, u16 duration) 2739d2609b34SFlorian Grandel { 2740d2609b34SFlorian Grandel struct adv_info *adv_instance; 2741d2609b34SFlorian Grandel 2742d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2743d2609b34SFlorian Grandel if (adv_instance) { 2744d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2745d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2746d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2747d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2748d2609b34SFlorian Grandel } else { 2749d2609b34SFlorian Grandel if (hdev->adv_instance_cnt >= HCI_MAX_ADV_INSTANCES || 2750d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2751d2609b34SFlorian Grandel return -EOVERFLOW; 2752d2609b34SFlorian Grandel 275339ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2754d2609b34SFlorian Grandel if (!adv_instance) 2755d2609b34SFlorian Grandel return -ENOMEM; 2756d2609b34SFlorian Grandel 2757fffd38bcSFlorian Grandel adv_instance->pending = true; 2758d2609b34SFlorian Grandel adv_instance->instance = instance; 2759d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2760d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2761d2609b34SFlorian Grandel } 2762d2609b34SFlorian Grandel 2763d2609b34SFlorian Grandel adv_instance->flags = flags; 2764d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2765d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2766d2609b34SFlorian Grandel 2767d2609b34SFlorian Grandel if (adv_data_len) 2768d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2769d2609b34SFlorian Grandel 2770d2609b34SFlorian Grandel if (scan_rsp_len) 2771d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2772d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2773d2609b34SFlorian Grandel 2774d2609b34SFlorian Grandel adv_instance->timeout = timeout; 27755d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2776d2609b34SFlorian Grandel 2777d2609b34SFlorian Grandel if (duration == 0) 2778d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2779d2609b34SFlorian Grandel else 2780d2609b34SFlorian Grandel adv_instance->duration = duration; 2781d2609b34SFlorian Grandel 2782de181e88SJaganath Kanakkassery adv_instance->tx_power = HCI_TX_POWER_INVALID; 2783de181e88SJaganath Kanakkassery 2784d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2785d2609b34SFlorian Grandel 2786d2609b34SFlorian Grandel return 0; 2787d2609b34SFlorian Grandel } 2788d2609b34SFlorian Grandel 2789dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2790b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2791b2a66aadSAntti Julku { 2792b2a66aadSAntti Julku struct bdaddr_list *b; 2793b2a66aadSAntti Julku 2794dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2795b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2796b2a66aadSAntti Julku return b; 2797b9ee0a78SMarcel Holtmann } 2798b2a66aadSAntti Julku 2799b2a66aadSAntti Julku return NULL; 2800b2a66aadSAntti Julku } 2801b2a66aadSAntti Julku 2802dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2803b2a66aadSAntti Julku { 28047eb7404fSGeliang Tang struct bdaddr_list *b, *n; 2805b2a66aadSAntti Julku 28067eb7404fSGeliang Tang list_for_each_entry_safe(b, n, bdaddr_list, list) { 28077eb7404fSGeliang Tang list_del(&b->list); 2808b2a66aadSAntti Julku kfree(b); 2809b2a66aadSAntti Julku } 2810b2a66aadSAntti Julku } 2811b2a66aadSAntti Julku 2812dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2813b2a66aadSAntti Julku { 2814b2a66aadSAntti Julku struct bdaddr_list *entry; 2815b2a66aadSAntti Julku 2816b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2817b2a66aadSAntti Julku return -EBADF; 2818b2a66aadSAntti Julku 2819dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 28205e762444SAntti Julku return -EEXIST; 2821b2a66aadSAntti Julku 282227f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 28235e762444SAntti Julku if (!entry) 28245e762444SAntti Julku return -ENOMEM; 2825b2a66aadSAntti Julku 2826b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2827b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2828b2a66aadSAntti Julku 2829dcc36c16SJohan Hedberg list_add(&entry->list, list); 2830b2a66aadSAntti Julku 28312a8357f2SJohan Hedberg return 0; 2832b2a66aadSAntti Julku } 2833b2a66aadSAntti Julku 2834dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2835b2a66aadSAntti Julku { 2836b2a66aadSAntti Julku struct bdaddr_list *entry; 2837b2a66aadSAntti Julku 283835f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2839dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 284035f7498aSJohan Hedberg return 0; 284135f7498aSJohan Hedberg } 2842b2a66aadSAntti Julku 2843dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2844d2ab0ac1SMarcel Holtmann if (!entry) 2845d2ab0ac1SMarcel Holtmann return -ENOENT; 2846d2ab0ac1SMarcel Holtmann 2847d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2848d2ab0ac1SMarcel Holtmann kfree(entry); 2849d2ab0ac1SMarcel Holtmann 2850d2ab0ac1SMarcel Holtmann return 0; 2851d2ab0ac1SMarcel Holtmann } 2852d2ab0ac1SMarcel Holtmann 285315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 285415819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 285515819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 285615819a70SAndre Guedes { 285715819a70SAndre Guedes struct hci_conn_params *params; 285815819a70SAndre Guedes 285915819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 286015819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 286115819a70SAndre Guedes params->addr_type == addr_type) { 286215819a70SAndre Guedes return params; 286315819a70SAndre Guedes } 286415819a70SAndre Guedes } 286515819a70SAndre Guedes 286615819a70SAndre Guedes return NULL; 286715819a70SAndre Guedes } 286815819a70SAndre Guedes 286915819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2870501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 28714b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 287215819a70SAndre Guedes { 2873912b42efSJohan Hedberg struct hci_conn_params *param; 287415819a70SAndre Guedes 2875501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2876912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2877912b42efSJohan Hedberg param->addr_type == addr_type) 2878912b42efSJohan Hedberg return param; 28794b10966fSMarcel Holtmann } 28804b10966fSMarcel Holtmann 28814b10966fSMarcel Holtmann return NULL; 288215819a70SAndre Guedes } 288315819a70SAndre Guedes 288415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 288551d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 288651d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 288715819a70SAndre Guedes { 288815819a70SAndre Guedes struct hci_conn_params *params; 288915819a70SAndre Guedes 289015819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2891cef952ceSAndre Guedes if (params) 289251d167c0SMarcel Holtmann return params; 289315819a70SAndre Guedes 289415819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 289515819a70SAndre Guedes if (!params) { 28962064ee33SMarcel Holtmann bt_dev_err(hdev, "out of memory"); 289751d167c0SMarcel Holtmann return NULL; 289815819a70SAndre Guedes } 289915819a70SAndre Guedes 290015819a70SAndre Guedes bacpy(¶ms->addr, addr); 290115819a70SAndre Guedes params->addr_type = addr_type; 2902cef952ceSAndre Guedes 2903cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 290493450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2905cef952ceSAndre Guedes 2906bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2907bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2908bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2909bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2910bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2911bf5b3c8bSMarcel Holtmann 2912bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2913bf5b3c8bSMarcel Holtmann 291451d167c0SMarcel Holtmann return params; 2915bf5b3c8bSMarcel Holtmann } 2916bf5b3c8bSMarcel Holtmann 2917f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2918f6c63249SJohan Hedberg { 2919f6c63249SJohan Hedberg if (params->conn) { 2920f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2921f6c63249SJohan Hedberg hci_conn_put(params->conn); 2922f6c63249SJohan Hedberg } 2923f6c63249SJohan Hedberg 2924f6c63249SJohan Hedberg list_del(¶ms->action); 2925f6c63249SJohan Hedberg list_del(¶ms->list); 2926f6c63249SJohan Hedberg kfree(params); 2927f6c63249SJohan Hedberg } 2928f6c63249SJohan Hedberg 292915819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 293015819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 293115819a70SAndre Guedes { 293215819a70SAndre Guedes struct hci_conn_params *params; 293315819a70SAndre Guedes 293415819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 293515819a70SAndre Guedes if (!params) 293615819a70SAndre Guedes return; 293715819a70SAndre Guedes 2938f6c63249SJohan Hedberg hci_conn_params_free(params); 293915819a70SAndre Guedes 294095305baaSJohan Hedberg hci_update_background_scan(hdev); 294195305baaSJohan Hedberg 294215819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 294315819a70SAndre Guedes } 294415819a70SAndre Guedes 294515819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 294655af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 294715819a70SAndre Guedes { 294815819a70SAndre Guedes struct hci_conn_params *params, *tmp; 294915819a70SAndre Guedes 295015819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 295155af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 295255af49a8SJohan Hedberg continue; 2953f75113a2SJakub Pawlowski 2954f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 2955f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 2956f75113a2SJakub Pawlowski */ 2957f75113a2SJakub Pawlowski if (params->explicit_connect) { 2958f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 2959f75113a2SJakub Pawlowski continue; 2960f75113a2SJakub Pawlowski } 2961f75113a2SJakub Pawlowski 296215819a70SAndre Guedes list_del(¶ms->list); 296315819a70SAndre Guedes kfree(params); 296415819a70SAndre Guedes } 296515819a70SAndre Guedes 296655af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 296755af49a8SJohan Hedberg } 296855af49a8SJohan Hedberg 296955af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 2970030e7f81SJohan Hedberg static void hci_conn_params_clear_all(struct hci_dev *hdev) 297115819a70SAndre Guedes { 297215819a70SAndre Guedes struct hci_conn_params *params, *tmp; 297315819a70SAndre Guedes 2974f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 2975f6c63249SJohan Hedberg hci_conn_params_free(params); 297615819a70SAndre Guedes 297715819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 297815819a70SAndre Guedes } 297915819a70SAndre Guedes 2980a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 2981a1f4c318SJohan Hedberg * 2982a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 2983a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 2984a1f4c318SJohan Hedberg * the static random address. 2985a1f4c318SJohan Hedberg * 2986a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 2987a1f4c318SJohan Hedberg * public address to use the static random address instead. 298850b5b952SMarcel Holtmann * 298950b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 299050b5b952SMarcel Holtmann * userspace has configured a static address, then that address 299150b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 2992a1f4c318SJohan Hedberg */ 2993a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 2994a1f4c318SJohan Hedberg u8 *bdaddr_type) 2995a1f4c318SJohan Hedberg { 2996b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 299750b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 2998d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 299950b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 3000a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3001a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3002a1f4c318SJohan Hedberg } else { 3003a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3004a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3005a1f4c318SJohan Hedberg } 3006a1f4c318SJohan Hedberg } 3007a1f4c318SJohan Hedberg 30089be0dab7SDavid Herrmann /* Alloc HCI device */ 30099be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 30109be0dab7SDavid Herrmann { 30119be0dab7SDavid Herrmann struct hci_dev *hdev; 30129be0dab7SDavid Herrmann 301327f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 30149be0dab7SDavid Herrmann if (!hdev) 30159be0dab7SDavid Herrmann return NULL; 30169be0dab7SDavid Herrmann 3017b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3018b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3019b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3020b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3021b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 302296c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3023bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3024bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3025d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 3026d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 30275d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 3028b1b813d4SDavid Herrmann 3029b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3030b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3031b1b813d4SDavid Herrmann 30323f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3033628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3034628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3035bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3036bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 3037b48c3b59SJonas Holmberg hdev->le_conn_min_interval = 0x0018; 3038b48c3b59SJonas Holmberg hdev->le_conn_max_interval = 0x0028; 303904fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 304004fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3041a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3042a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3043a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3044a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3045a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3046a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 30476decb5b4SJaganath Kanakkassery hdev->le_tx_def_phys = HCI_LE_SET_PHY_1M; 30486decb5b4SJaganath Kanakkassery hdev->le_rx_def_phys = HCI_LE_SET_PHY_1M; 3049bef64738SMarcel Holtmann 3050d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3051b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 305231ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 305331ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3054d6bfd59cSJohan Hedberg 3055b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3056b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3057b1b813d4SDavid Herrmann 3058b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3059b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 30606659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3061b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3062b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3063b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3064970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3065b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3066d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 3067cfdb0c2dSAnkit Navik INIT_LIST_HEAD(&hdev->le_resolv_list); 306815819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 306977a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 307066f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 30716b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3072d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3073b1b813d4SDavid Herrmann 3074b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3075b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3076b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3077b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3078c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3079b1b813d4SDavid Herrmann 3080b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3081b1b813d4SDavid Herrmann 3082b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3083b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3084b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3085b1b813d4SDavid Herrmann 3086b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3087b1b813d4SDavid Herrmann 308865cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3089b1b813d4SDavid Herrmann 30905fc16cc4SJohan Hedberg hci_request_setup(hdev); 30915fc16cc4SJohan Hedberg 3092b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3093b1b813d4SDavid Herrmann discovery_init(hdev); 30949be0dab7SDavid Herrmann 30959be0dab7SDavid Herrmann return hdev; 30969be0dab7SDavid Herrmann } 30979be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 30989be0dab7SDavid Herrmann 30999be0dab7SDavid Herrmann /* Free HCI device */ 31009be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 31019be0dab7SDavid Herrmann { 31029be0dab7SDavid Herrmann /* will free via device release */ 31039be0dab7SDavid Herrmann put_device(&hdev->dev); 31049be0dab7SDavid Herrmann } 31059be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 31069be0dab7SDavid Herrmann 31071da177e4SLinus Torvalds /* Register HCI device */ 31081da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 31091da177e4SLinus Torvalds { 3110b1b813d4SDavid Herrmann int id, error; 31111da177e4SLinus Torvalds 311274292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 31131da177e4SLinus Torvalds return -EINVAL; 31141da177e4SLinus Torvalds 311508add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 311608add513SMat Martineau * so the index can be used as the AMP controller ID. 311708add513SMat Martineau */ 31183df92b31SSasha Levin switch (hdev->dev_type) { 3119ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 31203df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 31211da177e4SLinus Torvalds break; 31223df92b31SSasha Levin case HCI_AMP: 31233df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 31243df92b31SSasha Levin break; 31253df92b31SSasha Levin default: 31263df92b31SSasha Levin return -EINVAL; 31271da177e4SLinus Torvalds } 31281da177e4SLinus Torvalds 31293df92b31SSasha Levin if (id < 0) 31303df92b31SSasha Levin return id; 31313df92b31SSasha Levin 31321da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 31331da177e4SLinus Torvalds hdev->id = id; 31342d8b3a11SAndrei Emeltchenko 31352d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 31362d8b3a11SAndrei Emeltchenko 313729e2dd0dSTejun Heo hdev->workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, hdev->name); 313833ca954dSDavid Herrmann if (!hdev->workqueue) { 313933ca954dSDavid Herrmann error = -ENOMEM; 314033ca954dSDavid Herrmann goto err; 314133ca954dSDavid Herrmann } 3142f48fd9c8SMarcel Holtmann 314329e2dd0dSTejun Heo hdev->req_workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, 314429e2dd0dSTejun Heo hdev->name); 31456ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 31466ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 31476ead1bbcSJohan Hedberg error = -ENOMEM; 31486ead1bbcSJohan Hedberg goto err; 31496ead1bbcSJohan Hedberg } 31506ead1bbcSJohan Hedberg 31510153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 31520153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 31530153e2ecSMarcel Holtmann 3154bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3155bdc3e0f1SMarcel Holtmann 3156bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 315733ca954dSDavid Herrmann if (error < 0) 315854506918SJohan Hedberg goto err_wqueue; 31591da177e4SLinus Torvalds 31606d5d2ee6SHeiner Kallweit hci_leds_init(hdev); 31616d5d2ee6SHeiner Kallweit 3162611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3163a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3164a8c5fb1aSGustavo Padovan hdev); 3165611b30f7SMarcel Holtmann if (hdev->rfkill) { 3166611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3167611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3168611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3169611b30f7SMarcel Holtmann } 3170611b30f7SMarcel Holtmann } 3171611b30f7SMarcel Holtmann 31725e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3173a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 31745e130367SJohan Hedberg 3175a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3176a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3177ce2be9acSAndrei Emeltchenko 3178ca8bee5dSMarcel Holtmann if (hdev->dev_type == HCI_PRIMARY) { 317956f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 318056f87901SJohan Hedberg * through reading supported features during init. 318156f87901SJohan Hedberg */ 3182a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 318356f87901SJohan Hedberg } 3184ce2be9acSAndrei Emeltchenko 3185fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3186fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3187fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3188fcee3377SGustavo Padovan 31894a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 31904a964404SMarcel Holtmann * and should not be included in normal operation. 3191fee746b0SMarcel Holtmann */ 3192fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3193a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3194fee746b0SMarcel Holtmann 319505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3196dc946bd8SDavid Herrmann hci_dev_hold(hdev); 31971da177e4SLinus Torvalds 319819202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3199fbe96d6fSMarcel Holtmann 32001da177e4SLinus Torvalds return id; 3201f48fd9c8SMarcel Holtmann 320233ca954dSDavid Herrmann err_wqueue: 320333ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 32046ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 320533ca954dSDavid Herrmann err: 32063df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3207f48fd9c8SMarcel Holtmann 320833ca954dSDavid Herrmann return error; 32091da177e4SLinus Torvalds } 32101da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 32111da177e4SLinus Torvalds 32121da177e4SLinus Torvalds /* Unregister HCI device */ 321359735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 32141da177e4SLinus Torvalds { 32152d7cc19eSMarcel Holtmann int id; 3216ef222013SMarcel Holtmann 3217c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 32181da177e4SLinus Torvalds 3219a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 322094324962SJohan Hovold 32213df92b31SSasha Levin id = hdev->id; 32223df92b31SSasha Levin 3223f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 32241da177e4SLinus Torvalds list_del(&hdev->list); 3225f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 32261da177e4SLinus Torvalds 3227b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3228b9b5ef18SGustavo Padovan 3229bf389cabSJiri Slaby hci_dev_do_close(hdev); 3230bf389cabSJiri Slaby 3231ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3232d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3233d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 323409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3235744cf19eSJohan Hedberg mgmt_index_removed(hdev); 323609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 323756e5cb86SJohan Hedberg } 3238ab81cbf9SJohan Hedberg 32392e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 32402e58ef3eSJohan Hedberg * pending list */ 32412e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 32422e58ef3eSJohan Hedberg 324305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 32441da177e4SLinus Torvalds 3245611b30f7SMarcel Holtmann if (hdev->rfkill) { 3246611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3247611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3248611b30f7SMarcel Holtmann } 3249611b30f7SMarcel Holtmann 3250bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3251147e2d59SDave Young 32520153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 32535177a838SMarcel Holtmann kfree_const(hdev->hw_info); 32545177a838SMarcel Holtmann kfree_const(hdev->fw_info); 32550153e2ecSMarcel Holtmann 3256f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 32576ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3258f48fd9c8SMarcel Holtmann 325909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3260dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 32616659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 32622aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 326355ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3264b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3265970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 32662763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3267d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3268dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3269cfdb0c2dSAnkit Navik hci_bdaddr_list_clear(&hdev->le_resolv_list); 3270373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 327122078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 327209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3273e2e0cacbSJohan Hedberg 3274dc946bd8SDavid Herrmann hci_dev_put(hdev); 32753df92b31SSasha Levin 32763df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 32771da177e4SLinus Torvalds } 32781da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 32791da177e4SLinus Torvalds 32801da177e4SLinus Torvalds /* Suspend HCI device */ 32811da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 32821da177e4SLinus Torvalds { 328305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 32841da177e4SLinus Torvalds return 0; 32851da177e4SLinus Torvalds } 32861da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 32871da177e4SLinus Torvalds 32881da177e4SLinus Torvalds /* Resume HCI device */ 32891da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 32901da177e4SLinus Torvalds { 329105fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 32921da177e4SLinus Torvalds return 0; 32931da177e4SLinus Torvalds } 32941da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 32951da177e4SLinus Torvalds 329675e0569fSMarcel Holtmann /* Reset HCI device */ 329775e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 329875e0569fSMarcel Holtmann { 329975e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 330075e0569fSMarcel Holtmann struct sk_buff *skb; 330175e0569fSMarcel Holtmann 330275e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 330375e0569fSMarcel Holtmann if (!skb) 330475e0569fSMarcel Holtmann return -ENOMEM; 330575e0569fSMarcel Holtmann 3306d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 330759ae1d12SJohannes Berg skb_put_data(skb, hw_err, 3); 330875e0569fSMarcel Holtmann 330975e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 331075e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 331175e0569fSMarcel Holtmann } 331275e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 331375e0569fSMarcel Holtmann 331476bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3315e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 331676bca880SMarcel Holtmann { 331776bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 331876bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 331976bca880SMarcel Holtmann kfree_skb(skb); 332076bca880SMarcel Holtmann return -ENXIO; 332176bca880SMarcel Holtmann } 332276bca880SMarcel Holtmann 3323d79f34e3SMarcel Holtmann if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT && 3324d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT && 3325d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_SCODATA_PKT) { 3326fe806dceSMarcel Holtmann kfree_skb(skb); 3327fe806dceSMarcel Holtmann return -EINVAL; 3328fe806dceSMarcel Holtmann } 3329fe806dceSMarcel Holtmann 3330d82603c6SJorrit Schippers /* Incoming skb */ 333176bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 333276bca880SMarcel Holtmann 333376bca880SMarcel Holtmann /* Time stamp */ 333476bca880SMarcel Holtmann __net_timestamp(skb); 333576bca880SMarcel Holtmann 333676bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3337b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3338c78ae283SMarcel Holtmann 333976bca880SMarcel Holtmann return 0; 334076bca880SMarcel Holtmann } 334176bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 334276bca880SMarcel Holtmann 3343e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3344e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3345e875ff84SMarcel Holtmann { 3346581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3347d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_DIAG_PKT; 3348581d6fd6SMarcel Holtmann 3349e875ff84SMarcel Holtmann /* Time stamp */ 3350e875ff84SMarcel Holtmann __net_timestamp(skb); 3351e875ff84SMarcel Holtmann 3352581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3353581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3354e875ff84SMarcel Holtmann 3355e875ff84SMarcel Holtmann return 0; 3356e875ff84SMarcel Holtmann } 3357e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3358e875ff84SMarcel Holtmann 33595177a838SMarcel Holtmann void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...) 33605177a838SMarcel Holtmann { 33615177a838SMarcel Holtmann va_list vargs; 33625177a838SMarcel Holtmann 33635177a838SMarcel Holtmann va_start(vargs, fmt); 33645177a838SMarcel Holtmann kfree_const(hdev->hw_info); 33655177a838SMarcel Holtmann hdev->hw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 33665177a838SMarcel Holtmann va_end(vargs); 33675177a838SMarcel Holtmann } 33685177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_hw_info); 33695177a838SMarcel Holtmann 33705177a838SMarcel Holtmann void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...) 33715177a838SMarcel Holtmann { 33725177a838SMarcel Holtmann va_list vargs; 33735177a838SMarcel Holtmann 33745177a838SMarcel Holtmann va_start(vargs, fmt); 33755177a838SMarcel Holtmann kfree_const(hdev->fw_info); 33765177a838SMarcel Holtmann hdev->fw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 33775177a838SMarcel Holtmann va_end(vargs); 33785177a838SMarcel Holtmann } 33795177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_fw_info); 33805177a838SMarcel Holtmann 33811da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 33821da177e4SLinus Torvalds 33831da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 33841da177e4SLinus Torvalds { 33851da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33861da177e4SLinus Torvalds 3387fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 338800629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3389fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 33901da177e4SLinus Torvalds 33911da177e4SLinus Torvalds return 0; 33921da177e4SLinus Torvalds } 33931da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 33941da177e4SLinus Torvalds 33951da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 33961da177e4SLinus Torvalds { 33971da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33981da177e4SLinus Torvalds 3399fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 34001da177e4SLinus Torvalds list_del(&cb->list); 3401fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 34021da177e4SLinus Torvalds 34031da177e4SLinus Torvalds return 0; 34041da177e4SLinus Torvalds } 34051da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 34061da177e4SLinus Torvalds 340751086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 34081da177e4SLinus Torvalds { 3409cdc52faaSMarcel Holtmann int err; 3410cdc52faaSMarcel Holtmann 3411d79f34e3SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb), 3412d79f34e3SMarcel Holtmann skb->len); 34131da177e4SLinus Torvalds 34141da177e4SLinus Torvalds /* Time stamp */ 3415a61bbcf2SPatrick McHardy __net_timestamp(skb); 34161da177e4SLinus Torvalds 3417cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3418cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3419cd82e61cSMarcel Holtmann 3420cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3421cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3422470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 34231da177e4SLinus Torvalds } 34241da177e4SLinus Torvalds 34251da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 34261da177e4SLinus Torvalds skb_orphan(skb); 34271da177e4SLinus Torvalds 342873d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 342973d0d3c8SMarcel Holtmann kfree_skb(skb); 343073d0d3c8SMarcel Holtmann return; 343173d0d3c8SMarcel Holtmann } 343273d0d3c8SMarcel Holtmann 3433cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3434cdc52faaSMarcel Holtmann if (err < 0) { 34352064ee33SMarcel Holtmann bt_dev_err(hdev, "sending frame failed (%d)", err); 3436cdc52faaSMarcel Holtmann kfree_skb(skb); 3437cdc52faaSMarcel Holtmann } 34381da177e4SLinus Torvalds } 34391da177e4SLinus Torvalds 34401ca3a9d0SJohan Hedberg /* Send HCI command */ 344107dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 344207dc93ddSJohan Hedberg const void *param) 34431ca3a9d0SJohan Hedberg { 34441ca3a9d0SJohan Hedberg struct sk_buff *skb; 34451ca3a9d0SJohan Hedberg 34461ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 34471ca3a9d0SJohan Hedberg 34481ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 34491ca3a9d0SJohan Hedberg if (!skb) { 34502064ee33SMarcel Holtmann bt_dev_err(hdev, "no memory for command"); 34511ca3a9d0SJohan Hedberg return -ENOMEM; 34521ca3a9d0SJohan Hedberg } 34531ca3a9d0SJohan Hedberg 345449c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 345511714b3dSJohan Hedberg * single-command requests. 345611714b3dSJohan Hedberg */ 345744d27137SJohan Hedberg bt_cb(skb)->hci.req_flags |= HCI_REQ_START; 345811714b3dSJohan Hedberg 34591da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3460c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 34611da177e4SLinus Torvalds 34621da177e4SLinus Torvalds return 0; 34631da177e4SLinus Torvalds } 34641da177e4SLinus Torvalds 3465d6ee6ad7SLoic Poulain int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen, 3466d6ee6ad7SLoic Poulain const void *param) 3467d6ee6ad7SLoic Poulain { 3468d6ee6ad7SLoic Poulain struct sk_buff *skb; 3469d6ee6ad7SLoic Poulain 3470d6ee6ad7SLoic Poulain if (hci_opcode_ogf(opcode) != 0x3f) { 3471d6ee6ad7SLoic Poulain /* A controller receiving a command shall respond with either 3472d6ee6ad7SLoic Poulain * a Command Status Event or a Command Complete Event. 3473d6ee6ad7SLoic Poulain * Therefore, all standard HCI commands must be sent via the 3474d6ee6ad7SLoic Poulain * standard API, using hci_send_cmd or hci_cmd_sync helpers. 3475d6ee6ad7SLoic Poulain * Some vendors do not comply with this rule for vendor-specific 3476d6ee6ad7SLoic Poulain * commands and do not return any event. We want to support 3477d6ee6ad7SLoic Poulain * unresponded commands for such cases only. 3478d6ee6ad7SLoic Poulain */ 3479d6ee6ad7SLoic Poulain bt_dev_err(hdev, "unresponded command not supported"); 3480d6ee6ad7SLoic Poulain return -EINVAL; 3481d6ee6ad7SLoic Poulain } 3482d6ee6ad7SLoic Poulain 3483d6ee6ad7SLoic Poulain skb = hci_prepare_cmd(hdev, opcode, plen, param); 3484d6ee6ad7SLoic Poulain if (!skb) { 3485d6ee6ad7SLoic Poulain bt_dev_err(hdev, "no memory for command (opcode 0x%4.4x)", 3486d6ee6ad7SLoic Poulain opcode); 3487d6ee6ad7SLoic Poulain return -ENOMEM; 3488d6ee6ad7SLoic Poulain } 3489d6ee6ad7SLoic Poulain 3490d6ee6ad7SLoic Poulain hci_send_frame(hdev, skb); 3491d6ee6ad7SLoic Poulain 3492d6ee6ad7SLoic Poulain return 0; 3493d6ee6ad7SLoic Poulain } 3494d6ee6ad7SLoic Poulain EXPORT_SYMBOL(__hci_cmd_send); 3495d6ee6ad7SLoic Poulain 34961da177e4SLinus Torvalds /* Get data from the previously sent command */ 3497a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 34981da177e4SLinus Torvalds { 34991da177e4SLinus Torvalds struct hci_command_hdr *hdr; 35001da177e4SLinus Torvalds 35011da177e4SLinus Torvalds if (!hdev->sent_cmd) 35021da177e4SLinus Torvalds return NULL; 35031da177e4SLinus Torvalds 35041da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 35051da177e4SLinus Torvalds 3506a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 35071da177e4SLinus Torvalds return NULL; 35081da177e4SLinus Torvalds 3509f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 35101da177e4SLinus Torvalds 35111da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 35121da177e4SLinus Torvalds } 35131da177e4SLinus Torvalds 3514fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3515fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3516fbef168fSLoic Poulain const void *param, u32 timeout) 3517fbef168fSLoic Poulain { 3518fbef168fSLoic Poulain struct sk_buff *skb; 3519fbef168fSLoic Poulain 3520fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3521fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3522fbef168fSLoic Poulain 3523fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3524fbef168fSLoic Poulain 3525b504430cSJohan Hedberg hci_req_sync_lock(hdev); 3526fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3527b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 3528fbef168fSLoic Poulain 3529fbef168fSLoic Poulain return skb; 3530fbef168fSLoic Poulain } 3531fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3532fbef168fSLoic Poulain 35331da177e4SLinus Torvalds /* Send ACL data */ 35341da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 35351da177e4SLinus Torvalds { 35361da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 35371da177e4SLinus Torvalds int len = skb->len; 35381da177e4SLinus Torvalds 3539badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3540badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 35419c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3542aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3543aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 35441da177e4SLinus Torvalds } 35451da177e4SLinus Torvalds 3546ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 354773d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 35481da177e4SLinus Torvalds { 3549ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 35501da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 35511da177e4SLinus Torvalds struct sk_buff *list; 35521da177e4SLinus Torvalds 3553087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3554087bfd99SGustavo Padovan skb->data_len = 0; 3555087bfd99SGustavo Padovan 3556d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3557204a6e54SAndrei Emeltchenko 3558204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3559ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 3560087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3561204a6e54SAndrei Emeltchenko break; 3562204a6e54SAndrei Emeltchenko case HCI_AMP: 3563204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3564204a6e54SAndrei Emeltchenko break; 3565204a6e54SAndrei Emeltchenko default: 35662064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown dev_type %d", hdev->dev_type); 3567204a6e54SAndrei Emeltchenko return; 3568204a6e54SAndrei Emeltchenko } 3569087bfd99SGustavo Padovan 357070f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 357170f23020SAndrei Emeltchenko if (!list) { 35721da177e4SLinus Torvalds /* Non fragmented */ 35731da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 35741da177e4SLinus Torvalds 357573d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 35761da177e4SLinus Torvalds } else { 35771da177e4SLinus Torvalds /* Fragmented */ 35781da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 35791da177e4SLinus Torvalds 35801da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 35811da177e4SLinus Torvalds 35829cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 35839cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 35849cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 35859cfd5a23SJukka Rissanen * deadlocks. 35869cfd5a23SJukka Rissanen */ 35879cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 35881da177e4SLinus Torvalds 358973d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3590e702112fSAndrei Emeltchenko 3591e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3592e702112fSAndrei Emeltchenko flags |= ACL_CONT; 35931da177e4SLinus Torvalds do { 35941da177e4SLinus Torvalds skb = list; list = list->next; 35951da177e4SLinus Torvalds 3596d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3597e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 35981da177e4SLinus Torvalds 35991da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 36001da177e4SLinus Torvalds 360173d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 36021da177e4SLinus Torvalds } while (list); 36031da177e4SLinus Torvalds 36049cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 36051da177e4SLinus Torvalds } 360673d80debSLuiz Augusto von Dentz } 360773d80debSLuiz Augusto von Dentz 360873d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 360973d80debSLuiz Augusto von Dentz { 3610ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 361173d80debSLuiz Augusto von Dentz 3612f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 361373d80debSLuiz Augusto von Dentz 3614ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 36151da177e4SLinus Torvalds 36163eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 36171da177e4SLinus Torvalds } 36181da177e4SLinus Torvalds 36191da177e4SLinus Torvalds /* Send SCO data */ 36200d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 36211da177e4SLinus Torvalds { 36221da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 36231da177e4SLinus Torvalds struct hci_sco_hdr hdr; 36241da177e4SLinus Torvalds 36251da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 36261da177e4SLinus Torvalds 3627aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 36281da177e4SLinus Torvalds hdr.dlen = skb->len; 36291da177e4SLinus Torvalds 3630badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3631badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 36329c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 36331da177e4SLinus Torvalds 3634d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 3635c78ae283SMarcel Holtmann 36361da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 36373eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 36381da177e4SLinus Torvalds } 36391da177e4SLinus Torvalds 36401da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 36411da177e4SLinus Torvalds 36421da177e4SLinus Torvalds /* HCI Connection scheduler */ 36436039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3644a8c5fb1aSGustavo Padovan int *quote) 36451da177e4SLinus Torvalds { 36461da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 36478035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3648abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 36491da177e4SLinus Torvalds 36501da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 36511da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3652bf4c6325SGustavo F. Padovan 3653bf4c6325SGustavo F. Padovan rcu_read_lock(); 3654bf4c6325SGustavo F. Padovan 3655bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3656769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 36571da177e4SLinus Torvalds continue; 3658769be974SMarcel Holtmann 3659769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3660769be974SMarcel Holtmann continue; 3661769be974SMarcel Holtmann 36621da177e4SLinus Torvalds num++; 36631da177e4SLinus Torvalds 36641da177e4SLinus Torvalds if (c->sent < min) { 36651da177e4SLinus Torvalds min = c->sent; 36661da177e4SLinus Torvalds conn = c; 36671da177e4SLinus Torvalds } 366852087a79SLuiz Augusto von Dentz 366952087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 367052087a79SLuiz Augusto von Dentz break; 36711da177e4SLinus Torvalds } 36721da177e4SLinus Torvalds 3673bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3674bf4c6325SGustavo F. Padovan 36751da177e4SLinus Torvalds if (conn) { 36766ed58ec5SVille Tervo int cnt, q; 36776ed58ec5SVille Tervo 36786ed58ec5SVille Tervo switch (conn->type) { 36796ed58ec5SVille Tervo case ACL_LINK: 36806ed58ec5SVille Tervo cnt = hdev->acl_cnt; 36816ed58ec5SVille Tervo break; 36826ed58ec5SVille Tervo case SCO_LINK: 36836ed58ec5SVille Tervo case ESCO_LINK: 36846ed58ec5SVille Tervo cnt = hdev->sco_cnt; 36856ed58ec5SVille Tervo break; 36866ed58ec5SVille Tervo case LE_LINK: 36876ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 36886ed58ec5SVille Tervo break; 36896ed58ec5SVille Tervo default: 36906ed58ec5SVille Tervo cnt = 0; 36912064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", conn->type); 36926ed58ec5SVille Tervo } 36936ed58ec5SVille Tervo 36946ed58ec5SVille Tervo q = cnt / num; 36951da177e4SLinus Torvalds *quote = q ? q : 1; 36961da177e4SLinus Torvalds } else 36971da177e4SLinus Torvalds *quote = 0; 36981da177e4SLinus Torvalds 36991da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 37001da177e4SLinus Torvalds return conn; 37011da177e4SLinus Torvalds } 37021da177e4SLinus Torvalds 37036039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 37041da177e4SLinus Torvalds { 37051da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 37061da177e4SLinus Torvalds struct hci_conn *c; 37071da177e4SLinus Torvalds 37082064ee33SMarcel Holtmann bt_dev_err(hdev, "link tx timeout"); 37091da177e4SLinus Torvalds 3710bf4c6325SGustavo F. Padovan rcu_read_lock(); 3711bf4c6325SGustavo F. Padovan 37121da177e4SLinus Torvalds /* Kill stalled connections */ 3713bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3714bae1f5d9SVille Tervo if (c->type == type && c->sent) { 37152064ee33SMarcel Holtmann bt_dev_err(hdev, "killing stalled connection %pMR", 37162064ee33SMarcel Holtmann &c->dst); 3717bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 37181da177e4SLinus Torvalds } 37191da177e4SLinus Torvalds } 3720bf4c6325SGustavo F. Padovan 3721bf4c6325SGustavo F. Padovan rcu_read_unlock(); 37221da177e4SLinus Torvalds } 37231da177e4SLinus Torvalds 37246039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 372573d80debSLuiz Augusto von Dentz int *quote) 372673d80debSLuiz Augusto von Dentz { 372773d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 372873d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3729abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 373073d80debSLuiz Augusto von Dentz struct hci_conn *conn; 373173d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 373273d80debSLuiz Augusto von Dentz 373373d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 373473d80debSLuiz Augusto von Dentz 3735bf4c6325SGustavo F. Padovan rcu_read_lock(); 3736bf4c6325SGustavo F. Padovan 3737bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 373873d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 373973d80debSLuiz Augusto von Dentz 374073d80debSLuiz Augusto von Dentz if (conn->type != type) 374173d80debSLuiz Augusto von Dentz continue; 374273d80debSLuiz Augusto von Dentz 374373d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 374473d80debSLuiz Augusto von Dentz continue; 374573d80debSLuiz Augusto von Dentz 374673d80debSLuiz Augusto von Dentz conn_num++; 374773d80debSLuiz Augusto von Dentz 37488192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 374973d80debSLuiz Augusto von Dentz struct sk_buff *skb; 375073d80debSLuiz Augusto von Dentz 375173d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 375273d80debSLuiz Augusto von Dentz continue; 375373d80debSLuiz Augusto von Dentz 375473d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 375573d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 375673d80debSLuiz Augusto von Dentz continue; 375773d80debSLuiz Augusto von Dentz 375873d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 375973d80debSLuiz Augusto von Dentz num = 0; 376073d80debSLuiz Augusto von Dentz min = ~0; 376173d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 376273d80debSLuiz Augusto von Dentz } 376373d80debSLuiz Augusto von Dentz 376473d80debSLuiz Augusto von Dentz num++; 376573d80debSLuiz Augusto von Dentz 376673d80debSLuiz Augusto von Dentz if (conn->sent < min) { 376773d80debSLuiz Augusto von Dentz min = conn->sent; 376873d80debSLuiz Augusto von Dentz chan = tmp; 376973d80debSLuiz Augusto von Dentz } 377073d80debSLuiz Augusto von Dentz } 377173d80debSLuiz Augusto von Dentz 377273d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 377373d80debSLuiz Augusto von Dentz break; 377473d80debSLuiz Augusto von Dentz } 377573d80debSLuiz Augusto von Dentz 3776bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3777bf4c6325SGustavo F. Padovan 377873d80debSLuiz Augusto von Dentz if (!chan) 377973d80debSLuiz Augusto von Dentz return NULL; 378073d80debSLuiz Augusto von Dentz 378173d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 378273d80debSLuiz Augusto von Dentz case ACL_LINK: 378373d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 378473d80debSLuiz Augusto von Dentz break; 3785bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3786bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3787bd1eb66bSAndrei Emeltchenko break; 378873d80debSLuiz Augusto von Dentz case SCO_LINK: 378973d80debSLuiz Augusto von Dentz case ESCO_LINK: 379073d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 379173d80debSLuiz Augusto von Dentz break; 379273d80debSLuiz Augusto von Dentz case LE_LINK: 379373d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 379473d80debSLuiz Augusto von Dentz break; 379573d80debSLuiz Augusto von Dentz default: 379673d80debSLuiz Augusto von Dentz cnt = 0; 37972064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", chan->conn->type); 379873d80debSLuiz Augusto von Dentz } 379973d80debSLuiz Augusto von Dentz 380073d80debSLuiz Augusto von Dentz q = cnt / num; 380173d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 380273d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 380373d80debSLuiz Augusto von Dentz return chan; 380473d80debSLuiz Augusto von Dentz } 380573d80debSLuiz Augusto von Dentz 380602b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 380702b20f0bSLuiz Augusto von Dentz { 380802b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 380902b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 381002b20f0bSLuiz Augusto von Dentz int num = 0; 381102b20f0bSLuiz Augusto von Dentz 381202b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 381302b20f0bSLuiz Augusto von Dentz 3814bf4c6325SGustavo F. Padovan rcu_read_lock(); 3815bf4c6325SGustavo F. Padovan 3816bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 381702b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 381802b20f0bSLuiz Augusto von Dentz 381902b20f0bSLuiz Augusto von Dentz if (conn->type != type) 382002b20f0bSLuiz Augusto von Dentz continue; 382102b20f0bSLuiz Augusto von Dentz 382202b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 382302b20f0bSLuiz Augusto von Dentz continue; 382402b20f0bSLuiz Augusto von Dentz 382502b20f0bSLuiz Augusto von Dentz num++; 382602b20f0bSLuiz Augusto von Dentz 38278192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 382802b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 382902b20f0bSLuiz Augusto von Dentz 383002b20f0bSLuiz Augusto von Dentz if (chan->sent) { 383102b20f0bSLuiz Augusto von Dentz chan->sent = 0; 383202b20f0bSLuiz Augusto von Dentz continue; 383302b20f0bSLuiz Augusto von Dentz } 383402b20f0bSLuiz Augusto von Dentz 383502b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 383602b20f0bSLuiz Augusto von Dentz continue; 383702b20f0bSLuiz Augusto von Dentz 383802b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 383902b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 384002b20f0bSLuiz Augusto von Dentz continue; 384102b20f0bSLuiz Augusto von Dentz 384202b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 384302b20f0bSLuiz Augusto von Dentz 384402b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 384502b20f0bSLuiz Augusto von Dentz skb->priority); 384602b20f0bSLuiz Augusto von Dentz } 384702b20f0bSLuiz Augusto von Dentz 384802b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 384902b20f0bSLuiz Augusto von Dentz break; 385002b20f0bSLuiz Augusto von Dentz } 3851bf4c6325SGustavo F. Padovan 3852bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3853bf4c6325SGustavo F. Padovan 385402b20f0bSLuiz Augusto von Dentz } 385502b20f0bSLuiz Augusto von Dentz 3856b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3857b71d385aSAndrei Emeltchenko { 3858b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3859b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3860b71d385aSAndrei Emeltchenko } 3861b71d385aSAndrei Emeltchenko 38626039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 38631da177e4SLinus Torvalds { 3864d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 38651da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 38661da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 386763d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 38685f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3869bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 38701da177e4SLinus Torvalds } 387163d2bc1bSAndrei Emeltchenko } 38721da177e4SLinus Torvalds 38736039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 387463d2bc1bSAndrei Emeltchenko { 387563d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 387663d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 387763d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 387863d2bc1bSAndrei Emeltchenko int quote; 387963d2bc1bSAndrei Emeltchenko 388063d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 388104837f64SMarcel Holtmann 388273d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 388373d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3884ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3885ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 388673d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 388773d80debSLuiz Augusto von Dentz skb->len, skb->priority); 388873d80debSLuiz Augusto von Dentz 3889ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3890ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3891ec1cce24SLuiz Augusto von Dentz break; 3892ec1cce24SLuiz Augusto von Dentz 3893ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3894ec1cce24SLuiz Augusto von Dentz 389573d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 389673d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 389704837f64SMarcel Holtmann 389857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38991da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 39001da177e4SLinus Torvalds 39011da177e4SLinus Torvalds hdev->acl_cnt--; 390273d80debSLuiz Augusto von Dentz chan->sent++; 390373d80debSLuiz Augusto von Dentz chan->conn->sent++; 39041da177e4SLinus Torvalds } 39051da177e4SLinus Torvalds } 390602b20f0bSLuiz Augusto von Dentz 390702b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 390802b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 39091da177e4SLinus Torvalds } 39101da177e4SLinus Torvalds 39116039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3912b71d385aSAndrei Emeltchenko { 391363d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3914b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3915b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3916b71d385aSAndrei Emeltchenko int quote; 3917bd1eb66bSAndrei Emeltchenko u8 type; 3918b71d385aSAndrei Emeltchenko 391963d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3920b71d385aSAndrei Emeltchenko 3921bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3922bd1eb66bSAndrei Emeltchenko 3923bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3924bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3925bd1eb66bSAndrei Emeltchenko else 3926bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3927bd1eb66bSAndrei Emeltchenko 3928b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3929bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3930b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3931b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3932b71d385aSAndrei Emeltchenko int blocks; 3933b71d385aSAndrei Emeltchenko 3934b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3935b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3936b71d385aSAndrei Emeltchenko 3937b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3938b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3939b71d385aSAndrei Emeltchenko break; 3940b71d385aSAndrei Emeltchenko 3941b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3942b71d385aSAndrei Emeltchenko 3943b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3944b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3945b71d385aSAndrei Emeltchenko return; 3946b71d385aSAndrei Emeltchenko 3947b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3948b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3949b71d385aSAndrei Emeltchenko 395057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3951b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3952b71d385aSAndrei Emeltchenko 3953b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3954b71d385aSAndrei Emeltchenko quote -= blocks; 3955b71d385aSAndrei Emeltchenko 3956b71d385aSAndrei Emeltchenko chan->sent += blocks; 3957b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3958b71d385aSAndrei Emeltchenko } 3959b71d385aSAndrei Emeltchenko } 3960b71d385aSAndrei Emeltchenko 3961b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3962bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3963b71d385aSAndrei Emeltchenko } 3964b71d385aSAndrei Emeltchenko 39656039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3966b71d385aSAndrei Emeltchenko { 3967b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3968b71d385aSAndrei Emeltchenko 3969bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3970ca8bee5dSMarcel Holtmann if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_PRIMARY) 3971bd1eb66bSAndrei Emeltchenko return; 3972bd1eb66bSAndrei Emeltchenko 3973bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3974bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3975b71d385aSAndrei Emeltchenko return; 3976b71d385aSAndrei Emeltchenko 3977b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3978b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3979b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3980b71d385aSAndrei Emeltchenko break; 3981b71d385aSAndrei Emeltchenko 3982b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3983b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3984b71d385aSAndrei Emeltchenko break; 3985b71d385aSAndrei Emeltchenko } 3986b71d385aSAndrei Emeltchenko } 3987b71d385aSAndrei Emeltchenko 39881da177e4SLinus Torvalds /* Schedule SCO */ 39896039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 39901da177e4SLinus Torvalds { 39911da177e4SLinus Torvalds struct hci_conn *conn; 39921da177e4SLinus Torvalds struct sk_buff *skb; 39931da177e4SLinus Torvalds int quote; 39941da177e4SLinus Torvalds 39951da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 39961da177e4SLinus Torvalds 399752087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 399852087a79SLuiz Augusto von Dentz return; 399952087a79SLuiz Augusto von Dentz 40001da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 40011da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 40021da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 400357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40041da177e4SLinus Torvalds 40051da177e4SLinus Torvalds conn->sent++; 40061da177e4SLinus Torvalds if (conn->sent == ~0) 40071da177e4SLinus Torvalds conn->sent = 0; 40081da177e4SLinus Torvalds } 40091da177e4SLinus Torvalds } 40101da177e4SLinus Torvalds } 40111da177e4SLinus Torvalds 40126039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4013b6a0dc82SMarcel Holtmann { 4014b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4015b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4016b6a0dc82SMarcel Holtmann int quote; 4017b6a0dc82SMarcel Holtmann 4018b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4019b6a0dc82SMarcel Holtmann 402052087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 402152087a79SLuiz Augusto von Dentz return; 402252087a79SLuiz Augusto von Dentz 40238fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 40248fc9ced3SGustavo Padovan "e))) { 4025b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4026b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 402757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4028b6a0dc82SMarcel Holtmann 4029b6a0dc82SMarcel Holtmann conn->sent++; 4030b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4031b6a0dc82SMarcel Holtmann conn->sent = 0; 4032b6a0dc82SMarcel Holtmann } 4033b6a0dc82SMarcel Holtmann } 4034b6a0dc82SMarcel Holtmann } 4035b6a0dc82SMarcel Holtmann 40366039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 40376ed58ec5SVille Tervo { 403873d80debSLuiz Augusto von Dentz struct hci_chan *chan; 40396ed58ec5SVille Tervo struct sk_buff *skb; 404002b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 40416ed58ec5SVille Tervo 40426ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 40436ed58ec5SVille Tervo 404452087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 404552087a79SLuiz Augusto von Dentz return; 404652087a79SLuiz Augusto von Dentz 4047d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 40486ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 40496ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4050bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 40516ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4052bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 40536ed58ec5SVille Tervo } 40546ed58ec5SVille Tervo 40556ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 405602b20f0bSLuiz Augusto von Dentz tmp = cnt; 405773d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_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); 40626ed58ec5SVille Tervo 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 406957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40706ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 40716ed58ec5SVille Tervo 40726ed58ec5SVille Tervo cnt--; 407373d80debSLuiz Augusto von Dentz chan->sent++; 407473d80debSLuiz Augusto von Dentz chan->conn->sent++; 40756ed58ec5SVille Tervo } 40766ed58ec5SVille Tervo } 407773d80debSLuiz Augusto von Dentz 40786ed58ec5SVille Tervo if (hdev->le_pkts) 40796ed58ec5SVille Tervo hdev->le_cnt = cnt; 40806ed58ec5SVille Tervo else 40816ed58ec5SVille Tervo hdev->acl_cnt = cnt; 408202b20f0bSLuiz Augusto von Dentz 408302b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 408402b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 40856ed58ec5SVille Tervo } 40866ed58ec5SVille Tervo 40873eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 40881da177e4SLinus Torvalds { 40893eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 40901da177e4SLinus Torvalds struct sk_buff *skb; 40911da177e4SLinus Torvalds 40926ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 40936ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 40941da177e4SLinus Torvalds 4095d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 40961da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 40971da177e4SLinus Torvalds hci_sched_acl(hdev); 40981da177e4SLinus Torvalds hci_sched_sco(hdev); 4099b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 41006ed58ec5SVille Tervo hci_sched_le(hdev); 410152de599eSMarcel Holtmann } 41026ed58ec5SVille Tervo 41031da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 41041da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 410557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41061da177e4SLinus Torvalds } 41071da177e4SLinus Torvalds 410825985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 41091da177e4SLinus Torvalds 41101da177e4SLinus Torvalds /* ACL data packet */ 41116039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 41121da177e4SLinus Torvalds { 41131da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 41141da177e4SLinus Torvalds struct hci_conn *conn; 41151da177e4SLinus Torvalds __u16 handle, flags; 41161da177e4SLinus Torvalds 41171da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 41181da177e4SLinus Torvalds 41191da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 41201da177e4SLinus Torvalds flags = hci_flags(handle); 41211da177e4SLinus Torvalds handle = hci_handle(handle); 41221da177e4SLinus Torvalds 4123f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4124a8c5fb1aSGustavo Padovan handle, flags); 41251da177e4SLinus Torvalds 41261da177e4SLinus Torvalds hdev->stat.acl_rx++; 41271da177e4SLinus Torvalds 41281da177e4SLinus Torvalds hci_dev_lock(hdev); 41291da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 41301da177e4SLinus Torvalds hci_dev_unlock(hdev); 41311da177e4SLinus Torvalds 41321da177e4SLinus Torvalds if (conn) { 413365983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 413404837f64SMarcel Holtmann 41351da177e4SLinus Torvalds /* Send to upper protocol */ 4136686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 41371da177e4SLinus Torvalds return; 41381da177e4SLinus Torvalds } else { 41392064ee33SMarcel Holtmann bt_dev_err(hdev, "ACL packet for unknown connection handle %d", 41402064ee33SMarcel Holtmann handle); 41411da177e4SLinus Torvalds } 41421da177e4SLinus Torvalds 41431da177e4SLinus Torvalds kfree_skb(skb); 41441da177e4SLinus Torvalds } 41451da177e4SLinus Torvalds 41461da177e4SLinus Torvalds /* SCO data packet */ 41476039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 41481da177e4SLinus Torvalds { 41491da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 41501da177e4SLinus Torvalds struct hci_conn *conn; 41511da177e4SLinus Torvalds __u16 handle; 41521da177e4SLinus Torvalds 41531da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 41541da177e4SLinus Torvalds 41551da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 41561da177e4SLinus Torvalds 4157f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 41581da177e4SLinus Torvalds 41591da177e4SLinus Torvalds hdev->stat.sco_rx++; 41601da177e4SLinus Torvalds 41611da177e4SLinus Torvalds hci_dev_lock(hdev); 41621da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 41631da177e4SLinus Torvalds hci_dev_unlock(hdev); 41641da177e4SLinus Torvalds 41651da177e4SLinus Torvalds if (conn) { 41661da177e4SLinus Torvalds /* Send to upper protocol */ 4167686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 41681da177e4SLinus Torvalds return; 41691da177e4SLinus Torvalds } else { 41702064ee33SMarcel Holtmann bt_dev_err(hdev, "SCO packet for unknown connection handle %d", 41712064ee33SMarcel Holtmann handle); 41721da177e4SLinus Torvalds } 41731da177e4SLinus Torvalds 41741da177e4SLinus Torvalds kfree_skb(skb); 41751da177e4SLinus Torvalds } 41761da177e4SLinus Torvalds 41779238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 41789238f36aSJohan Hedberg { 41799238f36aSJohan Hedberg struct sk_buff *skb; 41809238f36aSJohan Hedberg 41819238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 41829238f36aSJohan Hedberg if (!skb) 41839238f36aSJohan Hedberg return true; 41849238f36aSJohan Hedberg 418544d27137SJohan Hedberg return (bt_cb(skb)->hci.req_flags & HCI_REQ_START); 41869238f36aSJohan Hedberg } 41879238f36aSJohan Hedberg 418842c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 418942c6b129SJohan Hedberg { 419042c6b129SJohan Hedberg struct hci_command_hdr *sent; 419142c6b129SJohan Hedberg struct sk_buff *skb; 419242c6b129SJohan Hedberg u16 opcode; 419342c6b129SJohan Hedberg 419442c6b129SJohan Hedberg if (!hdev->sent_cmd) 419542c6b129SJohan Hedberg return; 419642c6b129SJohan Hedberg 419742c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 419842c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 419942c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 420042c6b129SJohan Hedberg return; 420142c6b129SJohan Hedberg 420242c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 420342c6b129SJohan Hedberg if (!skb) 420442c6b129SJohan Hedberg return; 420542c6b129SJohan Hedberg 420642c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 420742c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 420842c6b129SJohan Hedberg } 420942c6b129SJohan Hedberg 4210e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4211e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4212e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 42139238f36aSJohan Hedberg { 42149238f36aSJohan Hedberg struct sk_buff *skb; 42159238f36aSJohan Hedberg unsigned long flags; 42169238f36aSJohan Hedberg 42179238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 42189238f36aSJohan Hedberg 421942c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 422042c6b129SJohan Hedberg * sent we need to do special handling of it. 42219238f36aSJohan Hedberg */ 422242c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 422342c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 422442c6b129SJohan Hedberg * reset complete event during init and any pending 422542c6b129SJohan Hedberg * command will never be completed. In such a case we 422642c6b129SJohan Hedberg * need to resend whatever was the last sent 422742c6b129SJohan Hedberg * command. 422842c6b129SJohan Hedberg */ 422942c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 423042c6b129SJohan Hedberg hci_resend_last(hdev); 423142c6b129SJohan Hedberg 42329238f36aSJohan Hedberg return; 423342c6b129SJohan Hedberg } 42349238f36aSJohan Hedberg 42359238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 42369238f36aSJohan Hedberg * this request the request is not yet complete. 42379238f36aSJohan Hedberg */ 42389238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 42399238f36aSJohan Hedberg return; 42409238f36aSJohan Hedberg 42419238f36aSJohan Hedberg /* If this was the last command in a request the complete 42429238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 42439238f36aSJohan Hedberg * command queue (hdev->cmd_q). 42449238f36aSJohan Hedberg */ 424544d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_flags & HCI_REQ_SKB) { 424644d27137SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4247e6214487SJohan Hedberg return; 42489238f36aSJohan Hedberg } 4249e6214487SJohan Hedberg 425044d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 425144d27137SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4252e6214487SJohan Hedberg return; 425353e21fbcSJohan Hedberg } 42549238f36aSJohan Hedberg 42559238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 42569238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 42579238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 425844d27137SJohan Hedberg if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) { 42599238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 42609238f36aSJohan Hedberg break; 42619238f36aSJohan Hedberg } 42629238f36aSJohan Hedberg 42633bd7594eSDouglas Anderson if (bt_cb(skb)->hci.req_flags & HCI_REQ_SKB) 4264242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 42653bd7594eSDouglas Anderson else 42663bd7594eSDouglas Anderson *req_complete = bt_cb(skb)->hci.req_complete; 42679238f36aSJohan Hedberg kfree_skb(skb); 42689238f36aSJohan Hedberg } 42699238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 42709238f36aSJohan Hedberg } 42719238f36aSJohan Hedberg 4272b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 42731da177e4SLinus Torvalds { 4274b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 42751da177e4SLinus Torvalds struct sk_buff *skb; 42761da177e4SLinus Torvalds 42771da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 42781da177e4SLinus Torvalds 42791da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4280cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4281cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4282cd82e61cSMarcel Holtmann 42831da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 42841da177e4SLinus Torvalds /* Send copy to the sockets */ 4285470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 42861da177e4SLinus Torvalds } 42871da177e4SLinus Torvalds 4288d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 42891da177e4SLinus Torvalds kfree_skb(skb); 42901da177e4SLinus Torvalds continue; 42911da177e4SLinus Torvalds } 42921da177e4SLinus Torvalds 42931da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 42941da177e4SLinus Torvalds /* Don't process data packets in this states. */ 4295d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 42961da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 42971da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42981da177e4SLinus Torvalds kfree_skb(skb); 42991da177e4SLinus Torvalds continue; 43003ff50b79SStephen Hemminger } 43011da177e4SLinus Torvalds } 43021da177e4SLinus Torvalds 43031da177e4SLinus Torvalds /* Process frame */ 4304d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 43051da177e4SLinus Torvalds case HCI_EVENT_PKT: 4306b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 43071da177e4SLinus Torvalds hci_event_packet(hdev, skb); 43081da177e4SLinus Torvalds break; 43091da177e4SLinus Torvalds 43101da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 43111da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 43121da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 43131da177e4SLinus Torvalds break; 43141da177e4SLinus Torvalds 43151da177e4SLinus Torvalds case HCI_SCODATA_PKT: 43161da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 43171da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 43181da177e4SLinus Torvalds break; 43191da177e4SLinus Torvalds 43201da177e4SLinus Torvalds default: 43211da177e4SLinus Torvalds kfree_skb(skb); 43221da177e4SLinus Torvalds break; 43231da177e4SLinus Torvalds } 43241da177e4SLinus Torvalds } 43251da177e4SLinus Torvalds } 43261da177e4SLinus Torvalds 4327c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 43281da177e4SLinus Torvalds { 4329c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 43301da177e4SLinus Torvalds struct sk_buff *skb; 43311da177e4SLinus Torvalds 43322104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 43332104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 43341da177e4SLinus Torvalds 43351da177e4SLinus Torvalds /* Send queued commands */ 43365a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 43375a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 43385a08ecceSAndrei Emeltchenko if (!skb) 43395a08ecceSAndrei Emeltchenko return; 43405a08ecceSAndrei Emeltchenko 43411da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 43421da177e4SLinus Torvalds 4343a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 434470f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 43451da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 434657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 43477bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 434865cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 43497bdb8a5cSSzymon Janc else 435065cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 435165cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 43521da177e4SLinus Torvalds } else { 43531da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4354c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 43551da177e4SLinus Torvalds } 43561da177e4SLinus Torvalds } 43571da177e4SLinus Torvalds } 4358