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> 349952d90eSAbhishek Pandit-Subedi #include <linux/suspend.h> 359952d90eSAbhishek Pandit-Subedi #include <linux/wait.h> 3647219839SMarcel Holtmann #include <asm/unaligned.h> 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 391da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 404bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 41af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 421da177e4SLinus Torvalds 430857dd3bSJohan Hedberg #include "hci_request.h" 4460c5f5fbSMarcel Holtmann #include "hci_debugfs.h" 45970c4e46SJohan Hedberg #include "smp.h" 466d5d2ee6SHeiner Kallweit #include "leds.h" 47145373cbSMiao-chen Chou #include "msft.h" 48970c4e46SJohan Hedberg 49b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 50c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 513eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds /* HCI device list */ 541da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 551da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds /* HCI callback list */ 581da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 59fba7ecf0SJohan Hedberg DEFINE_MUTEX(hci_cb_list_lock); 601da177e4SLinus Torvalds 613df92b31SSasha Levin /* HCI ID Numbering */ 623df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 633df92b31SSasha Levin 64baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 65baf27f6eSMarcel Holtmann 664b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 674b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 684b4148e9SMarcel Holtmann { 694b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 704b4148e9SMarcel Holtmann char buf[3]; 714b4148e9SMarcel Holtmann 72b7cb93e5SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y' : 'N'; 734b4148e9SMarcel Holtmann buf[1] = '\n'; 744b4148e9SMarcel Holtmann buf[2] = '\0'; 754b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 764b4148e9SMarcel Holtmann } 774b4148e9SMarcel Holtmann 784b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 794b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 804b4148e9SMarcel Holtmann { 814b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 824b4148e9SMarcel Holtmann struct sk_buff *skb; 834b4148e9SMarcel Holtmann bool enable; 843bf5e97dSAndy Shevchenko int err; 854b4148e9SMarcel Holtmann 864b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 874b4148e9SMarcel Holtmann return -ENETDOWN; 884b4148e9SMarcel Holtmann 893bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 903bf5e97dSAndy Shevchenko if (err) 913bf5e97dSAndy Shevchenko return err; 924b4148e9SMarcel Holtmann 93b7cb93e5SMarcel Holtmann if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE)) 944b4148e9SMarcel Holtmann return -EALREADY; 954b4148e9SMarcel Holtmann 96b504430cSJohan Hedberg hci_req_sync_lock(hdev); 974b4148e9SMarcel Holtmann if (enable) 984b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 994b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1004b4148e9SMarcel Holtmann else 1014b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 1024b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 103b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1044b4148e9SMarcel Holtmann 1054b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1064b4148e9SMarcel Holtmann return PTR_ERR(skb); 1074b4148e9SMarcel Holtmann 1084b4148e9SMarcel Holtmann kfree_skb(skb); 1094b4148e9SMarcel Holtmann 110b7cb93e5SMarcel Holtmann hci_dev_change_flag(hdev, HCI_DUT_MODE); 1114b4148e9SMarcel Holtmann 1124b4148e9SMarcel Holtmann return count; 1134b4148e9SMarcel Holtmann } 1144b4148e9SMarcel Holtmann 1154b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1164b4148e9SMarcel Holtmann .open = simple_open, 1174b4148e9SMarcel Holtmann .read = dut_mode_read, 1184b4148e9SMarcel Holtmann .write = dut_mode_write, 1194b4148e9SMarcel Holtmann .llseek = default_llseek, 1204b4148e9SMarcel Holtmann }; 1214b4148e9SMarcel Holtmann 1224b4113d6SMarcel Holtmann static ssize_t vendor_diag_read(struct file *file, char __user *user_buf, 1234b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1244b4113d6SMarcel Holtmann { 1254b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1264b4113d6SMarcel Holtmann char buf[3]; 1274b4113d6SMarcel Holtmann 1284b4113d6SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y' : 'N'; 1294b4113d6SMarcel Holtmann buf[1] = '\n'; 1304b4113d6SMarcel Holtmann buf[2] = '\0'; 1314b4113d6SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 1324b4113d6SMarcel Holtmann } 1334b4113d6SMarcel Holtmann 1344b4113d6SMarcel Holtmann static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf, 1354b4113d6SMarcel Holtmann size_t count, loff_t *ppos) 1364b4113d6SMarcel Holtmann { 1374b4113d6SMarcel Holtmann struct hci_dev *hdev = file->private_data; 1384b4113d6SMarcel Holtmann bool enable; 1394b4113d6SMarcel Holtmann int err; 1404b4113d6SMarcel Holtmann 1413bf5e97dSAndy Shevchenko err = kstrtobool_from_user(user_buf, count, &enable); 1423bf5e97dSAndy Shevchenko if (err) 1433bf5e97dSAndy Shevchenko return err; 1444b4113d6SMarcel Holtmann 1457e995b9eSMarcel Holtmann /* When the diagnostic flags are not persistent and the transport 146b56c7b25SMarcel Holtmann * is not active or in user channel operation, then there is no need 147b56c7b25SMarcel Holtmann * for the vendor callback. Instead just store the desired value and 148b56c7b25SMarcel Holtmann * the setting will be programmed when the controller gets powered on. 1497e995b9eSMarcel Holtmann */ 1507e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 151b56c7b25SMarcel Holtmann (!test_bit(HCI_RUNNING, &hdev->flags) || 152b56c7b25SMarcel Holtmann hci_dev_test_flag(hdev, HCI_USER_CHANNEL))) 1537e995b9eSMarcel Holtmann goto done; 1547e995b9eSMarcel Holtmann 155b504430cSJohan Hedberg hci_req_sync_lock(hdev); 1564b4113d6SMarcel Holtmann err = hdev->set_diag(hdev, enable); 157b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1584b4113d6SMarcel Holtmann 1594b4113d6SMarcel Holtmann if (err < 0) 1604b4113d6SMarcel Holtmann return err; 1614b4113d6SMarcel Holtmann 1627e995b9eSMarcel Holtmann done: 1634b4113d6SMarcel Holtmann if (enable) 1644b4113d6SMarcel Holtmann hci_dev_set_flag(hdev, HCI_VENDOR_DIAG); 1654b4113d6SMarcel Holtmann else 1664b4113d6SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG); 1674b4113d6SMarcel Holtmann 1684b4113d6SMarcel Holtmann return count; 1694b4113d6SMarcel Holtmann } 1704b4113d6SMarcel Holtmann 1714b4113d6SMarcel Holtmann static const struct file_operations vendor_diag_fops = { 1724b4113d6SMarcel Holtmann .open = simple_open, 1734b4113d6SMarcel Holtmann .read = vendor_diag_read, 1744b4113d6SMarcel Holtmann .write = vendor_diag_write, 1754b4113d6SMarcel Holtmann .llseek = default_llseek, 1764b4113d6SMarcel Holtmann }; 1774b4113d6SMarcel Holtmann 178f640ee98SMarcel Holtmann static void hci_debugfs_create_basic(struct hci_dev *hdev) 179f640ee98SMarcel Holtmann { 180f640ee98SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 181f640ee98SMarcel Holtmann &dut_mode_fops); 182f640ee98SMarcel Holtmann 183f640ee98SMarcel Holtmann if (hdev->set_diag) 184f640ee98SMarcel Holtmann debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev, 185f640ee98SMarcel Holtmann &vendor_diag_fops); 186f640ee98SMarcel Holtmann } 187f640ee98SMarcel Holtmann 188a1d01db1SJohan Hedberg static int hci_reset_req(struct hci_request *req, unsigned long opt) 1891da177e4SLinus Torvalds { 19042c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds /* Reset device */ 19342c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 19442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 195a1d01db1SJohan Hedberg return 0; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds 19842c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 1991da177e4SLinus Torvalds { 20042c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 2012455a3eaSAndrei Emeltchenko 2021da177e4SLinus Torvalds /* Read Local Supported Features */ 20342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2041da177e4SLinus Torvalds 2051143e5a6SMarcel Holtmann /* Read Local Version */ 20642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2072177bab5SJohan Hedberg 2082177bab5SJohan Hedberg /* Read BD Address */ 20942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds 2120af801b9SJohan Hedberg static void amp_init1(struct hci_request *req) 213e61ef499SAndrei Emeltchenko { 21442c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 2152455a3eaSAndrei Emeltchenko 216e61ef499SAndrei Emeltchenko /* Read Local Version */ 21742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2186bcbc489SAndrei Emeltchenko 219f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 220f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 221f6996cfeSMarcel Holtmann 2226bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 22342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 224e71dfabaSAndrei Emeltchenko 225e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 22642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 2277528ca1cSMarcel Holtmann 228f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 229f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 230f38ba941SMarcel Holtmann 2317528ca1cSMarcel Holtmann /* Read Location Data */ 2327528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 233e61ef499SAndrei Emeltchenko } 234e61ef499SAndrei Emeltchenko 235a1d01db1SJohan Hedberg static int amp_init2(struct hci_request *req) 2360af801b9SJohan Hedberg { 2370af801b9SJohan Hedberg /* Read Local Supported Features. Not all AMP controllers 2380af801b9SJohan Hedberg * support this so it's placed conditionally in the second 2390af801b9SJohan Hedberg * stage init. 2400af801b9SJohan Hedberg */ 2410af801b9SJohan Hedberg if (req->hdev->commands[14] & 0x20) 2420af801b9SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 243a1d01db1SJohan Hedberg 244a1d01db1SJohan Hedberg return 0; 2450af801b9SJohan Hedberg } 2460af801b9SJohan Hedberg 247a1d01db1SJohan Hedberg static int hci_init1_req(struct hci_request *req, unsigned long opt) 248e61ef499SAndrei Emeltchenko { 24942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 250e61ef499SAndrei Emeltchenko 251e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 252e61ef499SAndrei Emeltchenko 25311778716SAndrei Emeltchenko /* Reset */ 25411778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 25542c6b129SJohan Hedberg hci_reset_req(req, 0); 25611778716SAndrei Emeltchenko 257e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 258ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 25942c6b129SJohan Hedberg bredr_init(req); 260e61ef499SAndrei Emeltchenko break; 261e61ef499SAndrei Emeltchenko case HCI_AMP: 2620af801b9SJohan Hedberg amp_init1(req); 263e61ef499SAndrei Emeltchenko break; 264e61ef499SAndrei Emeltchenko default: 2652064ee33SMarcel Holtmann bt_dev_err(hdev, "Unknown device type %d", hdev->dev_type); 266e61ef499SAndrei Emeltchenko break; 267e61ef499SAndrei Emeltchenko } 268a1d01db1SJohan Hedberg 269a1d01db1SJohan Hedberg return 0; 270e61ef499SAndrei Emeltchenko } 271e61ef499SAndrei Emeltchenko 27242c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 2732177bab5SJohan Hedberg { 2742177bab5SJohan Hedberg __le16 param; 2752177bab5SJohan Hedberg __u8 flt_type; 2762177bab5SJohan Hedberg 2772177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 27842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2792177bab5SJohan Hedberg 2802177bab5SJohan Hedberg /* Read Class of Device */ 28142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 2822177bab5SJohan Hedberg 2832177bab5SJohan Hedberg /* Read Local Name */ 28442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2852177bab5SJohan Hedberg 2862177bab5SJohan Hedberg /* Read Voice Setting */ 28742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2882177bab5SJohan Hedberg 289b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 290b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 291b4cb9fb2SMarcel Holtmann 2924b836f39SMarcel Holtmann /* Read Current IAC LAP */ 2934b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 2944b836f39SMarcel Holtmann 2952177bab5SJohan Hedberg /* Clear Event Filters */ 2962177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 29742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 2982177bab5SJohan Hedberg 2992177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 300dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 30142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 3022177bab5SJohan Hedberg } 3032177bab5SJohan Hedberg 30442c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 3052177bab5SJohan Hedberg { 306c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 307c73eee91SJohan Hedberg 3082177bab5SJohan Hedberg /* Read LE Buffer Size */ 30942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 3102177bab5SJohan Hedberg 3112177bab5SJohan Hedberg /* Read LE Local Supported Features */ 31242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 3132177bab5SJohan Hedberg 314747d3f03SMarcel Holtmann /* Read LE Supported States */ 315747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 316747d3f03SMarcel Holtmann 317c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 318c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 319a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_LE_ENABLED); 3202177bab5SJohan Hedberg } 3212177bab5SJohan Hedberg 32242c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 3232177bab5SJohan Hedberg { 32442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 32542c6b129SJohan Hedberg 3262177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 3272177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 3282177bab5SJohan Hedberg * command otherwise. 3292177bab5SJohan Hedberg */ 3302177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 3312177bab5SJohan Hedberg 3322177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 3332177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 3342177bab5SJohan Hedberg */ 3352177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 3362177bab5SJohan Hedberg return; 3372177bab5SJohan Hedberg 3382177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 3392177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 340c7882cbdSMarcel Holtmann } else { 341c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 342c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 343c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 344c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 345c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 3465c3d3b4cSMarcel Holtmann 3475c3d3b4cSMarcel Holtmann /* If the controller supports the Disconnect command, enable 3485c3d3b4cSMarcel Holtmann * the corresponding event. In addition enable packet flow 3495c3d3b4cSMarcel Holtmann * control related events. 3505c3d3b4cSMarcel Holtmann */ 3515c3d3b4cSMarcel Holtmann if (hdev->commands[0] & 0x20) { 3525c3d3b4cSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 353c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 354c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 3555c3d3b4cSMarcel Holtmann } 3565c3d3b4cSMarcel Holtmann 3575c3d3b4cSMarcel Holtmann /* If the controller supports the Read Remote Version 3585c3d3b4cSMarcel Holtmann * Information command, enable the corresponding event. 3595c3d3b4cSMarcel Holtmann */ 3605c3d3b4cSMarcel Holtmann if (hdev->commands[2] & 0x80) 3615c3d3b4cSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information 3625c3d3b4cSMarcel Holtmann * Complete 3635c3d3b4cSMarcel Holtmann */ 3640da71f1bSMarcel Holtmann 3650da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 3660da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 367c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3682177bab5SJohan Hedberg } 3690da71f1bSMarcel Holtmann } 3702177bab5SJohan Hedberg 3719fe759ceSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 3729fe759ceSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) 3732177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 3742177bab5SJohan Hedberg 37570f56aa2SMarcel Holtmann if (lmp_ext_feat_capable(hdev)) 37670f56aa2SMarcel Holtmann events[4] |= 0x04; /* Read Remote Extended Features Complete */ 37770f56aa2SMarcel Holtmann 37870f56aa2SMarcel Holtmann if (lmp_esco_capable(hdev)) { 37970f56aa2SMarcel Holtmann events[5] |= 0x08; /* Synchronous Connection Complete */ 38070f56aa2SMarcel Holtmann events[5] |= 0x10; /* Synchronous Connection Changed */ 38170f56aa2SMarcel Holtmann } 38270f56aa2SMarcel Holtmann 3832177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 3842177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 3852177bab5SJohan Hedberg 3862177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 3872177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3882177bab5SJohan Hedberg 3892177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 3902177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 3912177bab5SJohan Hedberg 3922177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 3932177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 3942177bab5SJohan Hedberg 3952177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 3962177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 3972177bab5SJohan Hedberg 3982177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 3992177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 4002177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 4012177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 4022177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 4032177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 4042177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 4052177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 4062177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 4072177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 4082177bab5SJohan Hedberg * Features Notification 4092177bab5SJohan Hedberg */ 4102177bab5SJohan Hedberg } 4112177bab5SJohan Hedberg 4122177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 4132177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 4142177bab5SJohan Hedberg 41542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 4162177bab5SJohan Hedberg } 4172177bab5SJohan Hedberg 418a1d01db1SJohan Hedberg static int hci_init2_req(struct hci_request *req, unsigned long opt) 4192177bab5SJohan Hedberg { 42042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 42142c6b129SJohan Hedberg 4220af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 4230af801b9SJohan Hedberg return amp_init2(req); 4240af801b9SJohan Hedberg 4252177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 42642c6b129SJohan Hedberg bredr_setup(req); 42756f87901SJohan Hedberg else 428a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 4292177bab5SJohan Hedberg 4302177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 43142c6b129SJohan Hedberg le_setup(req); 4322177bab5SJohan Hedberg 4330f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 4340f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 4350f3adeaeSMarcel Holtmann * 4360f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 4370f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 4380f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 4390f3adeaeSMarcel Holtmann * supported commands. 4403f8e2d75SJohan Hedberg */ 4410f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 4420f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 44342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 4442177bab5SJohan Hedberg 4452177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 44657af75a8SMarcel Holtmann /* When SSP is available, then the host features page 44757af75a8SMarcel Holtmann * should also be available as well. However some 44857af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 44957af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 45057af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 45157af75a8SMarcel Holtmann */ 45257af75a8SMarcel Holtmann hdev->max_page = 0x01; 45357af75a8SMarcel Holtmann 454d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 4552177bab5SJohan Hedberg u8 mode = 0x01; 456574ea3c7SMarcel Holtmann 45742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 4582177bab5SJohan Hedberg sizeof(mode), &mode); 4592177bab5SJohan Hedberg } else { 4602177bab5SJohan Hedberg struct hci_cp_write_eir cp; 4612177bab5SJohan Hedberg 4622177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 4632177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 4642177bab5SJohan Hedberg 46542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 4662177bab5SJohan Hedberg } 4672177bab5SJohan Hedberg } 4682177bab5SJohan Hedberg 469043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 470043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 47104422da9SMarcel Holtmann u8 mode; 47204422da9SMarcel Holtmann 47304422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 47404422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 47504422da9SMarcel Holtmann * events. 47604422da9SMarcel Holtmann */ 47704422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 47804422da9SMarcel Holtmann 47904422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 48004422da9SMarcel Holtmann } 4812177bab5SJohan Hedberg 4822177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 48342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 4842177bab5SJohan Hedberg 4852177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 4862177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 4872177bab5SJohan Hedberg 4882177bab5SJohan Hedberg cp.page = 0x01; 48942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 49042c6b129SJohan Hedberg sizeof(cp), &cp); 4912177bab5SJohan Hedberg } 4922177bab5SJohan Hedberg 493d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 4942177bab5SJohan Hedberg u8 enable = 1; 49542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 4962177bab5SJohan Hedberg &enable); 4972177bab5SJohan Hedberg } 498a1d01db1SJohan Hedberg 499a1d01db1SJohan Hedberg return 0; 5002177bab5SJohan Hedberg } 5012177bab5SJohan Hedberg 50242c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 5032177bab5SJohan Hedberg { 50442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5052177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 5062177bab5SJohan Hedberg u16 link_policy = 0; 5072177bab5SJohan Hedberg 5082177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 5092177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 5102177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 5112177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 5122177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 5132177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 5142177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 5152177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 5162177bab5SJohan Hedberg 5172177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 51842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 5192177bab5SJohan Hedberg } 5202177bab5SJohan Hedberg 52142c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 5222177bab5SJohan Hedberg { 52342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5242177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 5252177bab5SJohan Hedberg 526c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 527c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 528c73eee91SJohan Hedberg return; 529c73eee91SJohan Hedberg 5302177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 5312177bab5SJohan Hedberg 532d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 5332177bab5SJohan Hedberg cp.le = 0x01; 53432226e4fSMarcel Holtmann cp.simul = 0x00; 5352177bab5SJohan Hedberg } 5362177bab5SJohan Hedberg 5372177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 53842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 5392177bab5SJohan Hedberg &cp); 5402177bab5SJohan Hedberg } 5412177bab5SJohan Hedberg 542d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 543d62e6d67SJohan Hedberg { 544d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 545d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 546313f6888SMarcel Holtmann bool changed = false; 547d62e6d67SJohan Hedberg 548d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 549d62e6d67SJohan Hedberg * enable all necessary events for it. 550d62e6d67SJohan Hedberg */ 55153b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 552d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 553d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 554d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 555d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 556313f6888SMarcel Holtmann changed = true; 557d62e6d67SJohan Hedberg } 558d62e6d67SJohan Hedberg 559d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 560d62e6d67SJohan Hedberg * enable all necessary events for it. 561d62e6d67SJohan Hedberg */ 56253b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 563d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 564d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 565d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 566d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 567313f6888SMarcel Holtmann changed = true; 568d62e6d67SJohan Hedberg } 569d62e6d67SJohan Hedberg 57040c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 571313f6888SMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) { 57240c59fcbSMarcel Holtmann events[2] |= 0x80; 573313f6888SMarcel Holtmann changed = true; 574313f6888SMarcel Holtmann } 57540c59fcbSMarcel Holtmann 576313f6888SMarcel Holtmann /* Some Broadcom based controllers indicate support for Set Event 577313f6888SMarcel Holtmann * Mask Page 2 command, but then actually do not support it. Since 578313f6888SMarcel Holtmann * the default value is all bits set to zero, the command is only 579313f6888SMarcel Holtmann * required if the event mask has to be changed. In case no change 580313f6888SMarcel Holtmann * to the event mask is needed, skip this command. 581313f6888SMarcel Holtmann */ 582313f6888SMarcel Holtmann if (changed) 583313f6888SMarcel Holtmann hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, 584313f6888SMarcel Holtmann sizeof(events), events); 585d62e6d67SJohan Hedberg } 586d62e6d67SJohan Hedberg 587a1d01db1SJohan Hedberg static int hci_init3_req(struct hci_request *req, unsigned long opt) 5882177bab5SJohan Hedberg { 58942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 590d2c5d77fSJohan Hedberg u8 p; 59142c6b129SJohan Hedberg 5920da71f1bSMarcel Holtmann hci_setup_event_mask(req); 5930da71f1bSMarcel Holtmann 594e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 595e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 59648ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 59748ce62c4SMarcel Holtmann 59848ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 59948ce62c4SMarcel Holtmann cp.read_all = 0x01; 60048ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 60148ce62c4SMarcel Holtmann } 60248ce62c4SMarcel Holtmann 6032177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 60442c6b129SJohan Hedberg hci_setup_link_policy(req); 6052177bab5SJohan Hedberg 606417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 607417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 608417287deSMarcel Holtmann 6098a595619SAlain Michaud if (hdev->commands[18] & 0x04) 61000bce3fbSAlain Michaud hci_req_add(req, HCI_OP_READ_DEF_ERR_DATA_REPORTING, 0, NULL); 61100bce3fbSAlain Michaud 612417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 613417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 614417287deSMarcel Holtmann * this command in the bit mask of supported commands. 615417287deSMarcel Holtmann */ 616417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 617417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 618417287deSMarcel Holtmann 6199193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 6209193c6e8SAndre Guedes u8 events[8]; 6219193c6e8SAndre Guedes 6229193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 6234d6c705bSMarcel Holtmann 6244d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 6254d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 626662bc2e6SAndre Guedes 627662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 628662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 629662bc2e6SAndre Guedes */ 630662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 631662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 632662bc2e6SAndre Guedes * Parameter Request 633662bc2e6SAndre Guedes */ 634662bc2e6SAndre Guedes 635a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 636a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 637a9f6068eSMarcel Holtmann */ 638a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 639a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 640a9f6068eSMarcel Holtmann 641ff3b8df2SMarcel Holtmann /* If the controller supports LL Privacy feature, enable 642ff3b8df2SMarcel Holtmann * the corresponding event. 643ff3b8df2SMarcel Holtmann */ 644ff3b8df2SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_LL_PRIVACY) 645ff3b8df2SMarcel Holtmann events[1] |= 0x02; /* LE Enhanced Connection 646ff3b8df2SMarcel Holtmann * Complete 647ff3b8df2SMarcel Holtmann */ 648ff3b8df2SMarcel Holtmann 6494b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 6504b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 6514b71bba4SMarcel Holtmann */ 6524b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 6534b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 6544b71bba4SMarcel Holtmann * Report 6554b71bba4SMarcel Holtmann */ 6564b71bba4SMarcel Holtmann 6579756d33bSMarcel Holtmann /* If the controller supports Channel Selection Algorithm #2 6589756d33bSMarcel Holtmann * feature, enable the corresponding event. 6599756d33bSMarcel Holtmann */ 6609756d33bSMarcel Holtmann if (hdev->le_features[1] & HCI_LE_CHAN_SEL_ALG2) 6619756d33bSMarcel Holtmann events[2] |= 0x08; /* LE Channel Selection 6629756d33bSMarcel Holtmann * Algorithm 6639756d33bSMarcel Holtmann */ 6649756d33bSMarcel Holtmann 6657d26f5c4SMarcel Holtmann /* If the controller supports the LE Set Scan Enable command, 6667d26f5c4SMarcel Holtmann * enable the corresponding advertising report event. 6677d26f5c4SMarcel Holtmann */ 6687d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x08) 6697d26f5c4SMarcel Holtmann events[0] |= 0x02; /* LE Advertising Report */ 6707d26f5c4SMarcel Holtmann 6717d26f5c4SMarcel Holtmann /* If the controller supports the LE Create Connection 6727d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6737d26f5c4SMarcel Holtmann */ 6747d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x10) 6757d26f5c4SMarcel Holtmann events[0] |= 0x01; /* LE Connection Complete */ 6767d26f5c4SMarcel Holtmann 6777d26f5c4SMarcel Holtmann /* If the controller supports the LE Connection Update 6787d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6797d26f5c4SMarcel Holtmann */ 6807d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x04) 6817d26f5c4SMarcel Holtmann events[0] |= 0x04; /* LE Connection Update 6827d26f5c4SMarcel Holtmann * Complete 6837d26f5c4SMarcel Holtmann */ 6847d26f5c4SMarcel Holtmann 6857d26f5c4SMarcel Holtmann /* If the controller supports the LE Read Remote Used Features 6867d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6877d26f5c4SMarcel Holtmann */ 6887d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x20) 6897d26f5c4SMarcel Holtmann events[0] |= 0x08; /* LE Read Remote Used 6907d26f5c4SMarcel Holtmann * Features Complete 6917d26f5c4SMarcel Holtmann */ 6927d26f5c4SMarcel Holtmann 6935a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 6945a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 6955a34bd5fSMarcel Holtmann */ 6965a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 6975a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 6985a34bd5fSMarcel Holtmann * Public Key Complete 6995a34bd5fSMarcel Holtmann */ 7005a34bd5fSMarcel Holtmann 7015a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 7025a34bd5fSMarcel Holtmann * command, enable the corresponding event. 7035a34bd5fSMarcel Holtmann */ 7045a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 7055a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 7065a34bd5fSMarcel Holtmann 70727bbca44SMarcel Holtmann /* If the controller supports the LE Set Default PHY or 70827bbca44SMarcel Holtmann * LE Set PHY commands, enable the corresponding event. 70927bbca44SMarcel Holtmann */ 71027bbca44SMarcel Holtmann if (hdev->commands[35] & (0x20 | 0x40)) 71127bbca44SMarcel Holtmann events[1] |= 0x08; /* LE PHY Update Complete */ 71227bbca44SMarcel Holtmann 713c215e939SJaganath Kanakkassery /* If the controller supports LE Set Extended Scan Parameters 714c215e939SJaganath Kanakkassery * and LE Set Extended Scan Enable commands, enable the 715c215e939SJaganath Kanakkassery * corresponding event. 716c215e939SJaganath Kanakkassery */ 717c215e939SJaganath Kanakkassery if (use_ext_scan(hdev)) 718c215e939SJaganath Kanakkassery events[1] |= 0x10; /* LE Extended Advertising 719c215e939SJaganath Kanakkassery * Report 720c215e939SJaganath Kanakkassery */ 721c215e939SJaganath Kanakkassery 722acf0aeaeSJaganath Kanakkassery /* If the controller supports the LE Extended Advertising 723acf0aeaeSJaganath Kanakkassery * command, enable the corresponding event. 724acf0aeaeSJaganath Kanakkassery */ 725acf0aeaeSJaganath Kanakkassery if (ext_adv_capable(hdev)) 726acf0aeaeSJaganath Kanakkassery events[2] |= 0x02; /* LE Advertising Set 727acf0aeaeSJaganath Kanakkassery * Terminated 728acf0aeaeSJaganath Kanakkassery */ 729acf0aeaeSJaganath Kanakkassery 7309193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 7319193c6e8SAndre Guedes events); 7329193c6e8SAndre Guedes 73315a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 7346b49bcb4SJaganath Kanakkassery if ((hdev->commands[25] & 0x40) && !ext_adv_capable(hdev)) { 7356b49bcb4SJaganath Kanakkassery /* HCI TS spec forbids mixing of legacy and extended 7366b49bcb4SJaganath Kanakkassery * advertising commands wherein READ_ADV_TX_POWER is 7376b49bcb4SJaganath Kanakkassery * also included. So do not call it if extended adv 7386b49bcb4SJaganath Kanakkassery * is supported otherwise controller will return 7396b49bcb4SJaganath Kanakkassery * COMMAND_DISALLOWED for extended commands. 7406b49bcb4SJaganath Kanakkassery */ 74115a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 74215a49ccaSMarcel Holtmann } 74315a49ccaSMarcel Holtmann 7442ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 7452ab216a7SMarcel Holtmann /* Read LE White List Size */ 7462ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 7472ab216a7SMarcel Holtmann 0, NULL); 7482ab216a7SMarcel Holtmann } 7492ab216a7SMarcel Holtmann 7502ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 7512ab216a7SMarcel Holtmann /* Clear LE White List */ 7522ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 7532ab216a7SMarcel Holtmann } 7542ab216a7SMarcel Holtmann 755cfdb0c2dSAnkit Navik if (hdev->commands[34] & 0x40) { 756cfdb0c2dSAnkit Navik /* Read LE Resolving List Size */ 757cfdb0c2dSAnkit Navik hci_req_add(req, HCI_OP_LE_READ_RESOLV_LIST_SIZE, 758cfdb0c2dSAnkit Navik 0, NULL); 759cfdb0c2dSAnkit Navik } 760cfdb0c2dSAnkit Navik 761545f2596SAnkit Navik if (hdev->commands[34] & 0x20) { 762545f2596SAnkit Navik /* Clear LE Resolving List */ 763545f2596SAnkit Navik hci_req_add(req, HCI_OP_LE_CLEAR_RESOLV_LIST, 0, NULL); 764545f2596SAnkit Navik } 765545f2596SAnkit Navik 766a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 767a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 768a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 769a9f6068eSMarcel Holtmann 770a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 771a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 772a9f6068eSMarcel Holtmann } 773a9f6068eSMarcel Holtmann 7746b49bcb4SJaganath Kanakkassery if (ext_adv_capable(hdev)) { 7756b49bcb4SJaganath Kanakkassery /* Read LE Number of Supported Advertising Sets */ 7766b49bcb4SJaganath Kanakkassery hci_req_add(req, HCI_OP_LE_READ_NUM_SUPPORTED_ADV_SETS, 7776b49bcb4SJaganath Kanakkassery 0, NULL); 7786b49bcb4SJaganath Kanakkassery } 7796b49bcb4SJaganath Kanakkassery 78042c6b129SJohan Hedberg hci_set_le_support(req); 7819193c6e8SAndre Guedes } 782d2c5d77fSJohan Hedberg 783d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 784d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 785d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 786d2c5d77fSJohan Hedberg 787d2c5d77fSJohan Hedberg cp.page = p; 788d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 789d2c5d77fSJohan Hedberg sizeof(cp), &cp); 790d2c5d77fSJohan Hedberg } 791a1d01db1SJohan Hedberg 792a1d01db1SJohan Hedberg return 0; 7932177bab5SJohan Hedberg } 7942177bab5SJohan Hedberg 795a1d01db1SJohan Hedberg static int hci_init4_req(struct hci_request *req, unsigned long opt) 7965d4e7e8dSJohan Hedberg { 7975d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 7985d4e7e8dSJohan Hedberg 79936f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 80036f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 80136f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 80236f260ceSMarcel Holtmann * 80336f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 80436f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 80536f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 80636f260ceSMarcel Holtmann * command redundant anyway. 80736f260ceSMarcel Holtmann * 80836f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 80936f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 81036f260ceSMarcel Holtmann * just disable this command. 81136f260ceSMarcel Holtmann */ 81236f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 81336f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 81436f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 81536f260ceSMarcel Holtmann 81636f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 81736f260ceSMarcel Holtmann cp.delete_all = 0x01; 81836f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 81936f260ceSMarcel Holtmann sizeof(cp), &cp); 82036f260ceSMarcel Holtmann } 82136f260ceSMarcel Holtmann 822d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 823d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 824d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 825d62e6d67SJohan Hedberg 826109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 827109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 828109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 829109e3191SMarcel Holtmann 830a4790360SMarcel Holtmann /* Read local pairing options if the HCI command is supported */ 831a4790360SMarcel Holtmann if (hdev->commands[41] & 0x08) 832a4790360SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_PAIRING_OPTS, 0, NULL); 833a4790360SMarcel Holtmann 834f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 835f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 836f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 837f4fe73edSMarcel Holtmann 8385d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 83953b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 8405d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 841a6d0d690SMarcel Holtmann 842a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 843d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 844574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 845a6d0d690SMarcel Holtmann u8 support = 0x01; 846574ea3c7SMarcel Holtmann 847a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 848a6d0d690SMarcel Holtmann sizeof(support), &support); 849a6d0d690SMarcel Holtmann } 850a1d01db1SJohan Hedberg 85100bce3fbSAlain Michaud /* Set erroneous data reporting if supported to the wideband speech 85200bce3fbSAlain Michaud * setting value 85300bce3fbSAlain Michaud */ 8548a595619SAlain Michaud if (hdev->commands[18] & 0x08) { 85500bce3fbSAlain Michaud bool enabled = hci_dev_test_flag(hdev, 85600bce3fbSAlain Michaud HCI_WIDEBAND_SPEECH_ENABLED); 85700bce3fbSAlain Michaud 85800bce3fbSAlain Michaud if (enabled != 85900bce3fbSAlain Michaud (hdev->err_data_reporting == ERR_DATA_REPORTING_ENABLED)) { 86000bce3fbSAlain Michaud struct hci_cp_write_def_err_data_reporting cp; 86100bce3fbSAlain Michaud 86200bce3fbSAlain Michaud cp.err_data_reporting = enabled ? 86300bce3fbSAlain Michaud ERR_DATA_REPORTING_ENABLED : 86400bce3fbSAlain Michaud ERR_DATA_REPORTING_DISABLED; 86500bce3fbSAlain Michaud 86600bce3fbSAlain Michaud hci_req_add(req, HCI_OP_WRITE_DEF_ERR_DATA_REPORTING, 86700bce3fbSAlain Michaud sizeof(cp), &cp); 86800bce3fbSAlain Michaud } 86900bce3fbSAlain Michaud } 87000bce3fbSAlain Michaud 87112204875SMarcel Holtmann /* Set Suggested Default Data Length to maximum if supported */ 87212204875SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 87312204875SMarcel Holtmann struct hci_cp_le_write_def_data_len cp; 87412204875SMarcel Holtmann 875727ea61aSBen Dooks (Codethink) cp.tx_len = cpu_to_le16(hdev->le_max_tx_len); 876727ea61aSBen Dooks (Codethink) cp.tx_time = cpu_to_le16(hdev->le_max_tx_time); 87712204875SMarcel Holtmann hci_req_add(req, HCI_OP_LE_WRITE_DEF_DATA_LEN, sizeof(cp), &cp); 87812204875SMarcel Holtmann } 87912204875SMarcel Holtmann 880de2ba303SMarcel Holtmann /* Set Default PHY parameters if command is supported */ 881de2ba303SMarcel Holtmann if (hdev->commands[35] & 0x20) { 882de2ba303SMarcel Holtmann struct hci_cp_le_set_default_phy cp; 883de2ba303SMarcel Holtmann 8846decb5b4SJaganath Kanakkassery cp.all_phys = 0x00; 8856decb5b4SJaganath Kanakkassery cp.tx_phys = hdev->le_tx_def_phys; 8866decb5b4SJaganath Kanakkassery cp.rx_phys = hdev->le_rx_def_phys; 887de2ba303SMarcel Holtmann 888de2ba303SMarcel Holtmann hci_req_add(req, HCI_OP_LE_SET_DEFAULT_PHY, sizeof(cp), &cp); 889de2ba303SMarcel Holtmann } 890de2ba303SMarcel Holtmann 891a1d01db1SJohan Hedberg return 0; 8925d4e7e8dSJohan Hedberg } 8935d4e7e8dSJohan Hedberg 8942177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8952177bab5SJohan Hedberg { 8962177bab5SJohan Hedberg int err; 8972177bab5SJohan Hedberg 8984ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT, NULL); 8992177bab5SJohan Hedberg if (err < 0) 9002177bab5SJohan Hedberg return err; 9012177bab5SJohan Hedberg 902f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 903f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 9044b4148e9SMarcel Holtmann 9054ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT, NULL); 9062177bab5SJohan Hedberg if (err < 0) 9072177bab5SJohan Hedberg return err; 9082177bab5SJohan Hedberg 909ca8bee5dSMarcel Holtmann /* HCI_PRIMARY covers both single-mode LE, BR/EDR and dual-mode 9100af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 9110af801b9SJohan Hedberg * first two stages of init. 9120af801b9SJohan Hedberg */ 913ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) 9140af801b9SJohan Hedberg return 0; 9150af801b9SJohan Hedberg 9164ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT, NULL); 9175d4e7e8dSJohan Hedberg if (err < 0) 9185d4e7e8dSJohan Hedberg return err; 9195d4e7e8dSJohan Hedberg 9204ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT, NULL); 921baf27f6eSMarcel Holtmann if (err < 0) 922baf27f6eSMarcel Holtmann return err; 923baf27f6eSMarcel Holtmann 924ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 925ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 926ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 927ec6cef9cSMarcel Holtmann * 928ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 929ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 930ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 931ec6cef9cSMarcel Holtmann * be called during the config phase. 932ec6cef9cSMarcel Holtmann * 933ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 934ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 935baf27f6eSMarcel Holtmann */ 936d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 937d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 938baf27f6eSMarcel Holtmann return 0; 939baf27f6eSMarcel Holtmann 94060c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 94160c5f5fbSMarcel Holtmann 94271c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 94360c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9442bfa3531SMarcel Holtmann 945162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 94660c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 947e7b8fc92SMarcel Holtmann 948baf27f6eSMarcel Holtmann return 0; 9492177bab5SJohan Hedberg } 9502177bab5SJohan Hedberg 951a1d01db1SJohan Hedberg static int hci_init0_req(struct hci_request *req, unsigned long opt) 9520ebca7d6SMarcel Holtmann { 9530ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9540ebca7d6SMarcel Holtmann 9550ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9560ebca7d6SMarcel Holtmann 9570ebca7d6SMarcel Holtmann /* Reset */ 9580ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9590ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9600ebca7d6SMarcel Holtmann 9610ebca7d6SMarcel Holtmann /* Read Local Version */ 9620ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9630ebca7d6SMarcel Holtmann 9640ebca7d6SMarcel Holtmann /* Read BD Address */ 9650ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9660ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 967a1d01db1SJohan Hedberg 968a1d01db1SJohan Hedberg return 0; 9690ebca7d6SMarcel Holtmann } 9700ebca7d6SMarcel Holtmann 9710ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9720ebca7d6SMarcel Holtmann { 9730ebca7d6SMarcel Holtmann int err; 9740ebca7d6SMarcel Holtmann 975cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 976cc78b44bSMarcel Holtmann return 0; 977cc78b44bSMarcel Holtmann 9784ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT, NULL); 9790ebca7d6SMarcel Holtmann if (err < 0) 9800ebca7d6SMarcel Holtmann return err; 9810ebca7d6SMarcel Holtmann 982f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 983f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 984f640ee98SMarcel Holtmann 9850ebca7d6SMarcel Holtmann return 0; 9860ebca7d6SMarcel Holtmann } 9870ebca7d6SMarcel Holtmann 988a1d01db1SJohan Hedberg static int hci_scan_req(struct hci_request *req, unsigned long opt) 9891da177e4SLinus Torvalds { 9901da177e4SLinus Torvalds __u8 scan = opt; 9911da177e4SLinus Torvalds 99242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9931da177e4SLinus Torvalds 9941da177e4SLinus Torvalds /* Inquiry and Page scans */ 99542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 996a1d01db1SJohan Hedberg return 0; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 999a1d01db1SJohan Hedberg static int hci_auth_req(struct hci_request *req, unsigned long opt) 10001da177e4SLinus Torvalds { 10011da177e4SLinus Torvalds __u8 auth = opt; 10021da177e4SLinus Torvalds 100342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds /* Authentication */ 100642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 1007a1d01db1SJohan Hedberg return 0; 10081da177e4SLinus Torvalds } 10091da177e4SLinus Torvalds 1010a1d01db1SJohan Hedberg static int hci_encrypt_req(struct hci_request *req, unsigned long opt) 10111da177e4SLinus Torvalds { 10121da177e4SLinus Torvalds __u8 encrypt = opt; 10131da177e4SLinus Torvalds 101442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 10151da177e4SLinus Torvalds 1016e4e8e37cSMarcel Holtmann /* Encryption */ 101742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 1018a1d01db1SJohan Hedberg return 0; 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds 1021a1d01db1SJohan Hedberg static int hci_linkpol_req(struct hci_request *req, unsigned long opt) 1022e4e8e37cSMarcel Holtmann { 1023e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1024e4e8e37cSMarcel Holtmann 102542c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1026e4e8e37cSMarcel Holtmann 1027e4e8e37cSMarcel Holtmann /* Default link policy */ 102842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1029a1d01db1SJohan Hedberg return 0; 1030e4e8e37cSMarcel Holtmann } 1031e4e8e37cSMarcel Holtmann 10321da177e4SLinus Torvalds /* Get HCI device by index. 10331da177e4SLinus Torvalds * Device is held on return. */ 10341da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10351da177e4SLinus Torvalds { 10368035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds BT_DBG("%d", index); 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds if (index < 0) 10411da177e4SLinus Torvalds return NULL; 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10448035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10451da177e4SLinus Torvalds if (d->id == index) { 10461da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10471da177e4SLinus Torvalds break; 10481da177e4SLinus Torvalds } 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10511da177e4SLinus Torvalds return hdev; 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1055ff9ef578SJohan Hedberg 105630dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 105730dc78e1SJohan Hedberg { 105830dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 105930dc78e1SJohan Hedberg 10606fbe195dSAndre Guedes switch (discov->state) { 1061343f935bSAndre Guedes case DISCOVERY_FINDING: 10626fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 106330dc78e1SJohan Hedberg return true; 106430dc78e1SJohan Hedberg 10656fbe195dSAndre Guedes default: 106630dc78e1SJohan Hedberg return false; 106730dc78e1SJohan Hedberg } 10686fbe195dSAndre Guedes } 106930dc78e1SJohan Hedberg 1070ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1071ff9ef578SJohan Hedberg { 1072bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1073bb3e0a33SJohan Hedberg 1074ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1075ff9ef578SJohan Hedberg 1076bb3e0a33SJohan Hedberg if (old_state == state) 1077ff9ef578SJohan Hedberg return; 1078ff9ef578SJohan Hedberg 1079bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1080bb3e0a33SJohan Hedberg 1081ff9ef578SJohan Hedberg switch (state) { 1082ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1083c54c3860SAndre Guedes hci_update_background_scan(hdev); 1084c54c3860SAndre Guedes 1085bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1086ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1087ff9ef578SJohan Hedberg break; 1088ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1089ff9ef578SJohan Hedberg break; 1090343f935bSAndre Guedes case DISCOVERY_FINDING: 1091ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1092ff9ef578SJohan Hedberg break; 109330dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 109430dc78e1SJohan Hedberg break; 1095ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1096ff9ef578SJohan Hedberg break; 1097ff9ef578SJohan Hedberg } 1098ff9ef578SJohan Hedberg } 1099ff9ef578SJohan Hedberg 11001f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 11011da177e4SLinus Torvalds { 110230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1103b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 11041da177e4SLinus Torvalds 1105561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1106561aafbcSJohan Hedberg list_del(&p->all); 1107b57c1a56SJohan Hedberg kfree(p); 11081da177e4SLinus Torvalds } 1109561aafbcSJohan Hedberg 1110561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1111561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 11121da177e4SLinus Torvalds } 11131da177e4SLinus Torvalds 1114a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1115a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 11161da177e4SLinus Torvalds { 111730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11181da177e4SLinus Torvalds struct inquiry_entry *e; 11191da177e4SLinus Torvalds 11206ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 11211da177e4SLinus Torvalds 1122561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11231da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 11241da177e4SLinus Torvalds return e; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 1127b57c1a56SJohan Hedberg return NULL; 1128b57c1a56SJohan Hedberg } 1129b57c1a56SJohan Hedberg 1130561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1131561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1132561aafbcSJohan Hedberg { 113330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1134561aafbcSJohan Hedberg struct inquiry_entry *e; 1135561aafbcSJohan Hedberg 11366ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1137561aafbcSJohan Hedberg 1138561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1139561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1140561aafbcSJohan Hedberg return e; 1141561aafbcSJohan Hedberg } 1142561aafbcSJohan Hedberg 1143561aafbcSJohan Hedberg return NULL; 1144561aafbcSJohan Hedberg } 1145561aafbcSJohan Hedberg 114630dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 114730dc78e1SJohan Hedberg bdaddr_t *bdaddr, 114830dc78e1SJohan Hedberg int state) 114930dc78e1SJohan Hedberg { 115030dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 115130dc78e1SJohan Hedberg struct inquiry_entry *e; 115230dc78e1SJohan Hedberg 11536ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 115430dc78e1SJohan Hedberg 115530dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 115630dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 115730dc78e1SJohan Hedberg return e; 115830dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 115930dc78e1SJohan Hedberg return e; 116030dc78e1SJohan Hedberg } 116130dc78e1SJohan Hedberg 116230dc78e1SJohan Hedberg return NULL; 116330dc78e1SJohan Hedberg } 116430dc78e1SJohan Hedberg 1165a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1166a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1167a3d4e20aSJohan Hedberg { 1168a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1169a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1170a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1171a3d4e20aSJohan Hedberg 1172a3d4e20aSJohan Hedberg list_del(&ie->list); 1173a3d4e20aSJohan Hedberg 1174a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1175a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1176a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1177a3d4e20aSJohan Hedberg break; 1178a3d4e20aSJohan Hedberg pos = &p->list; 1179a3d4e20aSJohan Hedberg } 1180a3d4e20aSJohan Hedberg 1181a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1182a3d4e20aSJohan Hedberg } 1183a3d4e20aSJohan Hedberg 1184af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1185af58925cSMarcel Holtmann bool name_known) 11861da177e4SLinus Torvalds { 118730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 118870f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1189af58925cSMarcel Holtmann u32 flags = 0; 11901da177e4SLinus Torvalds 11916ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11921da177e4SLinus Torvalds 11936928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11942b2fec4dSSzymon Janc 1195af58925cSMarcel Holtmann if (!data->ssp_mode) 1196af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1197388fc8faSJohan Hedberg 119870f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1199a3d4e20aSJohan Hedberg if (ie) { 1200af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1201af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1202388fc8faSJohan Hedberg 1203a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1204a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1205a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1206a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1207a3d4e20aSJohan Hedberg } 1208a3d4e20aSJohan Hedberg 1209561aafbcSJohan Hedberg goto update; 1210a3d4e20aSJohan Hedberg } 1211561aafbcSJohan Hedberg 12121da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 121327f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1214af58925cSMarcel Holtmann if (!ie) { 1215af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1216af58925cSMarcel Holtmann goto done; 1217af58925cSMarcel Holtmann } 121870f23020SAndrei Emeltchenko 1219561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1220561aafbcSJohan Hedberg 1221561aafbcSJohan Hedberg if (name_known) { 1222561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1223561aafbcSJohan Hedberg } else { 1224561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1225561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1226561aafbcSJohan Hedberg } 1227561aafbcSJohan Hedberg 1228561aafbcSJohan Hedberg update: 1229561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1230561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1231561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1232561aafbcSJohan Hedberg list_del(&ie->list); 12331da177e4SLinus Torvalds } 12341da177e4SLinus Torvalds 123570f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 123670f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12371da177e4SLinus Torvalds cache->timestamp = jiffies; 12383175405bSJohan Hedberg 12393175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1240af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12413175405bSJohan Hedberg 1242af58925cSMarcel Holtmann done: 1243af58925cSMarcel Holtmann return flags; 12441da177e4SLinus Torvalds } 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12471da177e4SLinus Torvalds { 124830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12491da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12501da177e4SLinus Torvalds struct inquiry_entry *e; 12511da177e4SLinus Torvalds int copied = 0; 12521da177e4SLinus Torvalds 1253561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12541da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1255b57c1a56SJohan Hedberg 1256b57c1a56SJohan Hedberg if (copied >= num) 1257b57c1a56SJohan Hedberg break; 1258b57c1a56SJohan Hedberg 12591da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12601da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12611da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12621da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12631da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12641da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1265b57c1a56SJohan Hedberg 12661da177e4SLinus Torvalds info++; 1267b57c1a56SJohan Hedberg copied++; 12681da177e4SLinus Torvalds } 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12711da177e4SLinus Torvalds return copied; 12721da177e4SLinus Torvalds } 12731da177e4SLinus Torvalds 1274a1d01db1SJohan Hedberg static int hci_inq_req(struct hci_request *req, unsigned long opt) 12751da177e4SLinus Torvalds { 12761da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 127742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12781da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12791da177e4SLinus Torvalds 12801da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12811da177e4SLinus Torvalds 12821da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 1283a1d01db1SJohan Hedberg return 0; 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds /* Start Inquiry */ 12861da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12871da177e4SLinus Torvalds cp.length = ir->length; 12881da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 128942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 1290a1d01db1SJohan Hedberg 1291a1d01db1SJohan Hedberg return 0; 12921da177e4SLinus Torvalds } 12931da177e4SLinus Torvalds 12941da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12951da177e4SLinus Torvalds { 12961da177e4SLinus Torvalds __u8 __user *ptr = arg; 12971da177e4SLinus Torvalds struct hci_inquiry_req ir; 12981da177e4SLinus Torvalds struct hci_dev *hdev; 12991da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 13001da177e4SLinus Torvalds long timeo; 13011da177e4SLinus Torvalds __u8 *buf; 13021da177e4SLinus Torvalds 13031da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 13041da177e4SLinus Torvalds return -EFAULT; 13051da177e4SLinus Torvalds 13065a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 13075a08ecceSAndrei Emeltchenko if (!hdev) 13081da177e4SLinus Torvalds return -ENODEV; 13091da177e4SLinus Torvalds 1310d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 13110736cfa8SMarcel Holtmann err = -EBUSY; 13120736cfa8SMarcel Holtmann goto done; 13130736cfa8SMarcel Holtmann } 13140736cfa8SMarcel Holtmann 1315d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1316fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1317fee746b0SMarcel Holtmann goto done; 1318fee746b0SMarcel Holtmann } 1319fee746b0SMarcel Holtmann 1320ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 13215b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 13225b69bef5SMarcel Holtmann goto done; 13235b69bef5SMarcel Holtmann } 13245b69bef5SMarcel Holtmann 1325d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 132656f87901SJohan Hedberg err = -EOPNOTSUPP; 132756f87901SJohan Hedberg goto done; 132856f87901SJohan Hedberg } 132956f87901SJohan Hedberg 133009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13311da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1332a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13331f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13341da177e4SLinus Torvalds do_inquiry = 1; 13351da177e4SLinus Torvalds } 133609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13371da177e4SLinus Torvalds 133804837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 133970f23020SAndrei Emeltchenko 134070f23020SAndrei Emeltchenko if (do_inquiry) { 134101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 13424ebeee2dSJohan Hedberg timeo, NULL); 134370f23020SAndrei Emeltchenko if (err < 0) 13441da177e4SLinus Torvalds goto done; 13453e13fa1eSAndre Guedes 13463e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13473e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13483e13fa1eSAndre Guedes */ 134974316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13503e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13513e13fa1eSAndre Guedes return -EINTR; 135270f23020SAndrei Emeltchenko } 13531da177e4SLinus Torvalds 13548fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13558fc9ced3SGustavo Padovan * 255 entries 13568fc9ced3SGustavo Padovan */ 13571da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13581da177e4SLinus Torvalds 13591da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13601da177e4SLinus Torvalds * copy it to the user space. 13611da177e4SLinus Torvalds */ 13626da2ec56SKees Cook buf = kmalloc_array(max_rsp, sizeof(struct inquiry_info), GFP_KERNEL); 136370f23020SAndrei Emeltchenko if (!buf) { 13641da177e4SLinus Torvalds err = -ENOMEM; 13651da177e4SLinus Torvalds goto done; 13661da177e4SLinus Torvalds } 13671da177e4SLinus Torvalds 136809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13691da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 137009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13711da177e4SLinus Torvalds 13721da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13751da177e4SLinus Torvalds ptr += sizeof(ir); 13761da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13771da177e4SLinus Torvalds ir.num_rsp)) 13781da177e4SLinus Torvalds err = -EFAULT; 13791da177e4SLinus Torvalds } else 13801da177e4SLinus Torvalds err = -EFAULT; 13811da177e4SLinus Torvalds 13821da177e4SLinus Torvalds kfree(buf); 13831da177e4SLinus Torvalds 13841da177e4SLinus Torvalds done: 13851da177e4SLinus Torvalds hci_dev_put(hdev); 13861da177e4SLinus Torvalds return err; 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds 13897a0e5b15SMatthias Kaehlcke /** 13907a0e5b15SMatthias Kaehlcke * hci_dev_get_bd_addr_from_property - Get the Bluetooth Device Address 13917a0e5b15SMatthias Kaehlcke * (BD_ADDR) for a HCI device from 13927a0e5b15SMatthias Kaehlcke * a firmware node property. 13937a0e5b15SMatthias Kaehlcke * @hdev: The HCI device 13947a0e5b15SMatthias Kaehlcke * 13957a0e5b15SMatthias Kaehlcke * Search the firmware node for 'local-bd-address'. 13967a0e5b15SMatthias Kaehlcke * 13977a0e5b15SMatthias Kaehlcke * All-zero BD addresses are rejected, because those could be properties 13987a0e5b15SMatthias Kaehlcke * that exist in the firmware tables, but were not updated by the firmware. For 13997a0e5b15SMatthias Kaehlcke * example, the DTS could define 'local-bd-address', with zero BD addresses. 14007a0e5b15SMatthias Kaehlcke */ 14017a0e5b15SMatthias Kaehlcke static void hci_dev_get_bd_addr_from_property(struct hci_dev *hdev) 14027a0e5b15SMatthias Kaehlcke { 14037a0e5b15SMatthias Kaehlcke struct fwnode_handle *fwnode = dev_fwnode(hdev->dev.parent); 14047a0e5b15SMatthias Kaehlcke bdaddr_t ba; 14057a0e5b15SMatthias Kaehlcke int ret; 14067a0e5b15SMatthias Kaehlcke 14077a0e5b15SMatthias Kaehlcke ret = fwnode_property_read_u8_array(fwnode, "local-bd-address", 14087a0e5b15SMatthias Kaehlcke (u8 *)&ba, sizeof(ba)); 14097a0e5b15SMatthias Kaehlcke if (ret < 0 || !bacmp(&ba, BDADDR_ANY)) 14107a0e5b15SMatthias Kaehlcke return; 14117a0e5b15SMatthias Kaehlcke 14127a0e5b15SMatthias Kaehlcke bacpy(&hdev->public_addr, &ba); 14137a0e5b15SMatthias Kaehlcke } 14147a0e5b15SMatthias Kaehlcke 1415cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 14161da177e4SLinus Torvalds { 14171da177e4SLinus Torvalds int ret = 0; 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 14201da177e4SLinus Torvalds 1421b504430cSJohan Hedberg hci_req_sync_lock(hdev); 14221da177e4SLinus Torvalds 1423d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 142494324962SJohan Hovold ret = -ENODEV; 142594324962SJohan Hovold goto done; 142694324962SJohan Hovold } 142794324962SJohan Hovold 1428d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1429d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1430a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1431a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1432bf543036SJohan Hedberg */ 1433d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1434611b30f7SMarcel Holtmann ret = -ERFKILL; 1435611b30f7SMarcel Holtmann goto done; 1436611b30f7SMarcel Holtmann } 1437611b30f7SMarcel Holtmann 1438a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1439a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1440a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1441a5c8f270SMarcel Holtmann * or not. 1442a5c8f270SMarcel Holtmann * 1443c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1444c6beca0eSMarcel Holtmann * if a public address or static random address is 1445c6beca0eSMarcel Holtmann * available. 1446c6beca0eSMarcel Holtmann * 1447a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1448a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1449a5c8f270SMarcel Holtmann */ 1450d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1451ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY && 1452a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1453a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1454a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1455a5c8f270SMarcel Holtmann goto done; 1456a5c8f270SMarcel Holtmann } 1457a5c8f270SMarcel Holtmann } 1458a5c8f270SMarcel Holtmann 14591da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14601da177e4SLinus Torvalds ret = -EALREADY; 14611da177e4SLinus Torvalds goto done; 14621da177e4SLinus Torvalds } 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds if (hdev->open(hdev)) { 14651da177e4SLinus Torvalds ret = -EIO; 14661da177e4SLinus Torvalds goto done; 14671da177e4SLinus Torvalds } 14681da177e4SLinus Torvalds 1469e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 147005fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 14714a3f95b7SMarcel Holtmann 14721da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14731da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1474f41c70c4SMarcel Holtmann 1475740011cfSSean Wang if (hci_dev_test_flag(hdev, HCI_SETUP) || 1476740011cfSSean Wang test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks)) { 14777fdf6c6aSMarcel Holtmann bool invalid_bdaddr; 14787fdf6c6aSMarcel Holtmann 1479e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1480e131d74aSMarcel Holtmann 1481af202f84SMarcel Holtmann if (hdev->setup) 1482f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1483f41c70c4SMarcel Holtmann 14847fdf6c6aSMarcel Holtmann /* The transport driver can set the quirk to mark the 14857fdf6c6aSMarcel Holtmann * BD_ADDR invalid before creating the HCI device or in 14867fdf6c6aSMarcel Holtmann * its setup callback. 14877fdf6c6aSMarcel Holtmann */ 14887fdf6c6aSMarcel Holtmann invalid_bdaddr = test_bit(HCI_QUIRK_INVALID_BDADDR, 14897fdf6c6aSMarcel Holtmann &hdev->quirks); 14907fdf6c6aSMarcel Holtmann 14917a0e5b15SMatthias Kaehlcke if (ret) 14927a0e5b15SMatthias Kaehlcke goto setup_failed; 14937a0e5b15SMatthias Kaehlcke 14947a0e5b15SMatthias Kaehlcke if (test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) { 14957a0e5b15SMatthias Kaehlcke if (!bacmp(&hdev->public_addr, BDADDR_ANY)) 14967a0e5b15SMatthias Kaehlcke hci_dev_get_bd_addr_from_property(hdev); 14977a0e5b15SMatthias Kaehlcke 14987a0e5b15SMatthias Kaehlcke if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14997fdf6c6aSMarcel Holtmann hdev->set_bdaddr) { 15007a0e5b15SMatthias Kaehlcke ret = hdev->set_bdaddr(hdev, 15017a0e5b15SMatthias Kaehlcke &hdev->public_addr); 15027fdf6c6aSMarcel Holtmann 15037fdf6c6aSMarcel Holtmann /* If setting of the BD_ADDR from the device 15047fdf6c6aSMarcel Holtmann * property succeeds, then treat the address 15057fdf6c6aSMarcel Holtmann * as valid even if the invalid BD_ADDR 15067fdf6c6aSMarcel Holtmann * quirk indicates otherwise. 15077fdf6c6aSMarcel Holtmann */ 15087fdf6c6aSMarcel Holtmann if (!ret) 15097fdf6c6aSMarcel Holtmann invalid_bdaddr = false; 15107fdf6c6aSMarcel Holtmann } 15117a0e5b15SMatthias Kaehlcke } 15127a0e5b15SMatthias Kaehlcke 15137a0e5b15SMatthias Kaehlcke setup_failed: 1514af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1515af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1516af202f84SMarcel Holtmann * 15177fdf6c6aSMarcel Holtmann * For the invalid BD_ADDR quirk it is possible that 15187fdf6c6aSMarcel Holtmann * it becomes a valid address if the bootloader does 15197fdf6c6aSMarcel Holtmann * provide it (see above). 15207fdf6c6aSMarcel Holtmann * 1521af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1522af202f84SMarcel Holtmann * start up as unconfigured. 1523af202f84SMarcel Holtmann */ 1524eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 15257fdf6c6aSMarcel Holtmann invalid_bdaddr) 1526a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1527f41c70c4SMarcel Holtmann 15280ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 15290ebca7d6SMarcel Holtmann * read at least the version information provided by 15300ebca7d6SMarcel Holtmann * the Read Local Version Information command. 15310ebca7d6SMarcel Holtmann * 15320ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 15330ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 15340ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 15350ebca7d6SMarcel Holtmann */ 1536d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 15370ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 153889bc22d2SMarcel Holtmann } 153989bc22d2SMarcel Holtmann 1540d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 15419713c17bSMarcel Holtmann /* If public address change is configured, ensure that 15429713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 15439713c17bSMarcel Holtmann * support changing the public address, fail the power 15449713c17bSMarcel Holtmann * on procedure. 154524c457e2SMarcel Holtmann */ 15469713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 15479713c17bSMarcel Holtmann hdev->set_bdaddr) 154824c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 154924c457e2SMarcel Holtmann else 155024c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 155124c457e2SMarcel Holtmann } 155224c457e2SMarcel Holtmann 1553f41c70c4SMarcel Holtmann if (!ret) { 1554d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 155598a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 15562177bab5SJohan Hedberg ret = __hci_init(hdev); 155798a63aafSMarcel Holtmann if (!ret && hdev->post_init) 155898a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 155998a63aafSMarcel Holtmann } 15601da177e4SLinus Torvalds } 15611da177e4SLinus Torvalds 15627e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 15637e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 15647e995b9eSMarcel Holtmann * completed. 15657e995b9eSMarcel Holtmann */ 15667e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1567b56c7b25SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15687e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 15697e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 15707e995b9eSMarcel Holtmann 1571145373cbSMiao-chen Chou msft_do_open(hdev); 1572145373cbSMiao-chen Chou 1573f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1574f41c70c4SMarcel Holtmann 15751da177e4SLinus Torvalds if (!ret) { 15761da177e4SLinus Torvalds hci_dev_hold(hdev); 1577a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 1578a73c046aSJaganath Kanakkassery hci_adv_instances_set_rpa_expired(hdev, true); 15791da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 158005fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 15816d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, true); 1582d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1583d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1584d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1585d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15862ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 1587ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY) { 15882ff13894SJohan Hedberg ret = __hci_req_hci_power_on(hdev); 15892ff13894SJohan Hedberg mgmt_power_on(hdev, ret); 159056e5cb86SJohan Hedberg } 15911da177e4SLinus Torvalds } else { 15921da177e4SLinus Torvalds /* Init failed, cleanup */ 15933eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1594c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1595b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15961da177e4SLinus Torvalds 15971da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15981da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15991da177e4SLinus Torvalds 16001da177e4SLinus Torvalds if (hdev->flush) 16011da177e4SLinus Torvalds hdev->flush(hdev); 16021da177e4SLinus Torvalds 16031da177e4SLinus Torvalds if (hdev->sent_cmd) { 16041da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16051da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16061da177e4SLinus Torvalds } 16071da177e4SLinus Torvalds 1608e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 160905fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 16104a3f95b7SMarcel Holtmann 16111da177e4SLinus Torvalds hdev->close(hdev); 1612fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds done: 1616b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 16171da177e4SLinus Torvalds return ret; 16181da177e4SLinus Torvalds } 16191da177e4SLinus Torvalds 1620cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1621cbed0ca1SJohan Hedberg 1622cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1623cbed0ca1SJohan Hedberg { 1624cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1625cbed0ca1SJohan Hedberg int err; 1626cbed0ca1SJohan Hedberg 1627cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1628cbed0ca1SJohan Hedberg if (!hdev) 1629cbed0ca1SJohan Hedberg return -ENODEV; 1630cbed0ca1SJohan Hedberg 16314a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1632fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1633fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1634fee746b0SMarcel Holtmann * possible. 1635fee746b0SMarcel Holtmann * 1636fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1637fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1638fee746b0SMarcel Holtmann * open the device. 1639fee746b0SMarcel Holtmann */ 1640d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1641d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1642fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1643fee746b0SMarcel Holtmann goto done; 1644fee746b0SMarcel Holtmann } 1645fee746b0SMarcel Holtmann 1646e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1647e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1648e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1649e1d08f40SJohan Hedberg * completed. 1650e1d08f40SJohan Hedberg */ 1651a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1652e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1653e1d08f40SJohan Hedberg 1654a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1655a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1656a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1657a5c8f270SMarcel Holtmann */ 1658e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1659e1d08f40SJohan Hedberg 166012aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1661b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 166212aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 166312aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 166412aa4f0aSMarcel Holtmann * to explicitly enable it. 166512aa4f0aSMarcel Holtmann */ 1666d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1667d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1668a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 166912aa4f0aSMarcel Holtmann 1670cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1671cbed0ca1SJohan Hedberg 1672fee746b0SMarcel Holtmann done: 1673cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1674cbed0ca1SJohan Hedberg return err; 1675cbed0ca1SJohan Hedberg } 1676cbed0ca1SJohan Hedberg 1677d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1678d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1679d7347f3cSJohan Hedberg { 1680d7347f3cSJohan Hedberg struct hci_conn_params *p; 1681d7347f3cSJohan Hedberg 1682f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1683f161dd41SJohan Hedberg if (p->conn) { 1684f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1685f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1686f161dd41SJohan Hedberg p->conn = NULL; 1687f161dd41SJohan Hedberg } 1688d7347f3cSJohan Hedberg list_del_init(&p->action); 1689f161dd41SJohan Hedberg } 1690d7347f3cSJohan Hedberg 1691d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1692d7347f3cSJohan Hedberg } 1693d7347f3cSJohan Hedberg 16946b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 16951da177e4SLinus Torvalds { 1696acc649c6SMarcel Holtmann bool auto_off; 1697acc649c6SMarcel Holtmann 16981da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 16991da177e4SLinus Torvalds 1700d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1701867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1702d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1703a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1704a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1705a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1706a44fecbdSTedd Ho-Jeong An } 1707a44fecbdSTedd Ho-Jeong An 170878c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 170978c04c0bSVinicius Costa Gomes 17107df0f73eSJohan Hedberg hci_request_cancel_all(hdev); 1711b504430cSJohan Hedberg hci_req_sync_lock(hdev); 17121da177e4SLinus Torvalds 17131da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 171465cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 1715b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 17161da177e4SLinus Torvalds return 0; 17171da177e4SLinus Torvalds } 17181da177e4SLinus Torvalds 17196d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, false); 17206d5d2ee6SHeiner Kallweit 17213eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 17223eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1723b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 17241da177e4SLinus Torvalds 172516ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 172616ab91abSJohan Hedberg hdev->discov_timeout = 0; 1727a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1728a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 172916ab91abSJohan Hedberg } 173016ab91abSJohan Hedberg 1731a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 17327d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 17337d78525dSJohan Hedberg 1734a73c046aSJaganath Kanakkassery if (hci_dev_test_flag(hdev, HCI_MGMT)) { 1735a73c046aSJaganath Kanakkassery struct adv_info *adv_instance; 1736a73c046aSJaganath Kanakkassery 1737d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 17387ba8b4beSAndre Guedes 1739a73c046aSJaganath Kanakkassery list_for_each_entry(adv_instance, &hdev->adv_instances, list) 1740a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 1741a73c046aSJaganath Kanakkassery } 1742a73c046aSJaganath Kanakkassery 174376727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 174476727c02SJohan Hedberg * ensuring the workqueue is empty up front. 174576727c02SJohan Hedberg */ 174676727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 174776727c02SJohan Hedberg 174809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17491aeb9c65SJohan Hedberg 17508f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 17518f502f84SJohan Hedberg 1752acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1753acc649c6SMarcel Holtmann 1754ca8bee5dSMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_PRIMARY && 1755baab7932SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 17562ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT)) 17572ff13894SJohan Hedberg __mgmt_power_off(hdev); 17581aeb9c65SJohan Hedberg 17591f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1760d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1761f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 176209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17631da177e4SLinus Torvalds 176464dae967SMarcel Holtmann smp_unregister(hdev); 176564dae967SMarcel Holtmann 176605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 17671da177e4SLinus Torvalds 1768145373cbSMiao-chen Chou msft_do_close(hdev); 1769145373cbSMiao-chen Chou 17701da177e4SLinus Torvalds if (hdev->flush) 17711da177e4SLinus Torvalds hdev->flush(hdev); 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds /* Reset device */ 17741da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17751da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1776acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1777acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17781da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 17794ebeee2dSJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT, NULL); 17801da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 17811da177e4SLinus Torvalds } 17821da177e4SLinus Torvalds 1783c347b765SGustavo F. Padovan /* flush cmd work */ 1784c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 17851da177e4SLinus Torvalds 17861da177e4SLinus Torvalds /* Drop queues */ 17871da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17881da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17891da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 17901da177e4SLinus Torvalds 17911da177e4SLinus Torvalds /* Drop last sent command */ 17921da177e4SLinus Torvalds if (hdev->sent_cmd) { 179365cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 17941da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 17951da177e4SLinus Torvalds hdev->sent_cmd = NULL; 17961da177e4SLinus Torvalds } 17971da177e4SLinus Torvalds 1798e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 179905fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 18004a3f95b7SMarcel Holtmann 18019952d90eSAbhishek Pandit-Subedi if (test_and_clear_bit(SUSPEND_POWERING_DOWN, hdev->suspend_tasks)) 18029952d90eSAbhishek Pandit-Subedi wake_up(&hdev->suspend_wait_q); 18039952d90eSAbhishek Pandit-Subedi 18041da177e4SLinus Torvalds /* After this point our queues are empty 18051da177e4SLinus Torvalds * and no tasks are scheduled. */ 18061da177e4SLinus Torvalds hdev->close(hdev); 18071da177e4SLinus Torvalds 180835b973c9SJohan Hedberg /* Clear flags */ 1809fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1810eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 181135b973c9SJohan Hedberg 1812ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1813536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1814ced5c338SAndrei Emeltchenko 1815e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 181609b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 18177a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1818e59fda8dSJohan Hedberg 1819b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds hci_dev_put(hdev); 18221da177e4SLinus Torvalds return 0; 18231da177e4SLinus Torvalds } 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 18261da177e4SLinus Torvalds { 18271da177e4SLinus Torvalds struct hci_dev *hdev; 18281da177e4SLinus Torvalds int err; 18291da177e4SLinus Torvalds 183070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 183170f23020SAndrei Emeltchenko if (!hdev) 18321da177e4SLinus Torvalds return -ENODEV; 18338ee56540SMarcel Holtmann 1834d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18350736cfa8SMarcel Holtmann err = -EBUSY; 18360736cfa8SMarcel Holtmann goto done; 18370736cfa8SMarcel Holtmann } 18380736cfa8SMarcel Holtmann 1839a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 18408ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 18418ee56540SMarcel Holtmann 18421da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 18438ee56540SMarcel Holtmann 18440736cfa8SMarcel Holtmann done: 18451da177e4SLinus Torvalds hci_dev_put(hdev); 18461da177e4SLinus Torvalds return err; 18471da177e4SLinus Torvalds } 18481da177e4SLinus Torvalds 18495c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 18501da177e4SLinus Torvalds { 18515c912495SMarcel Holtmann int ret; 18521da177e4SLinus Torvalds 18535c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 18541da177e4SLinus Torvalds 1855b504430cSJohan Hedberg hci_req_sync_lock(hdev); 18561da177e4SLinus Torvalds 18571da177e4SLinus Torvalds /* Drop queues */ 18581da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18591da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18601da177e4SLinus Torvalds 186176727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 186276727c02SJohan Hedberg * ensuring the workqueue is empty up front. 186376727c02SJohan Hedberg */ 186476727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 186576727c02SJohan Hedberg 186609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 18671f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 18681da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 186909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18701da177e4SLinus Torvalds 18711da177e4SLinus Torvalds if (hdev->flush) 18721da177e4SLinus Torvalds hdev->flush(hdev); 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18756ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 18761da177e4SLinus Torvalds 18774ebeee2dSJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT, NULL); 18781da177e4SLinus Torvalds 1879b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 18801da177e4SLinus Torvalds return ret; 18811da177e4SLinus Torvalds } 18821da177e4SLinus Torvalds 18835c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 18845c912495SMarcel Holtmann { 18855c912495SMarcel Holtmann struct hci_dev *hdev; 18865c912495SMarcel Holtmann int err; 18875c912495SMarcel Holtmann 18885c912495SMarcel Holtmann hdev = hci_dev_get(dev); 18895c912495SMarcel Holtmann if (!hdev) 18905c912495SMarcel Holtmann return -ENODEV; 18915c912495SMarcel Holtmann 18925c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 18935c912495SMarcel Holtmann err = -ENETDOWN; 18945c912495SMarcel Holtmann goto done; 18955c912495SMarcel Holtmann } 18965c912495SMarcel Holtmann 1897d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18985c912495SMarcel Holtmann err = -EBUSY; 18995c912495SMarcel Holtmann goto done; 19005c912495SMarcel Holtmann } 19015c912495SMarcel Holtmann 1902d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 19035c912495SMarcel Holtmann err = -EOPNOTSUPP; 19045c912495SMarcel Holtmann goto done; 19055c912495SMarcel Holtmann } 19065c912495SMarcel Holtmann 19075c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 19085c912495SMarcel Holtmann 19095c912495SMarcel Holtmann done: 19105c912495SMarcel Holtmann hci_dev_put(hdev); 19115c912495SMarcel Holtmann return err; 19125c912495SMarcel Holtmann } 19135c912495SMarcel Holtmann 19141da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 19151da177e4SLinus Torvalds { 19161da177e4SLinus Torvalds struct hci_dev *hdev; 19171da177e4SLinus Torvalds int ret = 0; 19181da177e4SLinus Torvalds 191970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 192070f23020SAndrei Emeltchenko if (!hdev) 19211da177e4SLinus Torvalds return -ENODEV; 19221da177e4SLinus Torvalds 1923d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19240736cfa8SMarcel Holtmann ret = -EBUSY; 19250736cfa8SMarcel Holtmann goto done; 19260736cfa8SMarcel Holtmann } 19270736cfa8SMarcel Holtmann 1928d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1929fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1930fee746b0SMarcel Holtmann goto done; 1931fee746b0SMarcel Holtmann } 1932fee746b0SMarcel Holtmann 19331da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 19341da177e4SLinus Torvalds 19350736cfa8SMarcel Holtmann done: 19361da177e4SLinus Torvalds hci_dev_put(hdev); 19371da177e4SLinus Torvalds return ret; 19381da177e4SLinus Torvalds } 19391da177e4SLinus Torvalds 1940123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1941123abc08SJohan Hedberg { 1942bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1943123abc08SJohan Hedberg 1944123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1945123abc08SJohan Hedberg 1946123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1947238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1948238be788SMarcel Holtmann HCI_CONNECTABLE); 1949123abc08SJohan Hedberg else 1950a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1951a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1952123abc08SJohan Hedberg 1953bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1954238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1955238be788SMarcel Holtmann HCI_DISCOVERABLE); 1956bc6d2d04SJohan Hedberg } else { 1957a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1958a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1959a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1960bc6d2d04SJohan Hedberg } 1961bc6d2d04SJohan Hedberg 1962d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1963123abc08SJohan Hedberg return; 1964123abc08SJohan Hedberg 1965bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1966bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1967a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1968bc6d2d04SJohan Hedberg 1969d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1970cab054abSJohan Hedberg hci_req_update_adv_data(hdev, hdev->cur_adv_instance); 1971bc6d2d04SJohan Hedberg 1972123abc08SJohan Hedberg mgmt_new_settings(hdev); 1973123abc08SJohan Hedberg } 1974bc6d2d04SJohan Hedberg } 1975123abc08SJohan Hedberg 19761da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 19771da177e4SLinus Torvalds { 19781da177e4SLinus Torvalds struct hci_dev *hdev; 19791da177e4SLinus Torvalds struct hci_dev_req dr; 19801da177e4SLinus Torvalds int err = 0; 19811da177e4SLinus Torvalds 19821da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 19831da177e4SLinus Torvalds return -EFAULT; 19841da177e4SLinus Torvalds 198570f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 198670f23020SAndrei Emeltchenko if (!hdev) 19871da177e4SLinus Torvalds return -ENODEV; 19881da177e4SLinus Torvalds 1989d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 19900736cfa8SMarcel Holtmann err = -EBUSY; 19910736cfa8SMarcel Holtmann goto done; 19920736cfa8SMarcel Holtmann } 19930736cfa8SMarcel Holtmann 1994d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1995fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1996fee746b0SMarcel Holtmann goto done; 1997fee746b0SMarcel Holtmann } 1998fee746b0SMarcel Holtmann 1999ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 20005b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 20015b69bef5SMarcel Holtmann goto done; 20025b69bef5SMarcel Holtmann } 20035b69bef5SMarcel Holtmann 2004d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 200556f87901SJohan Hedberg err = -EOPNOTSUPP; 200656f87901SJohan Hedberg goto done; 200756f87901SJohan Hedberg } 200856f87901SJohan Hedberg 20091da177e4SLinus Torvalds switch (cmd) { 20101da177e4SLinus Torvalds case HCISETAUTH: 201101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 20124ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 20131da177e4SLinus Torvalds break; 20141da177e4SLinus Torvalds 20151da177e4SLinus Torvalds case HCISETENCRYPT: 20161da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 20171da177e4SLinus Torvalds err = -EOPNOTSUPP; 20181da177e4SLinus Torvalds break; 20191da177e4SLinus Torvalds } 20201da177e4SLinus Torvalds 20211da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 20221da177e4SLinus Torvalds /* Auth must be enabled first */ 202301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 20244ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 20251da177e4SLinus Torvalds if (err) 20261da177e4SLinus Torvalds break; 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds 202901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 20304ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 20311da177e4SLinus Torvalds break; 20321da177e4SLinus Torvalds 20331da177e4SLinus Torvalds case HCISETSCAN: 203401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 20354ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 203691a668b0SJohan Hedberg 2037bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2038bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 203991a668b0SJohan Hedberg */ 2040123abc08SJohan Hedberg if (!err) 2041123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 20421da177e4SLinus Torvalds break; 20431da177e4SLinus Torvalds 20441da177e4SLinus Torvalds case HCISETLINKPOL: 204501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 20464ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 20471da177e4SLinus Torvalds break; 20481da177e4SLinus Torvalds 20491da177e4SLinus Torvalds case HCISETLINKMODE: 2050e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2051e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2052e4e8e37cSMarcel Holtmann break; 2053e4e8e37cSMarcel Holtmann 2054e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2055b7c23df8SJaganath Kanakkassery if (hdev->pkt_type == (__u16) dr.dev_opt) 2056b7c23df8SJaganath Kanakkassery break; 2057b7c23df8SJaganath Kanakkassery 2058e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 2059b7c23df8SJaganath Kanakkassery mgmt_phy_configuration_changed(hdev, NULL); 20601da177e4SLinus Torvalds break; 20611da177e4SLinus Torvalds 20621da177e4SLinus Torvalds case HCISETACLMTU: 20631da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 20641da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 20651da177e4SLinus Torvalds break; 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds case HCISETSCOMTU: 20681da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 20691da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 20701da177e4SLinus Torvalds break; 20711da177e4SLinus Torvalds 20721da177e4SLinus Torvalds default: 20731da177e4SLinus Torvalds err = -EINVAL; 20741da177e4SLinus Torvalds break; 20751da177e4SLinus Torvalds } 2076e4e8e37cSMarcel Holtmann 20770736cfa8SMarcel Holtmann done: 20781da177e4SLinus Torvalds hci_dev_put(hdev); 20791da177e4SLinus Torvalds return err; 20801da177e4SLinus Torvalds } 20811da177e4SLinus Torvalds 20821da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 20831da177e4SLinus Torvalds { 20848035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 20851da177e4SLinus Torvalds struct hci_dev_list_req *dl; 20861da177e4SLinus Torvalds struct hci_dev_req *dr; 20871da177e4SLinus Torvalds int n = 0, size, err; 20881da177e4SLinus Torvalds __u16 dev_num; 20891da177e4SLinus Torvalds 20901da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 20911da177e4SLinus Torvalds return -EFAULT; 20921da177e4SLinus Torvalds 20931da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 20941da177e4SLinus Torvalds return -EINVAL; 20951da177e4SLinus Torvalds 20961da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 20971da177e4SLinus Torvalds 209870f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 209970f23020SAndrei Emeltchenko if (!dl) 21001da177e4SLinus Torvalds return -ENOMEM; 21011da177e4SLinus Torvalds 21021da177e4SLinus Torvalds dr = dl->dev_req; 21031da177e4SLinus Torvalds 2104f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 21058035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 21062e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2107c542a06cSJohan Hedberg 21082e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 21092e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 21102e84d8dbSMarcel Holtmann * device is actually down. 21112e84d8dbSMarcel Holtmann */ 2112d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 21132e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2114c542a06cSJohan Hedberg 21151da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 21162e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2117c542a06cSJohan Hedberg 21181da177e4SLinus Torvalds if (++n >= dev_num) 21191da177e4SLinus Torvalds break; 21201da177e4SLinus Torvalds } 2121f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 21221da177e4SLinus Torvalds 21231da177e4SLinus Torvalds dl->dev_num = n; 21241da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 21251da177e4SLinus Torvalds 21261da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 21271da177e4SLinus Torvalds kfree(dl); 21281da177e4SLinus Torvalds 21291da177e4SLinus Torvalds return err ? -EFAULT : 0; 21301da177e4SLinus Torvalds } 21311da177e4SLinus Torvalds 21321da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 21331da177e4SLinus Torvalds { 21341da177e4SLinus Torvalds struct hci_dev *hdev; 21351da177e4SLinus Torvalds struct hci_dev_info di; 21362e84d8dbSMarcel Holtmann unsigned long flags; 21371da177e4SLinus Torvalds int err = 0; 21381da177e4SLinus Torvalds 21391da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 21401da177e4SLinus Torvalds return -EFAULT; 21411da177e4SLinus Torvalds 214270f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 214370f23020SAndrei Emeltchenko if (!hdev) 21441da177e4SLinus Torvalds return -ENODEV; 21451da177e4SLinus Torvalds 21462e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 21472e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 21482e84d8dbSMarcel Holtmann * device is actually down. 21492e84d8dbSMarcel Holtmann */ 2150d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 21512e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 21522e84d8dbSMarcel Holtmann else 21532e84d8dbSMarcel Holtmann flags = hdev->flags; 2154c542a06cSJohan Hedberg 21551da177e4SLinus Torvalds strcpy(di.name, hdev->name); 21561da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 215760f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 21582e84d8dbSMarcel Holtmann di.flags = flags; 21591da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2160572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 21611da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 21621da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 21631da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 21641da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2165572c7f84SJohan Hedberg } else { 2166572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2167572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2168572c7f84SJohan Hedberg di.sco_mtu = 0; 2169572c7f84SJohan Hedberg di.sco_pkts = 0; 2170572c7f84SJohan Hedberg } 21711da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 21721da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 21731da177e4SLinus Torvalds 21741da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 21751da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 21761da177e4SLinus Torvalds 21771da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 21781da177e4SLinus Torvalds err = -EFAULT; 21791da177e4SLinus Torvalds 21801da177e4SLinus Torvalds hci_dev_put(hdev); 21811da177e4SLinus Torvalds 21821da177e4SLinus Torvalds return err; 21831da177e4SLinus Torvalds } 21841da177e4SLinus Torvalds 21851da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 21861da177e4SLinus Torvalds 2187611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2188611b30f7SMarcel Holtmann { 2189611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2190611b30f7SMarcel Holtmann 2191611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2192611b30f7SMarcel Holtmann 2193d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 21940736cfa8SMarcel Holtmann return -EBUSY; 21950736cfa8SMarcel Holtmann 21965e130367SJohan Hedberg if (blocked) { 2197a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2198d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2199d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2200611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 22015e130367SJohan Hedberg } else { 2202a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 22035e130367SJohan Hedberg } 2204611b30f7SMarcel Holtmann 2205611b30f7SMarcel Holtmann return 0; 2206611b30f7SMarcel Holtmann } 2207611b30f7SMarcel Holtmann 2208611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2209611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2210611b30f7SMarcel Holtmann }; 2211611b30f7SMarcel Holtmann 2212ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2213ab81cbf9SJohan Hedberg { 2214ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 221596570ffcSJohan Hedberg int err; 2216ab81cbf9SJohan Hedberg 2217ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2218ab81cbf9SJohan Hedberg 22192ff13894SJohan Hedberg if (test_bit(HCI_UP, &hdev->flags) && 22202ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 22212ff13894SJohan Hedberg hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) { 2222d82142a8SWei-Ning Huang cancel_delayed_work(&hdev->power_off); 22232ff13894SJohan Hedberg hci_req_sync_lock(hdev); 22242ff13894SJohan Hedberg err = __hci_req_hci_power_on(hdev); 22252ff13894SJohan Hedberg hci_req_sync_unlock(hdev); 22262ff13894SJohan Hedberg mgmt_power_on(hdev, err); 22272ff13894SJohan Hedberg return; 22282ff13894SJohan Hedberg } 22292ff13894SJohan Hedberg 2230cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 223196570ffcSJohan Hedberg if (err < 0) { 22323ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 223396570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 22343ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2235ab81cbf9SJohan Hedberg return; 223696570ffcSJohan Hedberg } 2237ab81cbf9SJohan Hedberg 2238a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2239a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2240a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2241a5c8f270SMarcel Holtmann */ 2242d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2243d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2244ca8bee5dSMarcel Holtmann (hdev->dev_type == HCI_PRIMARY && 2245a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2246a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2247a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2248bf543036SJohan Hedberg hci_dev_do_close(hdev); 2249d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 225019202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 225119202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2252bf543036SJohan Hedberg } 2253ab81cbf9SJohan Hedberg 2254a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 22554a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 22564a964404SMarcel Holtmann * so that userspace can easily identify them. 22574a964404SMarcel Holtmann */ 2258d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22594a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 22600602a8adSMarcel Holtmann 22610602a8adSMarcel Holtmann /* For fully configured devices, this will send 22620602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 22630602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 22640602a8adSMarcel Holtmann * 22650602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 22660602a8adSMarcel Holtmann * and no event will be send. 22670602a8adSMarcel Holtmann */ 2268744cf19eSJohan Hedberg mgmt_index_added(hdev); 2269a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 22705ea234d3SMarcel Holtmann /* When the controller is now configured, then it 22715ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 22725ea234d3SMarcel Holtmann */ 2273d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 22745ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 22755ea234d3SMarcel Holtmann 2276d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2277d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2278d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2279d603b76bSMarcel Holtmann */ 2280d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2281ab81cbf9SJohan Hedberg } 2282ab81cbf9SJohan Hedberg } 2283ab81cbf9SJohan Hedberg 2284ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2285ab81cbf9SJohan Hedberg { 22863243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 22873243553fSJohan Hedberg power_off.work); 2288ab81cbf9SJohan Hedberg 2289ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2290ab81cbf9SJohan Hedberg 22918ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2292ab81cbf9SJohan Hedberg } 2293ab81cbf9SJohan Hedberg 2294c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2295c7741d16SMarcel Holtmann { 2296c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2297c7741d16SMarcel Holtmann 2298c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2299c7741d16SMarcel Holtmann 2300c7741d16SMarcel Holtmann if (hdev->hw_error) 2301c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2302c7741d16SMarcel Holtmann else 23032064ee33SMarcel Holtmann bt_dev_err(hdev, "hardware error 0x%2.2x", hdev->hw_error_code); 2304c7741d16SMarcel Holtmann 2305c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2306c7741d16SMarcel Holtmann return; 2307c7741d16SMarcel Holtmann 2308c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2309c7741d16SMarcel Holtmann } 2310c7741d16SMarcel Holtmann 231135f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 23122aeb9a1aSJohan Hedberg { 23134821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 23142aeb9a1aSJohan Hedberg 23154821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 23164821002cSJohan Hedberg list_del(&uuid->list); 23172aeb9a1aSJohan Hedberg kfree(uuid); 23182aeb9a1aSJohan Hedberg } 23192aeb9a1aSJohan Hedberg } 23202aeb9a1aSJohan Hedberg 232135f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 232255ed8ca1SJohan Hedberg { 232355ed8ca1SJohan Hedberg struct link_key *key; 232455ed8ca1SJohan Hedberg 2325d7d41682SMadhuparna Bhowmik list_for_each_entry(key, &hdev->link_keys, list) { 23260378b597SJohan Hedberg list_del_rcu(&key->list); 23270378b597SJohan Hedberg kfree_rcu(key, rcu); 232855ed8ca1SJohan Hedberg } 232955ed8ca1SJohan Hedberg } 233055ed8ca1SJohan Hedberg 233135f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2332b899efafSVinicius Costa Gomes { 2333970d0f1bSJohan Hedberg struct smp_ltk *k; 2334b899efafSVinicius Costa Gomes 2335d7d41682SMadhuparna Bhowmik list_for_each_entry(k, &hdev->long_term_keys, list) { 2336970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2337970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2338b899efafSVinicius Costa Gomes } 2339b899efafSVinicius Costa Gomes } 2340b899efafSVinicius Costa Gomes 2341970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2342970c4e46SJohan Hedberg { 2343adae20cbSJohan Hedberg struct smp_irk *k; 2344970c4e46SJohan Hedberg 2345d7d41682SMadhuparna Bhowmik list_for_each_entry(k, &hdev->identity_resolving_keys, list) { 2346adae20cbSJohan Hedberg list_del_rcu(&k->list); 2347adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2348970c4e46SJohan Hedberg } 2349970c4e46SJohan Hedberg } 2350970c4e46SJohan Hedberg 2351600a8749SAlain Michaud void hci_blocked_keys_clear(struct hci_dev *hdev) 2352600a8749SAlain Michaud { 2353600a8749SAlain Michaud struct blocked_key *b; 2354600a8749SAlain Michaud 2355d7d41682SMadhuparna Bhowmik list_for_each_entry(b, &hdev->blocked_keys, list) { 2356600a8749SAlain Michaud list_del_rcu(&b->list); 2357600a8749SAlain Michaud kfree_rcu(b, rcu); 2358600a8749SAlain Michaud } 2359600a8749SAlain Michaud } 2360600a8749SAlain Michaud 2361600a8749SAlain Michaud bool hci_is_blocked_key(struct hci_dev *hdev, u8 type, u8 val[16]) 2362600a8749SAlain Michaud { 2363600a8749SAlain Michaud bool blocked = false; 2364600a8749SAlain Michaud struct blocked_key *b; 2365600a8749SAlain Michaud 2366600a8749SAlain Michaud rcu_read_lock(); 23670c2ac7d4SMadhuparna Bhowmik list_for_each_entry_rcu(b, &hdev->blocked_keys, list) { 2368600a8749SAlain Michaud if (b->type == type && !memcmp(b->val, val, sizeof(b->val))) { 2369600a8749SAlain Michaud blocked = true; 2370600a8749SAlain Michaud break; 2371600a8749SAlain Michaud } 2372600a8749SAlain Michaud } 2373600a8749SAlain Michaud 2374600a8749SAlain Michaud rcu_read_unlock(); 2375600a8749SAlain Michaud return blocked; 2376600a8749SAlain Michaud } 2377600a8749SAlain Michaud 237855ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 237955ed8ca1SJohan Hedberg { 238055ed8ca1SJohan Hedberg struct link_key *k; 238155ed8ca1SJohan Hedberg 23820378b597SJohan Hedberg rcu_read_lock(); 23830378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 23840378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 23850378b597SJohan Hedberg rcu_read_unlock(); 2386600a8749SAlain Michaud 2387600a8749SAlain Michaud if (hci_is_blocked_key(hdev, 2388600a8749SAlain Michaud HCI_BLOCKED_KEY_TYPE_LINKKEY, 2389600a8749SAlain Michaud k->val)) { 2390600a8749SAlain Michaud bt_dev_warn_ratelimited(hdev, 2391600a8749SAlain Michaud "Link key blocked for %pMR", 2392600a8749SAlain Michaud &k->bdaddr); 2393600a8749SAlain Michaud return NULL; 2394600a8749SAlain Michaud } 2395600a8749SAlain Michaud 239655ed8ca1SJohan Hedberg return k; 23970378b597SJohan Hedberg } 23980378b597SJohan Hedberg } 23990378b597SJohan Hedberg rcu_read_unlock(); 240055ed8ca1SJohan Hedberg 240155ed8ca1SJohan Hedberg return NULL; 240255ed8ca1SJohan Hedberg } 240355ed8ca1SJohan Hedberg 2404745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2405d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2406d25e28abSJohan Hedberg { 2407d25e28abSJohan Hedberg /* Legacy key */ 2408d25e28abSJohan Hedberg if (key_type < 0x03) 2409745c0ce3SVishal Agarwal return true; 2410d25e28abSJohan Hedberg 2411d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2412d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2413745c0ce3SVishal Agarwal return false; 2414d25e28abSJohan Hedberg 2415d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2416d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2417745c0ce3SVishal Agarwal return false; 2418d25e28abSJohan Hedberg 2419d25e28abSJohan Hedberg /* Security mode 3 case */ 2420d25e28abSJohan Hedberg if (!conn) 2421745c0ce3SVishal Agarwal return true; 2422d25e28abSJohan Hedberg 2423e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2424e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2425e3befab9SJohan Hedberg return true; 2426e3befab9SJohan Hedberg 2427d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2428d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2429745c0ce3SVishal Agarwal return true; 2430d25e28abSJohan Hedberg 2431d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2432d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2433745c0ce3SVishal Agarwal return true; 2434d25e28abSJohan Hedberg 2435d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2436d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2437745c0ce3SVishal Agarwal return true; 2438d25e28abSJohan Hedberg 2439d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2440d25e28abSJohan Hedberg * persistently */ 2441745c0ce3SVishal Agarwal return false; 2442d25e28abSJohan Hedberg } 2443d25e28abSJohan Hedberg 2444e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 244598a0b845SJohan Hedberg { 2446e804d25dSJohan Hedberg if (type == SMP_LTK) 2447e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 244898a0b845SJohan Hedberg 2449e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 245098a0b845SJohan Hedberg } 245198a0b845SJohan Hedberg 2452f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2453e804d25dSJohan Hedberg u8 addr_type, u8 role) 245475d262c2SVinicius Costa Gomes { 2455c9839a11SVinicius Costa Gomes struct smp_ltk *k; 245675d262c2SVinicius Costa Gomes 2457970d0f1bSJohan Hedberg rcu_read_lock(); 2458970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 24595378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 24605378bc56SJohan Hedberg continue; 24615378bc56SJohan Hedberg 2462923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2463970d0f1bSJohan Hedberg rcu_read_unlock(); 2464600a8749SAlain Michaud 2465600a8749SAlain Michaud if (hci_is_blocked_key(hdev, HCI_BLOCKED_KEY_TYPE_LTK, 2466600a8749SAlain Michaud k->val)) { 2467600a8749SAlain Michaud bt_dev_warn_ratelimited(hdev, 2468600a8749SAlain Michaud "LTK blocked for %pMR", 2469600a8749SAlain Michaud &k->bdaddr); 2470600a8749SAlain Michaud return NULL; 2471600a8749SAlain Michaud } 2472600a8749SAlain Michaud 247375d262c2SVinicius Costa Gomes return k; 2474970d0f1bSJohan Hedberg } 2475970d0f1bSJohan Hedberg } 2476970d0f1bSJohan Hedberg rcu_read_unlock(); 247775d262c2SVinicius Costa Gomes 247875d262c2SVinicius Costa Gomes return NULL; 247975d262c2SVinicius Costa Gomes } 248075d262c2SVinicius Costa Gomes 2481970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2482970c4e46SJohan Hedberg { 2483600a8749SAlain Michaud struct smp_irk *irk_to_return = NULL; 2484970c4e46SJohan Hedberg struct smp_irk *irk; 2485970c4e46SJohan Hedberg 2486adae20cbSJohan Hedberg rcu_read_lock(); 2487adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2488adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2489600a8749SAlain Michaud irk_to_return = irk; 2490600a8749SAlain Michaud goto done; 2491970c4e46SJohan Hedberg } 2492adae20cbSJohan Hedberg } 2493970c4e46SJohan Hedberg 2494adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2495defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2496970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2497600a8749SAlain Michaud irk_to_return = irk; 2498600a8749SAlain Michaud goto done; 2499970c4e46SJohan Hedberg } 2500970c4e46SJohan Hedberg } 2501600a8749SAlain Michaud 2502600a8749SAlain Michaud done: 2503600a8749SAlain Michaud if (irk_to_return && hci_is_blocked_key(hdev, HCI_BLOCKED_KEY_TYPE_IRK, 2504600a8749SAlain Michaud irk_to_return->val)) { 2505600a8749SAlain Michaud bt_dev_warn_ratelimited(hdev, "Identity key blocked for %pMR", 2506600a8749SAlain Michaud &irk_to_return->bdaddr); 2507600a8749SAlain Michaud irk_to_return = NULL; 2508600a8749SAlain Michaud } 2509600a8749SAlain Michaud 2510adae20cbSJohan Hedberg rcu_read_unlock(); 2511970c4e46SJohan Hedberg 2512600a8749SAlain Michaud return irk_to_return; 2513970c4e46SJohan Hedberg } 2514970c4e46SJohan Hedberg 2515970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2516970c4e46SJohan Hedberg u8 addr_type) 2517970c4e46SJohan Hedberg { 2518600a8749SAlain Michaud struct smp_irk *irk_to_return = NULL; 2519970c4e46SJohan Hedberg struct smp_irk *irk; 2520970c4e46SJohan Hedberg 25216cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 25226cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 25236cfc9988SJohan Hedberg return NULL; 25246cfc9988SJohan Hedberg 2525adae20cbSJohan Hedberg rcu_read_lock(); 2526adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2527970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2528adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2529600a8749SAlain Michaud irk_to_return = irk; 2530600a8749SAlain Michaud goto done; 2531970c4e46SJohan Hedberg } 2532adae20cbSJohan Hedberg } 2533600a8749SAlain Michaud 2534600a8749SAlain Michaud done: 2535600a8749SAlain Michaud 2536600a8749SAlain Michaud if (irk_to_return && hci_is_blocked_key(hdev, HCI_BLOCKED_KEY_TYPE_IRK, 2537600a8749SAlain Michaud irk_to_return->val)) { 2538600a8749SAlain Michaud bt_dev_warn_ratelimited(hdev, "Identity key blocked for %pMR", 2539600a8749SAlain Michaud &irk_to_return->bdaddr); 2540600a8749SAlain Michaud irk_to_return = NULL; 2541600a8749SAlain Michaud } 2542600a8749SAlain Michaud 2543adae20cbSJohan Hedberg rcu_read_unlock(); 2544970c4e46SJohan Hedberg 2545600a8749SAlain Michaud return irk_to_return; 2546970c4e46SJohan Hedberg } 2547970c4e46SJohan Hedberg 2548567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 25497652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 25507652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 255155ed8ca1SJohan Hedberg { 255255ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2553745c0ce3SVishal Agarwal u8 old_key_type; 255455ed8ca1SJohan Hedberg 255555ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 255655ed8ca1SJohan Hedberg if (old_key) { 255755ed8ca1SJohan Hedberg old_key_type = old_key->type; 255855ed8ca1SJohan Hedberg key = old_key; 255955ed8ca1SJohan Hedberg } else { 256012adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 25610a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 256255ed8ca1SJohan Hedberg if (!key) 2563567fa2aaSJohan Hedberg return NULL; 25640378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 256555ed8ca1SJohan Hedberg } 256655ed8ca1SJohan Hedberg 25676ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 256855ed8ca1SJohan Hedberg 2569d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2570d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2571d25e28abSJohan Hedberg * previous key */ 2572d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2573a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2574d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2575655fe6ecSJohan Hedberg if (conn) 2576655fe6ecSJohan Hedberg conn->key_type = type; 2577655fe6ecSJohan Hedberg } 2578d25e28abSJohan Hedberg 257955ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 25809b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 258155ed8ca1SJohan Hedberg key->pin_len = pin_len; 258255ed8ca1SJohan Hedberg 2583b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 258455ed8ca1SJohan Hedberg key->type = old_key_type; 25854748fed2SJohan Hedberg else 25864748fed2SJohan Hedberg key->type = type; 25874748fed2SJohan Hedberg 25887652ff6aSJohan Hedberg if (persistent) 25897652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 25907652ff6aSJohan Hedberg old_key_type); 25914df378a1SJohan Hedberg 2592567fa2aaSJohan Hedberg return key; 259355ed8ca1SJohan Hedberg } 259455ed8ca1SJohan Hedberg 2595ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 259635d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2597fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 259875d262c2SVinicius Costa Gomes { 2599c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2600e804d25dSJohan Hedberg u8 role = ltk_role(type); 260175d262c2SVinicius Costa Gomes 2602f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2603c9839a11SVinicius Costa Gomes if (old_key) 260475d262c2SVinicius Costa Gomes key = old_key; 2605c9839a11SVinicius Costa Gomes else { 26060a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 260775d262c2SVinicius Costa Gomes if (!key) 2608ca9142b8SJohan Hedberg return NULL; 2609970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 261075d262c2SVinicius Costa Gomes } 261175d262c2SVinicius Costa Gomes 261275d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2613c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2614c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2615c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2616c9839a11SVinicius Costa Gomes key->ediv = ediv; 2617fe39c7b2SMarcel Holtmann key->rand = rand; 2618c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2619c9839a11SVinicius Costa Gomes key->type = type; 262075d262c2SVinicius Costa Gomes 2621ca9142b8SJohan Hedberg return key; 262275d262c2SVinicius Costa Gomes } 262375d262c2SVinicius Costa Gomes 2624ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2625ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2626970c4e46SJohan Hedberg { 2627970c4e46SJohan Hedberg struct smp_irk *irk; 2628970c4e46SJohan Hedberg 2629970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2630970c4e46SJohan Hedberg if (!irk) { 2631970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2632970c4e46SJohan Hedberg if (!irk) 2633ca9142b8SJohan Hedberg return NULL; 2634970c4e46SJohan Hedberg 2635970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2636970c4e46SJohan Hedberg irk->addr_type = addr_type; 2637970c4e46SJohan Hedberg 2638adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2639970c4e46SJohan Hedberg } 2640970c4e46SJohan Hedberg 2641970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2642970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2643970c4e46SJohan Hedberg 2644ca9142b8SJohan Hedberg return irk; 2645970c4e46SJohan Hedberg } 2646970c4e46SJohan Hedberg 264755ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 264855ed8ca1SJohan Hedberg { 264955ed8ca1SJohan Hedberg struct link_key *key; 265055ed8ca1SJohan Hedberg 265155ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 265255ed8ca1SJohan Hedberg if (!key) 265355ed8ca1SJohan Hedberg return -ENOENT; 265455ed8ca1SJohan Hedberg 26556ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 265655ed8ca1SJohan Hedberg 26570378b597SJohan Hedberg list_del_rcu(&key->list); 26580378b597SJohan Hedberg kfree_rcu(key, rcu); 265955ed8ca1SJohan Hedberg 266055ed8ca1SJohan Hedberg return 0; 266155ed8ca1SJohan Hedberg } 266255ed8ca1SJohan Hedberg 2663e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2664b899efafSVinicius Costa Gomes { 2665970d0f1bSJohan Hedberg struct smp_ltk *k; 2666c51ffa0bSJohan Hedberg int removed = 0; 2667b899efafSVinicius Costa Gomes 2668970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2669e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2670b899efafSVinicius Costa Gomes continue; 2671b899efafSVinicius Costa Gomes 26726ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2673b899efafSVinicius Costa Gomes 2674970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2675970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2676c51ffa0bSJohan Hedberg removed++; 2677b899efafSVinicius Costa Gomes } 2678b899efafSVinicius Costa Gomes 2679c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2680b899efafSVinicius Costa Gomes } 2681b899efafSVinicius Costa Gomes 2682a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2683a7ec7338SJohan Hedberg { 2684adae20cbSJohan Hedberg struct smp_irk *k; 2685a7ec7338SJohan Hedberg 2686adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2687a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2688a7ec7338SJohan Hedberg continue; 2689a7ec7338SJohan Hedberg 2690a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2691a7ec7338SJohan Hedberg 2692adae20cbSJohan Hedberg list_del_rcu(&k->list); 2693adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2694a7ec7338SJohan Hedberg } 2695a7ec7338SJohan Hedberg } 2696a7ec7338SJohan Hedberg 269755e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 269855e76b38SJohan Hedberg { 269955e76b38SJohan Hedberg struct smp_ltk *k; 27004ba9faf3SJohan Hedberg struct smp_irk *irk; 270155e76b38SJohan Hedberg u8 addr_type; 270255e76b38SJohan Hedberg 270355e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 270455e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 270555e76b38SJohan Hedberg return true; 270655e76b38SJohan Hedberg return false; 270755e76b38SJohan Hedberg } 270855e76b38SJohan Hedberg 270955e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 271055e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 271155e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 271255e76b38SJohan Hedberg else 271355e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 271455e76b38SJohan Hedberg 27154ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 27164ba9faf3SJohan Hedberg if (irk) { 27174ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 27184ba9faf3SJohan Hedberg addr_type = irk->addr_type; 27194ba9faf3SJohan Hedberg } 27204ba9faf3SJohan Hedberg 272155e76b38SJohan Hedberg rcu_read_lock(); 272255e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 272387c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 272487c8b28dSJohan Hedberg rcu_read_unlock(); 272555e76b38SJohan Hedberg return true; 272655e76b38SJohan Hedberg } 272787c8b28dSJohan Hedberg } 272855e76b38SJohan Hedberg rcu_read_unlock(); 272955e76b38SJohan Hedberg 273055e76b38SJohan Hedberg return false; 273155e76b38SJohan Hedberg } 273255e76b38SJohan Hedberg 27336bd32326SVille Tervo /* HCI command timer function */ 273465cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 27356bd32326SVille Tervo { 273665cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 273765cc2b49SMarcel Holtmann cmd_timer.work); 27386bd32326SVille Tervo 2739bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2740bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2741bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2742bda4f23aSAndrei Emeltchenko 27432064ee33SMarcel Holtmann bt_dev_err(hdev, "command 0x%4.4x tx timeout", opcode); 2744bda4f23aSAndrei Emeltchenko } else { 27452064ee33SMarcel Holtmann bt_dev_err(hdev, "command tx timeout"); 2746bda4f23aSAndrei Emeltchenko } 2747bda4f23aSAndrei Emeltchenko 2748e2bef384SRajat Jain if (hdev->cmd_timeout) 2749e2bef384SRajat Jain hdev->cmd_timeout(hdev); 2750e2bef384SRajat Jain 27516bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2752c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 27536bd32326SVille Tervo } 27546bd32326SVille Tervo 27552763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 27566928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 27572763eda6SSzymon Janc { 27582763eda6SSzymon Janc struct oob_data *data; 27592763eda6SSzymon Janc 27606928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 27616928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 27626928a924SJohan Hedberg continue; 27636928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 27646928a924SJohan Hedberg continue; 27652763eda6SSzymon Janc return data; 27666928a924SJohan Hedberg } 27672763eda6SSzymon Janc 27682763eda6SSzymon Janc return NULL; 27692763eda6SSzymon Janc } 27702763eda6SSzymon Janc 27716928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 27726928a924SJohan Hedberg u8 bdaddr_type) 27732763eda6SSzymon Janc { 27742763eda6SSzymon Janc struct oob_data *data; 27752763eda6SSzymon Janc 27766928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 27772763eda6SSzymon Janc if (!data) 27782763eda6SSzymon Janc return -ENOENT; 27792763eda6SSzymon Janc 27806928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 27812763eda6SSzymon Janc 27822763eda6SSzymon Janc list_del(&data->list); 27832763eda6SSzymon Janc kfree(data); 27842763eda6SSzymon Janc 27852763eda6SSzymon Janc return 0; 27862763eda6SSzymon Janc } 27872763eda6SSzymon Janc 278835f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 27892763eda6SSzymon Janc { 27902763eda6SSzymon Janc struct oob_data *data, *n; 27912763eda6SSzymon Janc 27922763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 27932763eda6SSzymon Janc list_del(&data->list); 27942763eda6SSzymon Janc kfree(data); 27952763eda6SSzymon Janc } 27962763eda6SSzymon Janc } 27972763eda6SSzymon Janc 27980798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 27996928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 280038da1703SJohan Hedberg u8 *hash256, u8 *rand256) 28010798872eSMarcel Holtmann { 28020798872eSMarcel Holtmann struct oob_data *data; 28030798872eSMarcel Holtmann 28046928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 28050798872eSMarcel Holtmann if (!data) { 28060a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 28070798872eSMarcel Holtmann if (!data) 28080798872eSMarcel Holtmann return -ENOMEM; 28090798872eSMarcel Holtmann 28100798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 28116928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 28120798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 28130798872eSMarcel Holtmann } 28140798872eSMarcel Holtmann 281581328d5cSJohan Hedberg if (hash192 && rand192) { 28160798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 281738da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2818f7697b16SMarcel Holtmann if (hash256 && rand256) 2819f7697b16SMarcel Holtmann data->present = 0x03; 282081328d5cSJohan Hedberg } else { 282181328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 282281328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2823f7697b16SMarcel Holtmann if (hash256 && rand256) 2824f7697b16SMarcel Holtmann data->present = 0x02; 2825f7697b16SMarcel Holtmann else 2826f7697b16SMarcel Holtmann data->present = 0x00; 282781328d5cSJohan Hedberg } 28280798872eSMarcel Holtmann 282981328d5cSJohan Hedberg if (hash256 && rand256) { 28300798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 283138da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 283281328d5cSJohan Hedberg } else { 283381328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 283481328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2835f7697b16SMarcel Holtmann if (hash192 && rand192) 2836f7697b16SMarcel Holtmann data->present = 0x01; 283781328d5cSJohan Hedberg } 28380798872eSMarcel Holtmann 28396ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 28402763eda6SSzymon Janc 28412763eda6SSzymon Janc return 0; 28422763eda6SSzymon Janc } 28432763eda6SSzymon Janc 2844d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2845d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2846d2609b34SFlorian Grandel { 2847d2609b34SFlorian Grandel struct adv_info *adv_instance; 2848d2609b34SFlorian Grandel 2849d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2850d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2851d2609b34SFlorian Grandel return adv_instance; 2852d2609b34SFlorian Grandel } 2853d2609b34SFlorian Grandel 2854d2609b34SFlorian Grandel return NULL; 2855d2609b34SFlorian Grandel } 2856d2609b34SFlorian Grandel 2857d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 285874b93e9fSPrasanna Karthik struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) 285974b93e9fSPrasanna Karthik { 2860d2609b34SFlorian Grandel struct adv_info *cur_instance; 2861d2609b34SFlorian Grandel 2862d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2863d2609b34SFlorian Grandel if (!cur_instance) 2864d2609b34SFlorian Grandel return NULL; 2865d2609b34SFlorian Grandel 2866d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2867d2609b34SFlorian Grandel struct adv_info, list)) 2868d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2869d2609b34SFlorian Grandel struct adv_info, list); 2870d2609b34SFlorian Grandel else 2871d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2872d2609b34SFlorian Grandel } 2873d2609b34SFlorian Grandel 2874d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2875d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2876d2609b34SFlorian Grandel { 2877d2609b34SFlorian Grandel struct adv_info *adv_instance; 2878d2609b34SFlorian Grandel 2879d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2880d2609b34SFlorian Grandel if (!adv_instance) 2881d2609b34SFlorian Grandel return -ENOENT; 2882d2609b34SFlorian Grandel 2883d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2884d2609b34SFlorian Grandel 2885cab054abSJohan Hedberg if (hdev->cur_adv_instance == instance) { 2886cab054abSJohan Hedberg if (hdev->adv_instance_timeout) { 28875d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 28885d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 28895d900e46SFlorian Grandel } 2890cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2891cab054abSJohan Hedberg } 28925d900e46SFlorian Grandel 2893a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 2894a73c046aSJaganath Kanakkassery 2895d2609b34SFlorian Grandel list_del(&adv_instance->list); 2896d2609b34SFlorian Grandel kfree(adv_instance); 2897d2609b34SFlorian Grandel 2898d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2899d2609b34SFlorian Grandel 2900d2609b34SFlorian Grandel return 0; 2901d2609b34SFlorian Grandel } 2902d2609b34SFlorian Grandel 2903a73c046aSJaganath Kanakkassery void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired) 2904a73c046aSJaganath Kanakkassery { 2905a73c046aSJaganath Kanakkassery struct adv_info *adv_instance, *n; 2906a73c046aSJaganath Kanakkassery 2907a73c046aSJaganath Kanakkassery list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) 2908a73c046aSJaganath Kanakkassery adv_instance->rpa_expired = rpa_expired; 2909a73c046aSJaganath Kanakkassery } 2910a73c046aSJaganath Kanakkassery 2911d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2912d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2913d2609b34SFlorian Grandel { 2914d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2915d2609b34SFlorian Grandel 29165d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 29175d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 29185d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 29195d900e46SFlorian Grandel } 29205d900e46SFlorian Grandel 2921d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2922a73c046aSJaganath Kanakkassery cancel_delayed_work_sync(&adv_instance->rpa_expired_cb); 2923d2609b34SFlorian Grandel list_del(&adv_instance->list); 2924d2609b34SFlorian Grandel kfree(adv_instance); 2925d2609b34SFlorian Grandel } 2926d2609b34SFlorian Grandel 2927d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2928cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2929d2609b34SFlorian Grandel } 2930d2609b34SFlorian Grandel 2931a73c046aSJaganath Kanakkassery static void adv_instance_rpa_expired(struct work_struct *work) 2932a73c046aSJaganath Kanakkassery { 2933a73c046aSJaganath Kanakkassery struct adv_info *adv_instance = container_of(work, struct adv_info, 2934a73c046aSJaganath Kanakkassery rpa_expired_cb.work); 2935a73c046aSJaganath Kanakkassery 2936a73c046aSJaganath Kanakkassery BT_DBG(""); 2937a73c046aSJaganath Kanakkassery 2938a73c046aSJaganath Kanakkassery adv_instance->rpa_expired = true; 2939a73c046aSJaganath Kanakkassery } 2940a73c046aSJaganath Kanakkassery 2941d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2942d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2943d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2944d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2945d2609b34SFlorian Grandel u16 timeout, u16 duration) 2946d2609b34SFlorian Grandel { 2947d2609b34SFlorian Grandel struct adv_info *adv_instance; 2948d2609b34SFlorian Grandel 2949d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2950d2609b34SFlorian Grandel if (adv_instance) { 2951d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2952d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2953d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2954d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2955d2609b34SFlorian Grandel } else { 29561d0fac2cSLuiz Augusto von Dentz if (hdev->adv_instance_cnt >= hdev->le_num_of_adv_sets || 2957d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2958d2609b34SFlorian Grandel return -EOVERFLOW; 2959d2609b34SFlorian Grandel 296039ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2961d2609b34SFlorian Grandel if (!adv_instance) 2962d2609b34SFlorian Grandel return -ENOMEM; 2963d2609b34SFlorian Grandel 2964fffd38bcSFlorian Grandel adv_instance->pending = true; 2965d2609b34SFlorian Grandel adv_instance->instance = instance; 2966d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2967d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2968d2609b34SFlorian Grandel } 2969d2609b34SFlorian Grandel 2970d2609b34SFlorian Grandel adv_instance->flags = flags; 2971d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2972d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2973d2609b34SFlorian Grandel 2974d2609b34SFlorian Grandel if (adv_data_len) 2975d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2976d2609b34SFlorian Grandel 2977d2609b34SFlorian Grandel if (scan_rsp_len) 2978d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2979d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2980d2609b34SFlorian Grandel 2981d2609b34SFlorian Grandel adv_instance->timeout = timeout; 29825d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2983d2609b34SFlorian Grandel 2984d2609b34SFlorian Grandel if (duration == 0) 2985d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2986d2609b34SFlorian Grandel else 2987d2609b34SFlorian Grandel adv_instance->duration = duration; 2988d2609b34SFlorian Grandel 2989de181e88SJaganath Kanakkassery adv_instance->tx_power = HCI_TX_POWER_INVALID; 2990de181e88SJaganath Kanakkassery 2991a73c046aSJaganath Kanakkassery INIT_DELAYED_WORK(&adv_instance->rpa_expired_cb, 2992a73c046aSJaganath Kanakkassery adv_instance_rpa_expired); 2993a73c046aSJaganath Kanakkassery 2994d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2995d2609b34SFlorian Grandel 2996d2609b34SFlorian Grandel return 0; 2997d2609b34SFlorian Grandel } 2998d2609b34SFlorian Grandel 2999dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 3000b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3001b2a66aadSAntti Julku { 3002b2a66aadSAntti Julku struct bdaddr_list *b; 3003b2a66aadSAntti Julku 3004dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 3005b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3006b2a66aadSAntti Julku return b; 3007b9ee0a78SMarcel Holtmann } 3008b2a66aadSAntti Julku 3009b2a66aadSAntti Julku return NULL; 3010b2a66aadSAntti Julku } 3011b2a66aadSAntti Julku 3012b950aa88SAnkit Navik struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk( 3013b950aa88SAnkit Navik struct list_head *bdaddr_list, bdaddr_t *bdaddr, 3014b950aa88SAnkit Navik u8 type) 3015b950aa88SAnkit Navik { 3016b950aa88SAnkit Navik struct bdaddr_list_with_irk *b; 3017b950aa88SAnkit Navik 3018b950aa88SAnkit Navik list_for_each_entry(b, bdaddr_list, list) { 3019b950aa88SAnkit Navik if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3020b950aa88SAnkit Navik return b; 3021b950aa88SAnkit Navik } 3022b950aa88SAnkit Navik 3023b950aa88SAnkit Navik return NULL; 3024b950aa88SAnkit Navik } 3025b950aa88SAnkit Navik 3026dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 3027b2a66aadSAntti Julku { 30287eb7404fSGeliang Tang struct bdaddr_list *b, *n; 3029b2a66aadSAntti Julku 30307eb7404fSGeliang Tang list_for_each_entry_safe(b, n, bdaddr_list, list) { 30317eb7404fSGeliang Tang list_del(&b->list); 3032b2a66aadSAntti Julku kfree(b); 3033b2a66aadSAntti Julku } 3034b2a66aadSAntti Julku } 3035b2a66aadSAntti Julku 3036dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3037b2a66aadSAntti Julku { 3038b2a66aadSAntti Julku struct bdaddr_list *entry; 3039b2a66aadSAntti Julku 3040b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3041b2a66aadSAntti Julku return -EBADF; 3042b2a66aadSAntti Julku 3043dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 30445e762444SAntti Julku return -EEXIST; 3045b2a66aadSAntti Julku 304627f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 30475e762444SAntti Julku if (!entry) 30485e762444SAntti Julku return -ENOMEM; 3049b2a66aadSAntti Julku 3050b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3051b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3052b2a66aadSAntti Julku 3053dcc36c16SJohan Hedberg list_add(&entry->list, list); 3054b2a66aadSAntti Julku 30552a8357f2SJohan Hedberg return 0; 3056b2a66aadSAntti Julku } 3057b2a66aadSAntti Julku 3058b950aa88SAnkit Navik int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr, 3059b950aa88SAnkit Navik u8 type, u8 *peer_irk, u8 *local_irk) 3060b950aa88SAnkit Navik { 3061b950aa88SAnkit Navik struct bdaddr_list_with_irk *entry; 3062b950aa88SAnkit Navik 3063b950aa88SAnkit Navik if (!bacmp(bdaddr, BDADDR_ANY)) 3064b950aa88SAnkit Navik return -EBADF; 3065b950aa88SAnkit Navik 3066b950aa88SAnkit Navik if (hci_bdaddr_list_lookup(list, bdaddr, type)) 3067b950aa88SAnkit Navik return -EEXIST; 3068b950aa88SAnkit Navik 3069b950aa88SAnkit Navik entry = kzalloc(sizeof(*entry), GFP_KERNEL); 3070b950aa88SAnkit Navik if (!entry) 3071b950aa88SAnkit Navik return -ENOMEM; 3072b950aa88SAnkit Navik 3073b950aa88SAnkit Navik bacpy(&entry->bdaddr, bdaddr); 3074b950aa88SAnkit Navik entry->bdaddr_type = type; 3075b950aa88SAnkit Navik 3076b950aa88SAnkit Navik if (peer_irk) 3077b950aa88SAnkit Navik memcpy(entry->peer_irk, peer_irk, 16); 3078b950aa88SAnkit Navik 3079b950aa88SAnkit Navik if (local_irk) 3080b950aa88SAnkit Navik memcpy(entry->local_irk, local_irk, 16); 3081b950aa88SAnkit Navik 3082b950aa88SAnkit Navik list_add(&entry->list, list); 3083b950aa88SAnkit Navik 3084b950aa88SAnkit Navik return 0; 3085b950aa88SAnkit Navik } 3086b950aa88SAnkit Navik 3087dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3088b2a66aadSAntti Julku { 3089b2a66aadSAntti Julku struct bdaddr_list *entry; 3090b2a66aadSAntti Julku 309135f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 3092dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 309335f7498aSJohan Hedberg return 0; 309435f7498aSJohan Hedberg } 3095b2a66aadSAntti Julku 3096dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 3097d2ab0ac1SMarcel Holtmann if (!entry) 3098d2ab0ac1SMarcel Holtmann return -ENOENT; 3099d2ab0ac1SMarcel Holtmann 3100d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3101d2ab0ac1SMarcel Holtmann kfree(entry); 3102d2ab0ac1SMarcel Holtmann 3103d2ab0ac1SMarcel Holtmann return 0; 3104d2ab0ac1SMarcel Holtmann } 3105d2ab0ac1SMarcel Holtmann 3106b950aa88SAnkit Navik int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr, 3107b950aa88SAnkit Navik u8 type) 3108b950aa88SAnkit Navik { 3109b950aa88SAnkit Navik struct bdaddr_list_with_irk *entry; 3110b950aa88SAnkit Navik 3111b950aa88SAnkit Navik if (!bacmp(bdaddr, BDADDR_ANY)) { 3112b950aa88SAnkit Navik hci_bdaddr_list_clear(list); 3113b950aa88SAnkit Navik return 0; 3114b950aa88SAnkit Navik } 3115b950aa88SAnkit Navik 3116b950aa88SAnkit Navik entry = hci_bdaddr_list_lookup_with_irk(list, bdaddr, type); 3117b950aa88SAnkit Navik if (!entry) 3118b950aa88SAnkit Navik return -ENOENT; 3119b950aa88SAnkit Navik 3120b950aa88SAnkit Navik list_del(&entry->list); 3121b950aa88SAnkit Navik kfree(entry); 3122b950aa88SAnkit Navik 3123b950aa88SAnkit Navik return 0; 3124b950aa88SAnkit Navik } 3125b950aa88SAnkit Navik 312615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 312715819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 312815819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 312915819a70SAndre Guedes { 313015819a70SAndre Guedes struct hci_conn_params *params; 313115819a70SAndre Guedes 313215819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 313315819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 313415819a70SAndre Guedes params->addr_type == addr_type) { 313515819a70SAndre Guedes return params; 313615819a70SAndre Guedes } 313715819a70SAndre Guedes } 313815819a70SAndre Guedes 313915819a70SAndre Guedes return NULL; 314015819a70SAndre Guedes } 314115819a70SAndre Guedes 314215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3143501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 31444b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 314515819a70SAndre Guedes { 3146912b42efSJohan Hedberg struct hci_conn_params *param; 314715819a70SAndre Guedes 3148501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3149912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3150912b42efSJohan Hedberg param->addr_type == addr_type) 3151912b42efSJohan Hedberg return param; 31524b10966fSMarcel Holtmann } 31534b10966fSMarcel Holtmann 31544b10966fSMarcel Holtmann return NULL; 315515819a70SAndre Guedes } 315615819a70SAndre Guedes 315715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 315851d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 315951d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 316015819a70SAndre Guedes { 316115819a70SAndre Guedes struct hci_conn_params *params; 316215819a70SAndre Guedes 316315819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 3164cef952ceSAndre Guedes if (params) 316551d167c0SMarcel Holtmann return params; 316615819a70SAndre Guedes 316715819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 316815819a70SAndre Guedes if (!params) { 31692064ee33SMarcel Holtmann bt_dev_err(hdev, "out of memory"); 317051d167c0SMarcel Holtmann return NULL; 317115819a70SAndre Guedes } 317215819a70SAndre Guedes 317315819a70SAndre Guedes bacpy(¶ms->addr, addr); 317415819a70SAndre Guedes params->addr_type = addr_type; 3175cef952ceSAndre Guedes 3176cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 317793450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3178cef952ceSAndre Guedes 3179bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3180bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3181bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3182bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3183bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3184bf5b3c8bSMarcel Holtmann 3185bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3186bf5b3c8bSMarcel Holtmann 318751d167c0SMarcel Holtmann return params; 3188bf5b3c8bSMarcel Holtmann } 3189bf5b3c8bSMarcel Holtmann 3190f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 3191f6c63249SJohan Hedberg { 3192f6c63249SJohan Hedberg if (params->conn) { 3193f6c63249SJohan Hedberg hci_conn_drop(params->conn); 3194f6c63249SJohan Hedberg hci_conn_put(params->conn); 3195f6c63249SJohan Hedberg } 3196f6c63249SJohan Hedberg 3197f6c63249SJohan Hedberg list_del(¶ms->action); 3198f6c63249SJohan Hedberg list_del(¶ms->list); 3199f6c63249SJohan Hedberg kfree(params); 3200f6c63249SJohan Hedberg } 3201f6c63249SJohan Hedberg 320215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 320315819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 320415819a70SAndre Guedes { 320515819a70SAndre Guedes struct hci_conn_params *params; 320615819a70SAndre Guedes 320715819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 320815819a70SAndre Guedes if (!params) 320915819a70SAndre Guedes return; 321015819a70SAndre Guedes 3211f6c63249SJohan Hedberg hci_conn_params_free(params); 321215819a70SAndre Guedes 321395305baaSJohan Hedberg hci_update_background_scan(hdev); 321495305baaSJohan Hedberg 321515819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 321615819a70SAndre Guedes } 321715819a70SAndre Guedes 321815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 321955af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 322015819a70SAndre Guedes { 322115819a70SAndre Guedes struct hci_conn_params *params, *tmp; 322215819a70SAndre Guedes 322315819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 322455af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 322555af49a8SJohan Hedberg continue; 3226f75113a2SJakub Pawlowski 3227f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 3228f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 3229f75113a2SJakub Pawlowski */ 3230f75113a2SJakub Pawlowski if (params->explicit_connect) { 3231f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 3232f75113a2SJakub Pawlowski continue; 3233f75113a2SJakub Pawlowski } 3234f75113a2SJakub Pawlowski 323515819a70SAndre Guedes list_del(¶ms->list); 323615819a70SAndre Guedes kfree(params); 323715819a70SAndre Guedes } 323815819a70SAndre Guedes 323955af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 324055af49a8SJohan Hedberg } 324155af49a8SJohan Hedberg 324255af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3243030e7f81SJohan Hedberg static void hci_conn_params_clear_all(struct hci_dev *hdev) 324415819a70SAndre Guedes { 324515819a70SAndre Guedes struct hci_conn_params *params, *tmp; 324615819a70SAndre Guedes 3247f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3248f6c63249SJohan Hedberg hci_conn_params_free(params); 324915819a70SAndre Guedes 325015819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 325115819a70SAndre Guedes } 325215819a70SAndre Guedes 3253a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3254a1f4c318SJohan Hedberg * 3255a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3256a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3257a1f4c318SJohan Hedberg * the static random address. 3258a1f4c318SJohan Hedberg * 3259a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3260a1f4c318SJohan Hedberg * public address to use the static random address instead. 326150b5b952SMarcel Holtmann * 326250b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 326350b5b952SMarcel Holtmann * userspace has configured a static address, then that address 326450b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 3265a1f4c318SJohan Hedberg */ 3266a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3267a1f4c318SJohan Hedberg u8 *bdaddr_type) 3268a1f4c318SJohan Hedberg { 3269b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 327050b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 3271d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 327250b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 3273a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3274a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3275a1f4c318SJohan Hedberg } else { 3276a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3277a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3278a1f4c318SJohan Hedberg } 3279a1f4c318SJohan Hedberg } 3280a1f4c318SJohan Hedberg 32819952d90eSAbhishek Pandit-Subedi static int hci_suspend_wait_event(struct hci_dev *hdev) 32829952d90eSAbhishek Pandit-Subedi { 32839952d90eSAbhishek Pandit-Subedi #define WAKE_COND \ 32849952d90eSAbhishek Pandit-Subedi (find_first_bit(hdev->suspend_tasks, __SUSPEND_NUM_TASKS) == \ 32859952d90eSAbhishek Pandit-Subedi __SUSPEND_NUM_TASKS) 32869952d90eSAbhishek Pandit-Subedi 32879952d90eSAbhishek Pandit-Subedi int i; 32889952d90eSAbhishek Pandit-Subedi int ret = wait_event_timeout(hdev->suspend_wait_q, 32899952d90eSAbhishek Pandit-Subedi WAKE_COND, SUSPEND_NOTIFIER_TIMEOUT); 32909952d90eSAbhishek Pandit-Subedi 32919952d90eSAbhishek Pandit-Subedi if (ret == 0) { 3292a9ec8423SAbhishek Pandit-Subedi bt_dev_err(hdev, "Timed out waiting for suspend events"); 32939952d90eSAbhishek Pandit-Subedi for (i = 0; i < __SUSPEND_NUM_TASKS; ++i) { 32949952d90eSAbhishek Pandit-Subedi if (test_bit(i, hdev->suspend_tasks)) 3295a9ec8423SAbhishek Pandit-Subedi bt_dev_err(hdev, "Suspend timeout bit: %d", i); 32969952d90eSAbhishek Pandit-Subedi clear_bit(i, hdev->suspend_tasks); 32979952d90eSAbhishek Pandit-Subedi } 32989952d90eSAbhishek Pandit-Subedi 32999952d90eSAbhishek Pandit-Subedi ret = -ETIMEDOUT; 33009952d90eSAbhishek Pandit-Subedi } else { 33019952d90eSAbhishek Pandit-Subedi ret = 0; 33029952d90eSAbhishek Pandit-Subedi } 33039952d90eSAbhishek Pandit-Subedi 33049952d90eSAbhishek Pandit-Subedi return ret; 33059952d90eSAbhishek Pandit-Subedi } 33069952d90eSAbhishek Pandit-Subedi 33079952d90eSAbhishek Pandit-Subedi static void hci_prepare_suspend(struct work_struct *work) 33089952d90eSAbhishek Pandit-Subedi { 33099952d90eSAbhishek Pandit-Subedi struct hci_dev *hdev = 33109952d90eSAbhishek Pandit-Subedi container_of(work, struct hci_dev, suspend_prepare); 33119952d90eSAbhishek Pandit-Subedi 33129952d90eSAbhishek Pandit-Subedi hci_dev_lock(hdev); 33139952d90eSAbhishek Pandit-Subedi hci_req_prepare_suspend(hdev, hdev->suspend_state_next); 33149952d90eSAbhishek Pandit-Subedi hci_dev_unlock(hdev); 33159952d90eSAbhishek Pandit-Subedi } 33169952d90eSAbhishek Pandit-Subedi 33178731840aSAbhishek Pandit-Subedi static int hci_change_suspend_state(struct hci_dev *hdev, 33188731840aSAbhishek Pandit-Subedi enum suspended_state next) 33198731840aSAbhishek Pandit-Subedi { 33208731840aSAbhishek Pandit-Subedi hdev->suspend_state_next = next; 33218731840aSAbhishek Pandit-Subedi set_bit(SUSPEND_PREPARE_NOTIFIER, hdev->suspend_tasks); 33228731840aSAbhishek Pandit-Subedi queue_work(hdev->req_workqueue, &hdev->suspend_prepare); 33238731840aSAbhishek Pandit-Subedi return hci_suspend_wait_event(hdev); 33248731840aSAbhishek Pandit-Subedi } 33258731840aSAbhishek Pandit-Subedi 33269952d90eSAbhishek Pandit-Subedi static int hci_suspend_notifier(struct notifier_block *nb, unsigned long action, 33279952d90eSAbhishek Pandit-Subedi void *data) 33289952d90eSAbhishek Pandit-Subedi { 33299952d90eSAbhishek Pandit-Subedi struct hci_dev *hdev = 33309952d90eSAbhishek Pandit-Subedi container_of(nb, struct hci_dev, suspend_notifier); 33319952d90eSAbhishek Pandit-Subedi int ret = 0; 33329952d90eSAbhishek Pandit-Subedi 33339952d90eSAbhishek Pandit-Subedi /* If powering down, wait for completion. */ 33349952d90eSAbhishek Pandit-Subedi if (mgmt_powering_down(hdev)) { 33359952d90eSAbhishek Pandit-Subedi set_bit(SUSPEND_POWERING_DOWN, hdev->suspend_tasks); 33369952d90eSAbhishek Pandit-Subedi ret = hci_suspend_wait_event(hdev); 33379952d90eSAbhishek Pandit-Subedi if (ret) 33389952d90eSAbhishek Pandit-Subedi goto done; 33399952d90eSAbhishek Pandit-Subedi } 33409952d90eSAbhishek Pandit-Subedi 33419952d90eSAbhishek Pandit-Subedi /* Suspend notifier should only act on events when powered. */ 33429952d90eSAbhishek Pandit-Subedi if (!hdev_is_powered(hdev)) 33439952d90eSAbhishek Pandit-Subedi goto done; 33449952d90eSAbhishek Pandit-Subedi 33459952d90eSAbhishek Pandit-Subedi if (action == PM_SUSPEND_PREPARE) { 33464f40afc6SAbhishek Pandit-Subedi /* Suspend consists of two actions: 33474f40afc6SAbhishek Pandit-Subedi * - First, disconnect everything and make the controller not 33484f40afc6SAbhishek Pandit-Subedi * connectable (disabling scanning) 33494f40afc6SAbhishek Pandit-Subedi * - Second, program event filter/whitelist and enable scan 33504f40afc6SAbhishek Pandit-Subedi */ 33518731840aSAbhishek Pandit-Subedi ret = hci_change_suspend_state(hdev, BT_SUSPEND_DISCONNECT); 33524f40afc6SAbhishek Pandit-Subedi 335381dafad5SAbhishek Pandit-Subedi /* Only configure whitelist if disconnect succeeded and wake 335481dafad5SAbhishek Pandit-Subedi * isn't being prevented. 335581dafad5SAbhishek Pandit-Subedi */ 335681dafad5SAbhishek Pandit-Subedi if (!ret && !(hdev->prevent_wake && hdev->prevent_wake(hdev))) 33578731840aSAbhishek Pandit-Subedi ret = hci_change_suspend_state(hdev, 33580d2c9825SAbhishek Pandit-Subedi BT_SUSPEND_CONFIGURE_WAKE); 33599952d90eSAbhishek Pandit-Subedi } else if (action == PM_POST_SUSPEND) { 33608731840aSAbhishek Pandit-Subedi ret = hci_change_suspend_state(hdev, BT_RUNNING); 33619952d90eSAbhishek Pandit-Subedi } 33629952d90eSAbhishek Pandit-Subedi 33639952d90eSAbhishek Pandit-Subedi done: 3364a9ec8423SAbhishek Pandit-Subedi /* We always allow suspend even if suspend preparation failed and 3365a9ec8423SAbhishek Pandit-Subedi * attempt to recover in resume. 3366a9ec8423SAbhishek Pandit-Subedi */ 3367a9ec8423SAbhishek Pandit-Subedi if (ret) 3368a9ec8423SAbhishek Pandit-Subedi bt_dev_err(hdev, "Suspend notifier action (%lu) failed: %d", 3369a9ec8423SAbhishek Pandit-Subedi action, ret); 3370a9ec8423SAbhishek Pandit-Subedi 3371a9ec8423SAbhishek Pandit-Subedi return NOTIFY_STOP; 33729952d90eSAbhishek Pandit-Subedi } 33738731840aSAbhishek Pandit-Subedi 33749be0dab7SDavid Herrmann /* Alloc HCI device */ 33759be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 33769be0dab7SDavid Herrmann { 33779be0dab7SDavid Herrmann struct hci_dev *hdev; 33789be0dab7SDavid Herrmann 337927f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 33809be0dab7SDavid Herrmann if (!hdev) 33819be0dab7SDavid Herrmann return NULL; 33829be0dab7SDavid Herrmann 3383b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3384b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3385b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3386b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3387b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 338896c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3389bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3390bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3391d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 3392d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 33935d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 3394b1b813d4SDavid Herrmann 3395b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3396b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3397b1b813d4SDavid Herrmann 33983f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3399628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3400628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3401bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3402bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 3403b48c3b59SJonas Holmberg hdev->le_conn_min_interval = 0x0018; 3404b48c3b59SJonas Holmberg hdev->le_conn_max_interval = 0x0028; 340504fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 340604fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3407a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3408a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3409a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3410a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3411a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3412a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 341330d65e08SMatias Karhumaa hdev->le_max_key_size = SMP_MAX_ENC_KEY_SIZE; 341430d65e08SMatias Karhumaa hdev->le_min_key_size = SMP_MIN_ENC_KEY_SIZE; 34156decb5b4SJaganath Kanakkassery hdev->le_tx_def_phys = HCI_LE_SET_PHY_1M; 34166decb5b4SJaganath Kanakkassery hdev->le_rx_def_phys = HCI_LE_SET_PHY_1M; 34171d0fac2cSLuiz Augusto von Dentz hdev->le_num_of_adv_sets = HCI_MAX_ADV_INSTANCES; 3418bef64738SMarcel Holtmann 3419d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3420b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 342131ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 342231ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3423302975cbSSpoorthi Ravishankar Koppad hdev->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT; 342458a96fc3SMarcel Holtmann hdev->min_enc_key_size = HCI_MIN_ENC_KEY_SIZE; 3425d6bfd59cSJohan Hedberg 3426b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3427b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3428b1b813d4SDavid Herrmann 3429b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3430b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 34316659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 34324f40afc6SAbhishek Pandit-Subedi INIT_LIST_HEAD(&hdev->wakeable); 3433b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3434b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3435b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3436970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3437b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3438d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 3439cfdb0c2dSAnkit Navik INIT_LIST_HEAD(&hdev->le_resolv_list); 344015819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 344177a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 344266f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 34436b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3444d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3445600a8749SAlain Michaud INIT_LIST_HEAD(&hdev->blocked_keys); 3446b1b813d4SDavid Herrmann 3447b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3448b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3449b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3450b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3451c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 34529952d90eSAbhishek Pandit-Subedi INIT_WORK(&hdev->suspend_prepare, hci_prepare_suspend); 3453b1b813d4SDavid Herrmann 3454b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3455b1b813d4SDavid Herrmann 3456b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3457b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3458b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3459b1b813d4SDavid Herrmann 3460b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 34619952d90eSAbhishek Pandit-Subedi init_waitqueue_head(&hdev->suspend_wait_q); 3462b1b813d4SDavid Herrmann 346365cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3464b1b813d4SDavid Herrmann 34655fc16cc4SJohan Hedberg hci_request_setup(hdev); 34665fc16cc4SJohan Hedberg 3467b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3468b1b813d4SDavid Herrmann discovery_init(hdev); 34699be0dab7SDavid Herrmann 34709be0dab7SDavid Herrmann return hdev; 34719be0dab7SDavid Herrmann } 34729be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 34739be0dab7SDavid Herrmann 34749be0dab7SDavid Herrmann /* Free HCI device */ 34759be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 34769be0dab7SDavid Herrmann { 34779be0dab7SDavid Herrmann /* will free via device release */ 34789be0dab7SDavid Herrmann put_device(&hdev->dev); 34799be0dab7SDavid Herrmann } 34809be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 34819be0dab7SDavid Herrmann 34821da177e4SLinus Torvalds /* Register HCI device */ 34831da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 34841da177e4SLinus Torvalds { 3485b1b813d4SDavid Herrmann int id, error; 34861da177e4SLinus Torvalds 348774292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 34881da177e4SLinus Torvalds return -EINVAL; 34891da177e4SLinus Torvalds 349008add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 349108add513SMat Martineau * so the index can be used as the AMP controller ID. 349208add513SMat Martineau */ 34933df92b31SSasha Levin switch (hdev->dev_type) { 3494ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 34953df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 34961da177e4SLinus Torvalds break; 34973df92b31SSasha Levin case HCI_AMP: 34983df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 34993df92b31SSasha Levin break; 35003df92b31SSasha Levin default: 35013df92b31SSasha Levin return -EINVAL; 35021da177e4SLinus Torvalds } 35031da177e4SLinus Torvalds 35043df92b31SSasha Levin if (id < 0) 35053df92b31SSasha Levin return id; 35063df92b31SSasha Levin 35071da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 35081da177e4SLinus Torvalds hdev->id = id; 35092d8b3a11SAndrei Emeltchenko 35102d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 35112d8b3a11SAndrei Emeltchenko 351229e2dd0dSTejun Heo hdev->workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, hdev->name); 351333ca954dSDavid Herrmann if (!hdev->workqueue) { 351433ca954dSDavid Herrmann error = -ENOMEM; 351533ca954dSDavid Herrmann goto err; 351633ca954dSDavid Herrmann } 3517f48fd9c8SMarcel Holtmann 351829e2dd0dSTejun Heo hdev->req_workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, 351929e2dd0dSTejun Heo hdev->name); 35206ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 35216ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 35226ead1bbcSJohan Hedberg error = -ENOMEM; 35236ead1bbcSJohan Hedberg goto err; 35246ead1bbcSJohan Hedberg } 35256ead1bbcSJohan Hedberg 35260153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 35270153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 35280153e2ecSMarcel Holtmann 3529bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3530bdc3e0f1SMarcel Holtmann 3531bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 353233ca954dSDavid Herrmann if (error < 0) 353354506918SJohan Hedberg goto err_wqueue; 35341da177e4SLinus Torvalds 35356d5d2ee6SHeiner Kallweit hci_leds_init(hdev); 35366d5d2ee6SHeiner Kallweit 3537611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3538a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3539a8c5fb1aSGustavo Padovan hdev); 3540611b30f7SMarcel Holtmann if (hdev->rfkill) { 3541611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3542611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3543611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3544611b30f7SMarcel Holtmann } 3545611b30f7SMarcel Holtmann } 3546611b30f7SMarcel Holtmann 35475e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3548a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 35495e130367SJohan Hedberg 3550a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3551a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3552ce2be9acSAndrei Emeltchenko 3553ca8bee5dSMarcel Holtmann if (hdev->dev_type == HCI_PRIMARY) { 355456f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 355556f87901SJohan Hedberg * through reading supported features during init. 355656f87901SJohan Hedberg */ 3557a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 355856f87901SJohan Hedberg } 3559ce2be9acSAndrei Emeltchenko 3560fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3561fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3562fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3563fcee3377SGustavo Padovan 35644a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 35654a964404SMarcel Holtmann * and should not be included in normal operation. 3566fee746b0SMarcel Holtmann */ 3567fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3568a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3569fee746b0SMarcel Holtmann 357005fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3571dc946bd8SDavid Herrmann hci_dev_hold(hdev); 35721da177e4SLinus Torvalds 35739952d90eSAbhishek Pandit-Subedi hdev->suspend_notifier.notifier_call = hci_suspend_notifier; 35749952d90eSAbhishek Pandit-Subedi error = register_pm_notifier(&hdev->suspend_notifier); 35759952d90eSAbhishek Pandit-Subedi if (error) 35769952d90eSAbhishek Pandit-Subedi goto err_wqueue; 35779952d90eSAbhishek Pandit-Subedi 357819202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3579fbe96d6fSMarcel Holtmann 35801da177e4SLinus Torvalds return id; 3581f48fd9c8SMarcel Holtmann 358233ca954dSDavid Herrmann err_wqueue: 358333ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 35846ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 358533ca954dSDavid Herrmann err: 35863df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3587f48fd9c8SMarcel Holtmann 358833ca954dSDavid Herrmann return error; 35891da177e4SLinus Torvalds } 35901da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 35911da177e4SLinus Torvalds 35921da177e4SLinus Torvalds /* Unregister HCI device */ 359359735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 35941da177e4SLinus Torvalds { 35952d7cc19eSMarcel Holtmann int id; 3596ef222013SMarcel Holtmann 3597c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 35981da177e4SLinus Torvalds 3599a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 360094324962SJohan Hovold 36013df92b31SSasha Levin id = hdev->id; 36023df92b31SSasha Levin 3603f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 36041da177e4SLinus Torvalds list_del(&hdev->list); 3605f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 36061da177e4SLinus Torvalds 3607b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3608b9b5ef18SGustavo Padovan 3609bf389cabSJiri Slaby hci_dev_do_close(hdev); 3610bf389cabSJiri Slaby 36119952d90eSAbhishek Pandit-Subedi unregister_pm_notifier(&hdev->suspend_notifier); 36129952d90eSAbhishek Pandit-Subedi 3613ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3614d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3615d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 361609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3617744cf19eSJohan Hedberg mgmt_index_removed(hdev); 361809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 361956e5cb86SJohan Hedberg } 3620ab81cbf9SJohan Hedberg 36212e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 36222e58ef3eSJohan Hedberg * pending list */ 36232e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 36242e58ef3eSJohan Hedberg 362505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 36261da177e4SLinus Torvalds 3627611b30f7SMarcel Holtmann if (hdev->rfkill) { 3628611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3629611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3630611b30f7SMarcel Holtmann } 3631611b30f7SMarcel Holtmann 3632bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3633147e2d59SDave Young 36340153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 36355177a838SMarcel Holtmann kfree_const(hdev->hw_info); 36365177a838SMarcel Holtmann kfree_const(hdev->fw_info); 36370153e2ecSMarcel Holtmann 3638f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 36396ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3640f48fd9c8SMarcel Holtmann 364109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3642dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 36436659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 36442aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 364555ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3646b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3647970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 36482763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3649d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3650dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3651cfdb0c2dSAnkit Navik hci_bdaddr_list_clear(&hdev->le_resolv_list); 3652373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 365322078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 3654600a8749SAlain Michaud hci_blocked_keys_clear(hdev); 365509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3656e2e0cacbSJohan Hedberg 3657dc946bd8SDavid Herrmann hci_dev_put(hdev); 36583df92b31SSasha Levin 36593df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 36601da177e4SLinus Torvalds } 36611da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 36621da177e4SLinus Torvalds 36631da177e4SLinus Torvalds /* Suspend HCI device */ 36641da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 36651da177e4SLinus Torvalds { 366605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 36671da177e4SLinus Torvalds return 0; 36681da177e4SLinus Torvalds } 36691da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 36701da177e4SLinus Torvalds 36711da177e4SLinus Torvalds /* Resume HCI device */ 36721da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 36731da177e4SLinus Torvalds { 367405fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 36751da177e4SLinus Torvalds return 0; 36761da177e4SLinus Torvalds } 36771da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 36781da177e4SLinus Torvalds 367975e0569fSMarcel Holtmann /* Reset HCI device */ 368075e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 368175e0569fSMarcel Holtmann { 36821e4b6e91SColin Ian King static const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 368375e0569fSMarcel Holtmann struct sk_buff *skb; 368475e0569fSMarcel Holtmann 368575e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 368675e0569fSMarcel Holtmann if (!skb) 368775e0569fSMarcel Holtmann return -ENOMEM; 368875e0569fSMarcel Holtmann 3689d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 369059ae1d12SJohannes Berg skb_put_data(skb, hw_err, 3); 369175e0569fSMarcel Holtmann 369275e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 369375e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 369475e0569fSMarcel Holtmann } 369575e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 369675e0569fSMarcel Holtmann 369776bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3698e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 369976bca880SMarcel Holtmann { 370076bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 370176bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 370276bca880SMarcel Holtmann kfree_skb(skb); 370376bca880SMarcel Holtmann return -ENXIO; 370476bca880SMarcel Holtmann } 370576bca880SMarcel Holtmann 3706d79f34e3SMarcel Holtmann if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT && 3707d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT && 3708cc974003SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_SCODATA_PKT && 3709cc974003SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ISODATA_PKT) { 3710fe806dceSMarcel Holtmann kfree_skb(skb); 3711fe806dceSMarcel Holtmann return -EINVAL; 3712fe806dceSMarcel Holtmann } 3713fe806dceSMarcel Holtmann 3714d82603c6SJorrit Schippers /* Incoming skb */ 371576bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 371676bca880SMarcel Holtmann 371776bca880SMarcel Holtmann /* Time stamp */ 371876bca880SMarcel Holtmann __net_timestamp(skb); 371976bca880SMarcel Holtmann 372076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3721b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3722c78ae283SMarcel Holtmann 372376bca880SMarcel Holtmann return 0; 372476bca880SMarcel Holtmann } 372576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 372676bca880SMarcel Holtmann 3727e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3728e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3729e875ff84SMarcel Holtmann { 3730581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3731d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_DIAG_PKT; 3732581d6fd6SMarcel Holtmann 3733e875ff84SMarcel Holtmann /* Time stamp */ 3734e875ff84SMarcel Holtmann __net_timestamp(skb); 3735e875ff84SMarcel Holtmann 3736581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3737581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3738e875ff84SMarcel Holtmann 3739e875ff84SMarcel Holtmann return 0; 3740e875ff84SMarcel Holtmann } 3741e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3742e875ff84SMarcel Holtmann 37435177a838SMarcel Holtmann void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...) 37445177a838SMarcel Holtmann { 37455177a838SMarcel Holtmann va_list vargs; 37465177a838SMarcel Holtmann 37475177a838SMarcel Holtmann va_start(vargs, fmt); 37485177a838SMarcel Holtmann kfree_const(hdev->hw_info); 37495177a838SMarcel Holtmann hdev->hw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 37505177a838SMarcel Holtmann va_end(vargs); 37515177a838SMarcel Holtmann } 37525177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_hw_info); 37535177a838SMarcel Holtmann 37545177a838SMarcel Holtmann void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...) 37555177a838SMarcel Holtmann { 37565177a838SMarcel Holtmann va_list vargs; 37575177a838SMarcel Holtmann 37585177a838SMarcel Holtmann va_start(vargs, fmt); 37595177a838SMarcel Holtmann kfree_const(hdev->fw_info); 37605177a838SMarcel Holtmann hdev->fw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 37615177a838SMarcel Holtmann va_end(vargs); 37625177a838SMarcel Holtmann } 37635177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_fw_info); 37645177a838SMarcel Holtmann 37651da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 37661da177e4SLinus Torvalds 37671da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 37681da177e4SLinus Torvalds { 37691da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 37701da177e4SLinus Torvalds 3771fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 377200629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3773fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 37741da177e4SLinus Torvalds 37751da177e4SLinus Torvalds return 0; 37761da177e4SLinus Torvalds } 37771da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 37781da177e4SLinus Torvalds 37791da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 37801da177e4SLinus Torvalds { 37811da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 37821da177e4SLinus Torvalds 3783fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 37841da177e4SLinus Torvalds list_del(&cb->list); 3785fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 37861da177e4SLinus Torvalds 37871da177e4SLinus Torvalds return 0; 37881da177e4SLinus Torvalds } 37891da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 37901da177e4SLinus Torvalds 379151086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 37921da177e4SLinus Torvalds { 3793cdc52faaSMarcel Holtmann int err; 3794cdc52faaSMarcel Holtmann 3795d79f34e3SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb), 3796d79f34e3SMarcel Holtmann skb->len); 37971da177e4SLinus Torvalds 37981da177e4SLinus Torvalds /* Time stamp */ 3799a61bbcf2SPatrick McHardy __net_timestamp(skb); 38001da177e4SLinus Torvalds 3801cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3802cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3803cd82e61cSMarcel Holtmann 3804cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3805cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3806470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 38071da177e4SLinus Torvalds } 38081da177e4SLinus Torvalds 38091da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 38101da177e4SLinus Torvalds skb_orphan(skb); 38111da177e4SLinus Torvalds 381273d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 381373d0d3c8SMarcel Holtmann kfree_skb(skb); 381473d0d3c8SMarcel Holtmann return; 381573d0d3c8SMarcel Holtmann } 381673d0d3c8SMarcel Holtmann 3817cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3818cdc52faaSMarcel Holtmann if (err < 0) { 38192064ee33SMarcel Holtmann bt_dev_err(hdev, "sending frame failed (%d)", err); 3820cdc52faaSMarcel Holtmann kfree_skb(skb); 3821cdc52faaSMarcel Holtmann } 38221da177e4SLinus Torvalds } 38231da177e4SLinus Torvalds 38241ca3a9d0SJohan Hedberg /* Send HCI command */ 382507dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 382607dc93ddSJohan Hedberg const void *param) 38271ca3a9d0SJohan Hedberg { 38281ca3a9d0SJohan Hedberg struct sk_buff *skb; 38291ca3a9d0SJohan Hedberg 38301ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 38311ca3a9d0SJohan Hedberg 38321ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 38331ca3a9d0SJohan Hedberg if (!skb) { 38342064ee33SMarcel Holtmann bt_dev_err(hdev, "no memory for command"); 38351ca3a9d0SJohan Hedberg return -ENOMEM; 38361ca3a9d0SJohan Hedberg } 38371ca3a9d0SJohan Hedberg 383849c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 383911714b3dSJohan Hedberg * single-command requests. 384011714b3dSJohan Hedberg */ 384144d27137SJohan Hedberg bt_cb(skb)->hci.req_flags |= HCI_REQ_START; 384211714b3dSJohan Hedberg 38431da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3844c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 38451da177e4SLinus Torvalds 38461da177e4SLinus Torvalds return 0; 38471da177e4SLinus Torvalds } 38481da177e4SLinus Torvalds 3849d6ee6ad7SLoic Poulain int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen, 3850d6ee6ad7SLoic Poulain const void *param) 3851d6ee6ad7SLoic Poulain { 3852d6ee6ad7SLoic Poulain struct sk_buff *skb; 3853d6ee6ad7SLoic Poulain 3854d6ee6ad7SLoic Poulain if (hci_opcode_ogf(opcode) != 0x3f) { 3855d6ee6ad7SLoic Poulain /* A controller receiving a command shall respond with either 3856d6ee6ad7SLoic Poulain * a Command Status Event or a Command Complete Event. 3857d6ee6ad7SLoic Poulain * Therefore, all standard HCI commands must be sent via the 3858d6ee6ad7SLoic Poulain * standard API, using hci_send_cmd or hci_cmd_sync helpers. 3859d6ee6ad7SLoic Poulain * Some vendors do not comply with this rule for vendor-specific 3860d6ee6ad7SLoic Poulain * commands and do not return any event. We want to support 3861d6ee6ad7SLoic Poulain * unresponded commands for such cases only. 3862d6ee6ad7SLoic Poulain */ 3863d6ee6ad7SLoic Poulain bt_dev_err(hdev, "unresponded command not supported"); 3864d6ee6ad7SLoic Poulain return -EINVAL; 3865d6ee6ad7SLoic Poulain } 3866d6ee6ad7SLoic Poulain 3867d6ee6ad7SLoic Poulain skb = hci_prepare_cmd(hdev, opcode, plen, param); 3868d6ee6ad7SLoic Poulain if (!skb) { 3869d6ee6ad7SLoic Poulain bt_dev_err(hdev, "no memory for command (opcode 0x%4.4x)", 3870d6ee6ad7SLoic Poulain opcode); 3871d6ee6ad7SLoic Poulain return -ENOMEM; 3872d6ee6ad7SLoic Poulain } 3873d6ee6ad7SLoic Poulain 3874d6ee6ad7SLoic Poulain hci_send_frame(hdev, skb); 3875d6ee6ad7SLoic Poulain 3876d6ee6ad7SLoic Poulain return 0; 3877d6ee6ad7SLoic Poulain } 3878d6ee6ad7SLoic Poulain EXPORT_SYMBOL(__hci_cmd_send); 3879d6ee6ad7SLoic Poulain 38801da177e4SLinus Torvalds /* Get data from the previously sent command */ 3881a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 38821da177e4SLinus Torvalds { 38831da177e4SLinus Torvalds struct hci_command_hdr *hdr; 38841da177e4SLinus Torvalds 38851da177e4SLinus Torvalds if (!hdev->sent_cmd) 38861da177e4SLinus Torvalds return NULL; 38871da177e4SLinus Torvalds 38881da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 38891da177e4SLinus Torvalds 3890a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 38911da177e4SLinus Torvalds return NULL; 38921da177e4SLinus Torvalds 3893f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 38941da177e4SLinus Torvalds 38951da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 38961da177e4SLinus Torvalds } 38971da177e4SLinus Torvalds 3898fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3899fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3900fbef168fSLoic Poulain const void *param, u32 timeout) 3901fbef168fSLoic Poulain { 3902fbef168fSLoic Poulain struct sk_buff *skb; 3903fbef168fSLoic Poulain 3904fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3905fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3906fbef168fSLoic Poulain 3907fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3908fbef168fSLoic Poulain 3909b504430cSJohan Hedberg hci_req_sync_lock(hdev); 3910fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3911b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 3912fbef168fSLoic Poulain 3913fbef168fSLoic Poulain return skb; 3914fbef168fSLoic Poulain } 3915fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3916fbef168fSLoic Poulain 39171da177e4SLinus Torvalds /* Send ACL data */ 39181da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 39191da177e4SLinus Torvalds { 39201da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 39211da177e4SLinus Torvalds int len = skb->len; 39221da177e4SLinus Torvalds 3923badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3924badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 39259c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3926aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3927aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 39281da177e4SLinus Torvalds } 39291da177e4SLinus Torvalds 3930ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 393173d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 39321da177e4SLinus Torvalds { 3933ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 39341da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 39351da177e4SLinus Torvalds struct sk_buff *list; 39361da177e4SLinus Torvalds 3937087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3938087bfd99SGustavo Padovan skb->data_len = 0; 3939087bfd99SGustavo Padovan 3940d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3941204a6e54SAndrei Emeltchenko 3942204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3943ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 3944087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3945204a6e54SAndrei Emeltchenko break; 3946204a6e54SAndrei Emeltchenko case HCI_AMP: 3947204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3948204a6e54SAndrei Emeltchenko break; 3949204a6e54SAndrei Emeltchenko default: 39502064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown dev_type %d", hdev->dev_type); 3951204a6e54SAndrei Emeltchenko return; 3952204a6e54SAndrei Emeltchenko } 3953087bfd99SGustavo Padovan 395470f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 395570f23020SAndrei Emeltchenko if (!list) { 39561da177e4SLinus Torvalds /* Non fragmented */ 39571da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 39581da177e4SLinus Torvalds 395973d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 39601da177e4SLinus Torvalds } else { 39611da177e4SLinus Torvalds /* Fragmented */ 39621da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 39631da177e4SLinus Torvalds 39641da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 39651da177e4SLinus Torvalds 39669cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 39679cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 39689cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 39699cfd5a23SJukka Rissanen * deadlocks. 39709cfd5a23SJukka Rissanen */ 39719cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 39721da177e4SLinus Torvalds 397373d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3974e702112fSAndrei Emeltchenko 3975e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3976e702112fSAndrei Emeltchenko flags |= ACL_CONT; 39771da177e4SLinus Torvalds do { 39781da177e4SLinus Torvalds skb = list; list = list->next; 39791da177e4SLinus Torvalds 3980d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3981e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 39821da177e4SLinus Torvalds 39831da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 39841da177e4SLinus Torvalds 398573d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 39861da177e4SLinus Torvalds } while (list); 39871da177e4SLinus Torvalds 39889cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 39891da177e4SLinus Torvalds } 399073d80debSLuiz Augusto von Dentz } 399173d80debSLuiz Augusto von Dentz 399273d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 399373d80debSLuiz Augusto von Dentz { 3994ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 399573d80debSLuiz Augusto von Dentz 3996f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 399773d80debSLuiz Augusto von Dentz 3998ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 39991da177e4SLinus Torvalds 40003eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 40011da177e4SLinus Torvalds } 40021da177e4SLinus Torvalds 40031da177e4SLinus Torvalds /* Send SCO data */ 40040d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 40051da177e4SLinus Torvalds { 40061da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 40071da177e4SLinus Torvalds struct hci_sco_hdr hdr; 40081da177e4SLinus Torvalds 40091da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 40101da177e4SLinus Torvalds 4011aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 40121da177e4SLinus Torvalds hdr.dlen = skb->len; 40131da177e4SLinus Torvalds 4014badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4015badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 40169c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 40171da177e4SLinus Torvalds 4018d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 4019c78ae283SMarcel Holtmann 40201da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 40213eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 40221da177e4SLinus Torvalds } 40231da177e4SLinus Torvalds 40241da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 40251da177e4SLinus Torvalds 40261da177e4SLinus Torvalds /* HCI Connection scheduler */ 40276039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4028a8c5fb1aSGustavo Padovan int *quote) 40291da177e4SLinus Torvalds { 40301da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 40318035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4032abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 40331da177e4SLinus Torvalds 40341da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 40351da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4036bf4c6325SGustavo F. Padovan 4037bf4c6325SGustavo F. Padovan rcu_read_lock(); 4038bf4c6325SGustavo F. Padovan 4039bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4040769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 40411da177e4SLinus Torvalds continue; 4042769be974SMarcel Holtmann 4043769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4044769be974SMarcel Holtmann continue; 4045769be974SMarcel Holtmann 40461da177e4SLinus Torvalds num++; 40471da177e4SLinus Torvalds 40481da177e4SLinus Torvalds if (c->sent < min) { 40491da177e4SLinus Torvalds min = c->sent; 40501da177e4SLinus Torvalds conn = c; 40511da177e4SLinus Torvalds } 405252087a79SLuiz Augusto von Dentz 405352087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 405452087a79SLuiz Augusto von Dentz break; 40551da177e4SLinus Torvalds } 40561da177e4SLinus Torvalds 4057bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4058bf4c6325SGustavo F. Padovan 40591da177e4SLinus Torvalds if (conn) { 40606ed58ec5SVille Tervo int cnt, q; 40616ed58ec5SVille Tervo 40626ed58ec5SVille Tervo switch (conn->type) { 40636ed58ec5SVille Tervo case ACL_LINK: 40646ed58ec5SVille Tervo cnt = hdev->acl_cnt; 40656ed58ec5SVille Tervo break; 40666ed58ec5SVille Tervo case SCO_LINK: 40676ed58ec5SVille Tervo case ESCO_LINK: 40686ed58ec5SVille Tervo cnt = hdev->sco_cnt; 40696ed58ec5SVille Tervo break; 40706ed58ec5SVille Tervo case LE_LINK: 40716ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 40726ed58ec5SVille Tervo break; 40736ed58ec5SVille Tervo default: 40746ed58ec5SVille Tervo cnt = 0; 40752064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", conn->type); 40766ed58ec5SVille Tervo } 40776ed58ec5SVille Tervo 40786ed58ec5SVille Tervo q = cnt / num; 40791da177e4SLinus Torvalds *quote = q ? q : 1; 40801da177e4SLinus Torvalds } else 40811da177e4SLinus Torvalds *quote = 0; 40821da177e4SLinus Torvalds 40831da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 40841da177e4SLinus Torvalds return conn; 40851da177e4SLinus Torvalds } 40861da177e4SLinus Torvalds 40876039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 40881da177e4SLinus Torvalds { 40891da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 40901da177e4SLinus Torvalds struct hci_conn *c; 40911da177e4SLinus Torvalds 40922064ee33SMarcel Holtmann bt_dev_err(hdev, "link tx timeout"); 40931da177e4SLinus Torvalds 4094bf4c6325SGustavo F. Padovan rcu_read_lock(); 4095bf4c6325SGustavo F. Padovan 40961da177e4SLinus Torvalds /* Kill stalled connections */ 4097bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4098bae1f5d9SVille Tervo if (c->type == type && c->sent) { 40992064ee33SMarcel Holtmann bt_dev_err(hdev, "killing stalled connection %pMR", 41002064ee33SMarcel Holtmann &c->dst); 4101bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 41021da177e4SLinus Torvalds } 41031da177e4SLinus Torvalds } 4104bf4c6325SGustavo F. Padovan 4105bf4c6325SGustavo F. Padovan rcu_read_unlock(); 41061da177e4SLinus Torvalds } 41071da177e4SLinus Torvalds 41086039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 410973d80debSLuiz Augusto von Dentz int *quote) 411073d80debSLuiz Augusto von Dentz { 411173d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 411273d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4113abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 411473d80debSLuiz Augusto von Dentz struct hci_conn *conn; 411573d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 411673d80debSLuiz Augusto von Dentz 411773d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 411873d80debSLuiz Augusto von Dentz 4119bf4c6325SGustavo F. Padovan rcu_read_lock(); 4120bf4c6325SGustavo F. Padovan 4121bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 412273d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 412373d80debSLuiz Augusto von Dentz 412473d80debSLuiz Augusto von Dentz if (conn->type != type) 412573d80debSLuiz Augusto von Dentz continue; 412673d80debSLuiz Augusto von Dentz 412773d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 412873d80debSLuiz Augusto von Dentz continue; 412973d80debSLuiz Augusto von Dentz 413073d80debSLuiz Augusto von Dentz conn_num++; 413173d80debSLuiz Augusto von Dentz 41328192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 413373d80debSLuiz Augusto von Dentz struct sk_buff *skb; 413473d80debSLuiz Augusto von Dentz 413573d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 413673d80debSLuiz Augusto von Dentz continue; 413773d80debSLuiz Augusto von Dentz 413873d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 413973d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 414073d80debSLuiz Augusto von Dentz continue; 414173d80debSLuiz Augusto von Dentz 414273d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 414373d80debSLuiz Augusto von Dentz num = 0; 414473d80debSLuiz Augusto von Dentz min = ~0; 414573d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 414673d80debSLuiz Augusto von Dentz } 414773d80debSLuiz Augusto von Dentz 414873d80debSLuiz Augusto von Dentz num++; 414973d80debSLuiz Augusto von Dentz 415073d80debSLuiz Augusto von Dentz if (conn->sent < min) { 415173d80debSLuiz Augusto von Dentz min = conn->sent; 415273d80debSLuiz Augusto von Dentz chan = tmp; 415373d80debSLuiz Augusto von Dentz } 415473d80debSLuiz Augusto von Dentz } 415573d80debSLuiz Augusto von Dentz 415673d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 415773d80debSLuiz Augusto von Dentz break; 415873d80debSLuiz Augusto von Dentz } 415973d80debSLuiz Augusto von Dentz 4160bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4161bf4c6325SGustavo F. Padovan 416273d80debSLuiz Augusto von Dentz if (!chan) 416373d80debSLuiz Augusto von Dentz return NULL; 416473d80debSLuiz Augusto von Dentz 416573d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 416673d80debSLuiz Augusto von Dentz case ACL_LINK: 416773d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 416873d80debSLuiz Augusto von Dentz break; 4169bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4170bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4171bd1eb66bSAndrei Emeltchenko break; 417273d80debSLuiz Augusto von Dentz case SCO_LINK: 417373d80debSLuiz Augusto von Dentz case ESCO_LINK: 417473d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 417573d80debSLuiz Augusto von Dentz break; 417673d80debSLuiz Augusto von Dentz case LE_LINK: 417773d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 417873d80debSLuiz Augusto von Dentz break; 417973d80debSLuiz Augusto von Dentz default: 418073d80debSLuiz Augusto von Dentz cnt = 0; 41812064ee33SMarcel Holtmann bt_dev_err(hdev, "unknown link type %d", chan->conn->type); 418273d80debSLuiz Augusto von Dentz } 418373d80debSLuiz Augusto von Dentz 418473d80debSLuiz Augusto von Dentz q = cnt / num; 418573d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 418673d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 418773d80debSLuiz Augusto von Dentz return chan; 418873d80debSLuiz Augusto von Dentz } 418973d80debSLuiz Augusto von Dentz 419002b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 419102b20f0bSLuiz Augusto von Dentz { 419202b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 419302b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 419402b20f0bSLuiz Augusto von Dentz int num = 0; 419502b20f0bSLuiz Augusto von Dentz 419602b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 419702b20f0bSLuiz Augusto von Dentz 4198bf4c6325SGustavo F. Padovan rcu_read_lock(); 4199bf4c6325SGustavo F. Padovan 4200bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 420102b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 420202b20f0bSLuiz Augusto von Dentz 420302b20f0bSLuiz Augusto von Dentz if (conn->type != type) 420402b20f0bSLuiz Augusto von Dentz continue; 420502b20f0bSLuiz Augusto von Dentz 420602b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 420702b20f0bSLuiz Augusto von Dentz continue; 420802b20f0bSLuiz Augusto von Dentz 420902b20f0bSLuiz Augusto von Dentz num++; 421002b20f0bSLuiz Augusto von Dentz 42118192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 421202b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 421302b20f0bSLuiz Augusto von Dentz 421402b20f0bSLuiz Augusto von Dentz if (chan->sent) { 421502b20f0bSLuiz Augusto von Dentz chan->sent = 0; 421602b20f0bSLuiz Augusto von Dentz continue; 421702b20f0bSLuiz Augusto von Dentz } 421802b20f0bSLuiz Augusto von Dentz 421902b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 422002b20f0bSLuiz Augusto von Dentz continue; 422102b20f0bSLuiz Augusto von Dentz 422202b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 422302b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 422402b20f0bSLuiz Augusto von Dentz continue; 422502b20f0bSLuiz Augusto von Dentz 422602b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 422702b20f0bSLuiz Augusto von Dentz 422802b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 422902b20f0bSLuiz Augusto von Dentz skb->priority); 423002b20f0bSLuiz Augusto von Dentz } 423102b20f0bSLuiz Augusto von Dentz 423202b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 423302b20f0bSLuiz Augusto von Dentz break; 423402b20f0bSLuiz Augusto von Dentz } 4235bf4c6325SGustavo F. Padovan 4236bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4237bf4c6325SGustavo F. Padovan 423802b20f0bSLuiz Augusto von Dentz } 423902b20f0bSLuiz Augusto von Dentz 4240b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4241b71d385aSAndrei Emeltchenko { 4242b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4243b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4244b71d385aSAndrei Emeltchenko } 4245b71d385aSAndrei Emeltchenko 42466039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 42471da177e4SLinus Torvalds { 4248d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 42491da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 42501da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 425163d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 42525f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4253bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 42541da177e4SLinus Torvalds } 425563d2bc1bSAndrei Emeltchenko } 42561da177e4SLinus Torvalds 42577fedd3bbSAbhishek Pandit-Subedi /* Schedule SCO */ 42587fedd3bbSAbhishek Pandit-Subedi static void hci_sched_sco(struct hci_dev *hdev) 42597fedd3bbSAbhishek Pandit-Subedi { 42607fedd3bbSAbhishek Pandit-Subedi struct hci_conn *conn; 42617fedd3bbSAbhishek Pandit-Subedi struct sk_buff *skb; 42627fedd3bbSAbhishek Pandit-Subedi int quote; 42637fedd3bbSAbhishek Pandit-Subedi 42647fedd3bbSAbhishek Pandit-Subedi BT_DBG("%s", hdev->name); 42657fedd3bbSAbhishek Pandit-Subedi 42667fedd3bbSAbhishek Pandit-Subedi if (!hci_conn_num(hdev, SCO_LINK)) 42677fedd3bbSAbhishek Pandit-Subedi return; 42687fedd3bbSAbhishek Pandit-Subedi 42697fedd3bbSAbhishek Pandit-Subedi while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 42707fedd3bbSAbhishek Pandit-Subedi while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 42717fedd3bbSAbhishek Pandit-Subedi BT_DBG("skb %p len %d", skb, skb->len); 42727fedd3bbSAbhishek Pandit-Subedi hci_send_frame(hdev, skb); 42737fedd3bbSAbhishek Pandit-Subedi 42747fedd3bbSAbhishek Pandit-Subedi conn->sent++; 42757fedd3bbSAbhishek Pandit-Subedi if (conn->sent == ~0) 42767fedd3bbSAbhishek Pandit-Subedi conn->sent = 0; 42777fedd3bbSAbhishek Pandit-Subedi } 42787fedd3bbSAbhishek Pandit-Subedi } 42797fedd3bbSAbhishek Pandit-Subedi } 42807fedd3bbSAbhishek Pandit-Subedi 42817fedd3bbSAbhishek Pandit-Subedi static void hci_sched_esco(struct hci_dev *hdev) 42827fedd3bbSAbhishek Pandit-Subedi { 42837fedd3bbSAbhishek Pandit-Subedi struct hci_conn *conn; 42847fedd3bbSAbhishek Pandit-Subedi struct sk_buff *skb; 42857fedd3bbSAbhishek Pandit-Subedi int quote; 42867fedd3bbSAbhishek Pandit-Subedi 42877fedd3bbSAbhishek Pandit-Subedi BT_DBG("%s", hdev->name); 42887fedd3bbSAbhishek Pandit-Subedi 42897fedd3bbSAbhishek Pandit-Subedi if (!hci_conn_num(hdev, ESCO_LINK)) 42907fedd3bbSAbhishek Pandit-Subedi return; 42917fedd3bbSAbhishek Pandit-Subedi 42927fedd3bbSAbhishek Pandit-Subedi while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 42937fedd3bbSAbhishek Pandit-Subedi "e))) { 42947fedd3bbSAbhishek Pandit-Subedi while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 42957fedd3bbSAbhishek Pandit-Subedi BT_DBG("skb %p len %d", skb, skb->len); 42967fedd3bbSAbhishek Pandit-Subedi hci_send_frame(hdev, skb); 42977fedd3bbSAbhishek Pandit-Subedi 42987fedd3bbSAbhishek Pandit-Subedi conn->sent++; 42997fedd3bbSAbhishek Pandit-Subedi if (conn->sent == ~0) 43007fedd3bbSAbhishek Pandit-Subedi conn->sent = 0; 43017fedd3bbSAbhishek Pandit-Subedi } 43027fedd3bbSAbhishek Pandit-Subedi } 43037fedd3bbSAbhishek Pandit-Subedi } 43047fedd3bbSAbhishek Pandit-Subedi 43056039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 430663d2bc1bSAndrei Emeltchenko { 430763d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 430863d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 430963d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 431063d2bc1bSAndrei Emeltchenko int quote; 431163d2bc1bSAndrei Emeltchenko 431263d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 431304837f64SMarcel Holtmann 431473d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 431573d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4316ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4317ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 431873d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 431973d80debSLuiz Augusto von Dentz skb->len, skb->priority); 432073d80debSLuiz Augusto von Dentz 4321ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4322ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4323ec1cce24SLuiz Augusto von Dentz break; 4324ec1cce24SLuiz Augusto von Dentz 4325ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4326ec1cce24SLuiz Augusto von Dentz 432773d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 432873d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 432904837f64SMarcel Holtmann 433057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 43311da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 43321da177e4SLinus Torvalds 43331da177e4SLinus Torvalds hdev->acl_cnt--; 433473d80debSLuiz Augusto von Dentz chan->sent++; 433573d80debSLuiz Augusto von Dentz chan->conn->sent++; 43367fedd3bbSAbhishek Pandit-Subedi 43377fedd3bbSAbhishek Pandit-Subedi /* Send pending SCO packets right away */ 43387fedd3bbSAbhishek Pandit-Subedi hci_sched_sco(hdev); 43397fedd3bbSAbhishek Pandit-Subedi hci_sched_esco(hdev); 43401da177e4SLinus Torvalds } 43411da177e4SLinus Torvalds } 434202b20f0bSLuiz Augusto von Dentz 434302b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 434402b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 43451da177e4SLinus Torvalds } 43461da177e4SLinus Torvalds 43476039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4348b71d385aSAndrei Emeltchenko { 434963d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4350b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4351b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4352b71d385aSAndrei Emeltchenko int quote; 4353bd1eb66bSAndrei Emeltchenko u8 type; 4354b71d385aSAndrei Emeltchenko 435563d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4356b71d385aSAndrei Emeltchenko 4357bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4358bd1eb66bSAndrei Emeltchenko 4359bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4360bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4361bd1eb66bSAndrei Emeltchenko else 4362bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4363bd1eb66bSAndrei Emeltchenko 4364b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4365bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4366b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4367b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4368b71d385aSAndrei Emeltchenko int blocks; 4369b71d385aSAndrei Emeltchenko 4370b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4371b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4372b71d385aSAndrei Emeltchenko 4373b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4374b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4375b71d385aSAndrei Emeltchenko break; 4376b71d385aSAndrei Emeltchenko 4377b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4378b71d385aSAndrei Emeltchenko 4379b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4380b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4381b71d385aSAndrei Emeltchenko return; 4382b71d385aSAndrei Emeltchenko 4383b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4384b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4385b71d385aSAndrei Emeltchenko 438657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4387b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4388b71d385aSAndrei Emeltchenko 4389b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4390b71d385aSAndrei Emeltchenko quote -= blocks; 4391b71d385aSAndrei Emeltchenko 4392b71d385aSAndrei Emeltchenko chan->sent += blocks; 4393b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4394b71d385aSAndrei Emeltchenko } 4395b71d385aSAndrei Emeltchenko } 4396b71d385aSAndrei Emeltchenko 4397b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4398bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4399b71d385aSAndrei Emeltchenko } 4400b71d385aSAndrei Emeltchenko 44016039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4402b71d385aSAndrei Emeltchenko { 4403b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4404b71d385aSAndrei Emeltchenko 4405bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4406ca8bee5dSMarcel Holtmann if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_PRIMARY) 4407bd1eb66bSAndrei Emeltchenko return; 4408bd1eb66bSAndrei Emeltchenko 4409bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4410bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4411b71d385aSAndrei Emeltchenko return; 4412b71d385aSAndrei Emeltchenko 4413b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4414b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4415b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4416b71d385aSAndrei Emeltchenko break; 4417b71d385aSAndrei Emeltchenko 4418b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4419b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4420b71d385aSAndrei Emeltchenko break; 4421b71d385aSAndrei Emeltchenko } 4422b71d385aSAndrei Emeltchenko } 4423b71d385aSAndrei Emeltchenko 44246039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 44256ed58ec5SVille Tervo { 442673d80debSLuiz Augusto von Dentz struct hci_chan *chan; 44276ed58ec5SVille Tervo struct sk_buff *skb; 442802b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 44296ed58ec5SVille Tervo 44306ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 44316ed58ec5SVille Tervo 443252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 443352087a79SLuiz Augusto von Dentz return; 443452087a79SLuiz Augusto von Dentz 44356ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 44361b1d29e5SLuiz Augusto von Dentz 44371b1d29e5SLuiz Augusto von Dentz __check_timeout(hdev, cnt); 44381b1d29e5SLuiz Augusto von Dentz 443902b20f0bSLuiz Augusto von Dentz tmp = cnt; 444073d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4441ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4442ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 444373d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 444473d80debSLuiz Augusto von Dentz skb->len, skb->priority); 44456ed58ec5SVille Tervo 4446ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4447ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4448ec1cce24SLuiz Augusto von Dentz break; 4449ec1cce24SLuiz Augusto von Dentz 4450ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4451ec1cce24SLuiz Augusto von Dentz 445257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 44536ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 44546ed58ec5SVille Tervo 44556ed58ec5SVille Tervo cnt--; 445673d80debSLuiz Augusto von Dentz chan->sent++; 445773d80debSLuiz Augusto von Dentz chan->conn->sent++; 44587fedd3bbSAbhishek Pandit-Subedi 44597fedd3bbSAbhishek Pandit-Subedi /* Send pending SCO packets right away */ 44607fedd3bbSAbhishek Pandit-Subedi hci_sched_sco(hdev); 44617fedd3bbSAbhishek Pandit-Subedi hci_sched_esco(hdev); 44626ed58ec5SVille Tervo } 44636ed58ec5SVille Tervo } 446473d80debSLuiz Augusto von Dentz 44656ed58ec5SVille Tervo if (hdev->le_pkts) 44666ed58ec5SVille Tervo hdev->le_cnt = cnt; 44676ed58ec5SVille Tervo else 44686ed58ec5SVille Tervo hdev->acl_cnt = cnt; 446902b20f0bSLuiz Augusto von Dentz 447002b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 447102b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 44726ed58ec5SVille Tervo } 44736ed58ec5SVille Tervo 44743eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 44751da177e4SLinus Torvalds { 44763eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 44771da177e4SLinus Torvalds struct sk_buff *skb; 44781da177e4SLinus Torvalds 44796ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 44806ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 44811da177e4SLinus Torvalds 4482d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 44831da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 44841da177e4SLinus Torvalds hci_sched_sco(hdev); 4485b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 44867fedd3bbSAbhishek Pandit-Subedi hci_sched_acl(hdev); 44876ed58ec5SVille Tervo hci_sched_le(hdev); 448852de599eSMarcel Holtmann } 44896ed58ec5SVille Tervo 44901da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 44911da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 449257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 44931da177e4SLinus Torvalds } 44941da177e4SLinus Torvalds 449525985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 44961da177e4SLinus Torvalds 44971da177e4SLinus Torvalds /* ACL data packet */ 44986039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 44991da177e4SLinus Torvalds { 45001da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 45011da177e4SLinus Torvalds struct hci_conn *conn; 45021da177e4SLinus Torvalds __u16 handle, flags; 45031da177e4SLinus Torvalds 45041da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 45051da177e4SLinus Torvalds 45061da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 45071da177e4SLinus Torvalds flags = hci_flags(handle); 45081da177e4SLinus Torvalds handle = hci_handle(handle); 45091da177e4SLinus Torvalds 4510f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4511a8c5fb1aSGustavo Padovan handle, flags); 45121da177e4SLinus Torvalds 45131da177e4SLinus Torvalds hdev->stat.acl_rx++; 45141da177e4SLinus Torvalds 45151da177e4SLinus Torvalds hci_dev_lock(hdev); 45161da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 45171da177e4SLinus Torvalds hci_dev_unlock(hdev); 45181da177e4SLinus Torvalds 45191da177e4SLinus Torvalds if (conn) { 452065983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 452104837f64SMarcel Holtmann 45221da177e4SLinus Torvalds /* Send to upper protocol */ 4523686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 45241da177e4SLinus Torvalds return; 45251da177e4SLinus Torvalds } else { 45262064ee33SMarcel Holtmann bt_dev_err(hdev, "ACL packet for unknown connection handle %d", 45272064ee33SMarcel Holtmann handle); 45281da177e4SLinus Torvalds } 45291da177e4SLinus Torvalds 45301da177e4SLinus Torvalds kfree_skb(skb); 45311da177e4SLinus Torvalds } 45321da177e4SLinus Torvalds 45331da177e4SLinus Torvalds /* SCO data packet */ 45346039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 45351da177e4SLinus Torvalds { 45361da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 45371da177e4SLinus Torvalds struct hci_conn *conn; 4538debdedf2SMarcel Holtmann __u16 handle, flags; 45391da177e4SLinus Torvalds 45401da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 45411da177e4SLinus Torvalds 45421da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 4543debdedf2SMarcel Holtmann flags = hci_flags(handle); 4544debdedf2SMarcel Holtmann handle = hci_handle(handle); 45451da177e4SLinus Torvalds 4546debdedf2SMarcel Holtmann BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4547debdedf2SMarcel Holtmann handle, flags); 45481da177e4SLinus Torvalds 45491da177e4SLinus Torvalds hdev->stat.sco_rx++; 45501da177e4SLinus Torvalds 45511da177e4SLinus Torvalds hci_dev_lock(hdev); 45521da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 45531da177e4SLinus Torvalds hci_dev_unlock(hdev); 45541da177e4SLinus Torvalds 45551da177e4SLinus Torvalds if (conn) { 45561da177e4SLinus Torvalds /* Send to upper protocol */ 455700398e1dSAlain Michaud bt_cb(skb)->sco.pkt_status = flags & 0x03; 4558686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 45591da177e4SLinus Torvalds return; 45601da177e4SLinus Torvalds } else { 45612064ee33SMarcel Holtmann bt_dev_err(hdev, "SCO packet for unknown connection handle %d", 45622064ee33SMarcel Holtmann handle); 45631da177e4SLinus Torvalds } 45641da177e4SLinus Torvalds 45651da177e4SLinus Torvalds kfree_skb(skb); 45661da177e4SLinus Torvalds } 45671da177e4SLinus Torvalds 45689238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 45699238f36aSJohan Hedberg { 45709238f36aSJohan Hedberg struct sk_buff *skb; 45719238f36aSJohan Hedberg 45729238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 45739238f36aSJohan Hedberg if (!skb) 45749238f36aSJohan Hedberg return true; 45759238f36aSJohan Hedberg 457644d27137SJohan Hedberg return (bt_cb(skb)->hci.req_flags & HCI_REQ_START); 45779238f36aSJohan Hedberg } 45789238f36aSJohan Hedberg 457942c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 458042c6b129SJohan Hedberg { 458142c6b129SJohan Hedberg struct hci_command_hdr *sent; 458242c6b129SJohan Hedberg struct sk_buff *skb; 458342c6b129SJohan Hedberg u16 opcode; 458442c6b129SJohan Hedberg 458542c6b129SJohan Hedberg if (!hdev->sent_cmd) 458642c6b129SJohan Hedberg return; 458742c6b129SJohan Hedberg 458842c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 458942c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 459042c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 459142c6b129SJohan Hedberg return; 459242c6b129SJohan Hedberg 459342c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 459442c6b129SJohan Hedberg if (!skb) 459542c6b129SJohan Hedberg return; 459642c6b129SJohan Hedberg 459742c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 459842c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 459942c6b129SJohan Hedberg } 460042c6b129SJohan Hedberg 4601e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4602e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4603e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 46049238f36aSJohan Hedberg { 46059238f36aSJohan Hedberg struct sk_buff *skb; 46069238f36aSJohan Hedberg unsigned long flags; 46079238f36aSJohan Hedberg 46089238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 46099238f36aSJohan Hedberg 461042c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 461142c6b129SJohan Hedberg * sent we need to do special handling of it. 46129238f36aSJohan Hedberg */ 461342c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 461442c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 461542c6b129SJohan Hedberg * reset complete event during init and any pending 461642c6b129SJohan Hedberg * command will never be completed. In such a case we 461742c6b129SJohan Hedberg * need to resend whatever was the last sent 461842c6b129SJohan Hedberg * command. 461942c6b129SJohan Hedberg */ 462042c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 462142c6b129SJohan Hedberg hci_resend_last(hdev); 462242c6b129SJohan Hedberg 46239238f36aSJohan Hedberg return; 462442c6b129SJohan Hedberg } 46259238f36aSJohan Hedberg 4626f80c5dadSJoão Paulo Rechi Vita /* If we reach this point this event matches the last command sent */ 4627f80c5dadSJoão Paulo Rechi Vita hci_dev_clear_flag(hdev, HCI_CMD_PENDING); 4628f80c5dadSJoão Paulo Rechi Vita 46299238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 46309238f36aSJohan Hedberg * this request the request is not yet complete. 46319238f36aSJohan Hedberg */ 46329238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 46339238f36aSJohan Hedberg return; 46349238f36aSJohan Hedberg 46359238f36aSJohan Hedberg /* If this was the last command in a request the complete 46369238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 46379238f36aSJohan Hedberg * command queue (hdev->cmd_q). 46389238f36aSJohan Hedberg */ 463944d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_flags & HCI_REQ_SKB) { 464044d27137SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4641e6214487SJohan Hedberg return; 46429238f36aSJohan Hedberg } 4643e6214487SJohan Hedberg 464444d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 464544d27137SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4646e6214487SJohan Hedberg return; 464753e21fbcSJohan Hedberg } 46489238f36aSJohan Hedberg 46499238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 46509238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 46519238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 465244d27137SJohan Hedberg if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) { 46539238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 46549238f36aSJohan Hedberg break; 46559238f36aSJohan Hedberg } 46569238f36aSJohan Hedberg 46573bd7594eSDouglas Anderson if (bt_cb(skb)->hci.req_flags & HCI_REQ_SKB) 4658242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 46593bd7594eSDouglas Anderson else 46603bd7594eSDouglas Anderson *req_complete = bt_cb(skb)->hci.req_complete; 46619238f36aSJohan Hedberg kfree_skb(skb); 46629238f36aSJohan Hedberg } 46639238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 46649238f36aSJohan Hedberg } 46659238f36aSJohan Hedberg 4666b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 46671da177e4SLinus Torvalds { 4668b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 46691da177e4SLinus Torvalds struct sk_buff *skb; 46701da177e4SLinus Torvalds 46711da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 46721da177e4SLinus Torvalds 46731da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4674cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4675cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4676cd82e61cSMarcel Holtmann 46771da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 46781da177e4SLinus Torvalds /* Send copy to the sockets */ 4679470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 46801da177e4SLinus Torvalds } 46811da177e4SLinus Torvalds 4682eb8c101eSMattijs Korpershoek /* If the device has been opened in HCI_USER_CHANNEL, 4683eb8c101eSMattijs Korpershoek * the userspace has exclusive access to device. 4684eb8c101eSMattijs Korpershoek * When device is HCI_INIT, we still need to process 4685eb8c101eSMattijs Korpershoek * the data packets to the driver in order 4686eb8c101eSMattijs Korpershoek * to complete its setup(). 4687eb8c101eSMattijs Korpershoek */ 4688eb8c101eSMattijs Korpershoek if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 4689eb8c101eSMattijs Korpershoek !test_bit(HCI_INIT, &hdev->flags)) { 46901da177e4SLinus Torvalds kfree_skb(skb); 46911da177e4SLinus Torvalds continue; 46921da177e4SLinus Torvalds } 46931da177e4SLinus Torvalds 46941da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 46951da177e4SLinus Torvalds /* Don't process data packets in this states. */ 4696d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 46971da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 46981da177e4SLinus Torvalds case HCI_SCODATA_PKT: 4699cc974003SMarcel Holtmann case HCI_ISODATA_PKT: 47001da177e4SLinus Torvalds kfree_skb(skb); 47011da177e4SLinus Torvalds continue; 47023ff50b79SStephen Hemminger } 47031da177e4SLinus Torvalds } 47041da177e4SLinus Torvalds 47051da177e4SLinus Torvalds /* Process frame */ 4706d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 47071da177e4SLinus Torvalds case HCI_EVENT_PKT: 4708b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 47091da177e4SLinus Torvalds hci_event_packet(hdev, skb); 47101da177e4SLinus Torvalds break; 47111da177e4SLinus Torvalds 47121da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 47131da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 47141da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 47151da177e4SLinus Torvalds break; 47161da177e4SLinus Torvalds 47171da177e4SLinus Torvalds case HCI_SCODATA_PKT: 47181da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 47191da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 47201da177e4SLinus Torvalds break; 47211da177e4SLinus Torvalds 47221da177e4SLinus Torvalds default: 47231da177e4SLinus Torvalds kfree_skb(skb); 47241da177e4SLinus Torvalds break; 47251da177e4SLinus Torvalds } 47261da177e4SLinus Torvalds } 47271da177e4SLinus Torvalds } 47281da177e4SLinus Torvalds 4729c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 47301da177e4SLinus Torvalds { 4731c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 47321da177e4SLinus Torvalds struct sk_buff *skb; 47331da177e4SLinus Torvalds 47342104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 47352104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 47361da177e4SLinus Torvalds 47371da177e4SLinus Torvalds /* Send queued commands */ 47385a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 47395a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 47405a08ecceSAndrei Emeltchenko if (!skb) 47415a08ecceSAndrei Emeltchenko return; 47425a08ecceSAndrei Emeltchenko 47431da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 47441da177e4SLinus Torvalds 4745a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 474670f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 4747f80c5dadSJoão Paulo Rechi Vita if (hci_req_status_pend(hdev)) 4748f80c5dadSJoão Paulo Rechi Vita hci_dev_set_flag(hdev, HCI_CMD_PENDING); 47491da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 475057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 47517bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 475265cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 47537bdb8a5cSSzymon Janc else 475465cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 475565cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 47561da177e4SLinus Torvalds } else { 47571da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4758c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 47591da177e4SLinus Torvalds } 47601da177e4SLinus Torvalds } 47611da177e4SLinus Torvalds } 4762