11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 4590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 51da177e4SLinus Torvalds 61da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 101da177e4SLinus Torvalds published by the Free Software Foundation; 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 131da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 141da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 151da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 161da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 171da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 181da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 191da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 221da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 231da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds /* Bluetooth HCI core. */ 271da177e4SLinus Torvalds 288c520a59SGustavo Padovan #include <linux/export.h> 293df92b31SSasha Levin #include <linux/idr.h> 30611b30f7SMarcel Holtmann #include <linux/rfkill.h> 31baf27f6eSMarcel Holtmann #include <linux/debugfs.h> 3299780a7bSJohan Hedberg #include <linux/crypto.h> 337a0e5b15SMatthias Kaehlcke #include <linux/property.h> 3447219839SMarcel Holtmann #include <asm/unaligned.h> 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 371da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 384bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 39af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 401da177e4SLinus Torvalds 410857dd3bSJohan Hedberg #include "hci_request.h" 4260c5f5fbSMarcel Holtmann #include "hci_debugfs.h" 43970c4e46SJohan Hedberg #include "smp.h" 446d5d2ee6SHeiner Kallweit #include "leds.h" 45970c4e46SJohan Hedberg 46b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 47c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 483eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds /* HCI device list */ 511da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 521da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds /* HCI callback list */ 551da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 56fba7ecf0SJohan Hedberg DEFINE_MUTEX(hci_cb_list_lock); 571da177e4SLinus Torvalds 583df92b31SSasha Levin /* HCI ID Numbering */ 593df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 603df92b31SSasha Levin 61baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 62baf27f6eSMarcel Holtmann 634b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 644b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 654b4148e9SMarcel Holtmann { 664b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 674b4148e9SMarcel Holtmann char buf[3]; 684b4148e9SMarcel Holtmann 69b7cb93e5SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y' : 'N'; 704b4148e9SMarcel Holtmann buf[1] = '\n'; 714b4148e9SMarcel Holtmann buf[2] = '\0'; 724b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 734b4148e9SMarcel Holtmann } 744b4148e9SMarcel Holtmann 754b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 764b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 774b4148e9SMarcel Holtmann { 784b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 794b4148e9SMarcel Holtmann struct sk_buff *skb; 804b4148e9SMarcel Holtmann bool enable; 813bf5e97dSAndy Shevchenko int err; 824b4148e9SMarcel Holtmann 834b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 844b4148e9SMarcel Holtmann return -ENETDOWN; 854b4148e9SMarcel Holtmann 863bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 873bf5e97dSAndy Shevchenko if (err) 883bf5e97dSAndy Shevchenko return err; 894b4148e9SMarcel Holtmann 90b7cb93e5SMarcel Holtmann if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE)) 914b4148e9SMarcel Holtmann return -EALREADY; 924b4148e9SMarcel Holtmann 93b504430cSJohan Hedberg hci_req_sync_lock(hdev); 944b4148e9SMarcel Holtmann if (enable) 954b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 964b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 974b4148e9SMarcel Holtmann else 984b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 994b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 100b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1014b4148e9SMarcel Holtmann 1024b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1034b4148e9SMarcel Holtmann return PTR_ERR(skb); 1044b4148e9SMarcel Holtmann 1054b4148e9SMarcel Holtmann kfree_skb(skb); 1064b4148e9SMarcel Holtmann 107b7cb93e5SMarcel Holtmann hci_dev_change_flag(hdev, HCI_DUT_MODE); 1084b4148e9SMarcel Holtmann 1094b4148e9SMarcel Holtmann return count; 1104b4148e9SMarcel Holtmann } 1114b4148e9SMarcel Holtmann 1124b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1134b4148e9SMarcel Holtmann .open = simple_open, 1144b4148e9SMarcel Holtmann .read = dut_mode_read, 1154b4148e9SMarcel Holtmann .write = dut_mode_write, 1164b4148e9SMarcel Holtmann .llseek = default_llseek, 1174b4148e9SMarcel Holtmann }; 1184b4148e9SMarcel Holtmann 1194b4113d6SMarcel Holtmann static ssize_t vendor_diag_read(struct file *file, char __user *user_buf, 1204b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1214b4113d6SMarcel Holtmann { 1224b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1234b4113d6SMarcel Holtmann char buf[3]; 1244b4113d6SMarcel Holtmann 1254b4113d6SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y' : 'N'; 1264b4113d6SMarcel Holtmann buf[1] = '\n'; 1274b4113d6SMarcel Holtmann buf[2] = '\0'; 1284b4113d6SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 1294b4113d6SMarcel Holtmann } 1304b4113d6SMarcel Holtmann 1314b4113d6SMarcel Holtmann static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf, 1324b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1334b4113d6SMarcel Holtmann { 1344b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1354b4113d6SMarcel Holtmann bool enable; 1364b4113d6SMarcel Holtmann int err; 1374b4113d6SMarcel Holtmann 1383bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 1393bf5e97dSAndy Shevchenko if (err) 1403bf5e97dSAndy Shevchenko return err; 1414b4113d6SMarcel Holtmann 1427e995b9eSMarcel Holtmann /* When the diagnostic flags are not persistent and the transport 143b56c7b25SMarcel Holtmann * is not active or in user channel operation, then there is no need 144b56c7b25SMarcel Holtmann * for the vendor callback. Instead just store the desired value and 145b56c7b25SMarcel Holtmann * the setting will be programmed when the controller gets powered on. 1467e995b9eSMarcel Holtmann */ 1477e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 148b56c7b25SMarcel Holtmann (!test_bit(HCI_RUNNING, &hdev->flags) || 149b56c7b25SMarcel Holtmann hci_dev_test_flag(hdev, HCI_USER_CHANNEL))) 1507e995b9eSMarcel Holtmann goto done; 1517e995b9eSMarcel Holtmann 152b504430cSJohan Hedberg hci_req_sync_lock(hdev); 1534b4113d6SMarcel Holtmann err = hdev->set_diag(hdev, enable); 154b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1554b4113d6SMarcel Holtmann 1564b4113d6SMarcel Holtmann if (err < 0) 1574b4113d6SMarcel Holtmann return err; 1584b4113d6SMarcel Holtmann 1597e995b9eSMarcel Holtmann done: 1604b4113d6SMarcel Holtmann if (enable) 1614b4113d6SMarcel Holtmann hci_dev_set_flag(hdev, HCI_VENDOR_DIAG); 1624b4113d6SMarcel Holtmann else 1634b4113d6SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG); 1644b4113d6SMarcel Holtmann 1654b4113d6SMarcel Holtmann return count; 1664b4113d6SMarcel Holtmann } 1674b4113d6SMarcel Holtmann 1684b4113d6SMarcel Holtmann static const struct file_operations vendor_diag_fops = { 1694b4113d6SMarcel Holtmann .open = simple_open, 1704b4113d6SMarcel Holtmann .read = vendor_diag_read, 1714b4113d6SMarcel Holtmann .write = vendor_diag_write, 1724b4113d6SMarcel Holtmann .llseek = default_llseek, 1734b4113d6SMarcel Holtmann }; 1744b4113d6SMarcel Holtmann 175f640ee98SMarcel Holtmann static void hci_debugfs_create_basic(struct hci_dev *hdev) 176f640ee98SMarcel Holtmann { 177f640ee98SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 178f640ee98SMarcel Holtmann &dut_mode_fops); 179f640ee98SMarcel Holtmann 180f640ee98SMarcel Holtmann if (hdev->set_diag) 181f640ee98SMarcel Holtmann debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev, 182f640ee98SMarcel Holtmann &vendor_diag_fops); 183f640ee98SMarcel Holtmann } 184f640ee98SMarcel Holtmann 185a1d01db1SJohan Hedberg static int hci_reset_req(struct hci_request *req, unsigned long opt) 1861da177e4SLinus Torvalds { 18742c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds /* Reset device */ 19042c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 19142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 192a1d01db1SJohan Hedberg return 0; 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds 19542c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 1961da177e4SLinus Torvalds { 19742c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 1982455a3eaSAndrei Emeltchenko 1991da177e4SLinus Torvalds /* Read Local Supported Features */ 20042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2011da177e4SLinus Torvalds 2021143e5a6SMarcel Holtmann /* Read Local Version */ 20342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2042177bab5SJohan Hedberg 2052177bab5SJohan Hedberg /* Read BD Address */ 20642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2090af801b9SJohan Hedberg static void amp_init1(struct hci_request *req) 210e61ef499SAndrei Emeltchenko { 21142c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 2122455a3eaSAndrei Emeltchenko 213e61ef499SAndrei Emeltchenko /* Read Local Version */ 21442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2156bcbc489SAndrei Emeltchenko 216f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 217f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 218f6996cfeSMarcel Holtmann 2196bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 22042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 221e71dfabaSAndrei Emeltchenko 222e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 22342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 2247528ca1cSMarcel Holtmann 225f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 226f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 227f38ba941SMarcel Holtmann 2287528ca1cSMarcel Holtmann /* Read Location Data */ 2297528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 230e61ef499SAndrei Emeltchenko } 231e61ef499SAndrei Emeltchenko 232a1d01db1SJohan Hedberg static int amp_init2(struct hci_request *req) 2330af801b9SJohan Hedberg { 2340af801b9SJohan Hedberg /* Read Local Supported Features. Not all AMP controllers 2350af801b9SJohan Hedberg * support this so it's placed conditionally in the second 2360af801b9SJohan Hedberg * stage init. 2370af801b9SJohan Hedberg */ 2380af801b9SJohan Hedberg if (req->hdev->commands[14] & 0x20) 2390af801b9SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 240a1d01db1SJohan Hedberg 241a1d01db1SJohan Hedberg return 0; 2420af801b9SJohan Hedberg } 2430af801b9SJohan Hedberg 244a1d01db1SJohan Hedberg static int hci_init1_req(struct hci_request *req, unsigned long opt) 245e61ef499SAndrei Emeltchenko { 24642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 247e61ef499SAndrei Emeltchenko 248e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 249e61ef499SAndrei Emeltchenko 25011778716SAndrei Emeltchenko /* Reset */ 25111778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 25242c6b129SJohan Hedberg hci_reset_req(req, 0); 25311778716SAndrei Emeltchenko 254e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 255ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 25642c6b129SJohan Hedberg bredr_init(req); 257e61ef499SAndrei Emeltchenko break; 258e61ef499SAndrei Emeltchenko case HCI_AMP: 2590af801b9SJohan Hedberg amp_init1(req); 260e61ef499SAndrei Emeltchenko break; 261e61ef499SAndrei Emeltchenko default: 2622064ee33SMarcel Holtmann bt_dev_err(hdev, "Unknown device type %d", hdev->dev_type); 263e61ef499SAndrei Emeltchenko break; 264e61ef499SAndrei Emeltchenko } 265a1d01db1SJohan Hedberg 266a1d01db1SJohan Hedberg return 0; 267e61ef499SAndrei Emeltchenko } 268e61ef499SAndrei Emeltchenko 26942c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 2702177bab5SJohan Hedberg { 2712177bab5SJohan Hedberg __le16 param; 2722177bab5SJohan Hedberg __u8 flt_type; 2732177bab5SJohan Hedberg 2742177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 27542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2762177bab5SJohan Hedberg 2772177bab5SJohan Hedberg /* Read Class of Device */ 27842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 2792177bab5SJohan Hedberg 2802177bab5SJohan Hedberg /* Read Local Name */ 28142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2822177bab5SJohan Hedberg 2832177bab5SJohan Hedberg /* Read Voice Setting */ 28442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2852177bab5SJohan Hedberg 286b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 287b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 288b4cb9fb2SMarcel Holtmann 2894b836f39SMarcel Holtmann /* Read Current IAC LAP */ 2904b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 2914b836f39SMarcel Holtmann 2922177bab5SJohan Hedberg /* Clear Event Filters */ 2932177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 29442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2952177bab5SJohan Hedberg 2962177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 297dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 29842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 2992177bab5SJohan Hedberg } 3002177bab5SJohan Hedberg 30142c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 3022177bab5SJohan Hedberg { 303c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 304c73eee91SJohan Hedberg 3052177bab5SJohan Hedberg /* Read LE Buffer Size */ 30642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 3072177bab5SJohan Hedberg 3082177bab5SJohan Hedberg /* Read LE Local Supported Features */ 30942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 3102177bab5SJohan Hedberg 311747d3f03SMarcel Holtmann /* Read LE Supported States */ 312747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 313747d3f03SMarcel Holtmann 314c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 315c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 316a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_LE_ENABLED); 3172177bab5SJohan Hedberg } 3182177bab5SJohan Hedberg 31942c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 3202177bab5SJohan Hedberg { 32142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 32242c6b129SJohan Hedberg 3232177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 3242177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 3252177bab5SJohan Hedberg * command otherwise. 3262177bab5SJohan Hedberg */ 3272177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 3282177bab5SJohan Hedberg 3292177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 3302177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 3312177bab5SJohan Hedberg */ 3322177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 3332177bab5SJohan Hedberg return; 3342177bab5SJohan Hedberg 3352177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 3362177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 337c7882cbdSMarcel Holtmann } else { 338c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 339c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 340c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 341c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 342c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 3435c3d3b4cSMarcel Holtmann 3445c3d3b4cSMarcel Holtmann /* If the controller supports the Disconnect command, enable 3455c3d3b4cSMarcel Holtmann * the corresponding event. In addition enable packet flow 3465c3d3b4cSMarcel Holtmann * control related events. 3475c3d3b4cSMarcel Holtmann */ 3485c3d3b4cSMarcel Holtmann if (hdev->commands[0] & 0x20) { 3495c3d3b4cSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 350c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 351c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 3525c3d3b4cSMarcel Holtmann } 3535c3d3b4cSMarcel Holtmann 3545c3d3b4cSMarcel Holtmann /* If the controller supports the Read Remote Version 3555c3d3b4cSMarcel Holtmann * Information command, enable the corresponding event. 3565c3d3b4cSMarcel Holtmann */ 3575c3d3b4cSMarcel Holtmann if (hdev->commands[2] & 0x80) 3585c3d3b4cSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information 3595c3d3b4cSMarcel Holtmann * Complete 3605c3d3b4cSMarcel Holtmann */ 3610da71f1bSMarcel Holtmann 3620da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 3630da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 364c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3652177bab5SJohan Hedberg } 3660da71f1bSMarcel Holtmann } 3672177bab5SJohan Hedberg 3689fe759ceSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 3699fe759ceSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) 3702177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 3712177bab5SJohan Hedberg 37270f56aa2SMarcel Holtmann if (lmp_ext_feat_capable(hdev)) 37370f56aa2SMarcel Holtmann events[4] |= 0x04; /* Read Remote Extended Features Complete */ 37470f56aa2SMarcel Holtmann 37570f56aa2SMarcel Holtmann if (lmp_esco_capable(hdev)) { 37670f56aa2SMarcel Holtmann events[5] |= 0x08; /* Synchronous Connection Complete */ 37770f56aa2SMarcel Holtmann events[5] |= 0x10; /* Synchronous Connection Changed */ 37870f56aa2SMarcel Holtmann } 37970f56aa2SMarcel Holtmann 3802177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 3812177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 3822177bab5SJohan Hedberg 3832177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 3842177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3852177bab5SJohan Hedberg 3862177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 3872177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 3882177bab5SJohan Hedberg 3892177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 3902177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 3912177bab5SJohan Hedberg 3922177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 3932177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 3942177bab5SJohan Hedberg 3952177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 3962177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 3972177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 3982177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 3992177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 4002177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 4012177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 4022177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 4032177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 4042177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 4052177bab5SJohan Hedberg * Features Notification 4062177bab5SJohan Hedberg */ 4072177bab5SJohan Hedberg } 4082177bab5SJohan Hedberg 4092177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 4102177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 4112177bab5SJohan Hedberg 41242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 4132177bab5SJohan Hedberg } 4142177bab5SJohan Hedberg 415a1d01db1SJohan Hedberg static int hci_init2_req(struct hci_request *req, unsigned long opt) 4162177bab5SJohan Hedberg { 41742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 41842c6b129SJohan Hedberg 4190af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 4200af801b9SJohan Hedberg return amp_init2(req); 4210af801b9SJohan Hedberg 4222177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 42342c6b129SJohan Hedberg bredr_setup(req); 42456f87901SJohan Hedberg else 425a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 4262177bab5SJohan Hedberg 4272177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 42842c6b129SJohan Hedberg le_setup(req); 4292177bab5SJohan Hedberg 4300f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 4310f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 4320f3adeaeSMarcel Holtmann * 4330f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 4340f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 4350f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 4360f3adeaeSMarcel Holtmann * supported commands. 4373f8e2d75SJohan Hedberg */ 4380f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 4390f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 44042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 4412177bab5SJohan Hedberg 4422177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 44357af75a8SMarcel Holtmann /* When SSP is available, then the host features page 44457af75a8SMarcel Holtmann * should also be available as well. However some 44557af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 44657af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 44757af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 44857af75a8SMarcel Holtmann */ 44957af75a8SMarcel Holtmann hdev->max_page = 0x01; 45057af75a8SMarcel Holtmann 451d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 4522177bab5SJohan Hedberg u8 mode = 0x01; 453574ea3c7SMarcel Holtmann 45442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 4552177bab5SJohan Hedberg sizeof(mode), &mode); 4562177bab5SJohan Hedberg } else { 4572177bab5SJohan Hedberg struct hci_cp_write_eir cp; 4582177bab5SJohan Hedberg 4592177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 4602177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 4612177bab5SJohan Hedberg 46242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 4632177bab5SJohan Hedberg } 4642177bab5SJohan Hedberg } 4652177bab5SJohan Hedberg 466043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 467043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 46804422da9SMarcel Holtmann u8 mode; 46904422da9SMarcel Holtmann 47004422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 47104422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 47204422da9SMarcel Holtmann * events. 47304422da9SMarcel Holtmann */ 47404422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 47504422da9SMarcel Holtmann 47604422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 47704422da9SMarcel Holtmann } 4782177bab5SJohan Hedberg 4792177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 48042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 4812177bab5SJohan Hedberg 4822177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 4832177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 4842177bab5SJohan Hedberg 4852177bab5SJohan Hedberg cp.page = 0x01; 48642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 48742c6b129SJohan Hedberg sizeof(cp), &cp); 4882177bab5SJohan Hedberg } 4892177bab5SJohan Hedberg 490d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 4912177bab5SJohan Hedberg u8 enable = 1; 49242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 4932177bab5SJohan Hedberg &enable); 4942177bab5SJohan Hedberg } 495a1d01db1SJohan Hedberg 496a1d01db1SJohan Hedberg return 0; 4972177bab5SJohan Hedberg } 4982177bab5SJohan Hedberg 49942c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 5002177bab5SJohan Hedberg { 50142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5022177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 5032177bab5SJohan Hedberg u16 link_policy = 0; 5042177bab5SJohan Hedberg 5052177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 5062177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 5072177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 5082177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 5092177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 5102177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 5112177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 5122177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 5132177bab5SJohan Hedberg 5142177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 51542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 5162177bab5SJohan Hedberg } 5172177bab5SJohan Hedberg 51842c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 5192177bab5SJohan Hedberg { 52042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5212177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 5222177bab5SJohan Hedberg 523c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 524c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 525c73eee91SJohan Hedberg return; 526c73eee91SJohan Hedberg 5272177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 5282177bab5SJohan Hedberg 529d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 5302177bab5SJohan Hedberg cp.le = 0x01; 53132226e4fSMarcel Holtmann cp.simul = 0x00; 5322177bab5SJohan Hedberg } 5332177bab5SJohan Hedberg 5342177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 53542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 5362177bab5SJohan Hedberg &cp); 5372177bab5SJohan Hedberg } 5382177bab5SJohan Hedberg 539d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 540d62e6d67SJohan Hedberg { 541d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 542d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 543313f6888SMarcel Holtmann bool changed = false; 544d62e6d67SJohan Hedberg 545d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 546d62e6d67SJohan Hedberg * enable all necessary events for it. 547d62e6d67SJohan Hedberg */ 54853b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 549d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 550d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 551d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 552d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 553313f6888SMarcel Holtmann changed = true; 554d62e6d67SJohan Hedberg } 555d62e6d67SJohan Hedberg 556d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 557d62e6d67SJohan Hedberg * enable all necessary events for it. 558d62e6d67SJohan Hedberg */ 55953b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 560d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 561d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 562d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 563d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 564313f6888SMarcel Holtmann changed = true; 565d62e6d67SJohan Hedberg } 566d62e6d67SJohan Hedberg 56740c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 568313f6888SMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) { 56940c59fcbSMarcel Holtmann events[2] |= 0x80; 570313f6888SMarcel Holtmann changed = true; 571313f6888SMarcel Holtmann } 57240c59fcbSMarcel Holtmann 573313f6888SMarcel Holtmann /* Some Broadcom based controllers indicate support for Set Event 574313f6888SMarcel Holtmann * Mask Page 2 command, but then actually do not support it. Since 575313f6888SMarcel Holtmann * the default value is all bits set to zero, the command is only 576313f6888SMarcel Holtmann * required if the event mask has to be changed. In case no change 577313f6888SMarcel Holtmann * to the event mask is needed, skip this command. 578313f6888SMarcel Holtmann */ 579313f6888SMarcel Holtmann if (changed) 580313f6888SMarcel Holtmann hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, 581313f6888SMarcel Holtmann sizeof(events), events); 582d62e6d67SJohan Hedberg } 583d62e6d67SJohan Hedberg 584a1d01db1SJohan Hedberg static int hci_init3_req(struct hci_request *req, unsigned long opt) 5852177bab5SJohan Hedberg { 58642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 587d2c5d77fSJohan Hedberg u8 p; 58842c6b129SJohan Hedberg 5890da71f1bSMarcel Holtmann hci_setup_event_mask(req); 5900da71f1bSMarcel Holtmann 591e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 592e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 59348ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 59448ce62c4SMarcel Holtmann 59548ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 59648ce62c4SMarcel Holtmann cp.read_all = 0x01; 59748ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 59848ce62c4SMarcel Holtmann } 59948ce62c4SMarcel Holtmann 6002177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 60142c6b129SJohan Hedberg hci_setup_link_policy(req); 6022177bab5SJohan Hedberg 603417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 604417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 605417287deSMarcel Holtmann 606417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 607417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 608417287deSMarcel Holtmann * this command in the bit mask of supported commands. 609417287deSMarcel Holtmann */ 610417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 611417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 612417287deSMarcel Holtmann 6139193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 6149193c6e8SAndre Guedes u8 events[8]; 6159193c6e8SAndre Guedes 6169193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 6174d6c705bSMarcel Holtmann 6184d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 6194d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 620662bc2e6SAndre Guedes 621662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 622662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 623662bc2e6SAndre Guedes */ 624662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 625662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 626662bc2e6SAndre Guedes * Parameter Request 627662bc2e6SAndre Guedes */ 628662bc2e6SAndre Guedes 629a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 630a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 631a9f6068eSMarcel Holtmann */ 632a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 633a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 634a9f6068eSMarcel Holtmann 6354b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 6364b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 6374b71bba4SMarcel Holtmann */ 6384b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 6394b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 6404b71bba4SMarcel Holtmann * Report 6414b71bba4SMarcel Holtmann */ 6424b71bba4SMarcel Holtmann 6439756d33bSMarcel Holtmann /* If the controller supports Channel Selection Algorithm #2 6449756d33bSMarcel Holtmann * feature, enable the corresponding event. 6459756d33bSMarcel Holtmann */ 6469756d33bSMarcel Holtmann if (hdev->le_features[1] & HCI_LE_CHAN_SEL_ALG2) 6479756d33bSMarcel Holtmann events[2] |= 0x08; /* LE Channel Selection 6489756d33bSMarcel Holtmann * Algorithm 6499756d33bSMarcel Holtmann */ 6509756d33bSMarcel Holtmann 6517d26f5c4SMarcel Holtmann /* If the controller supports the LE Set Scan Enable command, 6527d26f5c4SMarcel Holtmann * enable the corresponding advertising report event. 6537d26f5c4SMarcel Holtmann */ 6547d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x08) 6557d26f5c4SMarcel Holtmann events[0] |= 0x02; /* LE Advertising Report */ 6567d26f5c4SMarcel Holtmann 6577d26f5c4SMarcel Holtmann /* If the controller supports the LE Create Connection 6587d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6597d26f5c4SMarcel Holtmann */ 6607d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x10) 6617d26f5c4SMarcel Holtmann events[0] |= 0x01; /* LE Connection Complete */ 6627d26f5c4SMarcel Holtmann 6637d26f5c4SMarcel Holtmann /* If the controller supports the LE Connection Update 6647d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6657d26f5c4SMarcel Holtmann */ 6667d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x04) 6677d26f5c4SMarcel Holtmann events[0] |= 0x04; /* LE Connection Update 6687d26f5c4SMarcel Holtmann * Complete 6697d26f5c4SMarcel Holtmann */ 6707d26f5c4SMarcel Holtmann 6717d26f5c4SMarcel Holtmann /* If the controller supports the LE Read Remote Used Features 6727d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6737d26f5c4SMarcel Holtmann */ 6747d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x20) 6757d26f5c4SMarcel Holtmann events[0] |= 0x08; /* LE Read Remote Used 6767d26f5c4SMarcel Holtmann * Features Complete 6777d26f5c4SMarcel Holtmann */ 6787d26f5c4SMarcel Holtmann 6795a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 6805a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 6815a34bd5fSMarcel Holtmann */ 6825a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 6835a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 6845a34bd5fSMarcel Holtmann * Public Key Complete 6855a34bd5fSMarcel Holtmann */ 6865a34bd5fSMarcel Holtmann 6875a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 6885a34bd5fSMarcel Holtmann * command, enable the corresponding event. 6895a34bd5fSMarcel Holtmann */ 6905a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 6915a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 6925a34bd5fSMarcel Holtmann 69327bbca44SMarcel Holtmann /* If the controller supports the LE Set Default PHY or 69427bbca44SMarcel Holtmann * LE Set PHY commands, enable the corresponding event. 69527bbca44SMarcel Holtmann */ 69627bbca44SMarcel Holtmann if (hdev->commands[35] & (0x20 | 0x40)) 69727bbca44SMarcel Holtmann events[1] |= 0x08; /* LE PHY Update Complete */ 69827bbca44SMarcel Holtmann 699c215e939SJaganath Kanakkassery /* If the controller supports LE Set Extended Scan Parameters 700c215e939SJaganath Kanakkassery * and LE Set Extended Scan Enable commands, enable the 701c215e939SJaganath Kanakkassery * corresponding event. 702c215e939SJaganath Kanakkassery */ 703c215e939SJaganath Kanakkassery if (use_ext_scan(hdev)) 704c215e939SJaganath Kanakkassery events[1] |= 0x10; /* LE Extended Advertising 705c215e939SJaganath Kanakkassery * Report 706c215e939SJaganath Kanakkassery */ 707c215e939SJaganath Kanakkassery 7084d94f95dSJaganath Kanakkassery /* If the controller supports the LE Extended Create Connection 7094d94f95dSJaganath Kanakkassery * command, enable the corresponding event. 7104d94f95dSJaganath Kanakkassery */ 7114d94f95dSJaganath Kanakkassery if (use_ext_conn(hdev)) 7124d94f95dSJaganath Kanakkassery events[1] |= 0x02; /* LE Enhanced Connection 7134d94f95dSJaganath Kanakkassery * Complete 7144d94f95dSJaganath Kanakkassery */ 7154d94f95dSJaganath Kanakkassery 716acf0aeaeSJaganath Kanakkassery /* If the controller supports the LE Extended Advertising 717acf0aeaeSJaganath Kanakkassery * command, enable the corresponding event. 718acf0aeaeSJaganath Kanakkassery */ 719acf0aeaeSJaganath Kanakkassery if (ext_adv_capable(hdev)) 720acf0aeaeSJaganath Kanakkassery events[2] |= 0x02; /* LE Advertising Set 721acf0aeaeSJaganath Kanakkassery * Terminated 722acf0aeaeSJaganath Kanakkassery */ 723acf0aeaeSJaganath Kanakkassery 7249193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 7259193c6e8SAndre Guedes events); 7269193c6e8SAndre Guedes 72715a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 7286b49bcb4SJaganath Kanakkassery if ((hdev->commands[25] & 0x40) && !ext_adv_capable(hdev)) { 7296b49bcb4SJaganath Kanakkassery /* HCI TS spec forbids mixing of legacy and extended 7306b49bcb4SJaganath Kanakkassery * advertising commands wherein READ_ADV_TX_POWER is 7316b49bcb4SJaganath Kanakkassery * also included. So do not call it if extended adv 7326b49bcb4SJaganath Kanakkassery * is supported otherwise controller will return 7336b49bcb4SJaganath Kanakkassery * COMMAND_DISALLOWED for extended commands. 7346b49bcb4SJaganath Kanakkassery */ 73515a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 73615a49ccaSMarcel Holtmann } 73715a49ccaSMarcel Holtmann 7382ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 7392ab216a7SMarcel Holtmann /* Read LE White List Size */ 7402ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 7412ab216a7SMarcel Holtmann 0, NULL); 7422ab216a7SMarcel Holtmann } 7432ab216a7SMarcel Holtmann 7442ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 7452ab216a7SMarcel Holtmann /* Clear LE White List */ 7462ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 7472ab216a7SMarcel Holtmann } 7482ab216a7SMarcel Holtmann 749cfdb0c2dSAnkit Navik if (hdev->commands[34] & 0x40) { 750cfdb0c2dSAnkit Navik /* Read LE Resolving List Size */ 751cfdb0c2dSAnkit Navik hci_req_add(req, HCI_OP_LE_READ_RESOLV_LIST_SIZE, 752cfdb0c2dSAnkit Navik 0, NULL); 753cfdb0c2dSAnkit Navik } 754cfdb0c2dSAnkit Navik 755545f2596SAnkit Navik if (hdev->commands[34] & 0x20) { 756545f2596SAnkit Navik /* Clear LE Resolving List */ 757545f2596SAnkit Navik hci_req_add(req, HCI_OP_LE_CLEAR_RESOLV_LIST, 0, NULL); 758545f2596SAnkit Navik } 759545f2596SAnkit Navik 760a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 761a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 762a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 763a9f6068eSMarcel Holtmann 764a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 765a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 766a9f6068eSMarcel Holtmann } 767a9f6068eSMarcel Holtmann 7686b49bcb4SJaganath Kanakkassery if (ext_adv_capable(hdev)) { 7696b49bcb4SJaganath Kanakkassery /* Read LE Number of Supported Advertising Sets */ 7706b49bcb4SJaganath Kanakkassery hci_req_add(req, HCI_OP_LE_READ_NUM_SUPPORTED_ADV_SETS, 7716b49bcb4SJaganath Kanakkassery 0, NULL); 7726b49bcb4SJaganath Kanakkassery } 7736b49bcb4SJaganath Kanakkassery 77442c6b129SJohan Hedberg hci_set_le_support(req); 7759193c6e8SAndre Guedes } 776d2c5d77fSJohan Hedberg 777d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 778d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 779d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 780d2c5d77fSJohan Hedberg 781d2c5d77fSJohan Hedberg cp.page = p; 782d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 783d2c5d77fSJohan Hedberg sizeof(cp), &cp); 784d2c5d77fSJohan Hedberg } 785a1d01db1SJohan Hedberg 786a1d01db1SJohan Hedberg return 0; 7872177bab5SJohan Hedberg } 7882177bab5SJohan Hedberg 789a1d01db1SJohan Hedberg static int hci_init4_req(struct hci_request *req, unsigned long opt) 7905d4e7e8dSJohan Hedberg { 7915d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 7925d4e7e8dSJohan Hedberg 79336f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 79436f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 79536f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 79636f260ceSMarcel Holtmann * 79736f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 79836f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 79936f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 80036f260ceSMarcel Holtmann * command redundant anyway. 80136f260ceSMarcel Holtmann * 80236f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 80336f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 80436f260ceSMarcel Holtmann * just disable this command. 80536f260ceSMarcel Holtmann */ 80636f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 80736f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 80836f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 80936f260ceSMarcel Holtmann 81036f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 81136f260ceSMarcel Holtmann cp.delete_all = 0x01; 81236f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 81336f260ceSMarcel Holtmann sizeof(cp), &cp); 81436f260ceSMarcel Holtmann } 81536f260ceSMarcel Holtmann 816d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 817d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 818d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 819d62e6d67SJohan Hedberg 820109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 821109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 822109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 823109e3191SMarcel Holtmann 824f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 825f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 826f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 827f4fe73edSMarcel Holtmann 8285d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 82953b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 8305d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 831a6d0d690SMarcel Holtmann 832a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 833d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 834574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 835a6d0d690SMarcel Holtmann u8 support = 0x01; 836574ea3c7SMarcel Holtmann 837a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 838a6d0d690SMarcel Holtmann sizeof(support), &support); 839a6d0d690SMarcel Holtmann } 840a1d01db1SJohan Hedberg 84112204875SMarcel Holtmann /* Set Suggested Default Data Length to maximum if supported */ 84212204875SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 84312204875SMarcel Holtmann struct hci_cp_le_write_def_data_len cp; 84412204875SMarcel Holtmann 84512204875SMarcel Holtmann cp.tx_len = hdev->le_max_tx_len; 84612204875SMarcel Holtmann cp.tx_time = hdev->le_max_tx_time; 84712204875SMarcel Holtmann hci_req_add(req, HCI_OP_LE_WRITE_DEF_DATA_LEN, sizeof(cp), &cp); 84812204875SMarcel Holtmann } 84912204875SMarcel Holtmann 850de2ba303SMarcel Holtmann /* Set Default PHY parameters if command is supported */ 851de2ba303SMarcel Holtmann if (hdev->commands[35] & 0x20) { 852de2ba303SMarcel Holtmann struct hci_cp_le_set_default_phy cp; 853de2ba303SMarcel Holtmann 8546decb5b4SJaganath Kanakkassery cp.all_phys = 0x00; 8556decb5b4SJaganath Kanakkassery cp.tx_phys = hdev->le_tx_def_phys; 8566decb5b4SJaganath Kanakkassery cp.rx_phys = hdev->le_rx_def_phys; 857de2ba303SMarcel Holtmann 858de2ba303SMarcel Holtmann hci_req_add(req, HCI_OP_LE_SET_DEFAULT_PHY, sizeof(cp), &cp); 859de2ba303SMarcel Holtmann } 860de2ba303SMarcel Holtmann 861a1d01db1SJohan Hedberg return 0; 8625d4e7e8dSJohan Hedberg } 8635d4e7e8dSJohan Hedberg 8642177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8652177bab5SJohan Hedberg { 8662177bab5SJohan Hedberg int err; 8672177bab5SJohan Hedberg 8684ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT, NULL); 8692177bab5SJohan Hedberg if (err < 0) 8702177bab5SJohan Hedberg return err; 8712177bab5SJohan Hedberg 872f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 873f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 8744b4148e9SMarcel Holtmann 8754ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT, NULL); 8762177bab5SJohan Hedberg if (err < 0) 8772177bab5SJohan Hedberg return err; 8782177bab5SJohan Hedberg 879ca8bee5dSMarcel Holtmann /* HCI_PRIMARY covers both single-mode LE, BR/EDR and dual-mode 8800af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8810af801b9SJohan Hedberg * first two stages of init. 8820af801b9SJohan Hedberg */ 883ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) 8840af801b9SJohan Hedberg return 0; 8850af801b9SJohan Hedberg 8864ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT, NULL); 8875d4e7e8dSJohan Hedberg if (err < 0) 8885d4e7e8dSJohan Hedberg return err; 8895d4e7e8dSJohan Hedberg 8904ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT, NULL); 891baf27f6eSMarcel Holtmann if (err < 0) 892baf27f6eSMarcel Holtmann return err; 893baf27f6eSMarcel Holtmann 894ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 895ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 896ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 897ec6cef9cSMarcel Holtmann * 898ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 899ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 900ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 901ec6cef9cSMarcel Holtmann * be called during the config phase. 902ec6cef9cSMarcel Holtmann * 903ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 904ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 905baf27f6eSMarcel Holtmann */ 906d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 907d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 908baf27f6eSMarcel Holtmann return 0; 909baf27f6eSMarcel Holtmann 91060c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 91160c5f5fbSMarcel Holtmann 91271c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 91360c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9142bfa3531SMarcel Holtmann 915162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 91660c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 917e7b8fc92SMarcel Holtmann 918baf27f6eSMarcel Holtmann return 0; 9192177bab5SJohan Hedberg } 9202177bab5SJohan Hedberg 921a1d01db1SJohan Hedberg static int hci_init0_req(struct hci_request *req, unsigned long opt) 9220ebca7d6SMarcel Holtmann { 9230ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9240ebca7d6SMarcel Holtmann 9250ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9260ebca7d6SMarcel Holtmann 9270ebca7d6SMarcel Holtmann /* Reset */ 9280ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9290ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9300ebca7d6SMarcel Holtmann 9310ebca7d6SMarcel Holtmann /* Read Local Version */ 9320ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9330ebca7d6SMarcel Holtmann 9340ebca7d6SMarcel Holtmann /* Read BD Address */ 9350ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9360ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 937a1d01db1SJohan Hedberg 938a1d01db1SJohan Hedberg return 0; 9390ebca7d6SMarcel Holtmann } 9400ebca7d6SMarcel Holtmann 9410ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9420ebca7d6SMarcel Holtmann { 9430ebca7d6SMarcel Holtmann int err; 9440ebca7d6SMarcel Holtmann 945cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 946cc78b44bSMarcel Holtmann return 0; 947cc78b44bSMarcel Holtmann 9484ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT, NULL); 9490ebca7d6SMarcel Holtmann if (err < 0) 9500ebca7d6SMarcel Holtmann return err; 9510ebca7d6SMarcel Holtmann 952f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 953f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 954f640ee98SMarcel Holtmann 9550ebca7d6SMarcel Holtmann return 0; 9560ebca7d6SMarcel Holtmann } 9570ebca7d6SMarcel Holtmann 958a1d01db1SJohan Hedberg static int hci_scan_req(struct hci_request *req, unsigned long opt) 9591da177e4SLinus Torvalds { 9601da177e4SLinus Torvalds __u8 scan = opt; 9611da177e4SLinus Torvalds 96242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9631da177e4SLinus Torvalds 9641da177e4SLinus Torvalds /* Inquiry and Page scans */ 96542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 966a1d01db1SJohan Hedberg return 0; 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds 969a1d01db1SJohan Hedberg static int hci_auth_req(struct hci_request *req, unsigned long opt) 9701da177e4SLinus Torvalds { 9711da177e4SLinus Torvalds __u8 auth = opt; 9721da177e4SLinus Torvalds 97342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9741da177e4SLinus Torvalds 9751da177e4SLinus Torvalds /* Authentication */ 97642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 977a1d01db1SJohan Hedberg return 0; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds 980a1d01db1SJohan Hedberg static int hci_encrypt_req(struct hci_request *req, unsigned long opt) 9811da177e4SLinus Torvalds { 9821da177e4SLinus Torvalds __u8 encrypt = opt; 9831da177e4SLinus Torvalds 98442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 9851da177e4SLinus Torvalds 986e4e8e37cSMarcel Holtmann /* Encryption */ 98742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 988a1d01db1SJohan Hedberg return 0; 9891da177e4SLinus Torvalds } 9901da177e4SLinus Torvalds 991a1d01db1SJohan Hedberg static int hci_linkpol_req(struct hci_request *req, unsigned long opt) 992e4e8e37cSMarcel Holtmann { 993e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 994e4e8e37cSMarcel Holtmann 99542c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 996e4e8e37cSMarcel Holtmann 997e4e8e37cSMarcel Holtmann /* Default link policy */ 99842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 999a1d01db1SJohan Hedberg return 0; 1000e4e8e37cSMarcel Holtmann } 1001e4e8e37cSMarcel Holtmann 10021da177e4SLinus Torvalds /* Get HCI device by index. 10031da177e4SLinus Torvalds * Device is held on return. */ 10041da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10051da177e4SLinus Torvalds { 10068035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds BT_DBG("%d", index); 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds if (index < 0) 10111da177e4SLinus Torvalds return NULL; 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10148035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10151da177e4SLinus Torvalds if (d->id == index) { 10161da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10171da177e4SLinus Torvalds break; 10181da177e4SLinus Torvalds } 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10211da177e4SLinus Torvalds return hdev; 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds 10241da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1025ff9ef578SJohan Hedberg 102630dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 102730dc78e1SJohan Hedberg { 102830dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 102930dc78e1SJohan Hedberg 10306fbe195dSAndre Guedes switch (discov->state) { 1031343f935bSAndre Guedes case DISCOVERY_FINDING: 10326fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 103330dc78e1SJohan Hedberg return true; 103430dc78e1SJohan Hedberg 10356fbe195dSAndre Guedes default: 103630dc78e1SJohan Hedberg return false; 103730dc78e1SJohan Hedberg } 10386fbe195dSAndre Guedes } 103930dc78e1SJohan Hedberg 1040ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1041ff9ef578SJohan Hedberg { 1042bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1043bb3e0a33SJohan Hedberg 1044ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1045ff9ef578SJohan Hedberg 1046bb3e0a33SJohan Hedberg if (old_state == state) 1047ff9ef578SJohan Hedberg return; 1048ff9ef578SJohan Hedberg 1049bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1050bb3e0a33SJohan Hedberg 1051ff9ef578SJohan Hedberg switch (state) { 1052ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1053c54c3860SAndre Guedes hci_update_background_scan(hdev); 1054c54c3860SAndre Guedes 1055bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1056ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1057ff9ef578SJohan Hedberg break; 1058ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1059ff9ef578SJohan Hedberg break; 1060343f935bSAndre Guedes case DISCOVERY_FINDING: 1061ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1062ff9ef578SJohan Hedberg break; 106330dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 106430dc78e1SJohan Hedberg break; 1065ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1066ff9ef578SJohan Hedberg break; 1067ff9ef578SJohan Hedberg } 1068ff9ef578SJohan Hedberg } 1069ff9ef578SJohan Hedberg 10701f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 10711da177e4SLinus Torvalds { 107230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1073b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10741da177e4SLinus Torvalds 1075561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1076561aafbcSJohan Hedberg list_del(&p->all); 1077b57c1a56SJohan Hedberg kfree(p); 10781da177e4SLinus Torvalds } 1079561aafbcSJohan Hedberg 1080561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1081561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds 1084a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1085a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 10861da177e4SLinus Torvalds { 108730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 10881da177e4SLinus Torvalds struct inquiry_entry *e; 10891da177e4SLinus Torvalds 10906ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 10911da177e4SLinus Torvalds 1092561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 10931da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 10941da177e4SLinus Torvalds return e; 10951da177e4SLinus Torvalds } 10961da177e4SLinus Torvalds 1097b57c1a56SJohan Hedberg return NULL; 1098b57c1a56SJohan Hedberg } 1099b57c1a56SJohan Hedberg 1100561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1101561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1102561aafbcSJohan Hedberg { 110330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1104561aafbcSJohan Hedberg struct inquiry_entry *e; 1105561aafbcSJohan Hedberg 11066ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1107561aafbcSJohan Hedberg 1108561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1109561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1110561aafbcSJohan Hedberg return e; 1111561aafbcSJohan Hedberg } 1112561aafbcSJohan Hedberg 1113561aafbcSJohan Hedberg return NULL; 1114561aafbcSJohan Hedberg } 1115561aafbcSJohan Hedberg 111630dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 111730dc78e1SJohan Hedberg bdaddr_t *bdaddr, 111830dc78e1SJohan Hedberg int state) 111930dc78e1SJohan Hedberg { 112030dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 112130dc78e1SJohan Hedberg struct inquiry_entry *e; 112230dc78e1SJohan Hedberg 11236ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 112430dc78e1SJohan Hedberg 112530dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 112630dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 112730dc78e1SJohan Hedberg return e; 112830dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 112930dc78e1SJohan Hedberg return e; 113030dc78e1SJohan Hedberg } 113130dc78e1SJohan Hedberg 113230dc78e1SJohan Hedberg return NULL; 113330dc78e1SJohan Hedberg } 113430dc78e1SJohan Hedberg 1135a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1136a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1137a3d4e20aSJohan Hedberg { 1138a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1139a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1140a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1141a3d4e20aSJohan Hedberg 1142a3d4e20aSJohan Hedberg list_del(&ie->list); 1143a3d4e20aSJohan Hedberg 1144a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1145a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1146a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1147a3d4e20aSJohan Hedberg break; 1148a3d4e20aSJohan Hedberg pos = &p->list; 1149a3d4e20aSJohan Hedberg } 1150a3d4e20aSJohan Hedberg 1151a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1152a3d4e20aSJohan Hedberg } 1153a3d4e20aSJohan Hedberg 1154af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1155af58925cSMarcel Holtmann bool name_known) 11561da177e4SLinus Torvalds { 115730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 115870f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1159af58925cSMarcel Holtmann u32 flags = 0; 11601da177e4SLinus Torvalds 11616ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11621da177e4SLinus Torvalds 11636928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11642b2fec4dSSzymon Janc 1165af58925cSMarcel Holtmann if (!data->ssp_mode) 1166af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1167388fc8faSJohan Hedberg 116870f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1169a3d4e20aSJohan Hedberg if (ie) { 1170af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1171af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1172388fc8faSJohan Hedberg 1173a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1174a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1175a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1176a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1177a3d4e20aSJohan Hedberg } 1178a3d4e20aSJohan Hedberg 1179561aafbcSJohan Hedberg goto update; 1180a3d4e20aSJohan Hedberg } 1181561aafbcSJohan Hedberg 11821da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 118327f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1184af58925cSMarcel Holtmann if (!ie) { 1185af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1186af58925cSMarcel Holtmann goto done; 1187af58925cSMarcel Holtmann } 118870f23020SAndrei Emeltchenko 1189561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1190561aafbcSJohan Hedberg 1191561aafbcSJohan Hedberg if (name_known) { 1192561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1193561aafbcSJohan Hedberg } else { 1194561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1195561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1196561aafbcSJohan Hedberg } 1197561aafbcSJohan Hedberg 1198561aafbcSJohan Hedberg update: 1199561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1200561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1201561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1202561aafbcSJohan Hedberg list_del(&ie->list); 12031da177e4SLinus Torvalds } 12041da177e4SLinus Torvalds 120570f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 120670f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12071da177e4SLinus Torvalds cache->timestamp = jiffies; 12083175405bSJohan Hedberg 12093175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1210af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12113175405bSJohan Hedberg 1212af58925cSMarcel Holtmann done: 1213af58925cSMarcel Holtmann return flags; 12141da177e4SLinus Torvalds } 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12171da177e4SLinus Torvalds { 121830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12191da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12201da177e4SLinus Torvalds struct inquiry_entry *e; 12211da177e4SLinus Torvalds int copied = 0; 12221da177e4SLinus Torvalds 1223561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12241da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1225b57c1a56SJohan Hedberg 1226b57c1a56SJohan Hedberg if (copied >= num) 1227b57c1a56SJohan Hedberg break; 1228b57c1a56SJohan Hedberg 12291da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12301da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12311da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12321da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12331da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12341da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1235b57c1a56SJohan Hedberg 12361da177e4SLinus Torvalds info++; 1237b57c1a56SJohan Hedberg copied++; 12381da177e4SLinus Torvalds } 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12411da177e4SLinus Torvalds return copied; 12421da177e4SLinus Torvalds } 12431da177e4SLinus Torvalds 1244a1d01db1SJohan Hedberg static int hci_inq_req(struct hci_request *req, unsigned long opt) 12451da177e4SLinus Torvalds { 12461da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 124742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12481da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12491da177e4SLinus Torvalds 12501da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12511da177e4SLinus Torvalds 12521da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 1253a1d01db1SJohan Hedberg return 0; 12541da177e4SLinus Torvalds 12551da177e4SLinus Torvalds /* Start Inquiry */ 12561da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12571da177e4SLinus Torvalds cp.length = ir->length; 12581da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 125942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 1260a1d01db1SJohan Hedberg 1261a1d01db1SJohan Hedberg return 0; 12621da177e4SLinus Torvalds } 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12651da177e4SLinus Torvalds { 12661da177e4SLinus Torvalds __u8 __user *ptr = arg; 12671da177e4SLinus Torvalds struct hci_inquiry_req ir; 12681da177e4SLinus Torvalds struct hci_dev *hdev; 12691da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 12701da177e4SLinus Torvalds long timeo; 12711da177e4SLinus Torvalds __u8 *buf; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12741da177e4SLinus Torvalds return -EFAULT; 12751da177e4SLinus Torvalds 12765a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12775a08ecceSAndrei Emeltchenko if (!hdev) 12781da177e4SLinus Torvalds return -ENODEV; 12791da177e4SLinus Torvalds 1280d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 12810736cfa8SMarcel Holtmann err = -EBUSY; 12820736cfa8SMarcel Holtmann goto done; 12830736cfa8SMarcel Holtmann } 12840736cfa8SMarcel Holtmann 1285d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1286fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1287fee746b0SMarcel Holtmann goto done; 1288fee746b0SMarcel Holtmann } 1289fee746b0SMarcel Holtmann 1290ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 12915b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 12925b69bef5SMarcel Holtmann goto done; 12935b69bef5SMarcel Holtmann } 12945b69bef5SMarcel Holtmann 1295d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 129656f87901SJohan Hedberg err = -EOPNOTSUPP; 129756f87901SJohan Hedberg goto done; 129856f87901SJohan Hedberg } 129956f87901SJohan Hedberg 130009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13011da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1302a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13031f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13041da177e4SLinus Torvalds do_inquiry = 1; 13051da177e4SLinus Torvalds } 130609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13071da177e4SLinus Torvalds 130804837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 130970f23020SAndrei Emeltchenko 131070f23020SAndrei Emeltchenko if (do_inquiry) { 131101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 13124ebeee2dSJohan Hedberg timeo, NULL); 131370f23020SAndrei Emeltchenko if (err < 0) 13141da177e4SLinus Torvalds goto done; 13153e13fa1eSAndre Guedes 13163e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13173e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13183e13fa1eSAndre Guedes */ 131974316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13203e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13213e13fa1eSAndre Guedes return -EINTR; 132270f23020SAndrei Emeltchenko } 13231da177e4SLinus Torvalds 13248fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13258fc9ced3SGustavo Padovan * 255 entries 13268fc9ced3SGustavo Padovan */ 13271da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13301da177e4SLinus Torvalds * copy it to the user space. 13311da177e4SLinus Torvalds */ 13326da2ec56SKees Cook buf = kmalloc_array(max_rsp, sizeof(struct inquiry_info), GFP_KERNEL); 133370f23020SAndrei Emeltchenko if (!buf) { 13341da177e4SLinus Torvalds err = -ENOMEM; 13351da177e4SLinus Torvalds goto done; 13361da177e4SLinus Torvalds } 13371da177e4SLinus Torvalds 133809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13391da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 134009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13411da177e4SLinus Torvalds 13421da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13431da177e4SLinus Torvalds 13441da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13451da177e4SLinus Torvalds ptr += sizeof(ir); 13461da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13471da177e4SLinus Torvalds ir.num_rsp)) 13481da177e4SLinus Torvalds err = -EFAULT; 13491da177e4SLinus Torvalds } else 13501da177e4SLinus Torvalds err = -EFAULT; 13511da177e4SLinus Torvalds 13521da177e4SLinus Torvalds kfree(buf); 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds done: 13551da177e4SLinus Torvalds hci_dev_put(hdev); 13561da177e4SLinus Torvalds return err; 13571da177e4SLinus Torvalds } 13581da177e4SLinus Torvalds 13597a0e5b15SMatthias Kaehlcke /** 13607a0e5b15SMatthias Kaehlcke * hci_dev_get_bd_addr_from_property - Get the Bluetooth Device Address 13617a0e5b15SMatthias Kaehlcke * (BD_ADDR) for a HCI device from 13627a0e5b15SMatthias Kaehlcke * a firmware node property. 13637a0e5b15SMatthias Kaehlcke * @hdev: The HCI device 13647a0e5b15SMatthias Kaehlcke * 13657a0e5b15SMatthias Kaehlcke * Search the firmware node for 'local-bd-address'. 13667a0e5b15SMatthias Kaehlcke * 13677a0e5b15SMatthias Kaehlcke * All-zero BD addresses are rejected, because those could be properties 13687a0e5b15SMatthias Kaehlcke * that exist in the firmware tables, but were not updated by the firmware. For 13697a0e5b15SMatthias Kaehlcke * example, the DTS could define 'local-bd-address', with zero BD addresses. 13707a0e5b15SMatthias Kaehlcke */ 13717a0e5b15SMatthias Kaehlcke static void hci_dev_get_bd_addr_from_property(struct hci_dev *hdev) 13727a0e5b15SMatthias Kaehlcke { 13737a0e5b15SMatthias Kaehlcke struct fwnode_handle *fwnode = dev_fwnode(hdev->dev.parent); 13747a0e5b15SMatthias Kaehlcke bdaddr_t ba; 13757a0e5b15SMatthias Kaehlcke int ret; 13767a0e5b15SMatthias Kaehlcke 13777a0e5b15SMatthias Kaehlcke ret = fwnode_property_read_u8_array(fwnode, "local-bd-address", 13787a0e5b15SMatthias Kaehlcke (u8 *)&ba, sizeof(ba)); 13797a0e5b15SMatthias Kaehlcke if (ret < 0 || !bacmp(&ba, BDADDR_ANY)) 13807a0e5b15SMatthias Kaehlcke return; 13817a0e5b15SMatthias Kaehlcke 13827a0e5b15SMatthias Kaehlcke bacpy(&hdev->public_addr, &ba); 13837a0e5b15SMatthias Kaehlcke } 13847a0e5b15SMatthias Kaehlcke 1385cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13861da177e4SLinus Torvalds { 13871da177e4SLinus Torvalds int ret = 0; 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13901da177e4SLinus Torvalds 1391b504430cSJohan Hedberg hci_req_sync_lock(hdev); 13921da177e4SLinus Torvalds 1393d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 139494324962SJohan Hovold ret = -ENODEV; 139594324962SJohan Hovold goto done; 139694324962SJohan Hovold } 139794324962SJohan Hovold 1398d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1399d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1400a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1401a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1402bf543036SJohan Hedberg */ 1403d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1404611b30f7SMarcel Holtmann ret = -ERFKILL; 1405611b30f7SMarcel Holtmann goto done; 1406611b30f7SMarcel Holtmann } 1407611b30f7SMarcel Holtmann 1408a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1409a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1410a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1411a5c8f270SMarcel Holtmann * or not. 1412a5c8f270SMarcel Holtmann * 1413c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1414c6beca0eSMarcel Holtmann * if a public address or static random address is 1415c6beca0eSMarcel Holtmann * available. 1416c6beca0eSMarcel Holtmann * 1417a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1418a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1419a5c8f270SMarcel Holtmann */ 1420d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1421ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY && 1422a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1423a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1424a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1425a5c8f270SMarcel Holtmann goto done; 1426a5c8f270SMarcel Holtmann } 1427a5c8f270SMarcel Holtmann } 1428a5c8f270SMarcel Holtmann 14291da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14301da177e4SLinus Torvalds ret = -EALREADY; 14311da177e4SLinus Torvalds goto done; 14321da177e4SLinus Torvalds } 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds if (hdev->open(hdev)) { 14351da177e4SLinus Torvalds ret = -EIO; 14361da177e4SLinus Torvalds goto done; 14371da177e4SLinus Torvalds } 14381da177e4SLinus Torvalds 1439e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 144005fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 14414a3f95b7SMarcel Holtmann 14421da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14431da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1444f41c70c4SMarcel Holtmann 1445740011cfSSean Wang if (hci_dev_test_flag(hdev, HCI_SETUP) || 1446740011cfSSean Wang test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks)) { 1447e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1448e131d74aSMarcel Holtmann 1449af202f84SMarcel Holtmann if (hdev->setup) 1450f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1451f41c70c4SMarcel Holtmann 14527a0e5b15SMatthias Kaehlcke if (ret) 14537a0e5b15SMatthias Kaehlcke goto setup_failed; 14547a0e5b15SMatthias Kaehlcke 14557a0e5b15SMatthias Kaehlcke if (test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) { 14567a0e5b15SMatthias Kaehlcke if (!bacmp(&hdev->public_addr, BDADDR_ANY)) 14577a0e5b15SMatthias Kaehlcke hci_dev_get_bd_addr_from_property(hdev); 14587a0e5b15SMatthias Kaehlcke 14597a0e5b15SMatthias Kaehlcke if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14607a0e5b15SMatthias Kaehlcke hdev->set_bdaddr) 14617a0e5b15SMatthias Kaehlcke ret = hdev->set_bdaddr(hdev, 14627a0e5b15SMatthias Kaehlcke &hdev->public_addr); 14637a0e5b15SMatthias Kaehlcke } 14647a0e5b15SMatthias Kaehlcke 14657a0e5b15SMatthias Kaehlcke setup_failed: 1466af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1467af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1468af202f84SMarcel Holtmann * 1469af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1470af202f84SMarcel Holtmann * start up as unconfigured. 1471af202f84SMarcel Holtmann */ 1472eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1473eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 1474a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1475f41c70c4SMarcel Holtmann 14760ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 14770ebca7d6SMarcel Holtmann * read at least the version information provided by 14780ebca7d6SMarcel Holtmann * the Read Local Version Information command. 14790ebca7d6SMarcel Holtmann * 14800ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 14810ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 14820ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 14830ebca7d6SMarcel Holtmann */ 1484d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 14850ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 148689bc22d2SMarcel Holtmann } 148789bc22d2SMarcel Holtmann 1488d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 14899713c17bSMarcel Holtmann /* If public address change is configured, ensure that 14909713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 14919713c17bSMarcel Holtmann * support changing the public address, fail the power 14929713c17bSMarcel Holtmann * on procedure. 149324c457e2SMarcel Holtmann */ 14949713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14959713c17bSMarcel Holtmann hdev->set_bdaddr) 149624c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 149724c457e2SMarcel Holtmann else 149824c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 149924c457e2SMarcel Holtmann } 150024c457e2SMarcel Holtmann 1501f41c70c4SMarcel Holtmann if (!ret) { 1502d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 150398a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 15042177bab5SJohan Hedberg ret = __hci_init(hdev); 150598a63aafSMarcel Holtmann if (!ret && hdev->post_init) 150698a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 150798a63aafSMarcel Holtmann } 15081da177e4SLinus Torvalds } 15091da177e4SLinus Torvalds 15107e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 15117e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 15127e995b9eSMarcel Holtmann * completed. 15137e995b9eSMarcel Holtmann */ 15147e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1515b56c7b25SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15167e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 15177e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 15187e995b9eSMarcel Holtmann 1519f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1520f41c70c4SMarcel Holtmann 15211da177e4SLinus Torvalds if (!ret) { 15221da177e4SLinus Torvalds hci_dev_hold(hdev); 1523a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 1524a73c046aSJaganath Kanakkassery hci_adv_instances_set_rpa_expired(hdev, true); 15251da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 152605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 15276d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, true); 1528d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1529d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1530d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1531d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15322ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 1533ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY) { 15342ff13894SJohan Hedberg ret = __hci_req_hci_power_on(hdev); 15352ff13894SJohan Hedberg mgmt_power_on(hdev, ret); 153656e5cb86SJohan Hedberg } 15371da177e4SLinus Torvalds } else { 15381da177e4SLinus Torvalds /* Init failed, cleanup */ 15393eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1540c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1541b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15421da177e4SLinus Torvalds 15431da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15441da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds if (hdev->flush) 15471da177e4SLinus Torvalds hdev->flush(hdev); 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds if (hdev->sent_cmd) { 15501da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15511da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15521da177e4SLinus Torvalds } 15531da177e4SLinus Torvalds 1554e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 155505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 15564a3f95b7SMarcel Holtmann 15571da177e4SLinus Torvalds hdev->close(hdev); 1558fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 15591da177e4SLinus Torvalds } 15601da177e4SLinus Torvalds 15611da177e4SLinus Torvalds done: 1562b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 15631da177e4SLinus Torvalds return ret; 15641da177e4SLinus Torvalds } 15651da177e4SLinus Torvalds 1566cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1567cbed0ca1SJohan Hedberg 1568cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1569cbed0ca1SJohan Hedberg { 1570cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1571cbed0ca1SJohan Hedberg int err; 1572cbed0ca1SJohan Hedberg 1573cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1574cbed0ca1SJohan Hedberg if (!hdev) 1575cbed0ca1SJohan Hedberg return -ENODEV; 1576cbed0ca1SJohan Hedberg 15774a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1578fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1579fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1580fee746b0SMarcel Holtmann * possible. 1581fee746b0SMarcel Holtmann * 1582fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1583fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1584fee746b0SMarcel Holtmann * open the device. 1585fee746b0SMarcel Holtmann */ 1586d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1587d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1588fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1589fee746b0SMarcel Holtmann goto done; 1590fee746b0SMarcel Holtmann } 1591fee746b0SMarcel Holtmann 1592e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1593e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1594e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1595e1d08f40SJohan Hedberg * completed. 1596e1d08f40SJohan Hedberg */ 1597a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1598e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1599e1d08f40SJohan Hedberg 1600a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1601a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1602a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1603a5c8f270SMarcel Holtmann */ 1604e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1605e1d08f40SJohan Hedberg 160612aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1607b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 160812aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 160912aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 161012aa4f0aSMarcel Holtmann * to explicitly enable it. 161112aa4f0aSMarcel Holtmann */ 1612d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1613d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1614a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 161512aa4f0aSMarcel Holtmann 1616cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1617cbed0ca1SJohan Hedberg 1618fee746b0SMarcel Holtmann done: 1619cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1620cbed0ca1SJohan Hedberg return err; 1621cbed0ca1SJohan Hedberg } 1622cbed0ca1SJohan Hedberg 1623d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1624d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1625d7347f3cSJohan Hedberg { 1626d7347f3cSJohan Hedberg struct hci_conn_params *p; 1627d7347f3cSJohan Hedberg 1628f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1629f161dd41SJohan Hedberg if (p->conn) { 1630f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1631f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1632f161dd41SJohan Hedberg p->conn = NULL; 1633f161dd41SJohan Hedberg } 1634d7347f3cSJohan Hedberg list_del_init(&p->action); 1635f161dd41SJohan Hedberg } 1636d7347f3cSJohan Hedberg 1637d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1638d7347f3cSJohan Hedberg } 1639d7347f3cSJohan Hedberg 16406b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 16411da177e4SLinus Torvalds { 1642acc649c6SMarcel Holtmann bool auto_off; 1643acc649c6SMarcel Holtmann 16441da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 16451da177e4SLinus Torvalds 1646d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1647867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1648d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1649a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1650a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1651a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1652a44fecbdSTedd Ho-Jeong An } 1653a44fecbdSTedd Ho-Jeong An 165478c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 165578c04c0bSVinicius Costa Gomes 16567df0f73eSJohan Hedberg hci_request_cancel_all(hdev); 1657b504430cSJohan Hedberg hci_req_sync_lock(hdev); 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 166065cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 1661b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 16621da177e4SLinus Torvalds return 0; 16631da177e4SLinus Torvalds } 16641da177e4SLinus Torvalds 16656d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, false); 16666d5d2ee6SHeiner Kallweit 16673eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16683eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1669b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16701da177e4SLinus Torvalds 167116ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 167216ab91abSJohan Hedberg hdev->discov_timeout = 0; 1673a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1674a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 167516ab91abSJohan Hedberg } 167616ab91abSJohan Hedberg 1677a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 16787d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 16797d78525dSJohan Hedberg 1680a73c046aSJaganath Kanakkassery if (hci_dev_test_flag(hdev, HCI_MGMT)) { 1681a73c046aSJaganath Kanakkassery struct adv_info *adv_instance; 1682a73c046aSJaganath Kanakkassery 1683d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 16847ba8b4beSAndre Guedes 1685a73c046aSJaganath Kanakkassery list_for_each_entry(adv_instance, &hdev->adv_instances, list) 1686a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 1687a73c046aSJaganath Kanakkassery } 1688a73c046aSJaganath Kanakkassery 168976727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 169076727c02SJohan Hedberg * ensuring the workqueue is empty up front. 169176727c02SJohan Hedberg */ 169276727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 169376727c02SJohan Hedberg 169409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16951aeb9c65SJohan Hedberg 16968f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 16978f502f84SJohan Hedberg 1698acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1699acc649c6SMarcel Holtmann 1700ca8bee5dSMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_PRIMARY && 1701baab7932SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 17022ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT)) 17032ff13894SJohan Hedberg __mgmt_power_off(hdev); 17041aeb9c65SJohan Hedberg 17051f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1706d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1707f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 170809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17091da177e4SLinus Torvalds 171064dae967SMarcel Holtmann smp_unregister(hdev); 171164dae967SMarcel Holtmann 171205fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 17131da177e4SLinus Torvalds 17141da177e4SLinus Torvalds if (hdev->flush) 17151da177e4SLinus Torvalds hdev->flush(hdev); 17161da177e4SLinus Torvalds 17171da177e4SLinus Torvalds /* Reset device */ 17181da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17191da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1720acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1721acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17221da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 17234ebeee2dSJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT, NULL); 17241da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 17251da177e4SLinus Torvalds } 17261da177e4SLinus Torvalds 1727c347b765SGustavo F. Padovan /* flush cmd work */ 1728c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 17291da177e4SLinus Torvalds 17301da177e4SLinus Torvalds /* Drop queues */ 17311da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17321da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17331da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 17341da177e4SLinus Torvalds 17351da177e4SLinus Torvalds /* Drop last sent command */ 17361da177e4SLinus Torvalds if (hdev->sent_cmd) { 173765cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 17381da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 17391da177e4SLinus Torvalds hdev->sent_cmd = NULL; 17401da177e4SLinus Torvalds } 17411da177e4SLinus Torvalds 1742e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 174305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 17444a3f95b7SMarcel Holtmann 17451da177e4SLinus Torvalds /* After this point our queues are empty 17461da177e4SLinus Torvalds * and no tasks are scheduled. */ 17471da177e4SLinus Torvalds hdev->close(hdev); 17481da177e4SLinus Torvalds 174935b973c9SJohan Hedberg /* Clear flags */ 1750fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1751eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 175235b973c9SJohan Hedberg 1753ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1754536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1755ced5c338SAndrei Emeltchenko 1756e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 175709b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 17587a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1759e59fda8dSJohan Hedberg 1760b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 17611da177e4SLinus Torvalds 17621da177e4SLinus Torvalds hci_dev_put(hdev); 17631da177e4SLinus Torvalds return 0; 17641da177e4SLinus Torvalds } 17651da177e4SLinus Torvalds 17661da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 17671da177e4SLinus Torvalds { 17681da177e4SLinus Torvalds struct hci_dev *hdev; 17691da177e4SLinus Torvalds int err; 17701da177e4SLinus Torvalds 177170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 177270f23020SAndrei Emeltchenko if (!hdev) 17731da177e4SLinus Torvalds return -ENODEV; 17748ee56540SMarcel Holtmann 1775d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17760736cfa8SMarcel Holtmann err = -EBUSY; 17770736cfa8SMarcel Holtmann goto done; 17780736cfa8SMarcel Holtmann } 17790736cfa8SMarcel Holtmann 1780a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 17818ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 17828ee56540SMarcel Holtmann 17831da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 17848ee56540SMarcel Holtmann 17850736cfa8SMarcel Holtmann done: 17861da177e4SLinus Torvalds hci_dev_put(hdev); 17871da177e4SLinus Torvalds return err; 17881da177e4SLinus Torvalds } 17891da177e4SLinus Torvalds 17905c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 17911da177e4SLinus Torvalds { 17925c912495SMarcel Holtmann int ret; 17931da177e4SLinus Torvalds 17945c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 17951da177e4SLinus Torvalds 1796b504430cSJohan Hedberg hci_req_sync_lock(hdev); 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds /* Drop queues */ 17991da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18001da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18011da177e4SLinus Torvalds 180276727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 180376727c02SJohan Hedberg * ensuring the workqueue is empty up front. 180476727c02SJohan Hedberg */ 180576727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 180676727c02SJohan Hedberg 180709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 18081f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 18091da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 181009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18111da177e4SLinus Torvalds 18121da177e4SLinus Torvalds if (hdev->flush) 18131da177e4SLinus Torvalds hdev->flush(hdev); 18141da177e4SLinus Torvalds 18151da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18166ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 18171da177e4SLinus Torvalds 18184ebeee2dSJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT, NULL); 18191da177e4SLinus Torvalds 1820b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 18211da177e4SLinus Torvalds return ret; 18221da177e4SLinus Torvalds } 18231da177e4SLinus Torvalds 18245c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 18255c912495SMarcel Holtmann { 18265c912495SMarcel Holtmann struct hci_dev *hdev; 18275c912495SMarcel Holtmann int err; 18285c912495SMarcel Holtmann 18295c912495SMarcel Holtmann hdev = hci_dev_get(dev); 18305c912495SMarcel Holtmann if (!hdev) 18315c912495SMarcel Holtmann return -ENODEV; 18325c912495SMarcel Holtmann 18335c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 18345c912495SMarcel Holtmann err = -ENETDOWN; 18355c912495SMarcel Holtmann goto done; 18365c912495SMarcel Holtmann } 18375c912495SMarcel Holtmann 1838d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18395c912495SMarcel Holtmann err = -EBUSY; 18405c912495SMarcel Holtmann goto done; 18415c912495SMarcel Holtmann } 18425c912495SMarcel Holtmann 1843d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 18445c912495SMarcel Holtmann err = -EOPNOTSUPP; 18455c912495SMarcel Holtmann goto done; 18465c912495SMarcel Holtmann } 18475c912495SMarcel Holtmann 18485c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 18495c912495SMarcel Holtmann 18505c912495SMarcel Holtmann done: 18515c912495SMarcel Holtmann hci_dev_put(hdev); 18525c912495SMarcel Holtmann return err; 18535c912495SMarcel Holtmann } 18545c912495SMarcel Holtmann 18551da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 18561da177e4SLinus Torvalds { 18571da177e4SLinus Torvalds struct hci_dev *hdev; 18581da177e4SLinus Torvalds int ret = 0; 18591da177e4SLinus Torvalds 186070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 186170f23020SAndrei Emeltchenko if (!hdev) 18621da177e4SLinus Torvalds return -ENODEV; 18631da177e4SLinus Torvalds 1864d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18650736cfa8SMarcel Holtmann ret = -EBUSY; 18660736cfa8SMarcel Holtmann goto done; 18670736cfa8SMarcel Holtmann } 18680736cfa8SMarcel Holtmann 1869d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1870fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1871fee746b0SMarcel Holtmann goto done; 1872fee746b0SMarcel Holtmann } 1873fee746b0SMarcel Holtmann 18741da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 18751da177e4SLinus Torvalds 18760736cfa8SMarcel Holtmann done: 18771da177e4SLinus Torvalds hci_dev_put(hdev); 18781da177e4SLinus Torvalds return ret; 18791da177e4SLinus Torvalds } 18801da177e4SLinus Torvalds 1881123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1882123abc08SJohan Hedberg { 1883bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1884123abc08SJohan Hedberg 1885123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1886123abc08SJohan Hedberg 1887123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1888238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1889238be788SMarcel Holtmann HCI_CONNECTABLE); 1890123abc08SJohan Hedberg else 1891a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1892a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1893123abc08SJohan Hedberg 1894bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1895238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1896238be788SMarcel Holtmann HCI_DISCOVERABLE); 1897bc6d2d04SJohan Hedberg } else { 1898a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1899a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1900a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1901bc6d2d04SJohan Hedberg } 1902bc6d2d04SJohan Hedberg 1903d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1904123abc08SJohan Hedberg return; 1905123abc08SJohan Hedberg 1906bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1907bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1908a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1909bc6d2d04SJohan Hedberg 1910d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1911cab054abSJohan Hedberg hci_req_update_adv_data(hdev, hdev->cur_adv_instance); 1912bc6d2d04SJohan Hedberg 1913123abc08SJohan Hedberg mgmt_new_settings(hdev); 1914123abc08SJohan Hedberg } 1915bc6d2d04SJohan Hedberg } 1916123abc08SJohan Hedberg 19171da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 19181da177e4SLinus Torvalds { 19191da177e4SLinus Torvalds struct hci_dev *hdev; 19201da177e4SLinus Torvalds struct hci_dev_req dr; 19211da177e4SLinus Torvalds int err = 0; 19221da177e4SLinus Torvalds 19231da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 19241da177e4SLinus Torvalds return -EFAULT; 19251da177e4SLinus Torvalds 192670f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 192770f23020SAndrei Emeltchenko if (!hdev) 19281da177e4SLinus Torvalds return -ENODEV; 19291da177e4SLinus Torvalds 1930d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19310736cfa8SMarcel Holtmann err = -EBUSY; 19320736cfa8SMarcel Holtmann goto done; 19330736cfa8SMarcel Holtmann } 19340736cfa8SMarcel Holtmann 1935d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1936fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1937fee746b0SMarcel Holtmann goto done; 1938fee746b0SMarcel Holtmann } 1939fee746b0SMarcel Holtmann 1940ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 19415b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 19425b69bef5SMarcel Holtmann goto done; 19435b69bef5SMarcel Holtmann } 19445b69bef5SMarcel Holtmann 1945d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 194656f87901SJohan Hedberg err = -EOPNOTSUPP; 194756f87901SJohan Hedberg goto done; 194856f87901SJohan Hedberg } 194956f87901SJohan Hedberg 19501da177e4SLinus Torvalds switch (cmd) { 19511da177e4SLinus Torvalds case HCISETAUTH: 195201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19534ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19541da177e4SLinus Torvalds break; 19551da177e4SLinus Torvalds 19561da177e4SLinus Torvalds case HCISETENCRYPT: 19571da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 19581da177e4SLinus Torvalds err = -EOPNOTSUPP; 19591da177e4SLinus Torvalds break; 19601da177e4SLinus Torvalds } 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 19631da177e4SLinus Torvalds /* Auth must be enabled first */ 196401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19654ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19661da177e4SLinus Torvalds if (err) 19671da177e4SLinus Torvalds break; 19681da177e4SLinus Torvalds } 19691da177e4SLinus Torvalds 197001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19714ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19721da177e4SLinus Torvalds break; 19731da177e4SLinus Torvalds 19741da177e4SLinus Torvalds case HCISETSCAN: 197501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19764ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 197791a668b0SJohan Hedberg 1978bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1979bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 198091a668b0SJohan Hedberg */ 1981123abc08SJohan Hedberg if (!err) 1982123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 19831da177e4SLinus Torvalds break; 19841da177e4SLinus Torvalds 19851da177e4SLinus Torvalds case HCISETLINKPOL: 198601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19874ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 19881da177e4SLinus Torvalds break; 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds case HCISETLINKMODE: 1991e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1992e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1993e4e8e37cSMarcel Holtmann break; 1994e4e8e37cSMarcel Holtmann 1995e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1996b7c23df8SJaganath Kanakkassery if (hdev->pkt_type == (__u16) dr.dev_opt) 1997b7c23df8SJaganath Kanakkassery break; 1998b7c23df8SJaganath Kanakkassery 1999e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 2000b7c23df8SJaganath Kanakkassery mgmt_phy_configuration_changed(hdev, NULL); 20011da177e4SLinus Torvalds break; 20021da177e4SLinus Torvalds 20031da177e4SLinus Torvalds case HCISETACLMTU: 20041da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 20051da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 20061da177e4SLinus Torvalds break; 20071da177e4SLinus Torvalds 20081da177e4SLinus Torvalds case HCISETSCOMTU: 20091da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 20101da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 20111da177e4SLinus Torvalds break; 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds default: 20141da177e4SLinus Torvalds err = -EINVAL; 20151da177e4SLinus Torvalds break; 20161da177e4SLinus Torvalds } 2017e4e8e37cSMarcel Holtmann 20180736cfa8SMarcel Holtmann done: 20191da177e4SLinus Torvalds hci_dev_put(hdev); 20201da177e4SLinus Torvalds return err; 20211da177e4SLinus Torvalds } 20221da177e4SLinus Torvalds 20231da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 20241da177e4SLinus Torvalds { 20258035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 20261da177e4SLinus Torvalds struct hci_dev_list_req *dl; 20271da177e4SLinus Torvalds struct hci_dev_req *dr; 20281da177e4SLinus Torvalds int n = 0, size, err; 20291da177e4SLinus Torvalds __u16 dev_num; 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 20321da177e4SLinus Torvalds return -EFAULT; 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 20351da177e4SLinus Torvalds return -EINVAL; 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 20381da177e4SLinus Torvalds 203970f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 204070f23020SAndrei Emeltchenko if (!dl) 20411da177e4SLinus Torvalds return -ENOMEM; 20421da177e4SLinus Torvalds 20431da177e4SLinus Torvalds dr = dl->dev_req; 20441da177e4SLinus Torvalds 2045f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 20468035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 20472e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2048c542a06cSJohan Hedberg 20492e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20502e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20512e84d8dbSMarcel Holtmann * device is actually down. 20522e84d8dbSMarcel Holtmann */ 2053d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20542e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2055c542a06cSJohan Hedberg 20561da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 20572e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2058c542a06cSJohan Hedberg 20591da177e4SLinus Torvalds if (++n >= dev_num) 20601da177e4SLinus Torvalds break; 20611da177e4SLinus Torvalds } 2062f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds dl->dev_num = n; 20651da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 20681da177e4SLinus Torvalds kfree(dl); 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds return err ? -EFAULT : 0; 20711da177e4SLinus Torvalds } 20721da177e4SLinus Torvalds 20731da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20741da177e4SLinus Torvalds { 20751da177e4SLinus Torvalds struct hci_dev *hdev; 20761da177e4SLinus Torvalds struct hci_dev_info di; 20772e84d8dbSMarcel Holtmann unsigned long flags; 20781da177e4SLinus Torvalds int err = 0; 20791da177e4SLinus Torvalds 20801da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 20811da177e4SLinus Torvalds return -EFAULT; 20821da177e4SLinus Torvalds 208370f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 208470f23020SAndrei Emeltchenko if (!hdev) 20851da177e4SLinus Torvalds return -ENODEV; 20861da177e4SLinus Torvalds 20872e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20882e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20892e84d8dbSMarcel Holtmann * device is actually down. 20902e84d8dbSMarcel Holtmann */ 2091d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 20922e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 20932e84d8dbSMarcel Holtmann else 20942e84d8dbSMarcel Holtmann flags = hdev->flags; 2095c542a06cSJohan Hedberg 20961da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20971da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 209860f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20992e84d8dbSMarcel Holtmann di.flags = flags; 21001da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2101572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 21021da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 21031da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 21041da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 21051da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2106572c7f84SJohan Hedberg } else { 2107572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2108572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2109572c7f84SJohan Hedberg di.sco_mtu = 0; 2110572c7f84SJohan Hedberg di.sco_pkts = 0; 2111572c7f84SJohan Hedberg } 21121da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 21131da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 21141da177e4SLinus Torvalds 21151da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 21161da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 21171da177e4SLinus Torvalds 21181da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 21191da177e4SLinus Torvalds err = -EFAULT; 21201da177e4SLinus Torvalds 21211da177e4SLinus Torvalds hci_dev_put(hdev); 21221da177e4SLinus Torvalds 21231da177e4SLinus Torvalds return err; 21241da177e4SLinus Torvalds } 21251da177e4SLinus Torvalds 21261da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 21271da177e4SLinus Torvalds 2128611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2129611b30f7SMarcel Holtmann { 2130611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2131611b30f7SMarcel Holtmann 2132611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2133611b30f7SMarcel Holtmann 2134d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 21350736cfa8SMarcel Holtmann return -EBUSY; 21360736cfa8SMarcel Holtmann 21375e130367SJohan Hedberg if (blocked) { 2138a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2139d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2140d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2141611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 21425e130367SJohan Hedberg } else { 2143a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 21445e130367SJohan Hedberg } 2145611b30f7SMarcel Holtmann 2146611b30f7SMarcel Holtmann return 0; 2147611b30f7SMarcel Holtmann } 2148611b30f7SMarcel Holtmann 2149611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2150611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2151611b30f7SMarcel Holtmann }; 2152611b30f7SMarcel Holtmann 2153ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2154ab81cbf9SJohan Hedberg { 2155ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 215696570ffcSJohan Hedberg int err; 2157ab81cbf9SJohan Hedberg 2158ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2159ab81cbf9SJohan Hedberg 21602ff13894SJohan Hedberg if (test_bit(HCI_UP, &hdev->flags) && 21612ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 21622ff13894SJohan Hedberg hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) { 2163d82142a8SWei-Ning Huang cancel_delayed_work(&hdev->power_off); 21642ff13894SJohan Hedberg hci_req_sync_lock(hdev); 21652ff13894SJohan Hedberg err = __hci_req_hci_power_on(hdev); 21662ff13894SJohan Hedberg hci_req_sync_unlock(hdev); 21672ff13894SJohan Hedberg mgmt_power_on(hdev, err); 21682ff13894SJohan Hedberg return; 21692ff13894SJohan Hedberg } 21702ff13894SJohan Hedberg 2171cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 217296570ffcSJohan Hedberg if (err < 0) { 21733ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 217496570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 21753ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2176ab81cbf9SJohan Hedberg return; 217796570ffcSJohan Hedberg } 2178ab81cbf9SJohan Hedberg 2179a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2180a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2181a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2182a5c8f270SMarcel Holtmann */ 2183d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2184d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2185ca8bee5dSMarcel Holtmann (hdev->dev_type == HCI_PRIMARY && 2186a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2187a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2188a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2189bf543036SJohan Hedberg hci_dev_do_close(hdev); 2190d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 219119202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 219219202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2193bf543036SJohan Hedberg } 2194ab81cbf9SJohan Hedberg 2195a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 21964a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 21974a964404SMarcel Holtmann * so that userspace can easily identify them. 21984a964404SMarcel Holtmann */ 2199d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22004a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 22010602a8adSMarcel Holtmann 22020602a8adSMarcel Holtmann /* For fully configured devices, this will send 22030602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 22040602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 22050602a8adSMarcel Holtmann * 22060602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 22070602a8adSMarcel Holtmann * and no event will be send. 22080602a8adSMarcel Holtmann */ 2209744cf19eSJohan Hedberg mgmt_index_added(hdev); 2210a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 22115ea234d3SMarcel Holtmann /* When the controller is now configured, then it 22125ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 22135ea234d3SMarcel Holtmann */ 2214d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22155ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 22165ea234d3SMarcel Holtmann 2217d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2218d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2219d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2220d603b76bSMarcel Holtmann */ 2221d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2222ab81cbf9SJohan Hedberg } 2223ab81cbf9SJohan Hedberg } 2224ab81cbf9SJohan Hedberg 2225ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2226ab81cbf9SJohan Hedberg { 22273243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 22283243553fSJohan Hedberg power_off.work); 2229ab81cbf9SJohan Hedberg 2230ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2231ab81cbf9SJohan Hedberg 22328ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2233ab81cbf9SJohan Hedberg } 2234ab81cbf9SJohan Hedberg 2235c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2236c7741d16SMarcel Holtmann { 2237c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2238c7741d16SMarcel Holtmann 2239c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2240c7741d16SMarcel Holtmann 2241c7741d16SMarcel Holtmann if (hdev->hw_error) 2242c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2243c7741d16SMarcel Holtmann else 22442064ee33SMarcel Holtmann bt_dev_err(hdev, "hardware error 0x%2.2x", hdev->hw_error_code); 2245c7741d16SMarcel Holtmann 2246c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2247c7741d16SMarcel Holtmann return; 2248c7741d16SMarcel Holtmann 2249c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2250c7741d16SMarcel Holtmann } 2251c7741d16SMarcel Holtmann 225235f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 22532aeb9a1aSJohan Hedberg { 22544821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 22552aeb9a1aSJohan Hedberg 22564821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 22574821002cSJohan Hedberg list_del(&uuid->list); 22582aeb9a1aSJohan Hedberg kfree(uuid); 22592aeb9a1aSJohan Hedberg } 22602aeb9a1aSJohan Hedberg } 22612aeb9a1aSJohan Hedberg 226235f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 226355ed8ca1SJohan Hedberg { 226455ed8ca1SJohan Hedberg struct link_key *key; 226555ed8ca1SJohan Hedberg 22660378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 22670378b597SJohan Hedberg list_del_rcu(&key->list); 22680378b597SJohan Hedberg kfree_rcu(key, rcu); 226955ed8ca1SJohan Hedberg } 227055ed8ca1SJohan Hedberg } 227155ed8ca1SJohan Hedberg 227235f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2273b899efafSVinicius Costa Gomes { 2274970d0f1bSJohan Hedberg struct smp_ltk *k; 2275b899efafSVinicius Costa Gomes 2276970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2277970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2278970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2279b899efafSVinicius Costa Gomes } 2280b899efafSVinicius Costa Gomes } 2281b899efafSVinicius Costa Gomes 2282970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2283970c4e46SJohan Hedberg { 2284adae20cbSJohan Hedberg struct smp_irk *k; 2285970c4e46SJohan Hedberg 2286adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2287adae20cbSJohan Hedberg list_del_rcu(&k->list); 2288adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2289970c4e46SJohan Hedberg } 2290970c4e46SJohan Hedberg } 2291970c4e46SJohan Hedberg 229255ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 229355ed8ca1SJohan Hedberg { 229455ed8ca1SJohan Hedberg struct link_key *k; 229555ed8ca1SJohan Hedberg 22960378b597SJohan Hedberg rcu_read_lock(); 22970378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 22980378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 22990378b597SJohan Hedberg rcu_read_unlock(); 230055ed8ca1SJohan Hedberg return k; 23010378b597SJohan Hedberg } 23020378b597SJohan Hedberg } 23030378b597SJohan Hedberg rcu_read_unlock(); 230455ed8ca1SJohan Hedberg 230555ed8ca1SJohan Hedberg return NULL; 230655ed8ca1SJohan Hedberg } 230755ed8ca1SJohan Hedberg 2308745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2309d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2310d25e28abSJohan Hedberg { 2311d25e28abSJohan Hedberg /* Legacy key */ 2312d25e28abSJohan Hedberg if (key_type < 0x03) 2313745c0ce3SVishal Agarwal return true; 2314d25e28abSJohan Hedberg 2315d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2316d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2317745c0ce3SVishal Agarwal return false; 2318d25e28abSJohan Hedberg 2319d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2320d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2321745c0ce3SVishal Agarwal return false; 2322d25e28abSJohan Hedberg 2323d25e28abSJohan Hedberg /* Security mode 3 case */ 2324d25e28abSJohan Hedberg if (!conn) 2325745c0ce3SVishal Agarwal return true; 2326d25e28abSJohan Hedberg 2327e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2328e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2329e3befab9SJohan Hedberg return true; 2330e3befab9SJohan Hedberg 2331d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2332d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2333745c0ce3SVishal Agarwal return true; 2334d25e28abSJohan Hedberg 2335d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2336d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2337745c0ce3SVishal Agarwal return true; 2338d25e28abSJohan Hedberg 2339d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2340d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2341745c0ce3SVishal Agarwal return true; 2342d25e28abSJohan Hedberg 2343d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2344d25e28abSJohan Hedberg * persistently */ 2345745c0ce3SVishal Agarwal return false; 2346d25e28abSJohan Hedberg } 2347d25e28abSJohan Hedberg 2348e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 234998a0b845SJohan Hedberg { 2350e804d25dSJohan Hedberg if (type == SMP_LTK) 2351e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 235298a0b845SJohan Hedberg 2353e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 235498a0b845SJohan Hedberg } 235598a0b845SJohan Hedberg 2356f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2357e804d25dSJohan Hedberg u8 addr_type, u8 role) 235875d262c2SVinicius Costa Gomes { 2359c9839a11SVinicius Costa Gomes struct smp_ltk *k; 236075d262c2SVinicius Costa Gomes 2361970d0f1bSJohan Hedberg rcu_read_lock(); 2362970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 23635378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 23645378bc56SJohan Hedberg continue; 23655378bc56SJohan Hedberg 2366923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2367970d0f1bSJohan Hedberg rcu_read_unlock(); 236875d262c2SVinicius Costa Gomes return k; 2369970d0f1bSJohan Hedberg } 2370970d0f1bSJohan Hedberg } 2371970d0f1bSJohan Hedberg rcu_read_unlock(); 237275d262c2SVinicius Costa Gomes 237375d262c2SVinicius Costa Gomes return NULL; 237475d262c2SVinicius Costa Gomes } 237575d262c2SVinicius Costa Gomes 2376970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2377970c4e46SJohan Hedberg { 2378970c4e46SJohan Hedberg struct smp_irk *irk; 2379970c4e46SJohan Hedberg 2380adae20cbSJohan Hedberg rcu_read_lock(); 2381adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2382adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2383adae20cbSJohan Hedberg rcu_read_unlock(); 2384970c4e46SJohan Hedberg return irk; 2385970c4e46SJohan Hedberg } 2386adae20cbSJohan Hedberg } 2387970c4e46SJohan Hedberg 2388adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2389defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2390970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2391adae20cbSJohan Hedberg rcu_read_unlock(); 2392970c4e46SJohan Hedberg return irk; 2393970c4e46SJohan Hedberg } 2394970c4e46SJohan Hedberg } 2395adae20cbSJohan Hedberg rcu_read_unlock(); 2396970c4e46SJohan Hedberg 2397970c4e46SJohan Hedberg return NULL; 2398970c4e46SJohan Hedberg } 2399970c4e46SJohan Hedberg 2400970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2401970c4e46SJohan Hedberg u8 addr_type) 2402970c4e46SJohan Hedberg { 2403970c4e46SJohan Hedberg struct smp_irk *irk; 2404970c4e46SJohan Hedberg 24056cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 24066cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 24076cfc9988SJohan Hedberg return NULL; 24086cfc9988SJohan Hedberg 2409adae20cbSJohan Hedberg rcu_read_lock(); 2410adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2411970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2412adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2413adae20cbSJohan Hedberg rcu_read_unlock(); 2414970c4e46SJohan Hedberg return irk; 2415970c4e46SJohan Hedberg } 2416adae20cbSJohan Hedberg } 2417adae20cbSJohan Hedberg rcu_read_unlock(); 2418970c4e46SJohan Hedberg 2419970c4e46SJohan Hedberg return NULL; 2420970c4e46SJohan Hedberg } 2421970c4e46SJohan Hedberg 2422567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 24237652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 24247652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 242555ed8ca1SJohan Hedberg { 242655ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2427745c0ce3SVishal Agarwal u8 old_key_type; 242855ed8ca1SJohan Hedberg 242955ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 243055ed8ca1SJohan Hedberg if (old_key) { 243155ed8ca1SJohan Hedberg old_key_type = old_key->type; 243255ed8ca1SJohan Hedberg key = old_key; 243355ed8ca1SJohan Hedberg } else { 243412adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 24350a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 243655ed8ca1SJohan Hedberg if (!key) 2437567fa2aaSJohan Hedberg return NULL; 24380378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 243955ed8ca1SJohan Hedberg } 244055ed8ca1SJohan Hedberg 24416ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 244255ed8ca1SJohan Hedberg 2443d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2444d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2445d25e28abSJohan Hedberg * previous key */ 2446d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2447a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2448d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2449655fe6ecSJohan Hedberg if (conn) 2450655fe6ecSJohan Hedberg conn->key_type = type; 2451655fe6ecSJohan Hedberg } 2452d25e28abSJohan Hedberg 245355ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 24549b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 245555ed8ca1SJohan Hedberg key->pin_len = pin_len; 245655ed8ca1SJohan Hedberg 2457b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 245855ed8ca1SJohan Hedberg key->type = old_key_type; 24594748fed2SJohan Hedberg else 24604748fed2SJohan Hedberg key->type = type; 24614748fed2SJohan Hedberg 24627652ff6aSJohan Hedberg if (persistent) 24637652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 24647652ff6aSJohan Hedberg old_key_type); 24654df378a1SJohan Hedberg 2466567fa2aaSJohan Hedberg return key; 246755ed8ca1SJohan Hedberg } 246855ed8ca1SJohan Hedberg 2469ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 247035d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2471fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 247275d262c2SVinicius Costa Gomes { 2473c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2474e804d25dSJohan Hedberg u8 role = ltk_role(type); 247575d262c2SVinicius Costa Gomes 2476f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2477c9839a11SVinicius Costa Gomes if (old_key) 247875d262c2SVinicius Costa Gomes key = old_key; 2479c9839a11SVinicius Costa Gomes else { 24800a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 248175d262c2SVinicius Costa Gomes if (!key) 2482ca9142b8SJohan Hedberg return NULL; 2483970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 248475d262c2SVinicius Costa Gomes } 248575d262c2SVinicius Costa Gomes 248675d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2487c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2488c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2489c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2490c9839a11SVinicius Costa Gomes key->ediv = ediv; 2491fe39c7b2SMarcel Holtmann key->rand = rand; 2492c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2493c9839a11SVinicius Costa Gomes key->type = type; 249475d262c2SVinicius Costa Gomes 2495ca9142b8SJohan Hedberg return key; 249675d262c2SVinicius Costa Gomes } 249775d262c2SVinicius Costa Gomes 2498ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2499ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2500970c4e46SJohan Hedberg { 2501970c4e46SJohan Hedberg struct smp_irk *irk; 2502970c4e46SJohan Hedberg 2503970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2504970c4e46SJohan Hedberg if (!irk) { 2505970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2506970c4e46SJohan Hedberg if (!irk) 2507ca9142b8SJohan Hedberg return NULL; 2508970c4e46SJohan Hedberg 2509970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2510970c4e46SJohan Hedberg irk->addr_type = addr_type; 2511970c4e46SJohan Hedberg 2512adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2513970c4e46SJohan Hedberg } 2514970c4e46SJohan Hedberg 2515970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2516970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2517970c4e46SJohan Hedberg 2518ca9142b8SJohan Hedberg return irk; 2519970c4e46SJohan Hedberg } 2520970c4e46SJohan Hedberg 252155ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 252255ed8ca1SJohan Hedberg { 252355ed8ca1SJohan Hedberg struct link_key *key; 252455ed8ca1SJohan Hedberg 252555ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 252655ed8ca1SJohan Hedberg if (!key) 252755ed8ca1SJohan Hedberg return -ENOENT; 252855ed8ca1SJohan Hedberg 25296ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 253055ed8ca1SJohan Hedberg 25310378b597SJohan Hedberg list_del_rcu(&key->list); 25320378b597SJohan Hedberg kfree_rcu(key, rcu); 253355ed8ca1SJohan Hedberg 253455ed8ca1SJohan Hedberg return 0; 253555ed8ca1SJohan Hedberg } 253655ed8ca1SJohan Hedberg 2537e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2538b899efafSVinicius Costa Gomes { 2539970d0f1bSJohan Hedberg struct smp_ltk *k; 2540c51ffa0bSJohan Hedberg int removed = 0; 2541b899efafSVinicius Costa Gomes 2542970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2543e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2544b899efafSVinicius Costa Gomes continue; 2545b899efafSVinicius Costa Gomes 25466ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2547b899efafSVinicius Costa Gomes 2548970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2549970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2550c51ffa0bSJohan Hedberg removed++; 2551b899efafSVinicius Costa Gomes } 2552b899efafSVinicius Costa Gomes 2553c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2554b899efafSVinicius Costa Gomes } 2555b899efafSVinicius Costa Gomes 2556a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2557a7ec7338SJohan Hedberg { 2558adae20cbSJohan Hedberg struct smp_irk *k; 2559a7ec7338SJohan Hedberg 2560adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2561a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2562a7ec7338SJohan Hedberg continue; 2563a7ec7338SJohan Hedberg 2564a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2565a7ec7338SJohan Hedberg 2566adae20cbSJohan Hedberg list_del_rcu(&k->list); 2567adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2568a7ec7338SJohan Hedberg } 2569a7ec7338SJohan Hedberg } 2570a7ec7338SJohan Hedberg 257155e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 257255e76b38SJohan Hedberg { 257355e76b38SJohan Hedberg struct smp_ltk *k; 25744ba9faf3SJohan Hedberg struct smp_irk *irk; 257555e76b38SJohan Hedberg u8 addr_type; 257655e76b38SJohan Hedberg 257755e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 257855e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 257955e76b38SJohan Hedberg return true; 258055e76b38SJohan Hedberg return false; 258155e76b38SJohan Hedberg } 258255e76b38SJohan Hedberg 258355e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 258455e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 258555e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 258655e76b38SJohan Hedberg else 258755e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 258855e76b38SJohan Hedberg 25894ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 25904ba9faf3SJohan Hedberg if (irk) { 25914ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 25924ba9faf3SJohan Hedberg addr_type = irk->addr_type; 25934ba9faf3SJohan Hedberg } 25944ba9faf3SJohan Hedberg 259555e76b38SJohan Hedberg rcu_read_lock(); 259655e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 259787c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 259887c8b28dSJohan Hedberg rcu_read_unlock(); 259955e76b38SJohan Hedberg return true; 260055e76b38SJohan Hedberg } 260187c8b28dSJohan Hedberg } 260255e76b38SJohan Hedberg rcu_read_unlock(); 260355e76b38SJohan Hedberg 260455e76b38SJohan Hedberg return false; 260555e76b38SJohan Hedberg } 260655e76b38SJohan Hedberg 26076bd32326SVille Tervo /* HCI command timer function */ 260865cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 26096bd32326SVille Tervo { 261065cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 261165cc2b49SMarcel Holtmann cmd_timer.work); 26126bd32326SVille Tervo 2613bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2614bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2615bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2616bda4f23aSAndrei Emeltchenko 26172064ee33SMarcel Holtmann bt_dev_err(hdev, "command 0x%4.4x tx timeout", opcode); 2618bda4f23aSAndrei Emeltchenko } else { 26192064ee33SMarcel Holtmann bt_dev_err(hdev, "command tx timeout"); 2620bda4f23aSAndrei Emeltchenko } 2621bda4f23aSAndrei Emeltchenko 2622e2bef384SRajat Jain if (hdev->cmd_timeout) 2623e2bef384SRajat Jain hdev->cmd_timeout(hdev); 2624e2bef384SRajat Jain 26256bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2626c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 26276bd32326SVille Tervo } 26286bd32326SVille Tervo 26292763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 26306928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 26312763eda6SSzymon Janc { 26322763eda6SSzymon Janc struct oob_data *data; 26332763eda6SSzymon Janc 26346928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 26356928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 26366928a924SJohan Hedberg continue; 26376928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 26386928a924SJohan Hedberg continue; 26392763eda6SSzymon Janc return data; 26406928a924SJohan Hedberg } 26412763eda6SSzymon Janc 26422763eda6SSzymon Janc return NULL; 26432763eda6SSzymon Janc } 26442763eda6SSzymon Janc 26456928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26466928a924SJohan Hedberg u8 bdaddr_type) 26472763eda6SSzymon Janc { 26482763eda6SSzymon Janc struct oob_data *data; 26492763eda6SSzymon Janc 26506928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26512763eda6SSzymon Janc if (!data) 26522763eda6SSzymon Janc return -ENOENT; 26532763eda6SSzymon Janc 26546928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 26552763eda6SSzymon Janc 26562763eda6SSzymon Janc list_del(&data->list); 26572763eda6SSzymon Janc kfree(data); 26582763eda6SSzymon Janc 26592763eda6SSzymon Janc return 0; 26602763eda6SSzymon Janc } 26612763eda6SSzymon Janc 266235f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 26632763eda6SSzymon Janc { 26642763eda6SSzymon Janc struct oob_data *data, *n; 26652763eda6SSzymon Janc 26662763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 26672763eda6SSzymon Janc list_del(&data->list); 26682763eda6SSzymon Janc kfree(data); 26692763eda6SSzymon Janc } 26702763eda6SSzymon Janc } 26712763eda6SSzymon Janc 26720798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 26736928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 267438da1703SJohan Hedberg u8 *hash256, u8 *rand256) 26750798872eSMarcel Holtmann { 26760798872eSMarcel Holtmann struct oob_data *data; 26770798872eSMarcel Holtmann 26786928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 26790798872eSMarcel Holtmann if (!data) { 26800a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 26810798872eSMarcel Holtmann if (!data) 26820798872eSMarcel Holtmann return -ENOMEM; 26830798872eSMarcel Holtmann 26840798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 26856928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 26860798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 26870798872eSMarcel Holtmann } 26880798872eSMarcel Holtmann 268981328d5cSJohan Hedberg if (hash192 && rand192) { 26900798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 269138da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2692f7697b16SMarcel Holtmann if (hash256 && rand256) 2693f7697b16SMarcel Holtmann data->present = 0x03; 269481328d5cSJohan Hedberg } else { 269581328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 269681328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2697f7697b16SMarcel Holtmann if (hash256 && rand256) 2698f7697b16SMarcel Holtmann data->present = 0x02; 2699f7697b16SMarcel Holtmann else 2700f7697b16SMarcel Holtmann data->present = 0x00; 270181328d5cSJohan Hedberg } 27020798872eSMarcel Holtmann 270381328d5cSJohan Hedberg if (hash256 && rand256) { 27040798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 270538da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 270681328d5cSJohan Hedberg } else { 270781328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 270881328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2709f7697b16SMarcel Holtmann if (hash192 && rand192) 2710f7697b16SMarcel Holtmann data->present = 0x01; 271181328d5cSJohan Hedberg } 27120798872eSMarcel Holtmann 27136ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 27142763eda6SSzymon Janc 27152763eda6SSzymon Janc return 0; 27162763eda6SSzymon Janc } 27172763eda6SSzymon Janc 2718d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2719d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2720d2609b34SFlorian Grandel { 2721d2609b34SFlorian Grandel struct adv_info *adv_instance; 2722d2609b34SFlorian Grandel 2723d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2724d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2725d2609b34SFlorian Grandel return adv_instance; 2726d2609b34SFlorian Grandel } 2727d2609b34SFlorian Grandel 2728d2609b34SFlorian Grandel return NULL; 2729d2609b34SFlorian Grandel } 2730d2609b34SFlorian Grandel 2731d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 273274b93e9fSPrasanna Karthik struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) 273374b93e9fSPrasanna Karthik { 2734d2609b34SFlorian Grandel struct adv_info *cur_instance; 2735d2609b34SFlorian Grandel 2736d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2737d2609b34SFlorian Grandel if (!cur_instance) 2738d2609b34SFlorian Grandel return NULL; 2739d2609b34SFlorian Grandel 2740d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2741d2609b34SFlorian Grandel struct adv_info, list)) 2742d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2743d2609b34SFlorian Grandel struct adv_info, list); 2744d2609b34SFlorian Grandel else 2745d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2746d2609b34SFlorian Grandel } 2747d2609b34SFlorian Grandel 2748d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2749d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2750d2609b34SFlorian Grandel { 2751d2609b34SFlorian Grandel struct adv_info *adv_instance; 2752d2609b34SFlorian Grandel 2753d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2754d2609b34SFlorian Grandel if (!adv_instance) 2755d2609b34SFlorian Grandel return -ENOENT; 2756d2609b34SFlorian Grandel 2757d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2758d2609b34SFlorian Grandel 2759cab054abSJohan Hedberg if (hdev->cur_adv_instance == instance) { 2760cab054abSJohan Hedberg if (hdev->adv_instance_timeout) { 27615d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27625d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27635d900e46SFlorian Grandel } 2764cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2765cab054abSJohan Hedberg } 27665d900e46SFlorian Grandel 2767a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 2768a73c046aSJaganath Kanakkassery 2769d2609b34SFlorian Grandel list_del(&adv_instance->list); 2770d2609b34SFlorian Grandel kfree(adv_instance); 2771d2609b34SFlorian Grandel 2772d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2773d2609b34SFlorian Grandel 2774d2609b34SFlorian Grandel return 0; 2775d2609b34SFlorian Grandel } 2776d2609b34SFlorian Grandel 2777a73c046aSJaganath Kanakkassery void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired) 2778a73c046aSJaganath Kanakkassery { 2779a73c046aSJaganath Kanakkassery struct adv_info *adv_instance, *n; 2780a73c046aSJaganath Kanakkassery 2781a73c046aSJaganath Kanakkassery list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) 2782a73c046aSJaganath Kanakkassery adv_instance->rpa_expired = rpa_expired; 2783a73c046aSJaganath Kanakkassery } 2784a73c046aSJaganath Kanakkassery 2785d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2786d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2787d2609b34SFlorian Grandel { 2788d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2789d2609b34SFlorian Grandel 27905d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 27915d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 27925d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 27935d900e46SFlorian Grandel } 27945d900e46SFlorian Grandel 2795d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2796a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 2797d2609b34SFlorian Grandel list_del(&adv_instance->list); 2798d2609b34SFlorian Grandel kfree(adv_instance); 2799d2609b34SFlorian Grandel } 2800d2609b34SFlorian Grandel 2801d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2802cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2803d2609b34SFlorian Grandel } 2804d2609b34SFlorian Grandel 2805a73c046aSJaganath Kanakkassery static void adv_instance_rpa_expired(struct work_struct *work) 2806a73c046aSJaganath Kanakkassery { 2807a73c046aSJaganath Kanakkassery struct adv_info *adv_instance = container_of(work, struct adv_info, 2808a73c046aSJaganath Kanakkassery rpa_expired_cb.work); 2809a73c046aSJaganath Kanakkassery 2810a73c046aSJaganath Kanakkassery BT_DBG(""); 2811a73c046aSJaganath Kanakkassery 2812a73c046aSJaganath Kanakkassery adv_instance->rpa_expired = true; 2813a73c046aSJaganath Kanakkassery } 2814a73c046aSJaganath Kanakkassery 2815d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2816d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2817d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2818d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2819d2609b34SFlorian Grandel u16 timeout, u16 duration) 2820d2609b34SFlorian Grandel { 2821d2609b34SFlorian Grandel struct adv_info *adv_instance; 2822d2609b34SFlorian Grandel 2823d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2824d2609b34SFlorian Grandel if (adv_instance) { 2825d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2826d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2827d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2828d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2829d2609b34SFlorian Grandel } else { 2830d2609b34SFlorian Grandel if (hdev->adv_instance_cnt >= HCI_MAX_ADV_INSTANCES || 2831d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2832d2609b34SFlorian Grandel return -EOVERFLOW; 2833d2609b34SFlorian Grandel 283439ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2835d2609b34SFlorian Grandel if (!adv_instance) 2836d2609b34SFlorian Grandel return -ENOMEM; 2837d2609b34SFlorian Grandel 2838fffd38bcSFlorian Grandel adv_instance->pending = true; 2839d2609b34SFlorian Grandel adv_instance->instance = instance; 2840d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2841d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2842d2609b34SFlorian Grandel } 2843d2609b34SFlorian Grandel 2844d2609b34SFlorian Grandel adv_instance->flags = flags; 2845d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2846d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2847d2609b34SFlorian Grandel 2848d2609b34SFlorian Grandel if (adv_data_len) 2849d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2850d2609b34SFlorian Grandel 2851d2609b34SFlorian Grandel if (scan_rsp_len) 2852d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2853d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2854d2609b34SFlorian Grandel 2855d2609b34SFlorian Grandel adv_instance->timeout = timeout; 28565d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2857d2609b34SFlorian Grandel 2858d2609b34SFlorian Grandel if (duration == 0) 2859d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2860d2609b34SFlorian Grandel else 2861d2609b34SFlorian Grandel adv_instance->duration = duration; 2862d2609b34SFlorian Grandel 2863de181e88SJaganath Kanakkassery adv_instance->tx_power = HCI_TX_POWER_INVALID; 2864de181e88SJaganath Kanakkassery 2865a73c046aSJaganath Kanakkassery INIT_DELAYED_WORK(&adv_instance->rpa_expired_cb, 2866a73c046aSJaganath Kanakkassery adv_instance_rpa_expired); 2867a73c046aSJaganath Kanakkassery 2868d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2869d2609b34SFlorian Grandel 2870d2609b34SFlorian Grandel return 0; 2871d2609b34SFlorian Grandel } 2872d2609b34SFlorian Grandel 2873dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2874b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2875b2a66aadSAntti Julku { 2876b2a66aadSAntti Julku struct bdaddr_list *b; 2877b2a66aadSAntti Julku 2878dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2879b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2880b2a66aadSAntti Julku return b; 2881b9ee0a78SMarcel Holtmann } 2882b2a66aadSAntti Julku 2883b2a66aadSAntti Julku return NULL; 2884b2a66aadSAntti Julku } 2885b2a66aadSAntti Julku 2886b950aa88SAnkit Navik struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk( 2887b950aa88SAnkit Navik struct list_head *bdaddr_list, bdaddr_t *bdaddr, 2888b950aa88SAnkit Navik u8 type) 2889b950aa88SAnkit Navik { 2890b950aa88SAnkit Navik struct bdaddr_list_with_irk *b; 2891b950aa88SAnkit Navik 2892b950aa88SAnkit Navik list_for_each_entry(b, bdaddr_list, list) { 2893b950aa88SAnkit Navik if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2894b950aa88SAnkit Navik return b; 2895b950aa88SAnkit Navik } 2896b950aa88SAnkit Navik 2897b950aa88SAnkit Navik return NULL; 2898b950aa88SAnkit Navik } 2899b950aa88SAnkit Navik 2900dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2901b2a66aadSAntti Julku { 29027eb7404fSGeliang Tang struct bdaddr_list *b, *n; 2903b2a66aadSAntti Julku 29047eb7404fSGeliang Tang list_for_each_entry_safe(b, n, bdaddr_list, list) { 29057eb7404fSGeliang Tang list_del(&b->list); 2906b2a66aadSAntti Julku kfree(b); 2907b2a66aadSAntti Julku } 2908b2a66aadSAntti Julku } 2909b2a66aadSAntti Julku 2910dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2911b2a66aadSAntti Julku { 2912b2a66aadSAntti Julku struct bdaddr_list *entry; 2913b2a66aadSAntti Julku 2914b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2915b2a66aadSAntti Julku return -EBADF; 2916b2a66aadSAntti Julku 2917dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 29185e762444SAntti Julku return -EEXIST; 2919b2a66aadSAntti Julku 292027f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 29215e762444SAntti Julku if (!entry) 29225e762444SAntti Julku return -ENOMEM; 2923b2a66aadSAntti Julku 2924b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2925b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2926b2a66aadSAntti Julku 2927dcc36c16SJohan Hedberg list_add(&entry->list, list); 2928b2a66aadSAntti Julku 29292a8357f2SJohan Hedberg return 0; 2930b2a66aadSAntti Julku } 2931b2a66aadSAntti Julku 2932b950aa88SAnkit Navik int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr, 2933b950aa88SAnkit Navik u8 type, u8 *peer_irk, u8 *local_irk) 2934b950aa88SAnkit Navik { 2935b950aa88SAnkit Navik struct bdaddr_list_with_irk *entry; 2936b950aa88SAnkit Navik 2937b950aa88SAnkit Navik if (!bacmp(bdaddr, BDADDR_ANY)) 2938b950aa88SAnkit Navik return -EBADF; 2939b950aa88SAnkit Navik 2940b950aa88SAnkit Navik if (hci_bdaddr_list_lookup(list, bdaddr, type)) 2941b950aa88SAnkit Navik return -EEXIST; 2942b950aa88SAnkit Navik 2943b950aa88SAnkit Navik entry = kzalloc(sizeof(*entry), GFP_KERNEL); 2944b950aa88SAnkit Navik if (!entry) 2945b950aa88SAnkit Navik return -ENOMEM; 2946b950aa88SAnkit Navik 2947b950aa88SAnkit Navik bacpy(&entry->bdaddr, bdaddr); 2948b950aa88SAnkit Navik entry->bdaddr_type = type; 2949b950aa88SAnkit Navik 2950b950aa88SAnkit Navik if (peer_irk) 2951b950aa88SAnkit Navik memcpy(entry->peer_irk, peer_irk, 16); 2952b950aa88SAnkit Navik 2953b950aa88SAnkit Navik if (local_irk) 2954b950aa88SAnkit Navik memcpy(entry->local_irk, local_irk, 16); 2955b950aa88SAnkit Navik 2956b950aa88SAnkit Navik list_add(&entry->list, list); 2957b950aa88SAnkit Navik 2958b950aa88SAnkit Navik return 0; 2959b950aa88SAnkit Navik } 2960b950aa88SAnkit Navik 2961dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2962b2a66aadSAntti Julku { 2963b2a66aadSAntti Julku struct bdaddr_list *entry; 2964b2a66aadSAntti Julku 296535f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2966dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 296735f7498aSJohan Hedberg return 0; 296835f7498aSJohan Hedberg } 2969b2a66aadSAntti Julku 2970dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2971d2ab0ac1SMarcel Holtmann if (!entry) 2972d2ab0ac1SMarcel Holtmann return -ENOENT; 2973d2ab0ac1SMarcel Holtmann 2974d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2975d2ab0ac1SMarcel Holtmann kfree(entry); 2976d2ab0ac1SMarcel Holtmann 2977d2ab0ac1SMarcel Holtmann return 0; 2978d2ab0ac1SMarcel Holtmann } 2979d2ab0ac1SMarcel Holtmann 2980b950aa88SAnkit Navik int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr, 2981b950aa88SAnkit Navik u8 type) 2982b950aa88SAnkit Navik { 2983b950aa88SAnkit Navik struct bdaddr_list_with_irk *entry; 2984b950aa88SAnkit Navik 2985b950aa88SAnkit Navik if (!bacmp(bdaddr, BDADDR_ANY)) { 2986b950aa88SAnkit Navik hci_bdaddr_list_clear(list); 2987b950aa88SAnkit Navik return 0; 2988b950aa88SAnkit Navik } 2989b950aa88SAnkit Navik 2990b950aa88SAnkit Navik entry = hci_bdaddr_list_lookup_with_irk(list, bdaddr, type); 2991b950aa88SAnkit Navik if (!entry) 2992b950aa88SAnkit Navik return -ENOENT; 2993b950aa88SAnkit Navik 2994b950aa88SAnkit Navik list_del(&entry->list); 2995b950aa88SAnkit Navik kfree(entry); 2996b950aa88SAnkit Navik 2997b950aa88SAnkit Navik return 0; 2998b950aa88SAnkit Navik } 2999b950aa88SAnkit Navik 300015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 300115819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 300215819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 300315819a70SAndre Guedes { 300415819a70SAndre Guedes struct hci_conn_params *params; 300515819a70SAndre Guedes 300615819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 300715819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 300815819a70SAndre Guedes params->addr_type == addr_type) { 300915819a70SAndre Guedes return params; 301015819a70SAndre Guedes } 301115819a70SAndre Guedes } 301215819a70SAndre Guedes 301315819a70SAndre Guedes return NULL; 301415819a70SAndre Guedes } 301515819a70SAndre Guedes 301615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3017501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 30184b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 301915819a70SAndre Guedes { 3020912b42efSJohan Hedberg struct hci_conn_params *param; 302115819a70SAndre Guedes 3022501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3023912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3024912b42efSJohan Hedberg param->addr_type == addr_type) 3025912b42efSJohan Hedberg return param; 30264b10966fSMarcel Holtmann } 30274b10966fSMarcel Holtmann 30284b10966fSMarcel Holtmann return NULL; 302915819a70SAndre Guedes } 303015819a70SAndre Guedes 303115819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 303251d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 303351d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 303415819a70SAndre Guedes { 303515819a70SAndre Guedes struct hci_conn_params *params; 303615819a70SAndre Guedes 303715819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 3038cef952ceSAndre Guedes if (params) 303951d167c0SMarcel Holtmann return params; 304015819a70SAndre Guedes 304115819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 304215819a70SAndre Guedes if (!params) { 30432064ee33SMarcel Holtmann bt_dev_err(hdev, "out of memory"); 304451d167c0SMarcel Holtmann return NULL; 304515819a70SAndre Guedes } 304615819a70SAndre Guedes 304715819a70SAndre Guedes bacpy(¶ms->addr, addr); 304815819a70SAndre Guedes params->addr_type = addr_type; 3049cef952ceSAndre Guedes 3050cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 305193450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3052cef952ceSAndre Guedes 3053bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3054bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3055bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3056bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3057bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3058bf5b3c8bSMarcel Holtmann 3059bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3060bf5b3c8bSMarcel Holtmann 306151d167c0SMarcel Holtmann return params; 3062bf5b3c8bSMarcel Holtmann } 3063bf5b3c8bSMarcel Holtmann 3064f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 3065f6c63249SJohan Hedberg { 3066f6c63249SJohan Hedberg if (params->conn) { 3067f6c63249SJohan Hedberg hci_conn_drop(params->conn); 3068f6c63249SJohan Hedberg hci_conn_put(params->conn); 3069f6c63249SJohan Hedberg } 3070f6c63249SJohan Hedberg 3071f6c63249SJohan Hedberg list_del(¶ms->action); 3072f6c63249SJohan Hedberg list_del(¶ms->list); 3073f6c63249SJohan Hedberg kfree(params); 3074f6c63249SJohan Hedberg } 3075f6c63249SJohan Hedberg 307615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 307715819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 307815819a70SAndre Guedes { 307915819a70SAndre Guedes struct hci_conn_params *params; 308015819a70SAndre Guedes 308115819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 308215819a70SAndre Guedes if (!params) 308315819a70SAndre Guedes return; 308415819a70SAndre Guedes 3085f6c63249SJohan Hedberg hci_conn_params_free(params); 308615819a70SAndre Guedes 308795305baaSJohan Hedberg hci_update_background_scan(hdev); 308895305baaSJohan Hedberg 308915819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 309015819a70SAndre Guedes } 309115819a70SAndre Guedes 309215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 309355af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 309415819a70SAndre Guedes { 309515819a70SAndre Guedes struct hci_conn_params *params, *tmp; 309615819a70SAndre Guedes 309715819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 309855af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 309955af49a8SJohan Hedberg continue; 3100f75113a2SJakub Pawlowski 3101f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 3102f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 3103f75113a2SJakub Pawlowski */ 3104f75113a2SJakub Pawlowski if (params->explicit_connect) { 3105f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 3106f75113a2SJakub Pawlowski continue; 3107f75113a2SJakub Pawlowski } 3108f75113a2SJakub Pawlowski 310915819a70SAndre Guedes list_del(¶ms->list); 311015819a70SAndre Guedes kfree(params); 311115819a70SAndre Guedes } 311215819a70SAndre Guedes 311355af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 311455af49a8SJohan Hedberg } 311555af49a8SJohan Hedberg 311655af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3117030e7f81SJohan Hedberg static void hci_conn_params_clear_all(struct hci_dev *hdev) 311815819a70SAndre Guedes { 311915819a70SAndre Guedes struct hci_conn_params *params, *tmp; 312015819a70SAndre Guedes 3121f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3122f6c63249SJohan Hedberg hci_conn_params_free(params); 312315819a70SAndre Guedes 312415819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 312515819a70SAndre Guedes } 312615819a70SAndre Guedes 3127a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3128a1f4c318SJohan Hedberg * 3129a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3130a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3131a1f4c318SJohan Hedberg * the static random address. 3132a1f4c318SJohan Hedberg * 3133a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3134a1f4c318SJohan Hedberg * public address to use the static random address instead. 313550b5b952SMarcel Holtmann * 313650b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 313750b5b952SMarcel Holtmann * userspace has configured a static address, then that address 313850b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 3139a1f4c318SJohan Hedberg */ 3140a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3141a1f4c318SJohan Hedberg u8 *bdaddr_type) 3142a1f4c318SJohan Hedberg { 3143b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 314450b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 3145d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 314650b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 3147a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3148a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3149a1f4c318SJohan Hedberg } else { 3150a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3151a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3152a1f4c318SJohan Hedberg } 3153a1f4c318SJohan Hedberg } 3154a1f4c318SJohan Hedberg 31559be0dab7SDavid Herrmann /* Alloc HCI device */ 31569be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 31579be0dab7SDavid Herrmann { 31589be0dab7SDavid Herrmann struct hci_dev *hdev; 31599be0dab7SDavid Herrmann 316027f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 31619be0dab7SDavid Herrmann if (!hdev) 31629be0dab7SDavid Herrmann return NULL; 31639be0dab7SDavid Herrmann 3164b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3165b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3166b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3167b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3168b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 316996c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3170bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3171bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3172d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 3173d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 31745d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 3175b1b813d4SDavid Herrmann 3176b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3177b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3178b1b813d4SDavid Herrmann 31793f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3180628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3181628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3182bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3183bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 3184b48c3b59SJonas Holmberg hdev->le_conn_min_interval = 0x0018; 3185b48c3b59SJonas Holmberg hdev->le_conn_max_interval = 0x0028; 318604fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 318704fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3188a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3189a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3190a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3191a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3192a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3193a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 319430d65e08SMatias Karhumaa hdev->le_max_key_size = SMP_MAX_ENC_KEY_SIZE; 319530d65e08SMatias Karhumaa hdev->le_min_key_size = SMP_MIN_ENC_KEY_SIZE; 31966decb5b4SJaganath Kanakkassery hdev->le_tx_def_phys = HCI_LE_SET_PHY_1M; 31976decb5b4SJaganath Kanakkassery hdev->le_rx_def_phys = HCI_LE_SET_PHY_1M; 3198bef64738SMarcel Holtmann 3199d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3200b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 320131ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 320231ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3203302975cbSSpoorthi Ravishankar Koppad hdev->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT; 3204d6bfd59cSJohan Hedberg 3205b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3206b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3207b1b813d4SDavid Herrmann 3208b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3209b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 32106659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3211b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3212b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3213b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3214970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3215b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3216d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 3217cfdb0c2dSAnkit Navik INIT_LIST_HEAD(&hdev->le_resolv_list); 321815819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 321977a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 322066f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 32216b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3222d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3223b1b813d4SDavid Herrmann 3224b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3225b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3226b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3227b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3228c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3229b1b813d4SDavid Herrmann 3230b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3231b1b813d4SDavid Herrmann 3232b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3233b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3234b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3235b1b813d4SDavid Herrmann 3236b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3237b1b813d4SDavid Herrmann 323865cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3239b1b813d4SDavid Herrmann 32405fc16cc4SJohan Hedberg hci_request_setup(hdev); 32415fc16cc4SJohan Hedberg 3242b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3243b1b813d4SDavid Herrmann discovery_init(hdev); 32449be0dab7SDavid Herrmann 32459be0dab7SDavid Herrmann return hdev; 32469be0dab7SDavid Herrmann } 32479be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 32489be0dab7SDavid Herrmann 32499be0dab7SDavid Herrmann /* Free HCI device */ 32509be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 32519be0dab7SDavid Herrmann { 32529be0dab7SDavid Herrmann /* will free via device release */ 32539be0dab7SDavid Herrmann put_device(&hdev->dev); 32549be0dab7SDavid Herrmann } 32559be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 32569be0dab7SDavid Herrmann 32571da177e4SLinus Torvalds /* Register HCI device */ 32581da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 32591da177e4SLinus Torvalds { 3260b1b813d4SDavid Herrmann int id, error; 32611da177e4SLinus Torvalds 326274292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 32631da177e4SLinus Torvalds return -EINVAL; 32641da177e4SLinus Torvalds 326508add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 326608add513SMat Martineau * so the index can be used as the AMP controller ID. 326708add513SMat Martineau */ 32683df92b31SSasha Levin switch (hdev->dev_type) { 3269ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 32703df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 32711da177e4SLinus Torvalds break; 32723df92b31SSasha Levin case HCI_AMP: 32733df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 32743df92b31SSasha Levin break; 32753df92b31SSasha Levin default: 32763df92b31SSasha Levin return -EINVAL; 32771da177e4SLinus Torvalds } 32781da177e4SLinus Torvalds 32793df92b31SSasha Levin if (id < 0) 32803df92b31SSasha Levin return id; 32813df92b31SSasha Levin 32821da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 32831da177e4SLinus Torvalds hdev->id = id; 32842d8b3a11SAndrei Emeltchenko 32852d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 32862d8b3a11SAndrei Emeltchenko 328729e2dd0dSTejun Heo hdev->workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, hdev->name); 328833ca954dSDavid Herrmann if (!hdev->workqueue) { 328933ca954dSDavid Herrmann error = -ENOMEM; 329033ca954dSDavid Herrmann goto err; 329133ca954dSDavid Herrmann } 3292f48fd9c8SMarcel Holtmann 329329e2dd0dSTejun Heo hdev->req_workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, 329429e2dd0dSTejun Heo hdev->name); 32956ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 32966ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 32976ead1bbcSJohan Hedberg error = -ENOMEM; 32986ead1bbcSJohan Hedberg goto err; 32996ead1bbcSJohan Hedberg } 33006ead1bbcSJohan Hedberg 33010153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 33020153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 33030153e2ecSMarcel Holtmann 3304bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3305bdc3e0f1SMarcel Holtmann 3306bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 330733ca954dSDavid Herrmann if (error < 0) 330854506918SJohan Hedberg goto err_wqueue; 33091da177e4SLinus Torvalds 33106d5d2ee6SHeiner Kallweit hci_leds_init(hdev); 33116d5d2ee6SHeiner Kallweit 3312611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3313a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3314a8c5fb1aSGustavo Padovan hdev); 3315611b30f7SMarcel Holtmann if (hdev->rfkill) { 3316611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3317611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3318611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3319611b30f7SMarcel Holtmann } 3320611b30f7SMarcel Holtmann } 3321611b30f7SMarcel Holtmann 33225e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3323a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 33245e130367SJohan Hedberg 3325a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3326a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3327ce2be9acSAndrei Emeltchenko 3328ca8bee5dSMarcel Holtmann if (hdev->dev_type == HCI_PRIMARY) { 332956f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 333056f87901SJohan Hedberg * through reading supported features during init. 333156f87901SJohan Hedberg */ 3332a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 333356f87901SJohan Hedberg } 3334ce2be9acSAndrei Emeltchenko 3335fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3336fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3337fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3338fcee3377SGustavo Padovan 33394a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 33404a964404SMarcel Holtmann * and should not be included in normal operation. 3341fee746b0SMarcel Holtmann */ 3342fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3343a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3344fee746b0SMarcel Holtmann 334505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3346dc946bd8SDavid Herrmann hci_dev_hold(hdev); 33471da177e4SLinus Torvalds 334819202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3349fbe96d6fSMarcel Holtmann 33501da177e4SLinus Torvalds return id; 3351f48fd9c8SMarcel Holtmann 335233ca954dSDavid Herrmann err_wqueue: 335333ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 33546ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 335533ca954dSDavid Herrmann err: 33563df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3357f48fd9c8SMarcel Holtmann 335833ca954dSDavid Herrmann return error; 33591da177e4SLinus Torvalds } 33601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 33611da177e4SLinus Torvalds 33621da177e4SLinus Torvalds /* Unregister HCI device */ 336359735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 33641da177e4SLinus Torvalds { 33652d7cc19eSMarcel Holtmann int id; 3366ef222013SMarcel Holtmann 3367c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 33681da177e4SLinus Torvalds 3369a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 337094324962SJohan Hovold 33713df92b31SSasha Levin id = hdev->id; 33723df92b31SSasha Levin 3373f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 33741da177e4SLinus Torvalds list_del(&hdev->list); 3375f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 33761da177e4SLinus Torvalds 3377b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3378b9b5ef18SGustavo Padovan 3379bf389cabSJiri Slaby hci_dev_do_close(hdev); 3380bf389cabSJiri Slaby 3381ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3382d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3383d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 338409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3385744cf19eSJohan Hedberg mgmt_index_removed(hdev); 338609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 338756e5cb86SJohan Hedberg } 3388ab81cbf9SJohan Hedberg 33892e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 33902e58ef3eSJohan Hedberg * pending list */ 33912e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 33922e58ef3eSJohan Hedberg 339305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 33941da177e4SLinus Torvalds 3395611b30f7SMarcel Holtmann if (hdev->rfkill) { 3396611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3397611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3398611b30f7SMarcel Holtmann } 3399611b30f7SMarcel Holtmann 3400bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3401147e2d59SDave Young 34020153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 34035177a838SMarcel Holtmann kfree_const(hdev->hw_info); 34045177a838SMarcel Holtmann kfree_const(hdev->fw_info); 34050153e2ecSMarcel Holtmann 3406f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 34076ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3408f48fd9c8SMarcel Holtmann 340909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3410dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 34116659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 34122aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 341355ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3414b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3415970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 34162763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3417d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3418dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3419cfdb0c2dSAnkit Navik hci_bdaddr_list_clear(&hdev->le_resolv_list); 3420373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 342122078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 342209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3423e2e0cacbSJohan Hedberg 3424dc946bd8SDavid Herrmann hci_dev_put(hdev); 34253df92b31SSasha Levin 34263df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 34271da177e4SLinus Torvalds } 34281da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 34291da177e4SLinus Torvalds 34301da177e4SLinus Torvalds /* Suspend HCI device */ 34311da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 34321da177e4SLinus Torvalds { 343305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 34341da177e4SLinus Torvalds return 0; 34351da177e4SLinus Torvalds } 34361da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 34371da177e4SLinus Torvalds 34381da177e4SLinus Torvalds /* Resume HCI device */ 34391da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 34401da177e4SLinus Torvalds { 344105fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 34421da177e4SLinus Torvalds return 0; 34431da177e4SLinus Torvalds } 34441da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 34451da177e4SLinus Torvalds 344675e0569fSMarcel Holtmann /* Reset HCI device */ 344775e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 344875e0569fSMarcel Holtmann { 34491e4b6e91SColin Ian King static const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 345075e0569fSMarcel Holtmann struct sk_buff *skb; 345175e0569fSMarcel Holtmann 345275e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 345375e0569fSMarcel Holtmann if (!skb) 345475e0569fSMarcel Holtmann return -ENOMEM; 345575e0569fSMarcel Holtmann 3456d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 345759ae1d12SJohannes Berg skb_put_data(skb, hw_err, 3); 345875e0569fSMarcel Holtmann 345975e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 346075e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 346175e0569fSMarcel Holtmann } 346275e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 346375e0569fSMarcel Holtmann 346476bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3465e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 346676bca880SMarcel Holtmann { 346776bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 346876bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 346976bca880SMarcel Holtmann kfree_skb(skb); 347076bca880SMarcel Holtmann return -ENXIO; 347176bca880SMarcel Holtmann } 347276bca880SMarcel Holtmann 3473d79f34e3SMarcel Holtmann if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT && 3474d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT && 3475d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_SCODATA_PKT) { 3476fe806dceSMarcel Holtmann kfree_skb(skb); 3477fe806dceSMarcel Holtmann return -EINVAL; 3478fe806dceSMarcel Holtmann } 3479fe806dceSMarcel Holtmann 3480d82603c6SJorrit Schippers /* Incoming skb */ 348176bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 348276bca880SMarcel Holtmann 348376bca880SMarcel Holtmann /* Time stamp */ 348476bca880SMarcel Holtmann __net_timestamp(skb); 348576bca880SMarcel Holtmann 348676bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3487b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3488c78ae283SMarcel Holtmann 348976bca880SMarcel Holtmann return 0; 349076bca880SMarcel Holtmann } 349176bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 349276bca880SMarcel Holtmann 3493e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3494e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3495e875ff84SMarcel Holtmann { 3496581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3497d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_DIAG_PKT; 3498581d6fd6SMarcel Holtmann 3499e875ff84SMarcel Holtmann /* Time stamp */ 3500e875ff84SMarcel Holtmann __net_timestamp(skb); 3501e875ff84SMarcel Holtmann 3502581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3503581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3504e875ff84SMarcel Holtmann 3505e875ff84SMarcel Holtmann return 0; 3506e875ff84SMarcel Holtmann } 3507e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3508e875ff84SMarcel Holtmann 35095177a838SMarcel Holtmann void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...) 35105177a838SMarcel Holtmann { 35115177a838SMarcel Holtmann va_list vargs; 35125177a838SMarcel Holtmann 35135177a838SMarcel Holtmann va_start(vargs, fmt); 35145177a838SMarcel Holtmann kfree_const(hdev->hw_info); 35155177a838SMarcel Holtmann hdev->hw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 35165177a838SMarcel Holtmann va_end(vargs); 35175177a838SMarcel Holtmann } 35185177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_hw_info); 35195177a838SMarcel Holtmann 35205177a838SMarcel Holtmann void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...) 35215177a838SMarcel Holtmann { 35225177a838SMarcel Holtmann va_list vargs; 35235177a838SMarcel Holtmann 35245177a838SMarcel Holtmann va_start(vargs, fmt); 35255177a838SMarcel Holtmann kfree_const(hdev->fw_info); 35265177a838SMarcel Holtmann hdev->fw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 35275177a838SMarcel Holtmann va_end(vargs); 35285177a838SMarcel Holtmann } 35295177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_fw_info); 35305177a838SMarcel Holtmann 35311da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 35321da177e4SLinus Torvalds 35331da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 35341da177e4SLinus Torvalds { 35351da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35361da177e4SLinus Torvalds 3537fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 353800629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3539fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 35401da177e4SLinus Torvalds 35411da177e4SLinus Torvalds return 0; 35421da177e4SLinus Torvalds } 35431da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 35441da177e4SLinus Torvalds 35451da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 35461da177e4SLinus Torvalds { 35471da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 35481da177e4SLinus Torvalds 3549fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 35501da177e4SLinus Torvalds list_del(&cb->list); 3551fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 35521da177e4SLinus Torvalds 35531da177e4SLinus Torvalds return 0; 35541da177e4SLinus Torvalds } 35551da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 35561da177e4SLinus Torvalds 355751086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 35581da177e4SLinus Torvalds { 3559cdc52faaSMarcel Holtmann int err; 3560cdc52faaSMarcel Holtmann 3561d79f34e3SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb), 3562d79f34e3SMarcel Holtmann skb->len); 35631da177e4SLinus Torvalds 35641da177e4SLinus Torvalds /* Time stamp */ 3565a61bbcf2SPatrick McHardy __net_timestamp(skb); 35661da177e4SLinus Torvalds 3567cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3568cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3569cd82e61cSMarcel Holtmann 3570cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3571cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3572470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 35731da177e4SLinus Torvalds } 35741da177e4SLinus Torvalds 35751da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 35761da177e4SLinus Torvalds skb_orphan(skb); 35771da177e4SLinus Torvalds 357873d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 357973d0d3c8SMarcel Holtmann kfree_skb(skb); 358073d0d3c8SMarcel Holtmann return; 358173d0d3c8SMarcel Holtmann } 358273d0d3c8SMarcel Holtmann 3583cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3584cdc52faaSMarcel Holtmann if (err < 0) { 35852064ee33SMarcel Holtmann bt_dev_err(hdev, "sending frame failed (%d)", err); 3586cdc52faaSMarcel Holtmann kfree_skb(skb); 3587cdc52faaSMarcel Holtmann } 35881da177e4SLinus Torvalds } 35891da177e4SLinus Torvalds 35901ca3a9d0SJohan Hedberg /* Send HCI command */ 359107dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 359207dc93ddSJohan Hedberg const void *param) 35931ca3a9d0SJohan Hedberg { 35941ca3a9d0SJohan Hedberg struct sk_buff *skb; 35951ca3a9d0SJohan Hedberg 35961ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 35971ca3a9d0SJohan Hedberg 35981ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 35991ca3a9d0SJohan Hedberg if (!skb) { 36002064ee33SMarcel Holtmann bt_dev_err(hdev, "no memory for command"); 36011ca3a9d0SJohan Hedberg return -ENOMEM; 36021ca3a9d0SJohan Hedberg } 36031ca3a9d0SJohan Hedberg 360449c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 360511714b3dSJohan Hedberg * single-command requests. 360611714b3dSJohan Hedberg */ 360744d27137SJohan Hedberg bt_cb(skb)->hci.req_flags |= HCI_REQ_START; 360811714b3dSJohan Hedberg 36091da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3610c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 36111da177e4SLinus Torvalds 36121da177e4SLinus Torvalds return 0; 36131da177e4SLinus Torvalds } 36141da177e4SLinus Torvalds 3615d6ee6ad7SLoic Poulain int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen, 3616d6ee6ad7SLoic Poulain const void *param) 3617d6ee6ad7SLoic Poulain { 3618d6ee6ad7SLoic Poulain struct sk_buff *skb; 3619d6ee6ad7SLoic Poulain 3620d6ee6ad7SLoic Poulain if (hci_opcode_ogf(opcode) != 0x3f) { 3621d6ee6ad7SLoic Poulain /* A controller receiving a command shall respond with either 3622d6ee6ad7SLoic Poulain * a Command Status Event or a Command Complete Event. 3623d6ee6ad7SLoic Poulain * Therefore, all standard HCI commands must be sent via the 3624d6ee6ad7SLoic Poulain * standard API, using hci_send_cmd or hci_cmd_sync helpers. 3625d6ee6ad7SLoic Poulain * Some vendors do not comply with this rule for vendor-specific 3626d6ee6ad7SLoic Poulain * commands and do not return any event. We want to support 3627d6ee6ad7SLoic Poulain * unresponded commands for such cases only. 3628d6ee6ad7SLoic Poulain */ 3629d6ee6ad7SLoic Poulain bt_dev_err(hdev, "unresponded command not supported"); 3630d6ee6ad7SLoic Poulain return -EINVAL; 3631d6ee6ad7SLoic Poulain } 3632d6ee6ad7SLoic Poulain 3633d6ee6ad7SLoic Poulain skb = hci_prepare_cmd(hdev, opcode, plen, param); 3634d6ee6ad7SLoic Poulain if (!skb) { 3635d6ee6ad7SLoic Poulain bt_dev_err(hdev, "no memory for command (opcode 0x%4.4x)", 3636d6ee6ad7SLoic Poulain opcode); 3637d6ee6ad7SLoic Poulain return -ENOMEM; 3638d6ee6ad7SLoic Poulain } 3639d6ee6ad7SLoic Poulain 3640d6ee6ad7SLoic Poulain hci_send_frame(hdev, skb); 3641d6ee6ad7SLoic Poulain 3642d6ee6ad7SLoic Poulain return 0; 3643d6ee6ad7SLoic Poulain } 3644d6ee6ad7SLoic Poulain EXPORT_SYMBOL(__hci_cmd_send); 3645d6ee6ad7SLoic Poulain 36461da177e4SLinus Torvalds /* Get data from the previously sent command */ 3647a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 36481da177e4SLinus Torvalds { 36491da177e4SLinus Torvalds struct hci_command_hdr *hdr; 36501da177e4SLinus Torvalds 36511da177e4SLinus Torvalds if (!hdev->sent_cmd) 36521da177e4SLinus Torvalds return NULL; 36531da177e4SLinus Torvalds 36541da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 36551da177e4SLinus Torvalds 3656a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 36571da177e4SLinus Torvalds return NULL; 36581da177e4SLinus Torvalds 3659f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 36601da177e4SLinus Torvalds 36611da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 36621da177e4SLinus Torvalds } 36631da177e4SLinus Torvalds 3664fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3665fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3666fbef168fSLoic Poulain const void *param, u32 timeout) 3667fbef168fSLoic Poulain { 3668fbef168fSLoic Poulain struct sk_buff *skb; 3669fbef168fSLoic Poulain 3670fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3671fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3672fbef168fSLoic Poulain 3673fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3674fbef168fSLoic Poulain 3675b504430cSJohan Hedberg hci_req_sync_lock(hdev); 3676fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3677b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 3678fbef168fSLoic Poulain 3679fbef168fSLoic Poulain return skb; 3680fbef168fSLoic Poulain } 3681fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3682fbef168fSLoic Poulain 36831da177e4SLinus Torvalds /* Send ACL data */ 36841da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 36851da177e4SLinus Torvalds { 36861da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 36871da177e4SLinus Torvalds int len = skb->len; 36881da177e4SLinus Torvalds 3689badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3690badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 36919c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3692aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3693aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 36941da177e4SLinus Torvalds } 36951da177e4SLinus Torvalds 3696ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 369773d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 36981da177e4SLinus Torvalds { 3699ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 37001da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37011da177e4SLinus Torvalds struct sk_buff *list; 37021da177e4SLinus Torvalds 3703087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3704087bfd99SGustavo Padovan skb->data_len = 0; 3705087bfd99SGustavo Padovan 3706d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3707204a6e54SAndrei Emeltchenko 3708204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3709ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 3710087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3711204a6e54SAndrei Emeltchenko break; 3712204a6e54SAndrei Emeltchenko case HCI_AMP: 3713204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3714204a6e54SAndrei Emeltchenko break; 3715204a6e54SAndrei Emeltchenko default: 37162064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown dev_type %d", hdev->dev_type); 3717204a6e54SAndrei Emeltchenko return; 3718204a6e54SAndrei Emeltchenko } 3719087bfd99SGustavo Padovan 372070f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 372170f23020SAndrei Emeltchenko if (!list) { 37221da177e4SLinus Torvalds /* Non fragmented */ 37231da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 37241da177e4SLinus Torvalds 372573d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 37261da177e4SLinus Torvalds } else { 37271da177e4SLinus Torvalds /* Fragmented */ 37281da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37291da177e4SLinus Torvalds 37301da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 37311da177e4SLinus Torvalds 37329cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 37339cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 37349cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 37359cfd5a23SJukka Rissanen * deadlocks. 37369cfd5a23SJukka Rissanen */ 37379cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 37381da177e4SLinus Torvalds 373973d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3740e702112fSAndrei Emeltchenko 3741e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3742e702112fSAndrei Emeltchenko flags |= ACL_CONT; 37431da177e4SLinus Torvalds do { 37441da177e4SLinus Torvalds skb = list; list = list->next; 37451da177e4SLinus Torvalds 3746d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3747e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 37481da177e4SLinus Torvalds 37491da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 37501da177e4SLinus Torvalds 375173d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 37521da177e4SLinus Torvalds } while (list); 37531da177e4SLinus Torvalds 37549cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 37551da177e4SLinus Torvalds } 375673d80debSLuiz Augusto von Dentz } 375773d80debSLuiz Augusto von Dentz 375873d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 375973d80debSLuiz Augusto von Dentz { 3760ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 376173d80debSLuiz Augusto von Dentz 3762f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 376373d80debSLuiz Augusto von Dentz 3764ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 37651da177e4SLinus Torvalds 37663eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 37671da177e4SLinus Torvalds } 37681da177e4SLinus Torvalds 37691da177e4SLinus Torvalds /* Send SCO data */ 37700d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 37711da177e4SLinus Torvalds { 37721da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 37731da177e4SLinus Torvalds struct hci_sco_hdr hdr; 37741da177e4SLinus Torvalds 37751da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 37761da177e4SLinus Torvalds 3777aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 37781da177e4SLinus Torvalds hdr.dlen = skb->len; 37791da177e4SLinus Torvalds 3780badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3781badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 37829c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 37831da177e4SLinus Torvalds 3784d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 3785c78ae283SMarcel Holtmann 37861da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 37873eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 37881da177e4SLinus Torvalds } 37891da177e4SLinus Torvalds 37901da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 37911da177e4SLinus Torvalds 37921da177e4SLinus Torvalds /* HCI Connection scheduler */ 37936039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3794a8c5fb1aSGustavo Padovan int *quote) 37951da177e4SLinus Torvalds { 37961da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 37978035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3798abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 37991da177e4SLinus Torvalds 38001da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 38011da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3802bf4c6325SGustavo F. Padovan 3803bf4c6325SGustavo F. Padovan rcu_read_lock(); 3804bf4c6325SGustavo F. Padovan 3805bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3806769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 38071da177e4SLinus Torvalds continue; 3808769be974SMarcel Holtmann 3809769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3810769be974SMarcel Holtmann continue; 3811769be974SMarcel Holtmann 38121da177e4SLinus Torvalds num++; 38131da177e4SLinus Torvalds 38141da177e4SLinus Torvalds if (c->sent < min) { 38151da177e4SLinus Torvalds min = c->sent; 38161da177e4SLinus Torvalds conn = c; 38171da177e4SLinus Torvalds } 381852087a79SLuiz Augusto von Dentz 381952087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 382052087a79SLuiz Augusto von Dentz break; 38211da177e4SLinus Torvalds } 38221da177e4SLinus Torvalds 3823bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3824bf4c6325SGustavo F. Padovan 38251da177e4SLinus Torvalds if (conn) { 38266ed58ec5SVille Tervo int cnt, q; 38276ed58ec5SVille Tervo 38286ed58ec5SVille Tervo switch (conn->type) { 38296ed58ec5SVille Tervo case ACL_LINK: 38306ed58ec5SVille Tervo cnt = hdev->acl_cnt; 38316ed58ec5SVille Tervo break; 38326ed58ec5SVille Tervo case SCO_LINK: 38336ed58ec5SVille Tervo case ESCO_LINK: 38346ed58ec5SVille Tervo cnt = hdev->sco_cnt; 38356ed58ec5SVille Tervo break; 38366ed58ec5SVille Tervo case LE_LINK: 38376ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 38386ed58ec5SVille Tervo break; 38396ed58ec5SVille Tervo default: 38406ed58ec5SVille Tervo cnt = 0; 38412064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", conn->type); 38426ed58ec5SVille Tervo } 38436ed58ec5SVille Tervo 38446ed58ec5SVille Tervo q = cnt / num; 38451da177e4SLinus Torvalds *quote = q ? q : 1; 38461da177e4SLinus Torvalds } else 38471da177e4SLinus Torvalds *quote = 0; 38481da177e4SLinus Torvalds 38491da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 38501da177e4SLinus Torvalds return conn; 38511da177e4SLinus Torvalds } 38521da177e4SLinus Torvalds 38536039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 38541da177e4SLinus Torvalds { 38551da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 38561da177e4SLinus Torvalds struct hci_conn *c; 38571da177e4SLinus Torvalds 38582064ee33SMarcel Holtmann bt_dev_err(hdev, "link tx timeout"); 38591da177e4SLinus Torvalds 3860bf4c6325SGustavo F. Padovan rcu_read_lock(); 3861bf4c6325SGustavo F. Padovan 38621da177e4SLinus Torvalds /* Kill stalled connections */ 3863bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3864bae1f5d9SVille Tervo if (c->type == type && c->sent) { 38652064ee33SMarcel Holtmann bt_dev_err(hdev, "killing stalled connection %pMR", 38662064ee33SMarcel Holtmann &c->dst); 3867bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 38681da177e4SLinus Torvalds } 38691da177e4SLinus Torvalds } 3870bf4c6325SGustavo F. Padovan 3871bf4c6325SGustavo F. Padovan rcu_read_unlock(); 38721da177e4SLinus Torvalds } 38731da177e4SLinus Torvalds 38746039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 387573d80debSLuiz Augusto von Dentz int *quote) 387673d80debSLuiz Augusto von Dentz { 387773d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 387873d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3879abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 388073d80debSLuiz Augusto von Dentz struct hci_conn *conn; 388173d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 388273d80debSLuiz Augusto von Dentz 388373d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 388473d80debSLuiz Augusto von Dentz 3885bf4c6325SGustavo F. Padovan rcu_read_lock(); 3886bf4c6325SGustavo F. Padovan 3887bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 388873d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 388973d80debSLuiz Augusto von Dentz 389073d80debSLuiz Augusto von Dentz if (conn->type != type) 389173d80debSLuiz Augusto von Dentz continue; 389273d80debSLuiz Augusto von Dentz 389373d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 389473d80debSLuiz Augusto von Dentz continue; 389573d80debSLuiz Augusto von Dentz 389673d80debSLuiz Augusto von Dentz conn_num++; 389773d80debSLuiz Augusto von Dentz 38988192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 389973d80debSLuiz Augusto von Dentz struct sk_buff *skb; 390073d80debSLuiz Augusto von Dentz 390173d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 390273d80debSLuiz Augusto von Dentz continue; 390373d80debSLuiz Augusto von Dentz 390473d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 390573d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 390673d80debSLuiz Augusto von Dentz continue; 390773d80debSLuiz Augusto von Dentz 390873d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 390973d80debSLuiz Augusto von Dentz num = 0; 391073d80debSLuiz Augusto von Dentz min = ~0; 391173d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 391273d80debSLuiz Augusto von Dentz } 391373d80debSLuiz Augusto von Dentz 391473d80debSLuiz Augusto von Dentz num++; 391573d80debSLuiz Augusto von Dentz 391673d80debSLuiz Augusto von Dentz if (conn->sent < min) { 391773d80debSLuiz Augusto von Dentz min = conn->sent; 391873d80debSLuiz Augusto von Dentz chan = tmp; 391973d80debSLuiz Augusto von Dentz } 392073d80debSLuiz Augusto von Dentz } 392173d80debSLuiz Augusto von Dentz 392273d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 392373d80debSLuiz Augusto von Dentz break; 392473d80debSLuiz Augusto von Dentz } 392573d80debSLuiz Augusto von Dentz 3926bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3927bf4c6325SGustavo F. Padovan 392873d80debSLuiz Augusto von Dentz if (!chan) 392973d80debSLuiz Augusto von Dentz return NULL; 393073d80debSLuiz Augusto von Dentz 393173d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 393273d80debSLuiz Augusto von Dentz case ACL_LINK: 393373d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 393473d80debSLuiz Augusto von Dentz break; 3935bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3936bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3937bd1eb66bSAndrei Emeltchenko break; 393873d80debSLuiz Augusto von Dentz case SCO_LINK: 393973d80debSLuiz Augusto von Dentz case ESCO_LINK: 394073d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 394173d80debSLuiz Augusto von Dentz break; 394273d80debSLuiz Augusto von Dentz case LE_LINK: 394373d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 394473d80debSLuiz Augusto von Dentz break; 394573d80debSLuiz Augusto von Dentz default: 394673d80debSLuiz Augusto von Dentz cnt = 0; 39472064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", chan->conn->type); 394873d80debSLuiz Augusto von Dentz } 394973d80debSLuiz Augusto von Dentz 395073d80debSLuiz Augusto von Dentz q = cnt / num; 395173d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 395273d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 395373d80debSLuiz Augusto von Dentz return chan; 395473d80debSLuiz Augusto von Dentz } 395573d80debSLuiz Augusto von Dentz 395602b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 395702b20f0bSLuiz Augusto von Dentz { 395802b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 395902b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 396002b20f0bSLuiz Augusto von Dentz int num = 0; 396102b20f0bSLuiz Augusto von Dentz 396202b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 396302b20f0bSLuiz Augusto von Dentz 3964bf4c6325SGustavo F. Padovan rcu_read_lock(); 3965bf4c6325SGustavo F. Padovan 3966bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 396702b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 396802b20f0bSLuiz Augusto von Dentz 396902b20f0bSLuiz Augusto von Dentz if (conn->type != type) 397002b20f0bSLuiz Augusto von Dentz continue; 397102b20f0bSLuiz Augusto von Dentz 397202b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 397302b20f0bSLuiz Augusto von Dentz continue; 397402b20f0bSLuiz Augusto von Dentz 397502b20f0bSLuiz Augusto von Dentz num++; 397602b20f0bSLuiz Augusto von Dentz 39778192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 397802b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 397902b20f0bSLuiz Augusto von Dentz 398002b20f0bSLuiz Augusto von Dentz if (chan->sent) { 398102b20f0bSLuiz Augusto von Dentz chan->sent = 0; 398202b20f0bSLuiz Augusto von Dentz continue; 398302b20f0bSLuiz Augusto von Dentz } 398402b20f0bSLuiz Augusto von Dentz 398502b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 398602b20f0bSLuiz Augusto von Dentz continue; 398702b20f0bSLuiz Augusto von Dentz 398802b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 398902b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 399002b20f0bSLuiz Augusto von Dentz continue; 399102b20f0bSLuiz Augusto von Dentz 399202b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 399302b20f0bSLuiz Augusto von Dentz 399402b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 399502b20f0bSLuiz Augusto von Dentz skb->priority); 399602b20f0bSLuiz Augusto von Dentz } 399702b20f0bSLuiz Augusto von Dentz 399802b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 399902b20f0bSLuiz Augusto von Dentz break; 400002b20f0bSLuiz Augusto von Dentz } 4001bf4c6325SGustavo F. Padovan 4002bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4003bf4c6325SGustavo F. Padovan 400402b20f0bSLuiz Augusto von Dentz } 400502b20f0bSLuiz Augusto von Dentz 4006b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4007b71d385aSAndrei Emeltchenko { 4008b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4009b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4010b71d385aSAndrei Emeltchenko } 4011b71d385aSAndrei Emeltchenko 40126039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 40131da177e4SLinus Torvalds { 4014d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 40151da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 40161da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 401763d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 40185f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4019bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 40201da177e4SLinus Torvalds } 402163d2bc1bSAndrei Emeltchenko } 40221da177e4SLinus Torvalds 40236039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 402463d2bc1bSAndrei Emeltchenko { 402563d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 402663d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 402763d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 402863d2bc1bSAndrei Emeltchenko int quote; 402963d2bc1bSAndrei Emeltchenko 403063d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 403104837f64SMarcel Holtmann 403273d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 403373d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4034ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4035ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 403673d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 403773d80debSLuiz Augusto von Dentz skb->len, skb->priority); 403873d80debSLuiz Augusto von Dentz 4039ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4040ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4041ec1cce24SLuiz Augusto von Dentz break; 4042ec1cce24SLuiz Augusto von Dentz 4043ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4044ec1cce24SLuiz Augusto von Dentz 404573d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 404673d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 404704837f64SMarcel Holtmann 404857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40491da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 40501da177e4SLinus Torvalds 40511da177e4SLinus Torvalds hdev->acl_cnt--; 405273d80debSLuiz Augusto von Dentz chan->sent++; 405373d80debSLuiz Augusto von Dentz chan->conn->sent++; 40541da177e4SLinus Torvalds } 40551da177e4SLinus Torvalds } 405602b20f0bSLuiz Augusto von Dentz 405702b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 405802b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 40591da177e4SLinus Torvalds } 40601da177e4SLinus Torvalds 40616039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4062b71d385aSAndrei Emeltchenko { 406363d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4064b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4065b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4066b71d385aSAndrei Emeltchenko int quote; 4067bd1eb66bSAndrei Emeltchenko u8 type; 4068b71d385aSAndrei Emeltchenko 406963d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4070b71d385aSAndrei Emeltchenko 4071bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4072bd1eb66bSAndrei Emeltchenko 4073bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4074bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4075bd1eb66bSAndrei Emeltchenko else 4076bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4077bd1eb66bSAndrei Emeltchenko 4078b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4079bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4080b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4081b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4082b71d385aSAndrei Emeltchenko int blocks; 4083b71d385aSAndrei Emeltchenko 4084b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4085b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4086b71d385aSAndrei Emeltchenko 4087b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4088b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4089b71d385aSAndrei Emeltchenko break; 4090b71d385aSAndrei Emeltchenko 4091b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4092b71d385aSAndrei Emeltchenko 4093b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4094b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4095b71d385aSAndrei Emeltchenko return; 4096b71d385aSAndrei Emeltchenko 4097b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4098b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4099b71d385aSAndrei Emeltchenko 410057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4101b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4102b71d385aSAndrei Emeltchenko 4103b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4104b71d385aSAndrei Emeltchenko quote -= blocks; 4105b71d385aSAndrei Emeltchenko 4106b71d385aSAndrei Emeltchenko chan->sent += blocks; 4107b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4108b71d385aSAndrei Emeltchenko } 4109b71d385aSAndrei Emeltchenko } 4110b71d385aSAndrei Emeltchenko 4111b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4112bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4113b71d385aSAndrei Emeltchenko } 4114b71d385aSAndrei Emeltchenko 41156039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4116b71d385aSAndrei Emeltchenko { 4117b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4118b71d385aSAndrei Emeltchenko 4119bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4120ca8bee5dSMarcel Holtmann if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_PRIMARY) 4121bd1eb66bSAndrei Emeltchenko return; 4122bd1eb66bSAndrei Emeltchenko 4123bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4124bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4125b71d385aSAndrei Emeltchenko return; 4126b71d385aSAndrei Emeltchenko 4127b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4128b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4129b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4130b71d385aSAndrei Emeltchenko break; 4131b71d385aSAndrei Emeltchenko 4132b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4133b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4134b71d385aSAndrei Emeltchenko break; 4135b71d385aSAndrei Emeltchenko } 4136b71d385aSAndrei Emeltchenko } 4137b71d385aSAndrei Emeltchenko 41381da177e4SLinus Torvalds /* Schedule SCO */ 41396039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 41401da177e4SLinus Torvalds { 41411da177e4SLinus Torvalds struct hci_conn *conn; 41421da177e4SLinus Torvalds struct sk_buff *skb; 41431da177e4SLinus Torvalds int quote; 41441da177e4SLinus Torvalds 41451da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 41461da177e4SLinus Torvalds 414752087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 414852087a79SLuiz Augusto von Dentz return; 414952087a79SLuiz Augusto von Dentz 41501da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 41511da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 41521da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 415357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41541da177e4SLinus Torvalds 41551da177e4SLinus Torvalds conn->sent++; 41561da177e4SLinus Torvalds if (conn->sent == ~0) 41571da177e4SLinus Torvalds conn->sent = 0; 41581da177e4SLinus Torvalds } 41591da177e4SLinus Torvalds } 41601da177e4SLinus Torvalds } 41611da177e4SLinus Torvalds 41626039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4163b6a0dc82SMarcel Holtmann { 4164b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4165b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4166b6a0dc82SMarcel Holtmann int quote; 4167b6a0dc82SMarcel Holtmann 4168b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4169b6a0dc82SMarcel Holtmann 417052087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 417152087a79SLuiz Augusto von Dentz return; 417252087a79SLuiz Augusto von Dentz 41738fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 41748fc9ced3SGustavo Padovan "e))) { 4175b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4176b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 417757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4178b6a0dc82SMarcel Holtmann 4179b6a0dc82SMarcel Holtmann conn->sent++; 4180b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4181b6a0dc82SMarcel Holtmann conn->sent = 0; 4182b6a0dc82SMarcel Holtmann } 4183b6a0dc82SMarcel Holtmann } 4184b6a0dc82SMarcel Holtmann } 4185b6a0dc82SMarcel Holtmann 41866039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 41876ed58ec5SVille Tervo { 418873d80debSLuiz Augusto von Dentz struct hci_chan *chan; 41896ed58ec5SVille Tervo struct sk_buff *skb; 419002b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 41916ed58ec5SVille Tervo 41926ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 41936ed58ec5SVille Tervo 419452087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 419552087a79SLuiz Augusto von Dentz return; 419652087a79SLuiz Augusto von Dentz 4197d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 41986ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 41996ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4200bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 42016ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4202bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 42036ed58ec5SVille Tervo } 42046ed58ec5SVille Tervo 42056ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 420602b20f0bSLuiz Augusto von Dentz tmp = cnt; 420773d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4208ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4209ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 421073d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 421173d80debSLuiz Augusto von Dentz skb->len, skb->priority); 42126ed58ec5SVille Tervo 4213ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4214ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4215ec1cce24SLuiz Augusto von Dentz break; 4216ec1cce24SLuiz Augusto von Dentz 4217ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4218ec1cce24SLuiz Augusto von Dentz 421957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42206ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 42216ed58ec5SVille Tervo 42226ed58ec5SVille Tervo cnt--; 422373d80debSLuiz Augusto von Dentz chan->sent++; 422473d80debSLuiz Augusto von Dentz chan->conn->sent++; 42256ed58ec5SVille Tervo } 42266ed58ec5SVille Tervo } 422773d80debSLuiz Augusto von Dentz 42286ed58ec5SVille Tervo if (hdev->le_pkts) 42296ed58ec5SVille Tervo hdev->le_cnt = cnt; 42306ed58ec5SVille Tervo else 42316ed58ec5SVille Tervo hdev->acl_cnt = cnt; 423202b20f0bSLuiz Augusto von Dentz 423302b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 423402b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 42356ed58ec5SVille Tervo } 42366ed58ec5SVille Tervo 42373eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 42381da177e4SLinus Torvalds { 42393eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 42401da177e4SLinus Torvalds struct sk_buff *skb; 42411da177e4SLinus Torvalds 42426ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 42436ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 42441da177e4SLinus Torvalds 4245d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 42461da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 42471da177e4SLinus Torvalds hci_sched_acl(hdev); 42481da177e4SLinus Torvalds hci_sched_sco(hdev); 4249b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 42506ed58ec5SVille Tervo hci_sched_le(hdev); 425152de599eSMarcel Holtmann } 42526ed58ec5SVille Tervo 42531da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 42541da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 425557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42561da177e4SLinus Torvalds } 42571da177e4SLinus Torvalds 425825985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 42591da177e4SLinus Torvalds 42601da177e4SLinus Torvalds /* ACL data packet */ 42616039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 42621da177e4SLinus Torvalds { 42631da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 42641da177e4SLinus Torvalds struct hci_conn *conn; 42651da177e4SLinus Torvalds __u16 handle, flags; 42661da177e4SLinus Torvalds 42671da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 42681da177e4SLinus Torvalds 42691da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 42701da177e4SLinus Torvalds flags = hci_flags(handle); 42711da177e4SLinus Torvalds handle = hci_handle(handle); 42721da177e4SLinus Torvalds 4273f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4274a8c5fb1aSGustavo Padovan handle, flags); 42751da177e4SLinus Torvalds 42761da177e4SLinus Torvalds hdev->stat.acl_rx++; 42771da177e4SLinus Torvalds 42781da177e4SLinus Torvalds hci_dev_lock(hdev); 42791da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 42801da177e4SLinus Torvalds hci_dev_unlock(hdev); 42811da177e4SLinus Torvalds 42821da177e4SLinus Torvalds if (conn) { 428365983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 428404837f64SMarcel Holtmann 42851da177e4SLinus Torvalds /* Send to upper protocol */ 4286686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 42871da177e4SLinus Torvalds return; 42881da177e4SLinus Torvalds } else { 42892064ee33SMarcel Holtmann bt_dev_err(hdev, "ACL packet for unknown connection handle %d", 42902064ee33SMarcel Holtmann handle); 42911da177e4SLinus Torvalds } 42921da177e4SLinus Torvalds 42931da177e4SLinus Torvalds kfree_skb(skb); 42941da177e4SLinus Torvalds } 42951da177e4SLinus Torvalds 42961da177e4SLinus Torvalds /* SCO data packet */ 42976039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 42981da177e4SLinus Torvalds { 42991da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 43001da177e4SLinus Torvalds struct hci_conn *conn; 43011da177e4SLinus Torvalds __u16 handle; 43021da177e4SLinus Torvalds 43031da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 43041da177e4SLinus Torvalds 43051da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 43061da177e4SLinus Torvalds 4307f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 43081da177e4SLinus Torvalds 43091da177e4SLinus Torvalds hdev->stat.sco_rx++; 43101da177e4SLinus Torvalds 43111da177e4SLinus Torvalds hci_dev_lock(hdev); 43121da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 43131da177e4SLinus Torvalds hci_dev_unlock(hdev); 43141da177e4SLinus Torvalds 43151da177e4SLinus Torvalds if (conn) { 43161da177e4SLinus Torvalds /* Send to upper protocol */ 4317686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 43181da177e4SLinus Torvalds return; 43191da177e4SLinus Torvalds } else { 43202064ee33SMarcel Holtmann bt_dev_err(hdev, "SCO packet for unknown connection handle %d", 43212064ee33SMarcel Holtmann handle); 43221da177e4SLinus Torvalds } 43231da177e4SLinus Torvalds 43241da177e4SLinus Torvalds kfree_skb(skb); 43251da177e4SLinus Torvalds } 43261da177e4SLinus Torvalds 43279238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 43289238f36aSJohan Hedberg { 43299238f36aSJohan Hedberg struct sk_buff *skb; 43309238f36aSJohan Hedberg 43319238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 43329238f36aSJohan Hedberg if (!skb) 43339238f36aSJohan Hedberg return true; 43349238f36aSJohan Hedberg 433544d27137SJohan Hedberg return (bt_cb(skb)->hci.req_flags & HCI_REQ_START); 43369238f36aSJohan Hedberg } 43379238f36aSJohan Hedberg 433842c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 433942c6b129SJohan Hedberg { 434042c6b129SJohan Hedberg struct hci_command_hdr *sent; 434142c6b129SJohan Hedberg struct sk_buff *skb; 434242c6b129SJohan Hedberg u16 opcode; 434342c6b129SJohan Hedberg 434442c6b129SJohan Hedberg if (!hdev->sent_cmd) 434542c6b129SJohan Hedberg return; 434642c6b129SJohan Hedberg 434742c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 434842c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 434942c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 435042c6b129SJohan Hedberg return; 435142c6b129SJohan Hedberg 435242c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 435342c6b129SJohan Hedberg if (!skb) 435442c6b129SJohan Hedberg return; 435542c6b129SJohan Hedberg 435642c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 435742c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 435842c6b129SJohan Hedberg } 435942c6b129SJohan Hedberg 4360e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4361e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4362e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 43639238f36aSJohan Hedberg { 43649238f36aSJohan Hedberg struct sk_buff *skb; 43659238f36aSJohan Hedberg unsigned long flags; 43669238f36aSJohan Hedberg 43679238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 43689238f36aSJohan Hedberg 436942c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 437042c6b129SJohan Hedberg * sent we need to do special handling of it. 43719238f36aSJohan Hedberg */ 437242c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 437342c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 437442c6b129SJohan Hedberg * reset complete event during init and any pending 437542c6b129SJohan Hedberg * command will never be completed. In such a case we 437642c6b129SJohan Hedberg * need to resend whatever was the last sent 437742c6b129SJohan Hedberg * command. 437842c6b129SJohan Hedberg */ 437942c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 438042c6b129SJohan Hedberg hci_resend_last(hdev); 438142c6b129SJohan Hedberg 43829238f36aSJohan Hedberg return; 438342c6b129SJohan Hedberg } 43849238f36aSJohan Hedberg 4385f80c5dadSJoão Paulo Rechi Vita /* If we reach this point this event matches the last command sent */ 4386f80c5dadSJoão Paulo Rechi Vita hci_dev_clear_flag(hdev, HCI_CMD_PENDING); 4387f80c5dadSJoão Paulo Rechi Vita 43889238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 43899238f36aSJohan Hedberg * this request the request is not yet complete. 43909238f36aSJohan Hedberg */ 43919238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 43929238f36aSJohan Hedberg return; 43939238f36aSJohan Hedberg 43949238f36aSJohan Hedberg /* If this was the last command in a request the complete 43959238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 43969238f36aSJohan Hedberg * command queue (hdev->cmd_q). 43979238f36aSJohan Hedberg */ 439844d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_flags & HCI_REQ_SKB) { 439944d27137SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4400e6214487SJohan Hedberg return; 44019238f36aSJohan Hedberg } 4402e6214487SJohan Hedberg 440344d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 440444d27137SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4405e6214487SJohan Hedberg return; 440653e21fbcSJohan Hedberg } 44079238f36aSJohan Hedberg 44089238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 44099238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44109238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 441144d27137SJohan Hedberg if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) { 44129238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 44139238f36aSJohan Hedberg break; 44149238f36aSJohan Hedberg } 44159238f36aSJohan Hedberg 44163bd7594eSDouglas Anderson if (bt_cb(skb)->hci.req_flags & HCI_REQ_SKB) 4417242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 44183bd7594eSDouglas Anderson else 44193bd7594eSDouglas Anderson *req_complete = bt_cb(skb)->hci.req_complete; 44209238f36aSJohan Hedberg kfree_skb(skb); 44219238f36aSJohan Hedberg } 44229238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44239238f36aSJohan Hedberg } 44249238f36aSJohan Hedberg 4425b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 44261da177e4SLinus Torvalds { 4427b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 44281da177e4SLinus Torvalds struct sk_buff *skb; 44291da177e4SLinus Torvalds 44301da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 44311da177e4SLinus Torvalds 44321da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4433cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4434cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4435cd82e61cSMarcel Holtmann 44361da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 44371da177e4SLinus Torvalds /* Send copy to the sockets */ 4438470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44391da177e4SLinus Torvalds } 44401da177e4SLinus Torvalds 4441d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 44421da177e4SLinus Torvalds kfree_skb(skb); 44431da177e4SLinus Torvalds continue; 44441da177e4SLinus Torvalds } 44451da177e4SLinus Torvalds 44461da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 44471da177e4SLinus Torvalds /* Don't process data packets in this states. */ 4448d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 44491da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44501da177e4SLinus Torvalds case HCI_SCODATA_PKT: 44511da177e4SLinus Torvalds kfree_skb(skb); 44521da177e4SLinus Torvalds continue; 44533ff50b79SStephen Hemminger } 44541da177e4SLinus Torvalds } 44551da177e4SLinus Torvalds 44561da177e4SLinus Torvalds /* Process frame */ 4457d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 44581da177e4SLinus Torvalds case HCI_EVENT_PKT: 4459b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 44601da177e4SLinus Torvalds hci_event_packet(hdev, skb); 44611da177e4SLinus Torvalds break; 44621da177e4SLinus Torvalds 44631da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 44641da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 44651da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 44661da177e4SLinus Torvalds break; 44671da177e4SLinus Torvalds 44681da177e4SLinus Torvalds case HCI_SCODATA_PKT: 44691da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 44701da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 44711da177e4SLinus Torvalds break; 44721da177e4SLinus Torvalds 44731da177e4SLinus Torvalds default: 44741da177e4SLinus Torvalds kfree_skb(skb); 44751da177e4SLinus Torvalds break; 44761da177e4SLinus Torvalds } 44771da177e4SLinus Torvalds } 44781da177e4SLinus Torvalds } 44791da177e4SLinus Torvalds 4480c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 44811da177e4SLinus Torvalds { 4482c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 44831da177e4SLinus Torvalds struct sk_buff *skb; 44841da177e4SLinus Torvalds 44852104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 44862104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 44871da177e4SLinus Torvalds 44881da177e4SLinus Torvalds /* Send queued commands */ 44895a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 44905a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 44915a08ecceSAndrei Emeltchenko if (!skb) 44925a08ecceSAndrei Emeltchenko return; 44935a08ecceSAndrei Emeltchenko 44941da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 44951da177e4SLinus Torvalds 4496a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 449770f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 4498f80c5dadSJoão Paulo Rechi Vita if (hci_req_status_pend(hdev)) 4499f80c5dadSJoão Paulo Rechi Vita hci_dev_set_flag(hdev, HCI_CMD_PENDING); 45001da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 450157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 45027bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 450365cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 45047bdb8a5cSSzymon Janc else 450565cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 450665cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 45071da177e4SLinus Torvalds } else { 45081da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4509c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45101da177e4SLinus Torvalds } 45111da177e4SLinus Torvalds } 45121da177e4SLinus Torvalds } 4513