11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 4590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 51da177e4SLinus Torvalds 61da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 101da177e4SLinus Torvalds published by the Free Software Foundation; 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 131da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 141da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 151da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 161da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 171da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 181da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 191da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 221da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 231da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds /* Bluetooth HCI core. */ 271da177e4SLinus Torvalds 288c520a59SGustavo Padovan #include <linux/export.h> 293df92b31SSasha Levin #include <linux/idr.h> 30611b30f7SMarcel Holtmann #include <linux/rfkill.h> 31baf27f6eSMarcel Holtmann #include <linux/debugfs.h> 3299780a7bSJohan Hedberg #include <linux/crypto.h> 3347219839SMarcel Holtmann #include <asm/unaligned.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 361da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 374bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 38af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 391da177e4SLinus Torvalds 400857dd3bSJohan Hedberg #include "hci_request.h" 4160c5f5fbSMarcel Holtmann #include "hci_debugfs.h" 42970c4e46SJohan Hedberg #include "smp.h" 436d5d2ee6SHeiner Kallweit #include "leds.h" 44970c4e46SJohan Hedberg 45b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 46c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 473eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds /* HCI device list */ 501da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 511da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds /* HCI callback list */ 541da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 55fba7ecf0SJohan Hedberg DEFINE_MUTEX(hci_cb_list_lock); 561da177e4SLinus Torvalds 573df92b31SSasha Levin /* HCI ID Numbering */ 583df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 593df92b31SSasha Levin 60baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 61baf27f6eSMarcel Holtmann 624b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 634b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 644b4148e9SMarcel Holtmann { 654b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 664b4148e9SMarcel Holtmann char buf[3]; 674b4148e9SMarcel Holtmann 68b7cb93e5SMarcel Holtmann buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y' : 'N'; 694b4148e9SMarcel Holtmann buf[1] = '\n'; 704b4148e9SMarcel Holtmann buf[2] = '\0'; 714b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 724b4148e9SMarcel Holtmann } 734b4148e9SMarcel Holtmann 744b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 754b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 764b4148e9SMarcel Holtmann { 774b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 784b4148e9SMarcel Holtmann struct sk_buff *skb; 794b4148e9SMarcel Holtmann char buf[32]; 804b4148e9SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 814b4148e9SMarcel Holtmann bool enable; 824b4148e9SMarcel Holtmann 834b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 844b4148e9SMarcel Holtmann return -ENETDOWN; 854b4148e9SMarcel Holtmann 864b4148e9SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 874b4148e9SMarcel Holtmann return -EFAULT; 884b4148e9SMarcel Holtmann 894b4148e9SMarcel Holtmann buf[buf_size] = '\0'; 904b4148e9SMarcel Holtmann if (strtobool(buf, &enable)) 914b4148e9SMarcel Holtmann return -EINVAL; 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 char buf[32]; 1394b4113d6SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 1404b4113d6SMarcel Holtmann bool enable; 1414b4113d6SMarcel Holtmann int err; 1424b4113d6SMarcel Holtmann 1434b4113d6SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 1444b4113d6SMarcel Holtmann return -EFAULT; 1454b4113d6SMarcel Holtmann 1464b4113d6SMarcel Holtmann buf[buf_size] = '\0'; 1474b4113d6SMarcel Holtmann if (strtobool(buf, &enable)) 1484b4113d6SMarcel Holtmann return -EINVAL; 1494b4113d6SMarcel Holtmann 1507e995b9eSMarcel Holtmann /* When the diagnostic flags are not persistent and the transport 1517e995b9eSMarcel Holtmann * is not active, then there is no need for the vendor callback. 1527e995b9eSMarcel Holtmann * 1537e995b9eSMarcel Holtmann * Instead just store the desired value. If needed the setting 1547e995b9eSMarcel Holtmann * will be programmed when the controller gets powered on. 1557e995b9eSMarcel Holtmann */ 1567e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1577e995b9eSMarcel Holtmann !test_bit(HCI_RUNNING, &hdev->flags)) 1587e995b9eSMarcel Holtmann goto done; 1597e995b9eSMarcel Holtmann 160b504430cSJohan Hedberg hci_req_sync_lock(hdev); 1614b4113d6SMarcel Holtmann err = hdev->set_diag(hdev, enable); 162b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 1634b4113d6SMarcel Holtmann 1644b4113d6SMarcel Holtmann if (err < 0) 1654b4113d6SMarcel Holtmann return err; 1664b4113d6SMarcel Holtmann 1677e995b9eSMarcel Holtmann done: 1684b4113d6SMarcel Holtmann if (enable) 1694b4113d6SMarcel Holtmann hci_dev_set_flag(hdev, HCI_VENDOR_DIAG); 1704b4113d6SMarcel Holtmann else 1714b4113d6SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG); 1724b4113d6SMarcel Holtmann 1734b4113d6SMarcel Holtmann return count; 1744b4113d6SMarcel Holtmann } 1754b4113d6SMarcel Holtmann 1764b4113d6SMarcel Holtmann static const struct file_operations vendor_diag_fops = { 1774b4113d6SMarcel Holtmann .open = simple_open, 1784b4113d6SMarcel Holtmann .read = vendor_diag_read, 1794b4113d6SMarcel Holtmann .write = vendor_diag_write, 1804b4113d6SMarcel Holtmann .llseek = default_llseek, 1814b4113d6SMarcel Holtmann }; 1824b4113d6SMarcel Holtmann 183f640ee98SMarcel Holtmann static void hci_debugfs_create_basic(struct hci_dev *hdev) 184f640ee98SMarcel Holtmann { 185f640ee98SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 186f640ee98SMarcel Holtmann &dut_mode_fops); 187f640ee98SMarcel Holtmann 188f640ee98SMarcel Holtmann if (hdev->set_diag) 189f640ee98SMarcel Holtmann debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev, 190f640ee98SMarcel Holtmann &vendor_diag_fops); 191f640ee98SMarcel Holtmann } 192f640ee98SMarcel Holtmann 193a1d01db1SJohan Hedberg static int hci_reset_req(struct hci_request *req, unsigned long opt) 1941da177e4SLinus Torvalds { 19542c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 1961da177e4SLinus Torvalds 1971da177e4SLinus Torvalds /* Reset device */ 19842c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 19942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 200a1d01db1SJohan Hedberg return 0; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 20342c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 2041da177e4SLinus Torvalds { 20542c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 2062455a3eaSAndrei Emeltchenko 2071da177e4SLinus Torvalds /* Read Local Supported Features */ 20842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 2091da177e4SLinus Torvalds 2101143e5a6SMarcel Holtmann /* Read Local Version */ 21142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2122177bab5SJohan Hedberg 2132177bab5SJohan Hedberg /* Read BD Address */ 21442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds 2170af801b9SJohan Hedberg static void amp_init1(struct hci_request *req) 218e61ef499SAndrei Emeltchenko { 21942c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 2202455a3eaSAndrei Emeltchenko 221e61ef499SAndrei Emeltchenko /* Read Local Version */ 22242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 2236bcbc489SAndrei Emeltchenko 224f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 225f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 226f6996cfeSMarcel Holtmann 2276bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 22842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 229e71dfabaSAndrei Emeltchenko 230e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 23142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 2327528ca1cSMarcel Holtmann 233f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 234f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 235f38ba941SMarcel Holtmann 2367528ca1cSMarcel Holtmann /* Read Location Data */ 2377528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 238e61ef499SAndrei Emeltchenko } 239e61ef499SAndrei Emeltchenko 240a1d01db1SJohan Hedberg static int amp_init2(struct hci_request *req) 2410af801b9SJohan Hedberg { 2420af801b9SJohan Hedberg /* Read Local Supported Features. Not all AMP controllers 2430af801b9SJohan Hedberg * support this so it's placed conditionally in the second 2440af801b9SJohan Hedberg * stage init. 2450af801b9SJohan Hedberg */ 2460af801b9SJohan Hedberg if (req->hdev->commands[14] & 0x20) 2470af801b9SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 248a1d01db1SJohan Hedberg 249a1d01db1SJohan Hedberg return 0; 2500af801b9SJohan Hedberg } 2510af801b9SJohan Hedberg 252a1d01db1SJohan Hedberg static int hci_init1_req(struct hci_request *req, unsigned long opt) 253e61ef499SAndrei Emeltchenko { 25442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 255e61ef499SAndrei Emeltchenko 256e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 257e61ef499SAndrei Emeltchenko 25811778716SAndrei Emeltchenko /* Reset */ 25911778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 26042c6b129SJohan Hedberg hci_reset_req(req, 0); 26111778716SAndrei Emeltchenko 262e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 263ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 26442c6b129SJohan Hedberg bredr_init(req); 265e61ef499SAndrei Emeltchenko break; 266e61ef499SAndrei Emeltchenko case HCI_AMP: 2670af801b9SJohan Hedberg amp_init1(req); 268e61ef499SAndrei Emeltchenko break; 269e61ef499SAndrei Emeltchenko default: 270e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 271e61ef499SAndrei Emeltchenko break; 272e61ef499SAndrei Emeltchenko } 273a1d01db1SJohan Hedberg 274a1d01db1SJohan Hedberg return 0; 275e61ef499SAndrei Emeltchenko } 276e61ef499SAndrei Emeltchenko 27742c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 2782177bab5SJohan Hedberg { 2792177bab5SJohan Hedberg __le16 param; 2802177bab5SJohan Hedberg __u8 flt_type; 2812177bab5SJohan Hedberg 2822177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 28342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 2842177bab5SJohan Hedberg 2852177bab5SJohan Hedberg /* Read Class of Device */ 28642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 2872177bab5SJohan Hedberg 2882177bab5SJohan Hedberg /* Read Local Name */ 28942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 2902177bab5SJohan Hedberg 2912177bab5SJohan Hedberg /* Read Voice Setting */ 29242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 2932177bab5SJohan Hedberg 294b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 295b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 296b4cb9fb2SMarcel Holtmann 2974b836f39SMarcel Holtmann /* Read Current IAC LAP */ 2984b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 2994b836f39SMarcel Holtmann 3002177bab5SJohan Hedberg /* Clear Event Filters */ 3012177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 30242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 3032177bab5SJohan Hedberg 3042177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 305dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 30642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 3072177bab5SJohan Hedberg } 3082177bab5SJohan Hedberg 30942c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 3102177bab5SJohan Hedberg { 311c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 312c73eee91SJohan Hedberg 3132177bab5SJohan Hedberg /* Read LE Buffer Size */ 31442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 3152177bab5SJohan Hedberg 3162177bab5SJohan Hedberg /* Read LE Local Supported Features */ 31742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 3182177bab5SJohan Hedberg 319747d3f03SMarcel Holtmann /* Read LE Supported States */ 320747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 321747d3f03SMarcel Holtmann 322c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 323c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 324a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_LE_ENABLED); 3252177bab5SJohan Hedberg } 3262177bab5SJohan Hedberg 32742c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 3282177bab5SJohan Hedberg { 32942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 33042c6b129SJohan Hedberg 3312177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 3322177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 3332177bab5SJohan Hedberg * command otherwise. 3342177bab5SJohan Hedberg */ 3352177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 3362177bab5SJohan Hedberg 3372177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 3382177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 3392177bab5SJohan Hedberg */ 3402177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 3412177bab5SJohan Hedberg return; 3422177bab5SJohan Hedberg 3432177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 3442177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 345c7882cbdSMarcel Holtmann } else { 346c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 347c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 348c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 349c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 350c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 3515c3d3b4cSMarcel Holtmann 3525c3d3b4cSMarcel Holtmann /* If the controller supports the Disconnect command, enable 3535c3d3b4cSMarcel Holtmann * the corresponding event. In addition enable packet flow 3545c3d3b4cSMarcel Holtmann * control related events. 3555c3d3b4cSMarcel Holtmann */ 3565c3d3b4cSMarcel Holtmann if (hdev->commands[0] & 0x20) { 3575c3d3b4cSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 358c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 359c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 3605c3d3b4cSMarcel Holtmann } 3615c3d3b4cSMarcel Holtmann 3625c3d3b4cSMarcel Holtmann /* If the controller supports the Read Remote Version 3635c3d3b4cSMarcel Holtmann * Information command, enable the corresponding event. 3645c3d3b4cSMarcel Holtmann */ 3655c3d3b4cSMarcel Holtmann if (hdev->commands[2] & 0x80) 3665c3d3b4cSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information 3675c3d3b4cSMarcel Holtmann * Complete 3685c3d3b4cSMarcel Holtmann */ 3690da71f1bSMarcel Holtmann 3700da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 3710da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 372c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3732177bab5SJohan Hedberg } 3740da71f1bSMarcel Holtmann } 3752177bab5SJohan Hedberg 3769fe759ceSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 3779fe759ceSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) 3782177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 3792177bab5SJohan Hedberg 38070f56aa2SMarcel Holtmann if (lmp_ext_feat_capable(hdev)) 38170f56aa2SMarcel Holtmann events[4] |= 0x04; /* Read Remote Extended Features Complete */ 38270f56aa2SMarcel Holtmann 38370f56aa2SMarcel Holtmann if (lmp_esco_capable(hdev)) { 38470f56aa2SMarcel Holtmann events[5] |= 0x08; /* Synchronous Connection Complete */ 38570f56aa2SMarcel Holtmann events[5] |= 0x10; /* Synchronous Connection Changed */ 38670f56aa2SMarcel Holtmann } 38770f56aa2SMarcel Holtmann 3882177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 3892177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 3902177bab5SJohan Hedberg 3912177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 3922177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 3932177bab5SJohan Hedberg 3942177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 3952177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 3962177bab5SJohan Hedberg 3972177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 3982177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 3992177bab5SJohan Hedberg 4002177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 4012177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 4022177bab5SJohan Hedberg 4032177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 4042177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 4052177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 4062177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 4072177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 4082177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 4092177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 4102177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 4112177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 4122177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 4132177bab5SJohan Hedberg * Features Notification 4142177bab5SJohan Hedberg */ 4152177bab5SJohan Hedberg } 4162177bab5SJohan Hedberg 4172177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 4182177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 4192177bab5SJohan Hedberg 42042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 4212177bab5SJohan Hedberg } 4222177bab5SJohan Hedberg 423a1d01db1SJohan Hedberg static int hci_init2_req(struct hci_request *req, unsigned long opt) 4242177bab5SJohan Hedberg { 42542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 42642c6b129SJohan Hedberg 4270af801b9SJohan Hedberg if (hdev->dev_type == HCI_AMP) 4280af801b9SJohan Hedberg return amp_init2(req); 4290af801b9SJohan Hedberg 4302177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 43142c6b129SJohan Hedberg bredr_setup(req); 43256f87901SJohan Hedberg else 433a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED); 4342177bab5SJohan Hedberg 4352177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 43642c6b129SJohan Hedberg le_setup(req); 4372177bab5SJohan Hedberg 4380f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 4390f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 4400f3adeaeSMarcel Holtmann * 4410f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 4420f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 4430f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 4440f3adeaeSMarcel Holtmann * supported commands. 4453f8e2d75SJohan Hedberg */ 4460f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 4470f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 44842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 4492177bab5SJohan Hedberg 4502177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 45157af75a8SMarcel Holtmann /* When SSP is available, then the host features page 45257af75a8SMarcel Holtmann * should also be available as well. However some 45357af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 45457af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 45557af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 45657af75a8SMarcel Holtmann */ 45757af75a8SMarcel Holtmann hdev->max_page = 0x01; 45857af75a8SMarcel Holtmann 459d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) { 4602177bab5SJohan Hedberg u8 mode = 0x01; 461574ea3c7SMarcel Holtmann 46242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 4632177bab5SJohan Hedberg sizeof(mode), &mode); 4642177bab5SJohan Hedberg } else { 4652177bab5SJohan Hedberg struct hci_cp_write_eir cp; 4662177bab5SJohan Hedberg 4672177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 4682177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 4692177bab5SJohan Hedberg 47042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 4712177bab5SJohan Hedberg } 4722177bab5SJohan Hedberg } 4732177bab5SJohan Hedberg 474043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 475043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 47604422da9SMarcel Holtmann u8 mode; 47704422da9SMarcel Holtmann 47804422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 47904422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 48004422da9SMarcel Holtmann * events. 48104422da9SMarcel Holtmann */ 48204422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 48304422da9SMarcel Holtmann 48404422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 48504422da9SMarcel Holtmann } 4862177bab5SJohan Hedberg 4872177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 48842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 4892177bab5SJohan Hedberg 4902177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 4912177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 4922177bab5SJohan Hedberg 4932177bab5SJohan Hedberg cp.page = 0x01; 49442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 49542c6b129SJohan Hedberg sizeof(cp), &cp); 4962177bab5SJohan Hedberg } 4972177bab5SJohan Hedberg 498d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) { 4992177bab5SJohan Hedberg u8 enable = 1; 50042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 5012177bab5SJohan Hedberg &enable); 5022177bab5SJohan Hedberg } 503a1d01db1SJohan Hedberg 504a1d01db1SJohan Hedberg return 0; 5052177bab5SJohan Hedberg } 5062177bab5SJohan Hedberg 50742c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 5082177bab5SJohan Hedberg { 50942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5102177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 5112177bab5SJohan Hedberg u16 link_policy = 0; 5122177bab5SJohan Hedberg 5132177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 5142177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 5152177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 5162177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 5172177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 5182177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 5192177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 5202177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 5212177bab5SJohan Hedberg 5222177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 52342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 5242177bab5SJohan Hedberg } 5252177bab5SJohan Hedberg 52642c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 5272177bab5SJohan Hedberg { 52842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 5292177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 5302177bab5SJohan Hedberg 531c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 532c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 533c73eee91SJohan Hedberg return; 534c73eee91SJohan Hedberg 5352177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 5362177bab5SJohan Hedberg 537d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) { 5382177bab5SJohan Hedberg cp.le = 0x01; 53932226e4fSMarcel Holtmann cp.simul = 0x00; 5402177bab5SJohan Hedberg } 5412177bab5SJohan Hedberg 5422177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 54342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 5442177bab5SJohan Hedberg &cp); 5452177bab5SJohan Hedberg } 5462177bab5SJohan Hedberg 547d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 548d62e6d67SJohan Hedberg { 549d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 550d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 551d62e6d67SJohan Hedberg 552d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 553d62e6d67SJohan Hedberg * enable all necessary events for it. 554d62e6d67SJohan Hedberg */ 55553b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 556d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 557d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 558d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 559d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 560d62e6d67SJohan Hedberg } 561d62e6d67SJohan Hedberg 562d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 563d62e6d67SJohan Hedberg * enable all necessary events for it. 564d62e6d67SJohan Hedberg */ 56553b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 566d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 567d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 568d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 569d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 570d62e6d67SJohan Hedberg } 571d62e6d67SJohan Hedberg 57240c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 573cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 57440c59fcbSMarcel Holtmann events[2] |= 0x80; 57540c59fcbSMarcel Holtmann 576d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 577d62e6d67SJohan Hedberg } 578d62e6d67SJohan Hedberg 579a1d01db1SJohan Hedberg static int hci_init3_req(struct hci_request *req, unsigned long opt) 5802177bab5SJohan Hedberg { 58142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 582d2c5d77fSJohan Hedberg u8 p; 58342c6b129SJohan Hedberg 5840da71f1bSMarcel Holtmann hci_setup_event_mask(req); 5850da71f1bSMarcel Holtmann 586e81be90bSJohan Hedberg if (hdev->commands[6] & 0x20 && 587e81be90bSJohan Hedberg !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 58848ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 58948ce62c4SMarcel Holtmann 59048ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 59148ce62c4SMarcel Holtmann cp.read_all = 0x01; 59248ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 59348ce62c4SMarcel Holtmann } 59448ce62c4SMarcel Holtmann 5952177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 59642c6b129SJohan Hedberg hci_setup_link_policy(req); 5972177bab5SJohan Hedberg 598417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 599417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 600417287deSMarcel Holtmann 601417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 602417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 603417287deSMarcel Holtmann * this command in the bit mask of supported commands. 604417287deSMarcel Holtmann */ 605417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 606417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 607417287deSMarcel Holtmann 6089193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 6099193c6e8SAndre Guedes u8 events[8]; 6109193c6e8SAndre Guedes 6119193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 6124d6c705bSMarcel Holtmann 6134d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 6144d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 615662bc2e6SAndre Guedes 616662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 617662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 618662bc2e6SAndre Guedes */ 619662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 620662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 621662bc2e6SAndre Guedes * Parameter Request 622662bc2e6SAndre Guedes */ 623662bc2e6SAndre Guedes 624a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 625a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 626a9f6068eSMarcel Holtmann */ 627a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 628a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 629a9f6068eSMarcel Holtmann 6304b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 6314b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 6324b71bba4SMarcel Holtmann */ 6334b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 6344b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 6354b71bba4SMarcel Holtmann * Report 6364b71bba4SMarcel Holtmann */ 6374b71bba4SMarcel Holtmann 6387d26f5c4SMarcel Holtmann /* If the controller supports the LE Set Scan Enable command, 6397d26f5c4SMarcel Holtmann * enable the corresponding advertising report event. 6407d26f5c4SMarcel Holtmann */ 6417d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x08) 6427d26f5c4SMarcel Holtmann events[0] |= 0x02; /* LE Advertising Report */ 6437d26f5c4SMarcel Holtmann 6447d26f5c4SMarcel Holtmann /* If the controller supports the LE Create Connection 6457d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6467d26f5c4SMarcel Holtmann */ 6477d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x10) 6487d26f5c4SMarcel Holtmann events[0] |= 0x01; /* LE Connection Complete */ 6497d26f5c4SMarcel Holtmann 6507d26f5c4SMarcel Holtmann /* If the controller supports the LE Connection Update 6517d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6527d26f5c4SMarcel Holtmann */ 6537d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x04) 6547d26f5c4SMarcel Holtmann events[0] |= 0x04; /* LE Connection Update 6557d26f5c4SMarcel Holtmann * Complete 6567d26f5c4SMarcel Holtmann */ 6577d26f5c4SMarcel Holtmann 6587d26f5c4SMarcel Holtmann /* If the controller supports the LE Read Remote Used Features 6597d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6607d26f5c4SMarcel Holtmann */ 6617d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x20) 6627d26f5c4SMarcel Holtmann events[0] |= 0x08; /* LE Read Remote Used 6637d26f5c4SMarcel Holtmann * Features Complete 6647d26f5c4SMarcel Holtmann */ 6657d26f5c4SMarcel Holtmann 6665a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 6675a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 6685a34bd5fSMarcel Holtmann */ 6695a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 6705a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 6715a34bd5fSMarcel Holtmann * Public Key Complete 6725a34bd5fSMarcel Holtmann */ 6735a34bd5fSMarcel Holtmann 6745a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 6755a34bd5fSMarcel Holtmann * command, enable the corresponding event. 6765a34bd5fSMarcel Holtmann */ 6775a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 6785a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 6795a34bd5fSMarcel Holtmann 6809193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 6819193c6e8SAndre Guedes events); 6829193c6e8SAndre Guedes 68315a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 68415a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 68515a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 68615a49ccaSMarcel Holtmann } 68715a49ccaSMarcel Holtmann 6882ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 6892ab216a7SMarcel Holtmann /* Read LE White List Size */ 6902ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 6912ab216a7SMarcel Holtmann 0, NULL); 6922ab216a7SMarcel Holtmann } 6932ab216a7SMarcel Holtmann 6942ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 6952ab216a7SMarcel Holtmann /* Clear LE White List */ 6962ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 6972ab216a7SMarcel Holtmann } 6982ab216a7SMarcel Holtmann 699a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 700a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 701a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 702a9f6068eSMarcel Holtmann 703a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 704a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 705a9f6068eSMarcel Holtmann } 706a9f6068eSMarcel Holtmann 70742c6b129SJohan Hedberg hci_set_le_support(req); 7089193c6e8SAndre Guedes } 709d2c5d77fSJohan Hedberg 710d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 711d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 712d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 713d2c5d77fSJohan Hedberg 714d2c5d77fSJohan Hedberg cp.page = p; 715d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 716d2c5d77fSJohan Hedberg sizeof(cp), &cp); 717d2c5d77fSJohan Hedberg } 718a1d01db1SJohan Hedberg 719a1d01db1SJohan Hedberg return 0; 7202177bab5SJohan Hedberg } 7212177bab5SJohan Hedberg 722a1d01db1SJohan Hedberg static int hci_init4_req(struct hci_request *req, unsigned long opt) 7235d4e7e8dSJohan Hedberg { 7245d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 7255d4e7e8dSJohan Hedberg 72636f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 72736f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 72836f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 72936f260ceSMarcel Holtmann * 73036f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 73136f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 73236f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 73336f260ceSMarcel Holtmann * command redundant anyway. 73436f260ceSMarcel Holtmann * 73536f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 73636f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 73736f260ceSMarcel Holtmann * just disable this command. 73836f260ceSMarcel Holtmann */ 73936f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 74036f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 74136f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 74236f260ceSMarcel Holtmann 74336f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 74436f260ceSMarcel Holtmann cp.delete_all = 0x01; 74536f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 74636f260ceSMarcel Holtmann sizeof(cp), &cp); 74736f260ceSMarcel Holtmann } 74836f260ceSMarcel Holtmann 749d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 750d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 751d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 752d62e6d67SJohan Hedberg 753109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 754109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 755109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 756109e3191SMarcel Holtmann 757f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 758f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 759f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 760f4fe73edSMarcel Holtmann 7615d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 76253b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 7635d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 764a6d0d690SMarcel Holtmann 765a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 766d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 767574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 768a6d0d690SMarcel Holtmann u8 support = 0x01; 769574ea3c7SMarcel Holtmann 770a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 771a6d0d690SMarcel Holtmann sizeof(support), &support); 772a6d0d690SMarcel Holtmann } 773a1d01db1SJohan Hedberg 77412204875SMarcel Holtmann /* Set Suggested Default Data Length to maximum if supported */ 77512204875SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 77612204875SMarcel Holtmann struct hci_cp_le_write_def_data_len cp; 77712204875SMarcel Holtmann 77812204875SMarcel Holtmann cp.tx_len = hdev->le_max_tx_len; 77912204875SMarcel Holtmann cp.tx_time = hdev->le_max_tx_time; 78012204875SMarcel Holtmann hci_req_add(req, HCI_OP_LE_WRITE_DEF_DATA_LEN, sizeof(cp), &cp); 78112204875SMarcel Holtmann } 78212204875SMarcel Holtmann 783a1d01db1SJohan Hedberg return 0; 7845d4e7e8dSJohan Hedberg } 7855d4e7e8dSJohan Hedberg 7862177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 7872177bab5SJohan Hedberg { 7882177bab5SJohan Hedberg int err; 7892177bab5SJohan Hedberg 7904ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT, NULL); 7912177bab5SJohan Hedberg if (err < 0) 7922177bab5SJohan Hedberg return err; 7932177bab5SJohan Hedberg 794f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 795f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 7964b4148e9SMarcel Holtmann 7974ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT, NULL); 7982177bab5SJohan Hedberg if (err < 0) 7992177bab5SJohan Hedberg return err; 8002177bab5SJohan Hedberg 801ca8bee5dSMarcel Holtmann /* HCI_PRIMARY covers both single-mode LE, BR/EDR and dual-mode 8020af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8030af801b9SJohan Hedberg * first two stages of init. 8040af801b9SJohan Hedberg */ 805ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) 8060af801b9SJohan Hedberg return 0; 8070af801b9SJohan Hedberg 8084ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT, NULL); 8095d4e7e8dSJohan Hedberg if (err < 0) 8105d4e7e8dSJohan Hedberg return err; 8115d4e7e8dSJohan Hedberg 8124ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT, NULL); 813baf27f6eSMarcel Holtmann if (err < 0) 814baf27f6eSMarcel Holtmann return err; 815baf27f6eSMarcel Holtmann 816ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 817ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 818ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 819ec6cef9cSMarcel Holtmann * 820ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 821ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 822ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 823ec6cef9cSMarcel Holtmann * be called during the config phase. 824ec6cef9cSMarcel Holtmann * 825ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 826ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 827baf27f6eSMarcel Holtmann */ 828d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 829d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 830baf27f6eSMarcel Holtmann return 0; 831baf27f6eSMarcel Holtmann 83260c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 83360c5f5fbSMarcel Holtmann 83471c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 83560c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 8362bfa3531SMarcel Holtmann 837162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 83860c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 839e7b8fc92SMarcel Holtmann 840baf27f6eSMarcel Holtmann return 0; 8412177bab5SJohan Hedberg } 8422177bab5SJohan Hedberg 843a1d01db1SJohan Hedberg static int hci_init0_req(struct hci_request *req, unsigned long opt) 8440ebca7d6SMarcel Holtmann { 8450ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 8460ebca7d6SMarcel Holtmann 8470ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 8480ebca7d6SMarcel Holtmann 8490ebca7d6SMarcel Holtmann /* Reset */ 8500ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 8510ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 8520ebca7d6SMarcel Holtmann 8530ebca7d6SMarcel Holtmann /* Read Local Version */ 8540ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 8550ebca7d6SMarcel Holtmann 8560ebca7d6SMarcel Holtmann /* Read BD Address */ 8570ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 8580ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 859a1d01db1SJohan Hedberg 860a1d01db1SJohan Hedberg return 0; 8610ebca7d6SMarcel Holtmann } 8620ebca7d6SMarcel Holtmann 8630ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 8640ebca7d6SMarcel Holtmann { 8650ebca7d6SMarcel Holtmann int err; 8660ebca7d6SMarcel Holtmann 867cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 868cc78b44bSMarcel Holtmann return 0; 869cc78b44bSMarcel Holtmann 8704ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT, NULL); 8710ebca7d6SMarcel Holtmann if (err < 0) 8720ebca7d6SMarcel Holtmann return err; 8730ebca7d6SMarcel Holtmann 874f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 875f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 876f640ee98SMarcel Holtmann 8770ebca7d6SMarcel Holtmann return 0; 8780ebca7d6SMarcel Holtmann } 8790ebca7d6SMarcel Holtmann 880a1d01db1SJohan Hedberg static int hci_scan_req(struct hci_request *req, unsigned long opt) 8811da177e4SLinus Torvalds { 8821da177e4SLinus Torvalds __u8 scan = opt; 8831da177e4SLinus Torvalds 88442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 8851da177e4SLinus Torvalds 8861da177e4SLinus Torvalds /* Inquiry and Page scans */ 88742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 888a1d01db1SJohan Hedberg return 0; 8891da177e4SLinus Torvalds } 8901da177e4SLinus Torvalds 891a1d01db1SJohan Hedberg static int hci_auth_req(struct hci_request *req, unsigned long opt) 8921da177e4SLinus Torvalds { 8931da177e4SLinus Torvalds __u8 auth = opt; 8941da177e4SLinus Torvalds 89542c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds /* Authentication */ 89842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 899a1d01db1SJohan Hedberg return 0; 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds 902a1d01db1SJohan Hedberg static int hci_encrypt_req(struct hci_request *req, unsigned long opt) 9031da177e4SLinus Torvalds { 9041da177e4SLinus Torvalds __u8 encrypt = opt; 9051da177e4SLinus Torvalds 90642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 9071da177e4SLinus Torvalds 908e4e8e37cSMarcel Holtmann /* Encryption */ 90942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 910a1d01db1SJohan Hedberg return 0; 9111da177e4SLinus Torvalds } 9121da177e4SLinus Torvalds 913a1d01db1SJohan Hedberg static int hci_linkpol_req(struct hci_request *req, unsigned long opt) 914e4e8e37cSMarcel Holtmann { 915e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 916e4e8e37cSMarcel Holtmann 91742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 918e4e8e37cSMarcel Holtmann 919e4e8e37cSMarcel Holtmann /* Default link policy */ 92042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 921a1d01db1SJohan Hedberg return 0; 922e4e8e37cSMarcel Holtmann } 923e4e8e37cSMarcel Holtmann 9241da177e4SLinus Torvalds /* Get HCI device by index. 9251da177e4SLinus Torvalds * Device is held on return. */ 9261da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 9271da177e4SLinus Torvalds { 9288035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 9291da177e4SLinus Torvalds 9301da177e4SLinus Torvalds BT_DBG("%d", index); 9311da177e4SLinus Torvalds 9321da177e4SLinus Torvalds if (index < 0) 9331da177e4SLinus Torvalds return NULL; 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 9368035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 9371da177e4SLinus Torvalds if (d->id == index) { 9381da177e4SLinus Torvalds hdev = hci_dev_hold(d); 9391da177e4SLinus Torvalds break; 9401da177e4SLinus Torvalds } 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 9431da177e4SLinus Torvalds return hdev; 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 947ff9ef578SJohan Hedberg 94830dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 94930dc78e1SJohan Hedberg { 95030dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 95130dc78e1SJohan Hedberg 9526fbe195dSAndre Guedes switch (discov->state) { 953343f935bSAndre Guedes case DISCOVERY_FINDING: 9546fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 95530dc78e1SJohan Hedberg return true; 95630dc78e1SJohan Hedberg 9576fbe195dSAndre Guedes default: 95830dc78e1SJohan Hedberg return false; 95930dc78e1SJohan Hedberg } 9606fbe195dSAndre Guedes } 96130dc78e1SJohan Hedberg 962ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 963ff9ef578SJohan Hedberg { 964bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 965bb3e0a33SJohan Hedberg 966ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 967ff9ef578SJohan Hedberg 968bb3e0a33SJohan Hedberg if (old_state == state) 969ff9ef578SJohan Hedberg return; 970ff9ef578SJohan Hedberg 971bb3e0a33SJohan Hedberg hdev->discovery.state = state; 972bb3e0a33SJohan Hedberg 973ff9ef578SJohan Hedberg switch (state) { 974ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 975c54c3860SAndre Guedes hci_update_background_scan(hdev); 976c54c3860SAndre Guedes 977bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 978ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 979ff9ef578SJohan Hedberg break; 980ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 981ff9ef578SJohan Hedberg break; 982343f935bSAndre Guedes case DISCOVERY_FINDING: 983ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 984ff9ef578SJohan Hedberg break; 98530dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 98630dc78e1SJohan Hedberg break; 987ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 988ff9ef578SJohan Hedberg break; 989ff9ef578SJohan Hedberg } 990ff9ef578SJohan Hedberg } 991ff9ef578SJohan Hedberg 9921f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 9931da177e4SLinus Torvalds { 99430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 995b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 9961da177e4SLinus Torvalds 997561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 998561aafbcSJohan Hedberg list_del(&p->all); 999b57c1a56SJohan Hedberg kfree(p); 10001da177e4SLinus Torvalds } 1001561aafbcSJohan Hedberg 1002561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1003561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 1006a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1007a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 10081da177e4SLinus Torvalds { 100930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 10101da177e4SLinus Torvalds struct inquiry_entry *e; 10111da177e4SLinus Torvalds 10126ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 10131da177e4SLinus Torvalds 1014561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 10151da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 10161da177e4SLinus Torvalds return e; 10171da177e4SLinus Torvalds } 10181da177e4SLinus Torvalds 1019b57c1a56SJohan Hedberg return NULL; 1020b57c1a56SJohan Hedberg } 1021b57c1a56SJohan Hedberg 1022561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1023561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1024561aafbcSJohan Hedberg { 102530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1026561aafbcSJohan Hedberg struct inquiry_entry *e; 1027561aafbcSJohan Hedberg 10286ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1029561aafbcSJohan Hedberg 1030561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1031561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1032561aafbcSJohan Hedberg return e; 1033561aafbcSJohan Hedberg } 1034561aafbcSJohan Hedberg 1035561aafbcSJohan Hedberg return NULL; 1036561aafbcSJohan Hedberg } 1037561aafbcSJohan Hedberg 103830dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 103930dc78e1SJohan Hedberg bdaddr_t *bdaddr, 104030dc78e1SJohan Hedberg int state) 104130dc78e1SJohan Hedberg { 104230dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 104330dc78e1SJohan Hedberg struct inquiry_entry *e; 104430dc78e1SJohan Hedberg 10456ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 104630dc78e1SJohan Hedberg 104730dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 104830dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 104930dc78e1SJohan Hedberg return e; 105030dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 105130dc78e1SJohan Hedberg return e; 105230dc78e1SJohan Hedberg } 105330dc78e1SJohan Hedberg 105430dc78e1SJohan Hedberg return NULL; 105530dc78e1SJohan Hedberg } 105630dc78e1SJohan Hedberg 1057a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1058a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1059a3d4e20aSJohan Hedberg { 1060a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1061a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1062a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1063a3d4e20aSJohan Hedberg 1064a3d4e20aSJohan Hedberg list_del(&ie->list); 1065a3d4e20aSJohan Hedberg 1066a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1067a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1068a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1069a3d4e20aSJohan Hedberg break; 1070a3d4e20aSJohan Hedberg pos = &p->list; 1071a3d4e20aSJohan Hedberg } 1072a3d4e20aSJohan Hedberg 1073a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1074a3d4e20aSJohan Hedberg } 1075a3d4e20aSJohan Hedberg 1076af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1077af58925cSMarcel Holtmann bool name_known) 10781da177e4SLinus Torvalds { 107930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 108070f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1081af58925cSMarcel Holtmann u32 flags = 0; 10821da177e4SLinus Torvalds 10836ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 10841da177e4SLinus Torvalds 10856928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 10862b2fec4dSSzymon Janc 1087af58925cSMarcel Holtmann if (!data->ssp_mode) 1088af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1089388fc8faSJohan Hedberg 109070f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1091a3d4e20aSJohan Hedberg if (ie) { 1092af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1093af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1094388fc8faSJohan Hedberg 1095a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1096a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1097a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1098a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1099a3d4e20aSJohan Hedberg } 1100a3d4e20aSJohan Hedberg 1101561aafbcSJohan Hedberg goto update; 1102a3d4e20aSJohan Hedberg } 1103561aafbcSJohan Hedberg 11041da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 110527f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1106af58925cSMarcel Holtmann if (!ie) { 1107af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1108af58925cSMarcel Holtmann goto done; 1109af58925cSMarcel Holtmann } 111070f23020SAndrei Emeltchenko 1111561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1112561aafbcSJohan Hedberg 1113561aafbcSJohan Hedberg if (name_known) { 1114561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1115561aafbcSJohan Hedberg } else { 1116561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1117561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1118561aafbcSJohan Hedberg } 1119561aafbcSJohan Hedberg 1120561aafbcSJohan Hedberg update: 1121561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1122561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1123561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1124561aafbcSJohan Hedberg list_del(&ie->list); 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 112770f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 112870f23020SAndrei Emeltchenko ie->timestamp = jiffies; 11291da177e4SLinus Torvalds cache->timestamp = jiffies; 11303175405bSJohan Hedberg 11313175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1132af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 11333175405bSJohan Hedberg 1134af58925cSMarcel Holtmann done: 1135af58925cSMarcel Holtmann return flags; 11361da177e4SLinus Torvalds } 11371da177e4SLinus Torvalds 11381da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 11391da177e4SLinus Torvalds { 114030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11411da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 11421da177e4SLinus Torvalds struct inquiry_entry *e; 11431da177e4SLinus Torvalds int copied = 0; 11441da177e4SLinus Torvalds 1145561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11461da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1147b57c1a56SJohan Hedberg 1148b57c1a56SJohan Hedberg if (copied >= num) 1149b57c1a56SJohan Hedberg break; 1150b57c1a56SJohan Hedberg 11511da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 11521da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 11531da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 11541da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 11551da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 11561da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1157b57c1a56SJohan Hedberg 11581da177e4SLinus Torvalds info++; 1159b57c1a56SJohan Hedberg copied++; 11601da177e4SLinus Torvalds } 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 11631da177e4SLinus Torvalds return copied; 11641da177e4SLinus Torvalds } 11651da177e4SLinus Torvalds 1166a1d01db1SJohan Hedberg static int hci_inq_req(struct hci_request *req, unsigned long opt) 11671da177e4SLinus Torvalds { 11681da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 116942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 11701da177e4SLinus Torvalds struct hci_cp_inquiry cp; 11711da177e4SLinus Torvalds 11721da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 1175a1d01db1SJohan Hedberg return 0; 11761da177e4SLinus Torvalds 11771da177e4SLinus Torvalds /* Start Inquiry */ 11781da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 11791da177e4SLinus Torvalds cp.length = ir->length; 11801da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 118142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 1182a1d01db1SJohan Hedberg 1183a1d01db1SJohan Hedberg return 0; 11841da177e4SLinus Torvalds } 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 11871da177e4SLinus Torvalds { 11881da177e4SLinus Torvalds __u8 __user *ptr = arg; 11891da177e4SLinus Torvalds struct hci_inquiry_req ir; 11901da177e4SLinus Torvalds struct hci_dev *hdev; 11911da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 11921da177e4SLinus Torvalds long timeo; 11931da177e4SLinus Torvalds __u8 *buf; 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 11961da177e4SLinus Torvalds return -EFAULT; 11971da177e4SLinus Torvalds 11985a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 11995a08ecceSAndrei Emeltchenko if (!hdev) 12001da177e4SLinus Torvalds return -ENODEV; 12011da177e4SLinus Torvalds 1202d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 12030736cfa8SMarcel Holtmann err = -EBUSY; 12040736cfa8SMarcel Holtmann goto done; 12050736cfa8SMarcel Holtmann } 12060736cfa8SMarcel Holtmann 1207d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1208fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1209fee746b0SMarcel Holtmann goto done; 1210fee746b0SMarcel Holtmann } 1211fee746b0SMarcel Holtmann 1212ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 12135b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 12145b69bef5SMarcel Holtmann goto done; 12155b69bef5SMarcel Holtmann } 12165b69bef5SMarcel Holtmann 1217d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 121856f87901SJohan Hedberg err = -EOPNOTSUPP; 121956f87901SJohan Hedberg goto done; 122056f87901SJohan Hedberg } 122156f87901SJohan Hedberg 122209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12231da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1224a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 12251f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 12261da177e4SLinus Torvalds do_inquiry = 1; 12271da177e4SLinus Torvalds } 122809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12291da177e4SLinus Torvalds 123004837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 123170f23020SAndrei Emeltchenko 123270f23020SAndrei Emeltchenko if (do_inquiry) { 123301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 12344ebeee2dSJohan Hedberg timeo, NULL); 123570f23020SAndrei Emeltchenko if (err < 0) 12361da177e4SLinus Torvalds goto done; 12373e13fa1eSAndre Guedes 12383e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 12393e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 12403e13fa1eSAndre Guedes */ 124174316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 12423e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 12433e13fa1eSAndre Guedes return -EINTR; 124470f23020SAndrei Emeltchenko } 12451da177e4SLinus Torvalds 12468fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 12478fc9ced3SGustavo Padovan * 255 entries 12488fc9ced3SGustavo Padovan */ 12491da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 12501da177e4SLinus Torvalds 12511da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 12521da177e4SLinus Torvalds * copy it to the user space. 12531da177e4SLinus Torvalds */ 125470f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 125570f23020SAndrei Emeltchenko if (!buf) { 12561da177e4SLinus Torvalds err = -ENOMEM; 12571da177e4SLinus Torvalds goto done; 12581da177e4SLinus Torvalds } 12591da177e4SLinus Torvalds 126009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12611da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 126209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 12671da177e4SLinus Torvalds ptr += sizeof(ir); 12681da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 12691da177e4SLinus Torvalds ir.num_rsp)) 12701da177e4SLinus Torvalds err = -EFAULT; 12711da177e4SLinus Torvalds } else 12721da177e4SLinus Torvalds err = -EFAULT; 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds kfree(buf); 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds done: 12771da177e4SLinus Torvalds hci_dev_put(hdev); 12781da177e4SLinus Torvalds return err; 12791da177e4SLinus Torvalds } 12801da177e4SLinus Torvalds 1281cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 12821da177e4SLinus Torvalds { 12831da177e4SLinus Torvalds int ret = 0; 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 12861da177e4SLinus Torvalds 1287b504430cSJohan Hedberg hci_req_sync_lock(hdev); 12881da177e4SLinus Torvalds 1289d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 129094324962SJohan Hovold ret = -ENODEV; 129194324962SJohan Hovold goto done; 129294324962SJohan Hovold } 129394324962SJohan Hovold 1294d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1295d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1296a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1297a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1298bf543036SJohan Hedberg */ 1299d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1300611b30f7SMarcel Holtmann ret = -ERFKILL; 1301611b30f7SMarcel Holtmann goto done; 1302611b30f7SMarcel Holtmann } 1303611b30f7SMarcel Holtmann 1304a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1305a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1306a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1307a5c8f270SMarcel Holtmann * or not. 1308a5c8f270SMarcel Holtmann * 1309c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1310c6beca0eSMarcel Holtmann * if a public address or static random address is 1311c6beca0eSMarcel Holtmann * available. 1312c6beca0eSMarcel Holtmann * 1313a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1314a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1315a5c8f270SMarcel Holtmann */ 1316d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1317ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY && 1318a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1319a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1320a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1321a5c8f270SMarcel Holtmann goto done; 1322a5c8f270SMarcel Holtmann } 1323a5c8f270SMarcel Holtmann } 1324a5c8f270SMarcel Holtmann 13251da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 13261da177e4SLinus Torvalds ret = -EALREADY; 13271da177e4SLinus Torvalds goto done; 13281da177e4SLinus Torvalds } 13291da177e4SLinus Torvalds 13301da177e4SLinus Torvalds if (hdev->open(hdev)) { 13311da177e4SLinus Torvalds ret = -EIO; 13321da177e4SLinus Torvalds goto done; 13331da177e4SLinus Torvalds } 13341da177e4SLinus Torvalds 1335e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 133605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 13374a3f95b7SMarcel Holtmann 13381da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 13391da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1340f41c70c4SMarcel Holtmann 1341d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) { 1342e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1343e131d74aSMarcel Holtmann 1344af202f84SMarcel Holtmann if (hdev->setup) 1345f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1346f41c70c4SMarcel Holtmann 1347af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1348af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1349af202f84SMarcel Holtmann * 1350af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1351af202f84SMarcel Holtmann * start up as unconfigured. 1352af202f84SMarcel Holtmann */ 1353eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1354eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 1355a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1356f41c70c4SMarcel Holtmann 13570ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 13580ebca7d6SMarcel Holtmann * read at least the version information provided by 13590ebca7d6SMarcel Holtmann * the Read Local Version Information command. 13600ebca7d6SMarcel Holtmann * 13610ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 13620ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 13630ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 13640ebca7d6SMarcel Holtmann */ 1365d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 13660ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 136789bc22d2SMarcel Holtmann } 136889bc22d2SMarcel Holtmann 1369d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 13709713c17bSMarcel Holtmann /* If public address change is configured, ensure that 13719713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 13729713c17bSMarcel Holtmann * support changing the public address, fail the power 13739713c17bSMarcel Holtmann * on procedure. 137424c457e2SMarcel Holtmann */ 13759713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 13769713c17bSMarcel Holtmann hdev->set_bdaddr) 137724c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 137824c457e2SMarcel Holtmann else 137924c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 138024c457e2SMarcel Holtmann } 138124c457e2SMarcel Holtmann 1382f41c70c4SMarcel Holtmann if (!ret) { 1383d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 138498a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 13852177bab5SJohan Hedberg ret = __hci_init(hdev); 138698a63aafSMarcel Holtmann if (!ret && hdev->post_init) 138798a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 138898a63aafSMarcel Holtmann } 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 13917e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 13927e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 13937e995b9eSMarcel Holtmann * completed. 13947e995b9eSMarcel Holtmann */ 13957e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 13967e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 13977e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 13987e995b9eSMarcel Holtmann 1399f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1400f41c70c4SMarcel Holtmann 14011da177e4SLinus Torvalds if (!ret) { 14021da177e4SLinus Torvalds hci_dev_hold(hdev); 1403a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 14041da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 140505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 14066d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, true); 1407d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1408d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1409d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1410d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 14112ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 1412ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY) { 14132ff13894SJohan Hedberg ret = __hci_req_hci_power_on(hdev); 14142ff13894SJohan Hedberg mgmt_power_on(hdev, ret); 141556e5cb86SJohan Hedberg } 14161da177e4SLinus Torvalds } else { 14171da177e4SLinus Torvalds /* Init failed, cleanup */ 14183eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1419c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1420b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14231da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14241da177e4SLinus Torvalds 14251da177e4SLinus Torvalds if (hdev->flush) 14261da177e4SLinus Torvalds hdev->flush(hdev); 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds if (hdev->sent_cmd) { 14291da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 14301da177e4SLinus Torvalds hdev->sent_cmd = NULL; 14311da177e4SLinus Torvalds } 14321da177e4SLinus Torvalds 1433e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 143405fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 14354a3f95b7SMarcel Holtmann 14361da177e4SLinus Torvalds hdev->close(hdev); 1437fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 14381da177e4SLinus Torvalds } 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds done: 1441b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 14421da177e4SLinus Torvalds return ret; 14431da177e4SLinus Torvalds } 14441da177e4SLinus Torvalds 1445cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1446cbed0ca1SJohan Hedberg 1447cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1448cbed0ca1SJohan Hedberg { 1449cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1450cbed0ca1SJohan Hedberg int err; 1451cbed0ca1SJohan Hedberg 1452cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1453cbed0ca1SJohan Hedberg if (!hdev) 1454cbed0ca1SJohan Hedberg return -ENODEV; 1455cbed0ca1SJohan Hedberg 14564a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1457fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1458fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1459fee746b0SMarcel Holtmann * possible. 1460fee746b0SMarcel Holtmann * 1461fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1462fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1463fee746b0SMarcel Holtmann * open the device. 1464fee746b0SMarcel Holtmann */ 1465d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1466d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1467fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1468fee746b0SMarcel Holtmann goto done; 1469fee746b0SMarcel Holtmann } 1470fee746b0SMarcel Holtmann 1471e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1472e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1473e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1474e1d08f40SJohan Hedberg * completed. 1475e1d08f40SJohan Hedberg */ 1476a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1477e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1478e1d08f40SJohan Hedberg 1479a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1480a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1481a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1482a5c8f270SMarcel Holtmann */ 1483e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1484e1d08f40SJohan Hedberg 148512aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1486b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 148712aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 148812aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 148912aa4f0aSMarcel Holtmann * to explicitly enable it. 149012aa4f0aSMarcel Holtmann */ 1491d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1492d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1493a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 149412aa4f0aSMarcel Holtmann 1495cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1496cbed0ca1SJohan Hedberg 1497fee746b0SMarcel Holtmann done: 1498cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1499cbed0ca1SJohan Hedberg return err; 1500cbed0ca1SJohan Hedberg } 1501cbed0ca1SJohan Hedberg 1502d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1503d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1504d7347f3cSJohan Hedberg { 1505d7347f3cSJohan Hedberg struct hci_conn_params *p; 1506d7347f3cSJohan Hedberg 1507f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1508f161dd41SJohan Hedberg if (p->conn) { 1509f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1510f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1511f161dd41SJohan Hedberg p->conn = NULL; 1512f161dd41SJohan Hedberg } 1513d7347f3cSJohan Hedberg list_del_init(&p->action); 1514f161dd41SJohan Hedberg } 1515d7347f3cSJohan Hedberg 1516d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1517d7347f3cSJohan Hedberg } 1518d7347f3cSJohan Hedberg 15196b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 15201da177e4SLinus Torvalds { 1521acc649c6SMarcel Holtmann bool auto_off; 1522acc649c6SMarcel Holtmann 15231da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 15241da177e4SLinus Torvalds 1525d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1526867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1527d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1528a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1529a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1530a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1531a44fecbdSTedd Ho-Jeong An } 1532a44fecbdSTedd Ho-Jeong An 153378c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 153478c04c0bSVinicius Costa Gomes 15357df0f73eSJohan Hedberg hci_request_cancel_all(hdev); 1536b504430cSJohan Hedberg hci_req_sync_lock(hdev); 15371da177e4SLinus Torvalds 15381da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 153965cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 1540b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 15411da177e4SLinus Torvalds return 0; 15421da177e4SLinus Torvalds } 15431da177e4SLinus Torvalds 15446d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, false); 15456d5d2ee6SHeiner Kallweit 15463eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 15473eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1548b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15491da177e4SLinus Torvalds 155016ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 155116ab91abSJohan Hedberg hdev->discov_timeout = 0; 1552a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1553a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 155416ab91abSJohan Hedberg } 155516ab91abSJohan Hedberg 1556a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 15577d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 15587d78525dSJohan Hedberg 1559d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_MGMT)) 1560d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 15617ba8b4beSAndre Guedes 156276727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 156376727c02SJohan Hedberg * ensuring the workqueue is empty up front. 156476727c02SJohan Hedberg */ 156576727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 156676727c02SJohan Hedberg 156709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 15681aeb9c65SJohan Hedberg 15698f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 15708f502f84SJohan Hedberg 1571acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1572acc649c6SMarcel Holtmann 1573ca8bee5dSMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_PRIMARY && 1574baab7932SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 15752ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT)) 15762ff13894SJohan Hedberg __mgmt_power_off(hdev); 15771aeb9c65SJohan Hedberg 15781f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1579d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1580f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 158109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15821da177e4SLinus Torvalds 158364dae967SMarcel Holtmann smp_unregister(hdev); 158464dae967SMarcel Holtmann 158505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 15861da177e4SLinus Torvalds 15871da177e4SLinus Torvalds if (hdev->flush) 15881da177e4SLinus Torvalds hdev->flush(hdev); 15891da177e4SLinus Torvalds 15901da177e4SLinus Torvalds /* Reset device */ 15911da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15921da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1593acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1594acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 15951da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 15964ebeee2dSJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT, NULL); 15971da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 15981da177e4SLinus Torvalds } 15991da177e4SLinus Torvalds 1600c347b765SGustavo F. Padovan /* flush cmd work */ 1601c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 16021da177e4SLinus Torvalds 16031da177e4SLinus Torvalds /* Drop queues */ 16041da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16051da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16061da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 16071da177e4SLinus Torvalds 16081da177e4SLinus Torvalds /* Drop last sent command */ 16091da177e4SLinus Torvalds if (hdev->sent_cmd) { 161065cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16111da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16121da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds 1615e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 161605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 16174a3f95b7SMarcel Holtmann 16181da177e4SLinus Torvalds /* After this point our queues are empty 16191da177e4SLinus Torvalds * and no tasks are scheduled. */ 16201da177e4SLinus Torvalds hdev->close(hdev); 16211da177e4SLinus Torvalds 162235b973c9SJohan Hedberg /* Clear flags */ 1623fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1624eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 162535b973c9SJohan Hedberg 1626ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1627536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1628ced5c338SAndrei Emeltchenko 1629e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 163009b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 16317a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1632e59fda8dSJohan Hedberg 1633b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 16341da177e4SLinus Torvalds 16351da177e4SLinus Torvalds hci_dev_put(hdev); 16361da177e4SLinus Torvalds return 0; 16371da177e4SLinus Torvalds } 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 16401da177e4SLinus Torvalds { 16411da177e4SLinus Torvalds struct hci_dev *hdev; 16421da177e4SLinus Torvalds int err; 16431da177e4SLinus Torvalds 164470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 164570f23020SAndrei Emeltchenko if (!hdev) 16461da177e4SLinus Torvalds return -ENODEV; 16478ee56540SMarcel Holtmann 1648d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 16490736cfa8SMarcel Holtmann err = -EBUSY; 16500736cfa8SMarcel Holtmann goto done; 16510736cfa8SMarcel Holtmann } 16520736cfa8SMarcel Holtmann 1653a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 16548ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 16558ee56540SMarcel Holtmann 16561da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 16578ee56540SMarcel Holtmann 16580736cfa8SMarcel Holtmann done: 16591da177e4SLinus Torvalds hci_dev_put(hdev); 16601da177e4SLinus Torvalds return err; 16611da177e4SLinus Torvalds } 16621da177e4SLinus Torvalds 16635c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 16641da177e4SLinus Torvalds { 16655c912495SMarcel Holtmann int ret; 16661da177e4SLinus Torvalds 16675c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 16681da177e4SLinus Torvalds 1669b504430cSJohan Hedberg hci_req_sync_lock(hdev); 16701da177e4SLinus Torvalds 16711da177e4SLinus Torvalds /* Drop queues */ 16721da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16731da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16741da177e4SLinus Torvalds 167576727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 167676727c02SJohan Hedberg * ensuring the workqueue is empty up front. 167776727c02SJohan Hedberg */ 167876727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 167976727c02SJohan Hedberg 168009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16811f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 16821da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 168309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16841da177e4SLinus Torvalds 16851da177e4SLinus Torvalds if (hdev->flush) 16861da177e4SLinus Torvalds hdev->flush(hdev); 16871da177e4SLinus Torvalds 16881da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 16896ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 16901da177e4SLinus Torvalds 16914ebeee2dSJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT, NULL); 16921da177e4SLinus Torvalds 1693b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 16941da177e4SLinus Torvalds return ret; 16951da177e4SLinus Torvalds } 16961da177e4SLinus Torvalds 16975c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 16985c912495SMarcel Holtmann { 16995c912495SMarcel Holtmann struct hci_dev *hdev; 17005c912495SMarcel Holtmann int err; 17015c912495SMarcel Holtmann 17025c912495SMarcel Holtmann hdev = hci_dev_get(dev); 17035c912495SMarcel Holtmann if (!hdev) 17045c912495SMarcel Holtmann return -ENODEV; 17055c912495SMarcel Holtmann 17065c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 17075c912495SMarcel Holtmann err = -ENETDOWN; 17085c912495SMarcel Holtmann goto done; 17095c912495SMarcel Holtmann } 17105c912495SMarcel Holtmann 1711d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17125c912495SMarcel Holtmann err = -EBUSY; 17135c912495SMarcel Holtmann goto done; 17145c912495SMarcel Holtmann } 17155c912495SMarcel Holtmann 1716d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17175c912495SMarcel Holtmann err = -EOPNOTSUPP; 17185c912495SMarcel Holtmann goto done; 17195c912495SMarcel Holtmann } 17205c912495SMarcel Holtmann 17215c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 17225c912495SMarcel Holtmann 17235c912495SMarcel Holtmann done: 17245c912495SMarcel Holtmann hci_dev_put(hdev); 17255c912495SMarcel Holtmann return err; 17265c912495SMarcel Holtmann } 17275c912495SMarcel Holtmann 17281da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 17291da177e4SLinus Torvalds { 17301da177e4SLinus Torvalds struct hci_dev *hdev; 17311da177e4SLinus Torvalds int ret = 0; 17321da177e4SLinus Torvalds 173370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 173470f23020SAndrei Emeltchenko if (!hdev) 17351da177e4SLinus Torvalds return -ENODEV; 17361da177e4SLinus Torvalds 1737d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17380736cfa8SMarcel Holtmann ret = -EBUSY; 17390736cfa8SMarcel Holtmann goto done; 17400736cfa8SMarcel Holtmann } 17410736cfa8SMarcel Holtmann 1742d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1743fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1744fee746b0SMarcel Holtmann goto done; 1745fee746b0SMarcel Holtmann } 1746fee746b0SMarcel Holtmann 17471da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 17481da177e4SLinus Torvalds 17490736cfa8SMarcel Holtmann done: 17501da177e4SLinus Torvalds hci_dev_put(hdev); 17511da177e4SLinus Torvalds return ret; 17521da177e4SLinus Torvalds } 17531da177e4SLinus Torvalds 1754123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1755123abc08SJohan Hedberg { 1756bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1757123abc08SJohan Hedberg 1758123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1759123abc08SJohan Hedberg 1760123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1761238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1762238be788SMarcel Holtmann HCI_CONNECTABLE); 1763123abc08SJohan Hedberg else 1764a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1765a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1766123abc08SJohan Hedberg 1767bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1768238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1769238be788SMarcel Holtmann HCI_DISCOVERABLE); 1770bc6d2d04SJohan Hedberg } else { 1771a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1772a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1773a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1774bc6d2d04SJohan Hedberg } 1775bc6d2d04SJohan Hedberg 1776d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1777123abc08SJohan Hedberg return; 1778123abc08SJohan Hedberg 1779bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1780bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1781a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1782bc6d2d04SJohan Hedberg 1783d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1784cab054abSJohan Hedberg hci_req_update_adv_data(hdev, hdev->cur_adv_instance); 1785bc6d2d04SJohan Hedberg 1786123abc08SJohan Hedberg mgmt_new_settings(hdev); 1787123abc08SJohan Hedberg } 1788bc6d2d04SJohan Hedberg } 1789123abc08SJohan Hedberg 17901da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 17911da177e4SLinus Torvalds { 17921da177e4SLinus Torvalds struct hci_dev *hdev; 17931da177e4SLinus Torvalds struct hci_dev_req dr; 17941da177e4SLinus Torvalds int err = 0; 17951da177e4SLinus Torvalds 17961da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 17971da177e4SLinus Torvalds return -EFAULT; 17981da177e4SLinus Torvalds 179970f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 180070f23020SAndrei Emeltchenko if (!hdev) 18011da177e4SLinus Torvalds return -ENODEV; 18021da177e4SLinus Torvalds 1803d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18040736cfa8SMarcel Holtmann err = -EBUSY; 18050736cfa8SMarcel Holtmann goto done; 18060736cfa8SMarcel Holtmann } 18070736cfa8SMarcel Holtmann 1808d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1809fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1810fee746b0SMarcel Holtmann goto done; 1811fee746b0SMarcel Holtmann } 1812fee746b0SMarcel Holtmann 1813ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 18145b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 18155b69bef5SMarcel Holtmann goto done; 18165b69bef5SMarcel Holtmann } 18175b69bef5SMarcel Holtmann 1818d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 181956f87901SJohan Hedberg err = -EOPNOTSUPP; 182056f87901SJohan Hedberg goto done; 182156f87901SJohan Hedberg } 182256f87901SJohan Hedberg 18231da177e4SLinus Torvalds switch (cmd) { 18241da177e4SLinus Torvalds case HCISETAUTH: 182501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18264ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18271da177e4SLinus Torvalds break; 18281da177e4SLinus Torvalds 18291da177e4SLinus Torvalds case HCISETENCRYPT: 18301da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 18311da177e4SLinus Torvalds err = -EOPNOTSUPP; 18321da177e4SLinus Torvalds break; 18331da177e4SLinus Torvalds } 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 18361da177e4SLinus Torvalds /* Auth must be enabled first */ 183701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18384ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18391da177e4SLinus Torvalds if (err) 18401da177e4SLinus Torvalds break; 18411da177e4SLinus Torvalds } 18421da177e4SLinus Torvalds 184301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 18444ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18451da177e4SLinus Torvalds break; 18461da177e4SLinus Torvalds 18471da177e4SLinus Torvalds case HCISETSCAN: 184801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 18494ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 185091a668b0SJohan Hedberg 1851bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1852bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 185391a668b0SJohan Hedberg */ 1854123abc08SJohan Hedberg if (!err) 1855123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 18561da177e4SLinus Torvalds break; 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds case HCISETLINKPOL: 185901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 18604ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18611da177e4SLinus Torvalds break; 18621da177e4SLinus Torvalds 18631da177e4SLinus Torvalds case HCISETLINKMODE: 1864e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1865e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1866e4e8e37cSMarcel Holtmann break; 1867e4e8e37cSMarcel Holtmann 1868e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1869e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 18701da177e4SLinus Torvalds break; 18711da177e4SLinus Torvalds 18721da177e4SLinus Torvalds case HCISETACLMTU: 18731da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 18741da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 18751da177e4SLinus Torvalds break; 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds case HCISETSCOMTU: 18781da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 18791da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 18801da177e4SLinus Torvalds break; 18811da177e4SLinus Torvalds 18821da177e4SLinus Torvalds default: 18831da177e4SLinus Torvalds err = -EINVAL; 18841da177e4SLinus Torvalds break; 18851da177e4SLinus Torvalds } 1886e4e8e37cSMarcel Holtmann 18870736cfa8SMarcel Holtmann done: 18881da177e4SLinus Torvalds hci_dev_put(hdev); 18891da177e4SLinus Torvalds return err; 18901da177e4SLinus Torvalds } 18911da177e4SLinus Torvalds 18921da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 18931da177e4SLinus Torvalds { 18948035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 18951da177e4SLinus Torvalds struct hci_dev_list_req *dl; 18961da177e4SLinus Torvalds struct hci_dev_req *dr; 18971da177e4SLinus Torvalds int n = 0, size, err; 18981da177e4SLinus Torvalds __u16 dev_num; 18991da177e4SLinus Torvalds 19001da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 19011da177e4SLinus Torvalds return -EFAULT; 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 19041da177e4SLinus Torvalds return -EINVAL; 19051da177e4SLinus Torvalds 19061da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 19071da177e4SLinus Torvalds 190870f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 190970f23020SAndrei Emeltchenko if (!dl) 19101da177e4SLinus Torvalds return -ENOMEM; 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds dr = dl->dev_req; 19131da177e4SLinus Torvalds 1914f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 19158035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 19162e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 1917c542a06cSJohan Hedberg 19182e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19192e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19202e84d8dbSMarcel Holtmann * device is actually down. 19212e84d8dbSMarcel Holtmann */ 1922d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 19232e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 1924c542a06cSJohan Hedberg 19251da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 19262e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 1927c542a06cSJohan Hedberg 19281da177e4SLinus Torvalds if (++n >= dev_num) 19291da177e4SLinus Torvalds break; 19301da177e4SLinus Torvalds } 1931f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 19321da177e4SLinus Torvalds 19331da177e4SLinus Torvalds dl->dev_num = n; 19341da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 19351da177e4SLinus Torvalds 19361da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 19371da177e4SLinus Torvalds kfree(dl); 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds return err ? -EFAULT : 0; 19401da177e4SLinus Torvalds } 19411da177e4SLinus Torvalds 19421da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 19431da177e4SLinus Torvalds { 19441da177e4SLinus Torvalds struct hci_dev *hdev; 19451da177e4SLinus Torvalds struct hci_dev_info di; 19462e84d8dbSMarcel Holtmann unsigned long flags; 19471da177e4SLinus Torvalds int err = 0; 19481da177e4SLinus Torvalds 19491da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 19501da177e4SLinus Torvalds return -EFAULT; 19511da177e4SLinus Torvalds 195270f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 195370f23020SAndrei Emeltchenko if (!hdev) 19541da177e4SLinus Torvalds return -ENODEV; 19551da177e4SLinus Torvalds 19562e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19572e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19582e84d8dbSMarcel Holtmann * device is actually down. 19592e84d8dbSMarcel Holtmann */ 1960d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 19612e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 19622e84d8dbSMarcel Holtmann else 19632e84d8dbSMarcel Holtmann flags = hdev->flags; 1964c542a06cSJohan Hedberg 19651da177e4SLinus Torvalds strcpy(di.name, hdev->name); 19661da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 196760f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 19682e84d8dbSMarcel Holtmann di.flags = flags; 19691da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 1970572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 19711da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 19721da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 19731da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 19741da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 1975572c7f84SJohan Hedberg } else { 1976572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 1977572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 1978572c7f84SJohan Hedberg di.sco_mtu = 0; 1979572c7f84SJohan Hedberg di.sco_pkts = 0; 1980572c7f84SJohan Hedberg } 19811da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 19821da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 19851da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 19861da177e4SLinus Torvalds 19871da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 19881da177e4SLinus Torvalds err = -EFAULT; 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds hci_dev_put(hdev); 19911da177e4SLinus Torvalds 19921da177e4SLinus Torvalds return err; 19931da177e4SLinus Torvalds } 19941da177e4SLinus Torvalds 19951da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 19961da177e4SLinus Torvalds 1997611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 1998611b30f7SMarcel Holtmann { 1999611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2000611b30f7SMarcel Holtmann 2001611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2002611b30f7SMarcel Holtmann 2003d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 20040736cfa8SMarcel Holtmann return -EBUSY; 20050736cfa8SMarcel Holtmann 20065e130367SJohan Hedberg if (blocked) { 2007a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2008d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2009d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2010611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 20115e130367SJohan Hedberg } else { 2012a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 20135e130367SJohan Hedberg } 2014611b30f7SMarcel Holtmann 2015611b30f7SMarcel Holtmann return 0; 2016611b30f7SMarcel Holtmann } 2017611b30f7SMarcel Holtmann 2018611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2019611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2020611b30f7SMarcel Holtmann }; 2021611b30f7SMarcel Holtmann 2022ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2023ab81cbf9SJohan Hedberg { 2024ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 202596570ffcSJohan Hedberg int err; 2026ab81cbf9SJohan Hedberg 2027ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2028ab81cbf9SJohan Hedberg 20292ff13894SJohan Hedberg if (test_bit(HCI_UP, &hdev->flags) && 20302ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 20312ff13894SJohan Hedberg hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) { 2032d82142a8SWei-Ning Huang cancel_delayed_work(&hdev->power_off); 20332ff13894SJohan Hedberg hci_req_sync_lock(hdev); 20342ff13894SJohan Hedberg err = __hci_req_hci_power_on(hdev); 20352ff13894SJohan Hedberg hci_req_sync_unlock(hdev); 20362ff13894SJohan Hedberg mgmt_power_on(hdev, err); 20372ff13894SJohan Hedberg return; 20382ff13894SJohan Hedberg } 20392ff13894SJohan Hedberg 2040cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 204196570ffcSJohan Hedberg if (err < 0) { 20423ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 204396570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 20443ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2045ab81cbf9SJohan Hedberg return; 204696570ffcSJohan Hedberg } 2047ab81cbf9SJohan Hedberg 2048a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2049a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2050a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2051a5c8f270SMarcel Holtmann */ 2052d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2053d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2054ca8bee5dSMarcel Holtmann (hdev->dev_type == HCI_PRIMARY && 2055a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2056a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2057a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2058bf543036SJohan Hedberg hci_dev_do_close(hdev); 2059d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 206019202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 206119202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2062bf543036SJohan Hedberg } 2063ab81cbf9SJohan Hedberg 2064a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 20654a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 20664a964404SMarcel Holtmann * so that userspace can easily identify them. 20674a964404SMarcel Holtmann */ 2068d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 20694a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 20700602a8adSMarcel Holtmann 20710602a8adSMarcel Holtmann /* For fully configured devices, this will send 20720602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 20730602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 20740602a8adSMarcel Holtmann * 20750602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 20760602a8adSMarcel Holtmann * and no event will be send. 20770602a8adSMarcel Holtmann */ 2078744cf19eSJohan Hedberg mgmt_index_added(hdev); 2079a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 20805ea234d3SMarcel Holtmann /* When the controller is now configured, then it 20815ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 20825ea234d3SMarcel Holtmann */ 2083d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 20845ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 20855ea234d3SMarcel Holtmann 2086d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2087d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2088d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2089d603b76bSMarcel Holtmann */ 2090d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2091ab81cbf9SJohan Hedberg } 2092ab81cbf9SJohan Hedberg } 2093ab81cbf9SJohan Hedberg 2094ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2095ab81cbf9SJohan Hedberg { 20963243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 20973243553fSJohan Hedberg power_off.work); 2098ab81cbf9SJohan Hedberg 2099ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2100ab81cbf9SJohan Hedberg 21018ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2102ab81cbf9SJohan Hedberg } 2103ab81cbf9SJohan Hedberg 2104c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2105c7741d16SMarcel Holtmann { 2106c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2107c7741d16SMarcel Holtmann 2108c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2109c7741d16SMarcel Holtmann 2110c7741d16SMarcel Holtmann if (hdev->hw_error) 2111c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2112c7741d16SMarcel Holtmann else 2113c7741d16SMarcel Holtmann BT_ERR("%s hardware error 0x%2.2x", hdev->name, 2114c7741d16SMarcel Holtmann hdev->hw_error_code); 2115c7741d16SMarcel Holtmann 2116c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2117c7741d16SMarcel Holtmann return; 2118c7741d16SMarcel Holtmann 2119c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2120c7741d16SMarcel Holtmann } 2121c7741d16SMarcel Holtmann 212235f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 21232aeb9a1aSJohan Hedberg { 21244821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 21252aeb9a1aSJohan Hedberg 21264821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 21274821002cSJohan Hedberg list_del(&uuid->list); 21282aeb9a1aSJohan Hedberg kfree(uuid); 21292aeb9a1aSJohan Hedberg } 21302aeb9a1aSJohan Hedberg } 21312aeb9a1aSJohan Hedberg 213235f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 213355ed8ca1SJohan Hedberg { 213455ed8ca1SJohan Hedberg struct link_key *key; 213555ed8ca1SJohan Hedberg 21360378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 21370378b597SJohan Hedberg list_del_rcu(&key->list); 21380378b597SJohan Hedberg kfree_rcu(key, rcu); 213955ed8ca1SJohan Hedberg } 214055ed8ca1SJohan Hedberg } 214155ed8ca1SJohan Hedberg 214235f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2143b899efafSVinicius Costa Gomes { 2144970d0f1bSJohan Hedberg struct smp_ltk *k; 2145b899efafSVinicius Costa Gomes 2146970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2147970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2148970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2149b899efafSVinicius Costa Gomes } 2150b899efafSVinicius Costa Gomes } 2151b899efafSVinicius Costa Gomes 2152970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2153970c4e46SJohan Hedberg { 2154adae20cbSJohan Hedberg struct smp_irk *k; 2155970c4e46SJohan Hedberg 2156adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2157adae20cbSJohan Hedberg list_del_rcu(&k->list); 2158adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2159970c4e46SJohan Hedberg } 2160970c4e46SJohan Hedberg } 2161970c4e46SJohan Hedberg 216255ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 216355ed8ca1SJohan Hedberg { 216455ed8ca1SJohan Hedberg struct link_key *k; 216555ed8ca1SJohan Hedberg 21660378b597SJohan Hedberg rcu_read_lock(); 21670378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 21680378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 21690378b597SJohan Hedberg rcu_read_unlock(); 217055ed8ca1SJohan Hedberg return k; 21710378b597SJohan Hedberg } 21720378b597SJohan Hedberg } 21730378b597SJohan Hedberg rcu_read_unlock(); 217455ed8ca1SJohan Hedberg 217555ed8ca1SJohan Hedberg return NULL; 217655ed8ca1SJohan Hedberg } 217755ed8ca1SJohan Hedberg 2178745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2179d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2180d25e28abSJohan Hedberg { 2181d25e28abSJohan Hedberg /* Legacy key */ 2182d25e28abSJohan Hedberg if (key_type < 0x03) 2183745c0ce3SVishal Agarwal return true; 2184d25e28abSJohan Hedberg 2185d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2186d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2187745c0ce3SVishal Agarwal return false; 2188d25e28abSJohan Hedberg 2189d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2190d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2191745c0ce3SVishal Agarwal return false; 2192d25e28abSJohan Hedberg 2193d25e28abSJohan Hedberg /* Security mode 3 case */ 2194d25e28abSJohan Hedberg if (!conn) 2195745c0ce3SVishal Agarwal return true; 2196d25e28abSJohan Hedberg 2197e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2198e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2199e3befab9SJohan Hedberg return true; 2200e3befab9SJohan Hedberg 2201d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2202d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2203745c0ce3SVishal Agarwal return true; 2204d25e28abSJohan Hedberg 2205d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2206d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2207745c0ce3SVishal Agarwal return true; 2208d25e28abSJohan Hedberg 2209d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2210d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2211745c0ce3SVishal Agarwal return true; 2212d25e28abSJohan Hedberg 2213d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2214d25e28abSJohan Hedberg * persistently */ 2215745c0ce3SVishal Agarwal return false; 2216d25e28abSJohan Hedberg } 2217d25e28abSJohan Hedberg 2218e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 221998a0b845SJohan Hedberg { 2220e804d25dSJohan Hedberg if (type == SMP_LTK) 2221e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 222298a0b845SJohan Hedberg 2223e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 222498a0b845SJohan Hedberg } 222598a0b845SJohan Hedberg 2226f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2227e804d25dSJohan Hedberg u8 addr_type, u8 role) 222875d262c2SVinicius Costa Gomes { 2229c9839a11SVinicius Costa Gomes struct smp_ltk *k; 223075d262c2SVinicius Costa Gomes 2231970d0f1bSJohan Hedberg rcu_read_lock(); 2232970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 22335378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 22345378bc56SJohan Hedberg continue; 22355378bc56SJohan Hedberg 2236923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2237970d0f1bSJohan Hedberg rcu_read_unlock(); 223875d262c2SVinicius Costa Gomes return k; 2239970d0f1bSJohan Hedberg } 2240970d0f1bSJohan Hedberg } 2241970d0f1bSJohan Hedberg rcu_read_unlock(); 224275d262c2SVinicius Costa Gomes 224375d262c2SVinicius Costa Gomes return NULL; 224475d262c2SVinicius Costa Gomes } 224575d262c2SVinicius Costa Gomes 2246970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2247970c4e46SJohan Hedberg { 2248970c4e46SJohan Hedberg struct smp_irk *irk; 2249970c4e46SJohan Hedberg 2250adae20cbSJohan Hedberg rcu_read_lock(); 2251adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2252adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2253adae20cbSJohan Hedberg rcu_read_unlock(); 2254970c4e46SJohan Hedberg return irk; 2255970c4e46SJohan Hedberg } 2256adae20cbSJohan Hedberg } 2257970c4e46SJohan Hedberg 2258adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2259defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2260970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2261adae20cbSJohan Hedberg rcu_read_unlock(); 2262970c4e46SJohan Hedberg return irk; 2263970c4e46SJohan Hedberg } 2264970c4e46SJohan Hedberg } 2265adae20cbSJohan Hedberg rcu_read_unlock(); 2266970c4e46SJohan Hedberg 2267970c4e46SJohan Hedberg return NULL; 2268970c4e46SJohan Hedberg } 2269970c4e46SJohan Hedberg 2270970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2271970c4e46SJohan Hedberg u8 addr_type) 2272970c4e46SJohan Hedberg { 2273970c4e46SJohan Hedberg struct smp_irk *irk; 2274970c4e46SJohan Hedberg 22756cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 22766cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 22776cfc9988SJohan Hedberg return NULL; 22786cfc9988SJohan Hedberg 2279adae20cbSJohan Hedberg rcu_read_lock(); 2280adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2281970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2282adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2283adae20cbSJohan Hedberg rcu_read_unlock(); 2284970c4e46SJohan Hedberg return irk; 2285970c4e46SJohan Hedberg } 2286adae20cbSJohan Hedberg } 2287adae20cbSJohan Hedberg rcu_read_unlock(); 2288970c4e46SJohan Hedberg 2289970c4e46SJohan Hedberg return NULL; 2290970c4e46SJohan Hedberg } 2291970c4e46SJohan Hedberg 2292567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 22937652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 22947652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 229555ed8ca1SJohan Hedberg { 229655ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2297745c0ce3SVishal Agarwal u8 old_key_type; 229855ed8ca1SJohan Hedberg 229955ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 230055ed8ca1SJohan Hedberg if (old_key) { 230155ed8ca1SJohan Hedberg old_key_type = old_key->type; 230255ed8ca1SJohan Hedberg key = old_key; 230355ed8ca1SJohan Hedberg } else { 230412adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 23050a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 230655ed8ca1SJohan Hedberg if (!key) 2307567fa2aaSJohan Hedberg return NULL; 23080378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 230955ed8ca1SJohan Hedberg } 231055ed8ca1SJohan Hedberg 23116ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 231255ed8ca1SJohan Hedberg 2313d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2314d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2315d25e28abSJohan Hedberg * previous key */ 2316d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2317a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2318d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2319655fe6ecSJohan Hedberg if (conn) 2320655fe6ecSJohan Hedberg conn->key_type = type; 2321655fe6ecSJohan Hedberg } 2322d25e28abSJohan Hedberg 232355ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 23249b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 232555ed8ca1SJohan Hedberg key->pin_len = pin_len; 232655ed8ca1SJohan Hedberg 2327b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 232855ed8ca1SJohan Hedberg key->type = old_key_type; 23294748fed2SJohan Hedberg else 23304748fed2SJohan Hedberg key->type = type; 23314748fed2SJohan Hedberg 23327652ff6aSJohan Hedberg if (persistent) 23337652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 23347652ff6aSJohan Hedberg old_key_type); 23354df378a1SJohan Hedberg 2336567fa2aaSJohan Hedberg return key; 233755ed8ca1SJohan Hedberg } 233855ed8ca1SJohan Hedberg 2339ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 234035d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2341fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 234275d262c2SVinicius Costa Gomes { 2343c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2344e804d25dSJohan Hedberg u8 role = ltk_role(type); 234575d262c2SVinicius Costa Gomes 2346f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2347c9839a11SVinicius Costa Gomes if (old_key) 234875d262c2SVinicius Costa Gomes key = old_key; 2349c9839a11SVinicius Costa Gomes else { 23500a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 235175d262c2SVinicius Costa Gomes if (!key) 2352ca9142b8SJohan Hedberg return NULL; 2353970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 235475d262c2SVinicius Costa Gomes } 235575d262c2SVinicius Costa Gomes 235675d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2357c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2358c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2359c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2360c9839a11SVinicius Costa Gomes key->ediv = ediv; 2361fe39c7b2SMarcel Holtmann key->rand = rand; 2362c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2363c9839a11SVinicius Costa Gomes key->type = type; 236475d262c2SVinicius Costa Gomes 2365ca9142b8SJohan Hedberg return key; 236675d262c2SVinicius Costa Gomes } 236775d262c2SVinicius Costa Gomes 2368ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2369ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2370970c4e46SJohan Hedberg { 2371970c4e46SJohan Hedberg struct smp_irk *irk; 2372970c4e46SJohan Hedberg 2373970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2374970c4e46SJohan Hedberg if (!irk) { 2375970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2376970c4e46SJohan Hedberg if (!irk) 2377ca9142b8SJohan Hedberg return NULL; 2378970c4e46SJohan Hedberg 2379970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2380970c4e46SJohan Hedberg irk->addr_type = addr_type; 2381970c4e46SJohan Hedberg 2382adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2383970c4e46SJohan Hedberg } 2384970c4e46SJohan Hedberg 2385970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2386970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2387970c4e46SJohan Hedberg 2388ca9142b8SJohan Hedberg return irk; 2389970c4e46SJohan Hedberg } 2390970c4e46SJohan Hedberg 239155ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 239255ed8ca1SJohan Hedberg { 239355ed8ca1SJohan Hedberg struct link_key *key; 239455ed8ca1SJohan Hedberg 239555ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 239655ed8ca1SJohan Hedberg if (!key) 239755ed8ca1SJohan Hedberg return -ENOENT; 239855ed8ca1SJohan Hedberg 23996ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 240055ed8ca1SJohan Hedberg 24010378b597SJohan Hedberg list_del_rcu(&key->list); 24020378b597SJohan Hedberg kfree_rcu(key, rcu); 240355ed8ca1SJohan Hedberg 240455ed8ca1SJohan Hedberg return 0; 240555ed8ca1SJohan Hedberg } 240655ed8ca1SJohan Hedberg 2407e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2408b899efafSVinicius Costa Gomes { 2409970d0f1bSJohan Hedberg struct smp_ltk *k; 2410c51ffa0bSJohan Hedberg int removed = 0; 2411b899efafSVinicius Costa Gomes 2412970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2413e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2414b899efafSVinicius Costa Gomes continue; 2415b899efafSVinicius Costa Gomes 24166ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2417b899efafSVinicius Costa Gomes 2418970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2419970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2420c51ffa0bSJohan Hedberg removed++; 2421b899efafSVinicius Costa Gomes } 2422b899efafSVinicius Costa Gomes 2423c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2424b899efafSVinicius Costa Gomes } 2425b899efafSVinicius Costa Gomes 2426a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2427a7ec7338SJohan Hedberg { 2428adae20cbSJohan Hedberg struct smp_irk *k; 2429a7ec7338SJohan Hedberg 2430adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2431a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2432a7ec7338SJohan Hedberg continue; 2433a7ec7338SJohan Hedberg 2434a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2435a7ec7338SJohan Hedberg 2436adae20cbSJohan Hedberg list_del_rcu(&k->list); 2437adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2438a7ec7338SJohan Hedberg } 2439a7ec7338SJohan Hedberg } 2440a7ec7338SJohan Hedberg 244155e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 244255e76b38SJohan Hedberg { 244355e76b38SJohan Hedberg struct smp_ltk *k; 24444ba9faf3SJohan Hedberg struct smp_irk *irk; 244555e76b38SJohan Hedberg u8 addr_type; 244655e76b38SJohan Hedberg 244755e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 244855e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 244955e76b38SJohan Hedberg return true; 245055e76b38SJohan Hedberg return false; 245155e76b38SJohan Hedberg } 245255e76b38SJohan Hedberg 245355e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 245455e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 245555e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 245655e76b38SJohan Hedberg else 245755e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 245855e76b38SJohan Hedberg 24594ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 24604ba9faf3SJohan Hedberg if (irk) { 24614ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 24624ba9faf3SJohan Hedberg addr_type = irk->addr_type; 24634ba9faf3SJohan Hedberg } 24644ba9faf3SJohan Hedberg 246555e76b38SJohan Hedberg rcu_read_lock(); 246655e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 246787c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 246887c8b28dSJohan Hedberg rcu_read_unlock(); 246955e76b38SJohan Hedberg return true; 247055e76b38SJohan Hedberg } 247187c8b28dSJohan Hedberg } 247255e76b38SJohan Hedberg rcu_read_unlock(); 247355e76b38SJohan Hedberg 247455e76b38SJohan Hedberg return false; 247555e76b38SJohan Hedberg } 247655e76b38SJohan Hedberg 24776bd32326SVille Tervo /* HCI command timer function */ 247865cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 24796bd32326SVille Tervo { 248065cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 248165cc2b49SMarcel Holtmann cmd_timer.work); 24826bd32326SVille Tervo 2483bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2484bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2485bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2486bda4f23aSAndrei Emeltchenko 2487bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2488bda4f23aSAndrei Emeltchenko } else { 24896bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2490bda4f23aSAndrei Emeltchenko } 2491bda4f23aSAndrei Emeltchenko 24926bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2493c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 24946bd32326SVille Tervo } 24956bd32326SVille Tervo 24962763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 24976928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 24982763eda6SSzymon Janc { 24992763eda6SSzymon Janc struct oob_data *data; 25002763eda6SSzymon Janc 25016928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 25026928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 25036928a924SJohan Hedberg continue; 25046928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 25056928a924SJohan Hedberg continue; 25062763eda6SSzymon Janc return data; 25076928a924SJohan Hedberg } 25082763eda6SSzymon Janc 25092763eda6SSzymon Janc return NULL; 25102763eda6SSzymon Janc } 25112763eda6SSzymon Janc 25126928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25136928a924SJohan Hedberg u8 bdaddr_type) 25142763eda6SSzymon Janc { 25152763eda6SSzymon Janc struct oob_data *data; 25162763eda6SSzymon Janc 25176928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25182763eda6SSzymon Janc if (!data) 25192763eda6SSzymon Janc return -ENOENT; 25202763eda6SSzymon Janc 25216928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 25222763eda6SSzymon Janc 25232763eda6SSzymon Janc list_del(&data->list); 25242763eda6SSzymon Janc kfree(data); 25252763eda6SSzymon Janc 25262763eda6SSzymon Janc return 0; 25272763eda6SSzymon Janc } 25282763eda6SSzymon Janc 252935f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 25302763eda6SSzymon Janc { 25312763eda6SSzymon Janc struct oob_data *data, *n; 25322763eda6SSzymon Janc 25332763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 25342763eda6SSzymon Janc list_del(&data->list); 25352763eda6SSzymon Janc kfree(data); 25362763eda6SSzymon Janc } 25372763eda6SSzymon Janc } 25382763eda6SSzymon Janc 25390798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25406928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 254138da1703SJohan Hedberg u8 *hash256, u8 *rand256) 25420798872eSMarcel Holtmann { 25430798872eSMarcel Holtmann struct oob_data *data; 25440798872eSMarcel Holtmann 25456928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25460798872eSMarcel Holtmann if (!data) { 25470a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 25480798872eSMarcel Holtmann if (!data) 25490798872eSMarcel Holtmann return -ENOMEM; 25500798872eSMarcel Holtmann 25510798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 25526928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 25530798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 25540798872eSMarcel Holtmann } 25550798872eSMarcel Holtmann 255681328d5cSJohan Hedberg if (hash192 && rand192) { 25570798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 255838da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2559f7697b16SMarcel Holtmann if (hash256 && rand256) 2560f7697b16SMarcel Holtmann data->present = 0x03; 256181328d5cSJohan Hedberg } else { 256281328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 256381328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2564f7697b16SMarcel Holtmann if (hash256 && rand256) 2565f7697b16SMarcel Holtmann data->present = 0x02; 2566f7697b16SMarcel Holtmann else 2567f7697b16SMarcel Holtmann data->present = 0x00; 256881328d5cSJohan Hedberg } 25690798872eSMarcel Holtmann 257081328d5cSJohan Hedberg if (hash256 && rand256) { 25710798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 257238da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 257381328d5cSJohan Hedberg } else { 257481328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 257581328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2576f7697b16SMarcel Holtmann if (hash192 && rand192) 2577f7697b16SMarcel Holtmann data->present = 0x01; 257881328d5cSJohan Hedberg } 25790798872eSMarcel Holtmann 25806ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 25812763eda6SSzymon Janc 25822763eda6SSzymon Janc return 0; 25832763eda6SSzymon Janc } 25842763eda6SSzymon Janc 2585d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2586d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2587d2609b34SFlorian Grandel { 2588d2609b34SFlorian Grandel struct adv_info *adv_instance; 2589d2609b34SFlorian Grandel 2590d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2591d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2592d2609b34SFlorian Grandel return adv_instance; 2593d2609b34SFlorian Grandel } 2594d2609b34SFlorian Grandel 2595d2609b34SFlorian Grandel return NULL; 2596d2609b34SFlorian Grandel } 2597d2609b34SFlorian Grandel 2598d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 259974b93e9fSPrasanna Karthik struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) 260074b93e9fSPrasanna Karthik { 2601d2609b34SFlorian Grandel struct adv_info *cur_instance; 2602d2609b34SFlorian Grandel 2603d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2604d2609b34SFlorian Grandel if (!cur_instance) 2605d2609b34SFlorian Grandel return NULL; 2606d2609b34SFlorian Grandel 2607d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2608d2609b34SFlorian Grandel struct adv_info, list)) 2609d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2610d2609b34SFlorian Grandel struct adv_info, list); 2611d2609b34SFlorian Grandel else 2612d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2613d2609b34SFlorian Grandel } 2614d2609b34SFlorian Grandel 2615d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2616d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2617d2609b34SFlorian Grandel { 2618d2609b34SFlorian Grandel struct adv_info *adv_instance; 2619d2609b34SFlorian Grandel 2620d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2621d2609b34SFlorian Grandel if (!adv_instance) 2622d2609b34SFlorian Grandel return -ENOENT; 2623d2609b34SFlorian Grandel 2624d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2625d2609b34SFlorian Grandel 2626cab054abSJohan Hedberg if (hdev->cur_adv_instance == instance) { 2627cab054abSJohan Hedberg if (hdev->adv_instance_timeout) { 26285d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 26295d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 26305d900e46SFlorian Grandel } 2631cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2632cab054abSJohan Hedberg } 26335d900e46SFlorian Grandel 2634d2609b34SFlorian Grandel list_del(&adv_instance->list); 2635d2609b34SFlorian Grandel kfree(adv_instance); 2636d2609b34SFlorian Grandel 2637d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2638d2609b34SFlorian Grandel 2639d2609b34SFlorian Grandel return 0; 2640d2609b34SFlorian Grandel } 2641d2609b34SFlorian Grandel 2642d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2643d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2644d2609b34SFlorian Grandel { 2645d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2646d2609b34SFlorian Grandel 26475d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 26485d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 26495d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 26505d900e46SFlorian Grandel } 26515d900e46SFlorian Grandel 2652d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2653d2609b34SFlorian Grandel list_del(&adv_instance->list); 2654d2609b34SFlorian Grandel kfree(adv_instance); 2655d2609b34SFlorian Grandel } 2656d2609b34SFlorian Grandel 2657d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2658cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2659d2609b34SFlorian Grandel } 2660d2609b34SFlorian Grandel 2661d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2662d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2663d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2664d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2665d2609b34SFlorian Grandel u16 timeout, u16 duration) 2666d2609b34SFlorian Grandel { 2667d2609b34SFlorian Grandel struct adv_info *adv_instance; 2668d2609b34SFlorian Grandel 2669d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2670d2609b34SFlorian Grandel if (adv_instance) { 2671d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2672d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2673d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2674d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2675d2609b34SFlorian Grandel } else { 2676d2609b34SFlorian Grandel if (hdev->adv_instance_cnt >= HCI_MAX_ADV_INSTANCES || 2677d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2678d2609b34SFlorian Grandel return -EOVERFLOW; 2679d2609b34SFlorian Grandel 268039ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2681d2609b34SFlorian Grandel if (!adv_instance) 2682d2609b34SFlorian Grandel return -ENOMEM; 2683d2609b34SFlorian Grandel 2684fffd38bcSFlorian Grandel adv_instance->pending = true; 2685d2609b34SFlorian Grandel adv_instance->instance = instance; 2686d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2687d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2688d2609b34SFlorian Grandel } 2689d2609b34SFlorian Grandel 2690d2609b34SFlorian Grandel adv_instance->flags = flags; 2691d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2692d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2693d2609b34SFlorian Grandel 2694d2609b34SFlorian Grandel if (adv_data_len) 2695d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2696d2609b34SFlorian Grandel 2697d2609b34SFlorian Grandel if (scan_rsp_len) 2698d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2699d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2700d2609b34SFlorian Grandel 2701d2609b34SFlorian Grandel adv_instance->timeout = timeout; 27025d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2703d2609b34SFlorian Grandel 2704d2609b34SFlorian Grandel if (duration == 0) 2705d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2706d2609b34SFlorian Grandel else 2707d2609b34SFlorian Grandel adv_instance->duration = duration; 2708d2609b34SFlorian Grandel 2709d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2710d2609b34SFlorian Grandel 2711d2609b34SFlorian Grandel return 0; 2712d2609b34SFlorian Grandel } 2713d2609b34SFlorian Grandel 2714dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2715b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2716b2a66aadSAntti Julku { 2717b2a66aadSAntti Julku struct bdaddr_list *b; 2718b2a66aadSAntti Julku 2719dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2720b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2721b2a66aadSAntti Julku return b; 2722b9ee0a78SMarcel Holtmann } 2723b2a66aadSAntti Julku 2724b2a66aadSAntti Julku return NULL; 2725b2a66aadSAntti Julku } 2726b2a66aadSAntti Julku 2727dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2728b2a66aadSAntti Julku { 27297eb7404fSGeliang Tang struct bdaddr_list *b, *n; 2730b2a66aadSAntti Julku 27317eb7404fSGeliang Tang list_for_each_entry_safe(b, n, bdaddr_list, list) { 27327eb7404fSGeliang Tang list_del(&b->list); 2733b2a66aadSAntti Julku kfree(b); 2734b2a66aadSAntti Julku } 2735b2a66aadSAntti Julku } 2736b2a66aadSAntti Julku 2737dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2738b2a66aadSAntti Julku { 2739b2a66aadSAntti Julku struct bdaddr_list *entry; 2740b2a66aadSAntti Julku 2741b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2742b2a66aadSAntti Julku return -EBADF; 2743b2a66aadSAntti Julku 2744dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 27455e762444SAntti Julku return -EEXIST; 2746b2a66aadSAntti Julku 274727f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 27485e762444SAntti Julku if (!entry) 27495e762444SAntti Julku return -ENOMEM; 2750b2a66aadSAntti Julku 2751b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2752b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2753b2a66aadSAntti Julku 2754dcc36c16SJohan Hedberg list_add(&entry->list, list); 2755b2a66aadSAntti Julku 27562a8357f2SJohan Hedberg return 0; 2757b2a66aadSAntti Julku } 2758b2a66aadSAntti Julku 2759dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2760b2a66aadSAntti Julku { 2761b2a66aadSAntti Julku struct bdaddr_list *entry; 2762b2a66aadSAntti Julku 276335f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2764dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 276535f7498aSJohan Hedberg return 0; 276635f7498aSJohan Hedberg } 2767b2a66aadSAntti Julku 2768dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2769d2ab0ac1SMarcel Holtmann if (!entry) 2770d2ab0ac1SMarcel Holtmann return -ENOENT; 2771d2ab0ac1SMarcel Holtmann 2772d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2773d2ab0ac1SMarcel Holtmann kfree(entry); 2774d2ab0ac1SMarcel Holtmann 2775d2ab0ac1SMarcel Holtmann return 0; 2776d2ab0ac1SMarcel Holtmann } 2777d2ab0ac1SMarcel Holtmann 277815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 277915819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 278015819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 278115819a70SAndre Guedes { 278215819a70SAndre Guedes struct hci_conn_params *params; 278315819a70SAndre Guedes 278415819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 278515819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 278615819a70SAndre Guedes params->addr_type == addr_type) { 278715819a70SAndre Guedes return params; 278815819a70SAndre Guedes } 278915819a70SAndre Guedes } 279015819a70SAndre Guedes 279115819a70SAndre Guedes return NULL; 279215819a70SAndre Guedes } 279315819a70SAndre Guedes 279415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2795501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 27964b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 279715819a70SAndre Guedes { 2798912b42efSJohan Hedberg struct hci_conn_params *param; 279915819a70SAndre Guedes 2800501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2801912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2802912b42efSJohan Hedberg param->addr_type == addr_type) 2803912b42efSJohan Hedberg return param; 28044b10966fSMarcel Holtmann } 28054b10966fSMarcel Holtmann 28064b10966fSMarcel Holtmann return NULL; 280715819a70SAndre Guedes } 280815819a70SAndre Guedes 280915819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 281051d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 281151d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 281215819a70SAndre Guedes { 281315819a70SAndre Guedes struct hci_conn_params *params; 281415819a70SAndre Guedes 281515819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2816cef952ceSAndre Guedes if (params) 281751d167c0SMarcel Holtmann return params; 281815819a70SAndre Guedes 281915819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 282015819a70SAndre Guedes if (!params) { 282115819a70SAndre Guedes BT_ERR("Out of memory"); 282251d167c0SMarcel Holtmann return NULL; 282315819a70SAndre Guedes } 282415819a70SAndre Guedes 282515819a70SAndre Guedes bacpy(¶ms->addr, addr); 282615819a70SAndre Guedes params->addr_type = addr_type; 2827cef952ceSAndre Guedes 2828cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 282993450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2830cef952ceSAndre Guedes 2831bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2832bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2833bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2834bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2835bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2836bf5b3c8bSMarcel Holtmann 2837bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2838bf5b3c8bSMarcel Holtmann 283951d167c0SMarcel Holtmann return params; 2840bf5b3c8bSMarcel Holtmann } 2841bf5b3c8bSMarcel Holtmann 2842f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2843f6c63249SJohan Hedberg { 2844f6c63249SJohan Hedberg if (params->conn) { 2845f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2846f6c63249SJohan Hedberg hci_conn_put(params->conn); 2847f6c63249SJohan Hedberg } 2848f6c63249SJohan Hedberg 2849f6c63249SJohan Hedberg list_del(¶ms->action); 2850f6c63249SJohan Hedberg list_del(¶ms->list); 2851f6c63249SJohan Hedberg kfree(params); 2852f6c63249SJohan Hedberg } 2853f6c63249SJohan Hedberg 285415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 285515819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 285615819a70SAndre Guedes { 285715819a70SAndre Guedes struct hci_conn_params *params; 285815819a70SAndre Guedes 285915819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 286015819a70SAndre Guedes if (!params) 286115819a70SAndre Guedes return; 286215819a70SAndre Guedes 2863f6c63249SJohan Hedberg hci_conn_params_free(params); 286415819a70SAndre Guedes 286595305baaSJohan Hedberg hci_update_background_scan(hdev); 286695305baaSJohan Hedberg 286715819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 286815819a70SAndre Guedes } 286915819a70SAndre Guedes 287015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 287155af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 287215819a70SAndre Guedes { 287315819a70SAndre Guedes struct hci_conn_params *params, *tmp; 287415819a70SAndre Guedes 287515819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 287655af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 287755af49a8SJohan Hedberg continue; 2878f75113a2SJakub Pawlowski 2879f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 2880f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 2881f75113a2SJakub Pawlowski */ 2882f75113a2SJakub Pawlowski if (params->explicit_connect) { 2883f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 2884f75113a2SJakub Pawlowski continue; 2885f75113a2SJakub Pawlowski } 2886f75113a2SJakub Pawlowski 288715819a70SAndre Guedes list_del(¶ms->list); 288815819a70SAndre Guedes kfree(params); 288915819a70SAndre Guedes } 289015819a70SAndre Guedes 289155af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 289255af49a8SJohan Hedberg } 289355af49a8SJohan Hedberg 289455af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 2895030e7f81SJohan Hedberg static void hci_conn_params_clear_all(struct hci_dev *hdev) 289615819a70SAndre Guedes { 289715819a70SAndre Guedes struct hci_conn_params *params, *tmp; 289815819a70SAndre Guedes 2899f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 2900f6c63249SJohan Hedberg hci_conn_params_free(params); 290115819a70SAndre Guedes 290215819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 290315819a70SAndre Guedes } 290415819a70SAndre Guedes 2905a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 2906a1f4c318SJohan Hedberg * 2907a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 2908a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 2909a1f4c318SJohan Hedberg * the static random address. 2910a1f4c318SJohan Hedberg * 2911a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 2912a1f4c318SJohan Hedberg * public address to use the static random address instead. 291350b5b952SMarcel Holtmann * 291450b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 291550b5b952SMarcel Holtmann * userspace has configured a static address, then that address 291650b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 2917a1f4c318SJohan Hedberg */ 2918a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 2919a1f4c318SJohan Hedberg u8 *bdaddr_type) 2920a1f4c318SJohan Hedberg { 2921b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 292250b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 2923d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 292450b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 2925a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 2926a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 2927a1f4c318SJohan Hedberg } else { 2928a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 2929a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 2930a1f4c318SJohan Hedberg } 2931a1f4c318SJohan Hedberg } 2932a1f4c318SJohan Hedberg 29339be0dab7SDavid Herrmann /* Alloc HCI device */ 29349be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 29359be0dab7SDavid Herrmann { 29369be0dab7SDavid Herrmann struct hci_dev *hdev; 29379be0dab7SDavid Herrmann 293827f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 29399be0dab7SDavid Herrmann if (!hdev) 29409be0dab7SDavid Herrmann return NULL; 29419be0dab7SDavid Herrmann 2942b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2943b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2944b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2945b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2946b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 294796c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 2948bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2949bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2950d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2951d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 29525d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 2953b1b813d4SDavid Herrmann 2954b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2955b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2956b1b813d4SDavid Herrmann 29573f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 2958628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 2959628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 2960bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2961bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 2962b48c3b59SJonas Holmberg hdev->le_conn_min_interval = 0x0018; 2963b48c3b59SJonas Holmberg hdev->le_conn_max_interval = 0x0028; 296404fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 296504fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 2966a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 2967a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 2968a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 2969a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 2970a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 2971a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 2972bef64738SMarcel Holtmann 2973d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 2974b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 297531ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 297631ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 2977d6bfd59cSJohan Hedberg 2978b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 2979b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 2980b1b813d4SDavid Herrmann 2981b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 2982b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 29836659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 2984b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 2985b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 2986b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 2987970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 2988b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 2989d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 299015819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 299177a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 299266f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 29936b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 2994d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 2995b1b813d4SDavid Herrmann 2996b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 2997b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 2998b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 2999b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3000c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3001b1b813d4SDavid Herrmann 3002b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3003b1b813d4SDavid Herrmann 3004b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3005b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3006b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3007b1b813d4SDavid Herrmann 3008b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3009b1b813d4SDavid Herrmann 301065cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3011b1b813d4SDavid Herrmann 30125fc16cc4SJohan Hedberg hci_request_setup(hdev); 30135fc16cc4SJohan Hedberg 3014b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3015b1b813d4SDavid Herrmann discovery_init(hdev); 30169be0dab7SDavid Herrmann 30179be0dab7SDavid Herrmann return hdev; 30189be0dab7SDavid Herrmann } 30199be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 30209be0dab7SDavid Herrmann 30219be0dab7SDavid Herrmann /* Free HCI device */ 30229be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 30239be0dab7SDavid Herrmann { 30249be0dab7SDavid Herrmann /* will free via device release */ 30259be0dab7SDavid Herrmann put_device(&hdev->dev); 30269be0dab7SDavid Herrmann } 30279be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 30289be0dab7SDavid Herrmann 30291da177e4SLinus Torvalds /* Register HCI device */ 30301da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 30311da177e4SLinus Torvalds { 3032b1b813d4SDavid Herrmann int id, error; 30331da177e4SLinus Torvalds 303474292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 30351da177e4SLinus Torvalds return -EINVAL; 30361da177e4SLinus Torvalds 303708add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 303808add513SMat Martineau * so the index can be used as the AMP controller ID. 303908add513SMat Martineau */ 30403df92b31SSasha Levin switch (hdev->dev_type) { 3041ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 30423df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 30431da177e4SLinus Torvalds break; 30443df92b31SSasha Levin case HCI_AMP: 30453df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 30463df92b31SSasha Levin break; 30473df92b31SSasha Levin default: 30483df92b31SSasha Levin return -EINVAL; 30491da177e4SLinus Torvalds } 30501da177e4SLinus Torvalds 30513df92b31SSasha Levin if (id < 0) 30523df92b31SSasha Levin return id; 30533df92b31SSasha Levin 30541da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 30551da177e4SLinus Torvalds hdev->id = id; 30562d8b3a11SAndrei Emeltchenko 30572d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 30582d8b3a11SAndrei Emeltchenko 3059d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3060d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 306133ca954dSDavid Herrmann if (!hdev->workqueue) { 306233ca954dSDavid Herrmann error = -ENOMEM; 306333ca954dSDavid Herrmann goto err; 306433ca954dSDavid Herrmann } 3065f48fd9c8SMarcel Holtmann 3066d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3067d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 30686ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 30696ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 30706ead1bbcSJohan Hedberg error = -ENOMEM; 30716ead1bbcSJohan Hedberg goto err; 30726ead1bbcSJohan Hedberg } 30736ead1bbcSJohan Hedberg 30740153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 30750153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 30760153e2ecSMarcel Holtmann 3077bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3078bdc3e0f1SMarcel Holtmann 3079bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 308033ca954dSDavid Herrmann if (error < 0) 308154506918SJohan Hedberg goto err_wqueue; 30821da177e4SLinus Torvalds 30836d5d2ee6SHeiner Kallweit hci_leds_init(hdev); 30846d5d2ee6SHeiner Kallweit 3085611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3086a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3087a8c5fb1aSGustavo Padovan hdev); 3088611b30f7SMarcel Holtmann if (hdev->rfkill) { 3089611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3090611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3091611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3092611b30f7SMarcel Holtmann } 3093611b30f7SMarcel Holtmann } 3094611b30f7SMarcel Holtmann 30955e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3096a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 30975e130367SJohan Hedberg 3098a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3099a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3100ce2be9acSAndrei Emeltchenko 3101ca8bee5dSMarcel Holtmann if (hdev->dev_type == HCI_PRIMARY) { 310256f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 310356f87901SJohan Hedberg * through reading supported features during init. 310456f87901SJohan Hedberg */ 3105a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 310656f87901SJohan Hedberg } 3107ce2be9acSAndrei Emeltchenko 3108fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3109fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3110fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3111fcee3377SGustavo Padovan 31124a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 31134a964404SMarcel Holtmann * and should not be included in normal operation. 3114fee746b0SMarcel Holtmann */ 3115fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3116a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3117fee746b0SMarcel Holtmann 311805fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3119dc946bd8SDavid Herrmann hci_dev_hold(hdev); 31201da177e4SLinus Torvalds 312119202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3122fbe96d6fSMarcel Holtmann 31231da177e4SLinus Torvalds return id; 3124f48fd9c8SMarcel Holtmann 312533ca954dSDavid Herrmann err_wqueue: 312633ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 31276ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 312833ca954dSDavid Herrmann err: 31293df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3130f48fd9c8SMarcel Holtmann 313133ca954dSDavid Herrmann return error; 31321da177e4SLinus Torvalds } 31331da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 31341da177e4SLinus Torvalds 31351da177e4SLinus Torvalds /* Unregister HCI device */ 313659735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 31371da177e4SLinus Torvalds { 31382d7cc19eSMarcel Holtmann int id; 3139ef222013SMarcel Holtmann 3140c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 31411da177e4SLinus Torvalds 3142a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 314394324962SJohan Hovold 31443df92b31SSasha Levin id = hdev->id; 31453df92b31SSasha Levin 3146f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 31471da177e4SLinus Torvalds list_del(&hdev->list); 3148f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 31491da177e4SLinus Torvalds 3150b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3151b9b5ef18SGustavo Padovan 3152bf389cabSJiri Slaby hci_dev_do_close(hdev); 3153bf389cabSJiri Slaby 3154ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3155d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3156d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 315709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3158744cf19eSJohan Hedberg mgmt_index_removed(hdev); 315909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 316056e5cb86SJohan Hedberg } 3161ab81cbf9SJohan Hedberg 31622e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 31632e58ef3eSJohan Hedberg * pending list */ 31642e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 31652e58ef3eSJohan Hedberg 316605fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 31671da177e4SLinus Torvalds 3168611b30f7SMarcel Holtmann if (hdev->rfkill) { 3169611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3170611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3171611b30f7SMarcel Holtmann } 3172611b30f7SMarcel Holtmann 3173bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3174147e2d59SDave Young 31750153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 31765177a838SMarcel Holtmann kfree_const(hdev->hw_info); 31775177a838SMarcel Holtmann kfree_const(hdev->fw_info); 31780153e2ecSMarcel Holtmann 3179f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 31806ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3181f48fd9c8SMarcel Holtmann 318209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3183dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 31846659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 31852aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 318655ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3187b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3188970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 31892763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3190d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3191dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3192373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 319322078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 319409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3195e2e0cacbSJohan Hedberg 3196dc946bd8SDavid Herrmann hci_dev_put(hdev); 31973df92b31SSasha Levin 31983df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 31991da177e4SLinus Torvalds } 32001da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 32011da177e4SLinus Torvalds 32021da177e4SLinus Torvalds /* Suspend HCI device */ 32031da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 32041da177e4SLinus Torvalds { 320505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 32061da177e4SLinus Torvalds return 0; 32071da177e4SLinus Torvalds } 32081da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 32091da177e4SLinus Torvalds 32101da177e4SLinus Torvalds /* Resume HCI device */ 32111da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 32121da177e4SLinus Torvalds { 321305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 32141da177e4SLinus Torvalds return 0; 32151da177e4SLinus Torvalds } 32161da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 32171da177e4SLinus Torvalds 321875e0569fSMarcel Holtmann /* Reset HCI device */ 321975e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 322075e0569fSMarcel Holtmann { 322175e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 322275e0569fSMarcel Holtmann struct sk_buff *skb; 322375e0569fSMarcel Holtmann 322475e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 322575e0569fSMarcel Holtmann if (!skb) 322675e0569fSMarcel Holtmann return -ENOMEM; 322775e0569fSMarcel Holtmann 3228d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 322975e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 323075e0569fSMarcel Holtmann 323175e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 323275e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 323375e0569fSMarcel Holtmann } 323475e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 323575e0569fSMarcel Holtmann 323676bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3237e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 323876bca880SMarcel Holtmann { 323976bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 324076bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 324176bca880SMarcel Holtmann kfree_skb(skb); 324276bca880SMarcel Holtmann return -ENXIO; 324376bca880SMarcel Holtmann } 324476bca880SMarcel Holtmann 3245d79f34e3SMarcel Holtmann if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT && 3246d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT && 3247d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_SCODATA_PKT) { 3248fe806dceSMarcel Holtmann kfree_skb(skb); 3249fe806dceSMarcel Holtmann return -EINVAL; 3250fe806dceSMarcel Holtmann } 3251fe806dceSMarcel Holtmann 3252d82603c6SJorrit Schippers /* Incoming skb */ 325376bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 325476bca880SMarcel Holtmann 325576bca880SMarcel Holtmann /* Time stamp */ 325676bca880SMarcel Holtmann __net_timestamp(skb); 325776bca880SMarcel Holtmann 325876bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3259b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3260c78ae283SMarcel Holtmann 326176bca880SMarcel Holtmann return 0; 326276bca880SMarcel Holtmann } 326376bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 326476bca880SMarcel Holtmann 3265e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3266e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3267e875ff84SMarcel Holtmann { 3268581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3269d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_DIAG_PKT; 3270581d6fd6SMarcel Holtmann 3271e875ff84SMarcel Holtmann /* Time stamp */ 3272e875ff84SMarcel Holtmann __net_timestamp(skb); 3273e875ff84SMarcel Holtmann 3274581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3275581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3276e875ff84SMarcel Holtmann 3277e875ff84SMarcel Holtmann return 0; 3278e875ff84SMarcel Holtmann } 3279e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3280e875ff84SMarcel Holtmann 32815177a838SMarcel Holtmann void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...) 32825177a838SMarcel Holtmann { 32835177a838SMarcel Holtmann va_list vargs; 32845177a838SMarcel Holtmann 32855177a838SMarcel Holtmann va_start(vargs, fmt); 32865177a838SMarcel Holtmann kfree_const(hdev->hw_info); 32875177a838SMarcel Holtmann hdev->hw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 32885177a838SMarcel Holtmann va_end(vargs); 32895177a838SMarcel Holtmann } 32905177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_hw_info); 32915177a838SMarcel Holtmann 32925177a838SMarcel Holtmann void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...) 32935177a838SMarcel Holtmann { 32945177a838SMarcel Holtmann va_list vargs; 32955177a838SMarcel Holtmann 32965177a838SMarcel Holtmann va_start(vargs, fmt); 32975177a838SMarcel Holtmann kfree_const(hdev->fw_info); 32985177a838SMarcel Holtmann hdev->fw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 32995177a838SMarcel Holtmann va_end(vargs); 33005177a838SMarcel Holtmann } 33015177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_fw_info); 33025177a838SMarcel Holtmann 33031da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 33041da177e4SLinus Torvalds 33051da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 33061da177e4SLinus Torvalds { 33071da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33081da177e4SLinus Torvalds 3309fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 331000629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3311fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 33121da177e4SLinus Torvalds 33131da177e4SLinus Torvalds return 0; 33141da177e4SLinus Torvalds } 33151da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 33161da177e4SLinus Torvalds 33171da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 33181da177e4SLinus Torvalds { 33191da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33201da177e4SLinus Torvalds 3321fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 33221da177e4SLinus Torvalds list_del(&cb->list); 3323fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 33241da177e4SLinus Torvalds 33251da177e4SLinus Torvalds return 0; 33261da177e4SLinus Torvalds } 33271da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 33281da177e4SLinus Torvalds 332951086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 33301da177e4SLinus Torvalds { 3331cdc52faaSMarcel Holtmann int err; 3332cdc52faaSMarcel Holtmann 3333d79f34e3SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb), 3334d79f34e3SMarcel Holtmann skb->len); 33351da177e4SLinus Torvalds 33361da177e4SLinus Torvalds /* Time stamp */ 3337a61bbcf2SPatrick McHardy __net_timestamp(skb); 33381da177e4SLinus Torvalds 3339cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3340cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3341cd82e61cSMarcel Holtmann 3342cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3343cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3344470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 33451da177e4SLinus Torvalds } 33461da177e4SLinus Torvalds 33471da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 33481da177e4SLinus Torvalds skb_orphan(skb); 33491da177e4SLinus Torvalds 335073d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 335173d0d3c8SMarcel Holtmann kfree_skb(skb); 335273d0d3c8SMarcel Holtmann return; 335373d0d3c8SMarcel Holtmann } 335473d0d3c8SMarcel Holtmann 3355cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3356cdc52faaSMarcel Holtmann if (err < 0) { 3357cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3358cdc52faaSMarcel Holtmann kfree_skb(skb); 3359cdc52faaSMarcel Holtmann } 33601da177e4SLinus Torvalds } 33611da177e4SLinus Torvalds 33621ca3a9d0SJohan Hedberg /* Send HCI command */ 336307dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 336407dc93ddSJohan Hedberg const void *param) 33651ca3a9d0SJohan Hedberg { 33661ca3a9d0SJohan Hedberg struct sk_buff *skb; 33671ca3a9d0SJohan Hedberg 33681ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 33691ca3a9d0SJohan Hedberg 33701ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 33711ca3a9d0SJohan Hedberg if (!skb) { 33721ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 33731ca3a9d0SJohan Hedberg return -ENOMEM; 33741ca3a9d0SJohan Hedberg } 33751ca3a9d0SJohan Hedberg 337649c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 337711714b3dSJohan Hedberg * single-command requests. 337811714b3dSJohan Hedberg */ 337944d27137SJohan Hedberg bt_cb(skb)->hci.req_flags |= HCI_REQ_START; 338011714b3dSJohan Hedberg 33811da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3382c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 33831da177e4SLinus Torvalds 33841da177e4SLinus Torvalds return 0; 33851da177e4SLinus Torvalds } 33861da177e4SLinus Torvalds 33871da177e4SLinus Torvalds /* Get data from the previously sent command */ 3388a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 33891da177e4SLinus Torvalds { 33901da177e4SLinus Torvalds struct hci_command_hdr *hdr; 33911da177e4SLinus Torvalds 33921da177e4SLinus Torvalds if (!hdev->sent_cmd) 33931da177e4SLinus Torvalds return NULL; 33941da177e4SLinus Torvalds 33951da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 33961da177e4SLinus Torvalds 3397a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 33981da177e4SLinus Torvalds return NULL; 33991da177e4SLinus Torvalds 3400f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 34011da177e4SLinus Torvalds 34021da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 34031da177e4SLinus Torvalds } 34041da177e4SLinus Torvalds 3405fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3406fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3407fbef168fSLoic Poulain const void *param, u32 timeout) 3408fbef168fSLoic Poulain { 3409fbef168fSLoic Poulain struct sk_buff *skb; 3410fbef168fSLoic Poulain 3411fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3412fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3413fbef168fSLoic Poulain 3414fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3415fbef168fSLoic Poulain 3416b504430cSJohan Hedberg hci_req_sync_lock(hdev); 3417fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3418b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 3419fbef168fSLoic Poulain 3420fbef168fSLoic Poulain return skb; 3421fbef168fSLoic Poulain } 3422fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3423fbef168fSLoic Poulain 34241da177e4SLinus Torvalds /* Send ACL data */ 34251da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 34261da177e4SLinus Torvalds { 34271da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 34281da177e4SLinus Torvalds int len = skb->len; 34291da177e4SLinus Torvalds 3430badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3431badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 34329c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3433aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3434aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 34351da177e4SLinus Torvalds } 34361da177e4SLinus Torvalds 3437ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 343873d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 34391da177e4SLinus Torvalds { 3440ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 34411da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 34421da177e4SLinus Torvalds struct sk_buff *list; 34431da177e4SLinus Torvalds 3444087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3445087bfd99SGustavo Padovan skb->data_len = 0; 3446087bfd99SGustavo Padovan 3447d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3448204a6e54SAndrei Emeltchenko 3449204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3450ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 3451087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3452204a6e54SAndrei Emeltchenko break; 3453204a6e54SAndrei Emeltchenko case HCI_AMP: 3454204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3455204a6e54SAndrei Emeltchenko break; 3456204a6e54SAndrei Emeltchenko default: 3457204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3458204a6e54SAndrei Emeltchenko return; 3459204a6e54SAndrei Emeltchenko } 3460087bfd99SGustavo Padovan 346170f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 346270f23020SAndrei Emeltchenko if (!list) { 34631da177e4SLinus Torvalds /* Non fragmented */ 34641da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 34651da177e4SLinus Torvalds 346673d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 34671da177e4SLinus Torvalds } else { 34681da177e4SLinus Torvalds /* Fragmented */ 34691da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 34701da177e4SLinus Torvalds 34711da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 34721da177e4SLinus Torvalds 34739cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 34749cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 34759cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 34769cfd5a23SJukka Rissanen * deadlocks. 34779cfd5a23SJukka Rissanen */ 34789cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 34791da177e4SLinus Torvalds 348073d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3481e702112fSAndrei Emeltchenko 3482e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3483e702112fSAndrei Emeltchenko flags |= ACL_CONT; 34841da177e4SLinus Torvalds do { 34851da177e4SLinus Torvalds skb = list; list = list->next; 34861da177e4SLinus Torvalds 3487d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3488e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 34891da177e4SLinus Torvalds 34901da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 34911da177e4SLinus Torvalds 349273d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 34931da177e4SLinus Torvalds } while (list); 34941da177e4SLinus Torvalds 34959cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 34961da177e4SLinus Torvalds } 349773d80debSLuiz Augusto von Dentz } 349873d80debSLuiz Augusto von Dentz 349973d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 350073d80debSLuiz Augusto von Dentz { 3501ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 350273d80debSLuiz Augusto von Dentz 3503f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 350473d80debSLuiz Augusto von Dentz 3505ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 35061da177e4SLinus Torvalds 35073eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35081da177e4SLinus Torvalds } 35091da177e4SLinus Torvalds 35101da177e4SLinus Torvalds /* Send SCO data */ 35110d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 35121da177e4SLinus Torvalds { 35131da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 35141da177e4SLinus Torvalds struct hci_sco_hdr hdr; 35151da177e4SLinus Torvalds 35161da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 35171da177e4SLinus Torvalds 3518aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 35191da177e4SLinus Torvalds hdr.dlen = skb->len; 35201da177e4SLinus Torvalds 3521badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3522badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 35239c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 35241da177e4SLinus Torvalds 3525d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 3526c78ae283SMarcel Holtmann 35271da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 35283eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35291da177e4SLinus Torvalds } 35301da177e4SLinus Torvalds 35311da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 35321da177e4SLinus Torvalds 35331da177e4SLinus Torvalds /* HCI Connection scheduler */ 35346039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3535a8c5fb1aSGustavo Padovan int *quote) 35361da177e4SLinus Torvalds { 35371da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 35388035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3539abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 35401da177e4SLinus Torvalds 35411da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 35421da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3543bf4c6325SGustavo F. Padovan 3544bf4c6325SGustavo F. Padovan rcu_read_lock(); 3545bf4c6325SGustavo F. Padovan 3546bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3547769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 35481da177e4SLinus Torvalds continue; 3549769be974SMarcel Holtmann 3550769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3551769be974SMarcel Holtmann continue; 3552769be974SMarcel Holtmann 35531da177e4SLinus Torvalds num++; 35541da177e4SLinus Torvalds 35551da177e4SLinus Torvalds if (c->sent < min) { 35561da177e4SLinus Torvalds min = c->sent; 35571da177e4SLinus Torvalds conn = c; 35581da177e4SLinus Torvalds } 355952087a79SLuiz Augusto von Dentz 356052087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 356152087a79SLuiz Augusto von Dentz break; 35621da177e4SLinus Torvalds } 35631da177e4SLinus Torvalds 3564bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3565bf4c6325SGustavo F. Padovan 35661da177e4SLinus Torvalds if (conn) { 35676ed58ec5SVille Tervo int cnt, q; 35686ed58ec5SVille Tervo 35696ed58ec5SVille Tervo switch (conn->type) { 35706ed58ec5SVille Tervo case ACL_LINK: 35716ed58ec5SVille Tervo cnt = hdev->acl_cnt; 35726ed58ec5SVille Tervo break; 35736ed58ec5SVille Tervo case SCO_LINK: 35746ed58ec5SVille Tervo case ESCO_LINK: 35756ed58ec5SVille Tervo cnt = hdev->sco_cnt; 35766ed58ec5SVille Tervo break; 35776ed58ec5SVille Tervo case LE_LINK: 35786ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 35796ed58ec5SVille Tervo break; 35806ed58ec5SVille Tervo default: 35816ed58ec5SVille Tervo cnt = 0; 35826ed58ec5SVille Tervo BT_ERR("Unknown link type"); 35836ed58ec5SVille Tervo } 35846ed58ec5SVille Tervo 35856ed58ec5SVille Tervo q = cnt / num; 35861da177e4SLinus Torvalds *quote = q ? q : 1; 35871da177e4SLinus Torvalds } else 35881da177e4SLinus Torvalds *quote = 0; 35891da177e4SLinus Torvalds 35901da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 35911da177e4SLinus Torvalds return conn; 35921da177e4SLinus Torvalds } 35931da177e4SLinus Torvalds 35946039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 35951da177e4SLinus Torvalds { 35961da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 35971da177e4SLinus Torvalds struct hci_conn *c; 35981da177e4SLinus Torvalds 3599bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 36001da177e4SLinus Torvalds 3601bf4c6325SGustavo F. Padovan rcu_read_lock(); 3602bf4c6325SGustavo F. Padovan 36031da177e4SLinus Torvalds /* Kill stalled connections */ 3604bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3605bae1f5d9SVille Tervo if (c->type == type && c->sent) { 36066ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 36076ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3608bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 36091da177e4SLinus Torvalds } 36101da177e4SLinus Torvalds } 3611bf4c6325SGustavo F. Padovan 3612bf4c6325SGustavo F. Padovan rcu_read_unlock(); 36131da177e4SLinus Torvalds } 36141da177e4SLinus Torvalds 36156039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 361673d80debSLuiz Augusto von Dentz int *quote) 361773d80debSLuiz Augusto von Dentz { 361873d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 361973d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3620abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 362173d80debSLuiz Augusto von Dentz struct hci_conn *conn; 362273d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 362373d80debSLuiz Augusto von Dentz 362473d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 362573d80debSLuiz Augusto von Dentz 3626bf4c6325SGustavo F. Padovan rcu_read_lock(); 3627bf4c6325SGustavo F. Padovan 3628bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 362973d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 363073d80debSLuiz Augusto von Dentz 363173d80debSLuiz Augusto von Dentz if (conn->type != type) 363273d80debSLuiz Augusto von Dentz continue; 363373d80debSLuiz Augusto von Dentz 363473d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 363573d80debSLuiz Augusto von Dentz continue; 363673d80debSLuiz Augusto von Dentz 363773d80debSLuiz Augusto von Dentz conn_num++; 363873d80debSLuiz Augusto von Dentz 36398192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 364073d80debSLuiz Augusto von Dentz struct sk_buff *skb; 364173d80debSLuiz Augusto von Dentz 364273d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 364373d80debSLuiz Augusto von Dentz continue; 364473d80debSLuiz Augusto von Dentz 364573d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 364673d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 364773d80debSLuiz Augusto von Dentz continue; 364873d80debSLuiz Augusto von Dentz 364973d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 365073d80debSLuiz Augusto von Dentz num = 0; 365173d80debSLuiz Augusto von Dentz min = ~0; 365273d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 365373d80debSLuiz Augusto von Dentz } 365473d80debSLuiz Augusto von Dentz 365573d80debSLuiz Augusto von Dentz num++; 365673d80debSLuiz Augusto von Dentz 365773d80debSLuiz Augusto von Dentz if (conn->sent < min) { 365873d80debSLuiz Augusto von Dentz min = conn->sent; 365973d80debSLuiz Augusto von Dentz chan = tmp; 366073d80debSLuiz Augusto von Dentz } 366173d80debSLuiz Augusto von Dentz } 366273d80debSLuiz Augusto von Dentz 366373d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 366473d80debSLuiz Augusto von Dentz break; 366573d80debSLuiz Augusto von Dentz } 366673d80debSLuiz Augusto von Dentz 3667bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3668bf4c6325SGustavo F. Padovan 366973d80debSLuiz Augusto von Dentz if (!chan) 367073d80debSLuiz Augusto von Dentz return NULL; 367173d80debSLuiz Augusto von Dentz 367273d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 367373d80debSLuiz Augusto von Dentz case ACL_LINK: 367473d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 367573d80debSLuiz Augusto von Dentz break; 3676bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3677bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3678bd1eb66bSAndrei Emeltchenko break; 367973d80debSLuiz Augusto von Dentz case SCO_LINK: 368073d80debSLuiz Augusto von Dentz case ESCO_LINK: 368173d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 368273d80debSLuiz Augusto von Dentz break; 368373d80debSLuiz Augusto von Dentz case LE_LINK: 368473d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 368573d80debSLuiz Augusto von Dentz break; 368673d80debSLuiz Augusto von Dentz default: 368773d80debSLuiz Augusto von Dentz cnt = 0; 368873d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 368973d80debSLuiz Augusto von Dentz } 369073d80debSLuiz Augusto von Dentz 369173d80debSLuiz Augusto von Dentz q = cnt / num; 369273d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 369373d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 369473d80debSLuiz Augusto von Dentz return chan; 369573d80debSLuiz Augusto von Dentz } 369673d80debSLuiz Augusto von Dentz 369702b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 369802b20f0bSLuiz Augusto von Dentz { 369902b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 370002b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 370102b20f0bSLuiz Augusto von Dentz int num = 0; 370202b20f0bSLuiz Augusto von Dentz 370302b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 370402b20f0bSLuiz Augusto von Dentz 3705bf4c6325SGustavo F. Padovan rcu_read_lock(); 3706bf4c6325SGustavo F. Padovan 3707bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 370802b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 370902b20f0bSLuiz Augusto von Dentz 371002b20f0bSLuiz Augusto von Dentz if (conn->type != type) 371102b20f0bSLuiz Augusto von Dentz continue; 371202b20f0bSLuiz Augusto von Dentz 371302b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 371402b20f0bSLuiz Augusto von Dentz continue; 371502b20f0bSLuiz Augusto von Dentz 371602b20f0bSLuiz Augusto von Dentz num++; 371702b20f0bSLuiz Augusto von Dentz 37188192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 371902b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 372002b20f0bSLuiz Augusto von Dentz 372102b20f0bSLuiz Augusto von Dentz if (chan->sent) { 372202b20f0bSLuiz Augusto von Dentz chan->sent = 0; 372302b20f0bSLuiz Augusto von Dentz continue; 372402b20f0bSLuiz Augusto von Dentz } 372502b20f0bSLuiz Augusto von Dentz 372602b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 372702b20f0bSLuiz Augusto von Dentz continue; 372802b20f0bSLuiz Augusto von Dentz 372902b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 373002b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 373102b20f0bSLuiz Augusto von Dentz continue; 373202b20f0bSLuiz Augusto von Dentz 373302b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 373402b20f0bSLuiz Augusto von Dentz 373502b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 373602b20f0bSLuiz Augusto von Dentz skb->priority); 373702b20f0bSLuiz Augusto von Dentz } 373802b20f0bSLuiz Augusto von Dentz 373902b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 374002b20f0bSLuiz Augusto von Dentz break; 374102b20f0bSLuiz Augusto von Dentz } 3742bf4c6325SGustavo F. Padovan 3743bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3744bf4c6325SGustavo F. Padovan 374502b20f0bSLuiz Augusto von Dentz } 374602b20f0bSLuiz Augusto von Dentz 3747b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3748b71d385aSAndrei Emeltchenko { 3749b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3750b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3751b71d385aSAndrei Emeltchenko } 3752b71d385aSAndrei Emeltchenko 37536039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 37541da177e4SLinus Torvalds { 3755d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 37561da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 37571da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 375863d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 37595f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3760bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 37611da177e4SLinus Torvalds } 376263d2bc1bSAndrei Emeltchenko } 37631da177e4SLinus Torvalds 37646039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 376563d2bc1bSAndrei Emeltchenko { 376663d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 376763d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 376863d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 376963d2bc1bSAndrei Emeltchenko int quote; 377063d2bc1bSAndrei Emeltchenko 377163d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 377204837f64SMarcel Holtmann 377373d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 377473d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3775ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3776ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 377773d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 377873d80debSLuiz Augusto von Dentz skb->len, skb->priority); 377973d80debSLuiz Augusto von Dentz 3780ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3781ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3782ec1cce24SLuiz Augusto von Dentz break; 3783ec1cce24SLuiz Augusto von Dentz 3784ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3785ec1cce24SLuiz Augusto von Dentz 378673d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 378773d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 378804837f64SMarcel Holtmann 378957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 37901da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 37911da177e4SLinus Torvalds 37921da177e4SLinus Torvalds hdev->acl_cnt--; 379373d80debSLuiz Augusto von Dentz chan->sent++; 379473d80debSLuiz Augusto von Dentz chan->conn->sent++; 37951da177e4SLinus Torvalds } 37961da177e4SLinus Torvalds } 379702b20f0bSLuiz Augusto von Dentz 379802b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 379902b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 38001da177e4SLinus Torvalds } 38011da177e4SLinus Torvalds 38026039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3803b71d385aSAndrei Emeltchenko { 380463d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3805b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3806b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3807b71d385aSAndrei Emeltchenko int quote; 3808bd1eb66bSAndrei Emeltchenko u8 type; 3809b71d385aSAndrei Emeltchenko 381063d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3811b71d385aSAndrei Emeltchenko 3812bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3813bd1eb66bSAndrei Emeltchenko 3814bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3815bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3816bd1eb66bSAndrei Emeltchenko else 3817bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3818bd1eb66bSAndrei Emeltchenko 3819b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3820bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3821b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3822b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3823b71d385aSAndrei Emeltchenko int blocks; 3824b71d385aSAndrei Emeltchenko 3825b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3826b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3827b71d385aSAndrei Emeltchenko 3828b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3829b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3830b71d385aSAndrei Emeltchenko break; 3831b71d385aSAndrei Emeltchenko 3832b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3833b71d385aSAndrei Emeltchenko 3834b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3835b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3836b71d385aSAndrei Emeltchenko return; 3837b71d385aSAndrei Emeltchenko 3838b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3839b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3840b71d385aSAndrei Emeltchenko 384157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3842b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3843b71d385aSAndrei Emeltchenko 3844b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3845b71d385aSAndrei Emeltchenko quote -= blocks; 3846b71d385aSAndrei Emeltchenko 3847b71d385aSAndrei Emeltchenko chan->sent += blocks; 3848b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3849b71d385aSAndrei Emeltchenko } 3850b71d385aSAndrei Emeltchenko } 3851b71d385aSAndrei Emeltchenko 3852b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3853bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3854b71d385aSAndrei Emeltchenko } 3855b71d385aSAndrei Emeltchenko 38566039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3857b71d385aSAndrei Emeltchenko { 3858b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3859b71d385aSAndrei Emeltchenko 3860bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3861ca8bee5dSMarcel Holtmann if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_PRIMARY) 3862bd1eb66bSAndrei Emeltchenko return; 3863bd1eb66bSAndrei Emeltchenko 3864bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3865bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3866b71d385aSAndrei Emeltchenko return; 3867b71d385aSAndrei Emeltchenko 3868b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3869b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3870b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3871b71d385aSAndrei Emeltchenko break; 3872b71d385aSAndrei Emeltchenko 3873b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3874b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3875b71d385aSAndrei Emeltchenko break; 3876b71d385aSAndrei Emeltchenko } 3877b71d385aSAndrei Emeltchenko } 3878b71d385aSAndrei Emeltchenko 38791da177e4SLinus Torvalds /* Schedule SCO */ 38806039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 38811da177e4SLinus Torvalds { 38821da177e4SLinus Torvalds struct hci_conn *conn; 38831da177e4SLinus Torvalds struct sk_buff *skb; 38841da177e4SLinus Torvalds int quote; 38851da177e4SLinus Torvalds 38861da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 38871da177e4SLinus Torvalds 388852087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 388952087a79SLuiz Augusto von Dentz return; 389052087a79SLuiz Augusto von Dentz 38911da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 38921da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 38931da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 389457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38951da177e4SLinus Torvalds 38961da177e4SLinus Torvalds conn->sent++; 38971da177e4SLinus Torvalds if (conn->sent == ~0) 38981da177e4SLinus Torvalds conn->sent = 0; 38991da177e4SLinus Torvalds } 39001da177e4SLinus Torvalds } 39011da177e4SLinus Torvalds } 39021da177e4SLinus Torvalds 39036039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3904b6a0dc82SMarcel Holtmann { 3905b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3906b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3907b6a0dc82SMarcel Holtmann int quote; 3908b6a0dc82SMarcel Holtmann 3909b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3910b6a0dc82SMarcel Holtmann 391152087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 391252087a79SLuiz Augusto von Dentz return; 391352087a79SLuiz Augusto von Dentz 39148fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 39158fc9ced3SGustavo Padovan "e))) { 3916b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3917b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 391857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3919b6a0dc82SMarcel Holtmann 3920b6a0dc82SMarcel Holtmann conn->sent++; 3921b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3922b6a0dc82SMarcel Holtmann conn->sent = 0; 3923b6a0dc82SMarcel Holtmann } 3924b6a0dc82SMarcel Holtmann } 3925b6a0dc82SMarcel Holtmann } 3926b6a0dc82SMarcel Holtmann 39276039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 39286ed58ec5SVille Tervo { 392973d80debSLuiz Augusto von Dentz struct hci_chan *chan; 39306ed58ec5SVille Tervo struct sk_buff *skb; 393102b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 39326ed58ec5SVille Tervo 39336ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 39346ed58ec5SVille Tervo 393552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 393652087a79SLuiz Augusto von Dentz return; 393752087a79SLuiz Augusto von Dentz 3938d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 39396ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 39406ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3941bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 39426ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3943bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 39446ed58ec5SVille Tervo } 39456ed58ec5SVille Tervo 39466ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 394702b20f0bSLuiz Augusto von Dentz tmp = cnt; 394873d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3949ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3950ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 395173d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 395273d80debSLuiz Augusto von Dentz skb->len, skb->priority); 39536ed58ec5SVille Tervo 3954ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3955ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3956ec1cce24SLuiz Augusto von Dentz break; 3957ec1cce24SLuiz Augusto von Dentz 3958ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3959ec1cce24SLuiz Augusto von Dentz 396057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39616ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 39626ed58ec5SVille Tervo 39636ed58ec5SVille Tervo cnt--; 396473d80debSLuiz Augusto von Dentz chan->sent++; 396573d80debSLuiz Augusto von Dentz chan->conn->sent++; 39666ed58ec5SVille Tervo } 39676ed58ec5SVille Tervo } 396873d80debSLuiz Augusto von Dentz 39696ed58ec5SVille Tervo if (hdev->le_pkts) 39706ed58ec5SVille Tervo hdev->le_cnt = cnt; 39716ed58ec5SVille Tervo else 39726ed58ec5SVille Tervo hdev->acl_cnt = cnt; 397302b20f0bSLuiz Augusto von Dentz 397402b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 397502b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 39766ed58ec5SVille Tervo } 39776ed58ec5SVille Tervo 39783eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 39791da177e4SLinus Torvalds { 39803eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 39811da177e4SLinus Torvalds struct sk_buff *skb; 39821da177e4SLinus Torvalds 39836ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 39846ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 39851da177e4SLinus Torvalds 3986d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 39871da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 39881da177e4SLinus Torvalds hci_sched_acl(hdev); 39891da177e4SLinus Torvalds hci_sched_sco(hdev); 3990b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 39916ed58ec5SVille Tervo hci_sched_le(hdev); 399252de599eSMarcel Holtmann } 39936ed58ec5SVille Tervo 39941da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 39951da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 399657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39971da177e4SLinus Torvalds } 39981da177e4SLinus Torvalds 399925985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 40001da177e4SLinus Torvalds 40011da177e4SLinus Torvalds /* ACL data packet */ 40026039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40031da177e4SLinus Torvalds { 40041da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 40051da177e4SLinus Torvalds struct hci_conn *conn; 40061da177e4SLinus Torvalds __u16 handle, flags; 40071da177e4SLinus Torvalds 40081da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 40091da177e4SLinus Torvalds 40101da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40111da177e4SLinus Torvalds flags = hci_flags(handle); 40121da177e4SLinus Torvalds handle = hci_handle(handle); 40131da177e4SLinus Torvalds 4014f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4015a8c5fb1aSGustavo Padovan handle, flags); 40161da177e4SLinus Torvalds 40171da177e4SLinus Torvalds hdev->stat.acl_rx++; 40181da177e4SLinus Torvalds 40191da177e4SLinus Torvalds hci_dev_lock(hdev); 40201da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40211da177e4SLinus Torvalds hci_dev_unlock(hdev); 40221da177e4SLinus Torvalds 40231da177e4SLinus Torvalds if (conn) { 402465983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 402504837f64SMarcel Holtmann 40261da177e4SLinus Torvalds /* Send to upper protocol */ 4027686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 40281da177e4SLinus Torvalds return; 40291da177e4SLinus Torvalds } else { 40301da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 40311da177e4SLinus Torvalds hdev->name, handle); 40321da177e4SLinus Torvalds } 40331da177e4SLinus Torvalds 40341da177e4SLinus Torvalds kfree_skb(skb); 40351da177e4SLinus Torvalds } 40361da177e4SLinus Torvalds 40371da177e4SLinus Torvalds /* SCO data packet */ 40386039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40391da177e4SLinus Torvalds { 40401da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 40411da177e4SLinus Torvalds struct hci_conn *conn; 40421da177e4SLinus Torvalds __u16 handle; 40431da177e4SLinus Torvalds 40441da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 40451da177e4SLinus Torvalds 40461da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40471da177e4SLinus Torvalds 4048f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 40491da177e4SLinus Torvalds 40501da177e4SLinus Torvalds hdev->stat.sco_rx++; 40511da177e4SLinus Torvalds 40521da177e4SLinus Torvalds hci_dev_lock(hdev); 40531da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40541da177e4SLinus Torvalds hci_dev_unlock(hdev); 40551da177e4SLinus Torvalds 40561da177e4SLinus Torvalds if (conn) { 40571da177e4SLinus Torvalds /* Send to upper protocol */ 4058686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 40591da177e4SLinus Torvalds return; 40601da177e4SLinus Torvalds } else { 40611da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 40621da177e4SLinus Torvalds hdev->name, handle); 40631da177e4SLinus Torvalds } 40641da177e4SLinus Torvalds 40651da177e4SLinus Torvalds kfree_skb(skb); 40661da177e4SLinus Torvalds } 40671da177e4SLinus Torvalds 40689238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 40699238f36aSJohan Hedberg { 40709238f36aSJohan Hedberg struct sk_buff *skb; 40719238f36aSJohan Hedberg 40729238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 40739238f36aSJohan Hedberg if (!skb) 40749238f36aSJohan Hedberg return true; 40759238f36aSJohan Hedberg 407644d27137SJohan Hedberg return (bt_cb(skb)->hci.req_flags & HCI_REQ_START); 40779238f36aSJohan Hedberg } 40789238f36aSJohan Hedberg 407942c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 408042c6b129SJohan Hedberg { 408142c6b129SJohan Hedberg struct hci_command_hdr *sent; 408242c6b129SJohan Hedberg struct sk_buff *skb; 408342c6b129SJohan Hedberg u16 opcode; 408442c6b129SJohan Hedberg 408542c6b129SJohan Hedberg if (!hdev->sent_cmd) 408642c6b129SJohan Hedberg return; 408742c6b129SJohan Hedberg 408842c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 408942c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 409042c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 409142c6b129SJohan Hedberg return; 409242c6b129SJohan Hedberg 409342c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 409442c6b129SJohan Hedberg if (!skb) 409542c6b129SJohan Hedberg return; 409642c6b129SJohan Hedberg 409742c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 409842c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 409942c6b129SJohan Hedberg } 410042c6b129SJohan Hedberg 4101e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4102e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4103e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 41049238f36aSJohan Hedberg { 41059238f36aSJohan Hedberg struct sk_buff *skb; 41069238f36aSJohan Hedberg unsigned long flags; 41079238f36aSJohan Hedberg 41089238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 41099238f36aSJohan Hedberg 411042c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 411142c6b129SJohan Hedberg * sent we need to do special handling of it. 41129238f36aSJohan Hedberg */ 411342c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 411442c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 411542c6b129SJohan Hedberg * reset complete event during init and any pending 411642c6b129SJohan Hedberg * command will never be completed. In such a case we 411742c6b129SJohan Hedberg * need to resend whatever was the last sent 411842c6b129SJohan Hedberg * command. 411942c6b129SJohan Hedberg */ 412042c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 412142c6b129SJohan Hedberg hci_resend_last(hdev); 412242c6b129SJohan Hedberg 41239238f36aSJohan Hedberg return; 412442c6b129SJohan Hedberg } 41259238f36aSJohan Hedberg 41269238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 41279238f36aSJohan Hedberg * this request the request is not yet complete. 41289238f36aSJohan Hedberg */ 41299238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 41309238f36aSJohan Hedberg return; 41319238f36aSJohan Hedberg 41329238f36aSJohan Hedberg /* If this was the last command in a request the complete 41339238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 41349238f36aSJohan Hedberg * command queue (hdev->cmd_q). 41359238f36aSJohan Hedberg */ 413644d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_flags & HCI_REQ_SKB) { 413744d27137SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4138e6214487SJohan Hedberg return; 41399238f36aSJohan Hedberg } 4140e6214487SJohan Hedberg 414144d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 414244d27137SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4143e6214487SJohan Hedberg return; 414453e21fbcSJohan Hedberg } 41459238f36aSJohan Hedberg 41469238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 41479238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 41489238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 414944d27137SJohan Hedberg if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) { 41509238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 41519238f36aSJohan Hedberg break; 41529238f36aSJohan Hedberg } 41539238f36aSJohan Hedberg 41543bd7594eSDouglas Anderson if (bt_cb(skb)->hci.req_flags & HCI_REQ_SKB) 4155242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 41563bd7594eSDouglas Anderson else 41573bd7594eSDouglas Anderson *req_complete = bt_cb(skb)->hci.req_complete; 41589238f36aSJohan Hedberg kfree_skb(skb); 41599238f36aSJohan Hedberg } 41609238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 41619238f36aSJohan Hedberg } 41629238f36aSJohan Hedberg 4163b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 41641da177e4SLinus Torvalds { 4165b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 41661da177e4SLinus Torvalds struct sk_buff *skb; 41671da177e4SLinus Torvalds 41681da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 41691da177e4SLinus Torvalds 41701da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4171cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4172cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4173cd82e61cSMarcel Holtmann 41741da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 41751da177e4SLinus Torvalds /* Send copy to the sockets */ 4176470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 41771da177e4SLinus Torvalds } 41781da177e4SLinus Torvalds 4179d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 41801da177e4SLinus Torvalds kfree_skb(skb); 41811da177e4SLinus Torvalds continue; 41821da177e4SLinus Torvalds } 41831da177e4SLinus Torvalds 41841da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 41851da177e4SLinus Torvalds /* Don't process data packets in this states. */ 4186d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 41871da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 41881da177e4SLinus Torvalds case HCI_SCODATA_PKT: 41891da177e4SLinus Torvalds kfree_skb(skb); 41901da177e4SLinus Torvalds continue; 41913ff50b79SStephen Hemminger } 41921da177e4SLinus Torvalds } 41931da177e4SLinus Torvalds 41941da177e4SLinus Torvalds /* Process frame */ 4195d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 41961da177e4SLinus Torvalds case HCI_EVENT_PKT: 4197b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 41981da177e4SLinus Torvalds hci_event_packet(hdev, skb); 41991da177e4SLinus Torvalds break; 42001da177e4SLinus Torvalds 42011da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 42021da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 42031da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 42041da177e4SLinus Torvalds break; 42051da177e4SLinus Torvalds 42061da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42071da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 42081da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 42091da177e4SLinus Torvalds break; 42101da177e4SLinus Torvalds 42111da177e4SLinus Torvalds default: 42121da177e4SLinus Torvalds kfree_skb(skb); 42131da177e4SLinus Torvalds break; 42141da177e4SLinus Torvalds } 42151da177e4SLinus Torvalds } 42161da177e4SLinus Torvalds } 42171da177e4SLinus Torvalds 4218c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 42191da177e4SLinus Torvalds { 4220c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 42211da177e4SLinus Torvalds struct sk_buff *skb; 42221da177e4SLinus Torvalds 42232104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 42242104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 42251da177e4SLinus Torvalds 42261da177e4SLinus Torvalds /* Send queued commands */ 42275a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 42285a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 42295a08ecceSAndrei Emeltchenko if (!skb) 42305a08ecceSAndrei Emeltchenko return; 42315a08ecceSAndrei Emeltchenko 42321da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 42331da177e4SLinus Torvalds 4234a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 423570f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 42361da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 423757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42387bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 423965cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 42407bdb8a5cSSzymon Janc else 424165cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 424265cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 42431da177e4SLinus Torvalds } else { 42441da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4245c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 42461da177e4SLinus Torvalds } 42471da177e4SLinus Torvalds } 42481da177e4SLinus Torvalds } 4249