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 151b56c7b25SMarcel Holtmann * is not active or in user channel operation, then there is no need 152b56c7b25SMarcel Holtmann * for the vendor callback. Instead just store the desired value and 153b56c7b25SMarcel Holtmann * the setting will be programmed when the controller gets powered on. 1547e995b9eSMarcel Holtmann */ 1557e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 156b56c7b25SMarcel Holtmann (!test_bit(HCI_RUNNING, &hdev->flags) || 157b56c7b25SMarcel Holtmann hci_dev_test_flag(hdev, HCI_USER_CHANNEL))) 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 6389756d33bSMarcel Holtmann /* If the controller supports Channel Selection Algorithm #2 6399756d33bSMarcel Holtmann * feature, enable the corresponding event. 6409756d33bSMarcel Holtmann */ 6419756d33bSMarcel Holtmann if (hdev->le_features[1] & HCI_LE_CHAN_SEL_ALG2) 6429756d33bSMarcel Holtmann events[2] |= 0x08; /* LE Channel Selection 6439756d33bSMarcel Holtmann * Algorithm 6449756d33bSMarcel Holtmann */ 6459756d33bSMarcel Holtmann 6467d26f5c4SMarcel Holtmann /* If the controller supports the LE Set Scan Enable command, 6477d26f5c4SMarcel Holtmann * enable the corresponding advertising report event. 6487d26f5c4SMarcel Holtmann */ 6497d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x08) 6507d26f5c4SMarcel Holtmann events[0] |= 0x02; /* LE Advertising Report */ 6517d26f5c4SMarcel Holtmann 6527d26f5c4SMarcel Holtmann /* If the controller supports the LE Create Connection 6537d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6547d26f5c4SMarcel Holtmann */ 6557d26f5c4SMarcel Holtmann if (hdev->commands[26] & 0x10) 6567d26f5c4SMarcel Holtmann events[0] |= 0x01; /* LE Connection Complete */ 6577d26f5c4SMarcel Holtmann 6587d26f5c4SMarcel Holtmann /* If the controller supports the LE Connection Update 6597d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6607d26f5c4SMarcel Holtmann */ 6617d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x04) 6627d26f5c4SMarcel Holtmann events[0] |= 0x04; /* LE Connection Update 6637d26f5c4SMarcel Holtmann * Complete 6647d26f5c4SMarcel Holtmann */ 6657d26f5c4SMarcel Holtmann 6667d26f5c4SMarcel Holtmann /* If the controller supports the LE Read Remote Used Features 6677d26f5c4SMarcel Holtmann * command, enable the corresponding event. 6687d26f5c4SMarcel Holtmann */ 6697d26f5c4SMarcel Holtmann if (hdev->commands[27] & 0x20) 6707d26f5c4SMarcel Holtmann events[0] |= 0x08; /* LE Read Remote Used 6717d26f5c4SMarcel Holtmann * Features Complete 6727d26f5c4SMarcel Holtmann */ 6737d26f5c4SMarcel Holtmann 6745a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 6755a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 6765a34bd5fSMarcel Holtmann */ 6775a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 6785a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 6795a34bd5fSMarcel Holtmann * Public Key Complete 6805a34bd5fSMarcel Holtmann */ 6815a34bd5fSMarcel Holtmann 6825a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 6835a34bd5fSMarcel Holtmann * command, enable the corresponding event. 6845a34bd5fSMarcel Holtmann */ 6855a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 6865a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 6875a34bd5fSMarcel Holtmann 68827bbca44SMarcel Holtmann /* If the controller supports the LE Set Default PHY or 68927bbca44SMarcel Holtmann * LE Set PHY commands, enable the corresponding event. 69027bbca44SMarcel Holtmann */ 69127bbca44SMarcel Holtmann if (hdev->commands[35] & (0x20 | 0x40)) 69227bbca44SMarcel Holtmann events[1] |= 0x08; /* LE PHY Update Complete */ 69327bbca44SMarcel Holtmann 6949193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 6959193c6e8SAndre Guedes events); 6969193c6e8SAndre Guedes 69715a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 69815a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 69915a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 70015a49ccaSMarcel Holtmann } 70115a49ccaSMarcel Holtmann 7022ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x40) { 7032ab216a7SMarcel Holtmann /* Read LE White List Size */ 7042ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 7052ab216a7SMarcel Holtmann 0, NULL); 7062ab216a7SMarcel Holtmann } 7072ab216a7SMarcel Holtmann 7082ab216a7SMarcel Holtmann if (hdev->commands[26] & 0x80) { 7092ab216a7SMarcel Holtmann /* Clear LE White List */ 7102ab216a7SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 7112ab216a7SMarcel Holtmann } 7122ab216a7SMarcel Holtmann 713a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 714a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 715a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 716a9f6068eSMarcel Holtmann 717a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 718a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 719a9f6068eSMarcel Holtmann } 720a9f6068eSMarcel Holtmann 72142c6b129SJohan Hedberg hci_set_le_support(req); 7229193c6e8SAndre Guedes } 723d2c5d77fSJohan Hedberg 724d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 725d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 726d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 727d2c5d77fSJohan Hedberg 728d2c5d77fSJohan Hedberg cp.page = p; 729d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 730d2c5d77fSJohan Hedberg sizeof(cp), &cp); 731d2c5d77fSJohan Hedberg } 732a1d01db1SJohan Hedberg 733a1d01db1SJohan Hedberg return 0; 7342177bab5SJohan Hedberg } 7352177bab5SJohan Hedberg 736a1d01db1SJohan Hedberg static int hci_init4_req(struct hci_request *req, unsigned long opt) 7375d4e7e8dSJohan Hedberg { 7385d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 7395d4e7e8dSJohan Hedberg 74036f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 74136f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 74236f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 74336f260ceSMarcel Holtmann * 74436f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 74536f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 74636f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 74736f260ceSMarcel Holtmann * command redundant anyway. 74836f260ceSMarcel Holtmann * 74936f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 75036f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 75136f260ceSMarcel Holtmann * just disable this command. 75236f260ceSMarcel Holtmann */ 75336f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 75436f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 75536f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 75636f260ceSMarcel Holtmann 75736f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 75836f260ceSMarcel Holtmann cp.delete_all = 0x01; 75936f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 76036f260ceSMarcel Holtmann sizeof(cp), &cp); 76136f260ceSMarcel Holtmann } 76236f260ceSMarcel Holtmann 763d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 764d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 765d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 766d62e6d67SJohan Hedberg 767109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 768109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 769109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 770109e3191SMarcel Holtmann 771f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 772f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 773f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 774f4fe73edSMarcel Holtmann 7755d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 77653b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 7775d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 778a6d0d690SMarcel Holtmann 779a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 780d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED) && 781574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 782a6d0d690SMarcel Holtmann u8 support = 0x01; 783574ea3c7SMarcel Holtmann 784a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 785a6d0d690SMarcel Holtmann sizeof(support), &support); 786a6d0d690SMarcel Holtmann } 787a1d01db1SJohan Hedberg 78812204875SMarcel Holtmann /* Set Suggested Default Data Length to maximum if supported */ 78912204875SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 79012204875SMarcel Holtmann struct hci_cp_le_write_def_data_len cp; 79112204875SMarcel Holtmann 79212204875SMarcel Holtmann cp.tx_len = hdev->le_max_tx_len; 79312204875SMarcel Holtmann cp.tx_time = hdev->le_max_tx_time; 79412204875SMarcel Holtmann hci_req_add(req, HCI_OP_LE_WRITE_DEF_DATA_LEN, sizeof(cp), &cp); 79512204875SMarcel Holtmann } 79612204875SMarcel Holtmann 797de2ba303SMarcel Holtmann /* Set Default PHY parameters if command is supported */ 798de2ba303SMarcel Holtmann if (hdev->commands[35] & 0x20) { 799de2ba303SMarcel Holtmann struct hci_cp_le_set_default_phy cp; 800de2ba303SMarcel Holtmann 801de2ba303SMarcel Holtmann /* No transmitter PHY or receiver PHY preferences */ 802de2ba303SMarcel Holtmann cp.all_phys = 0x03; 803de2ba303SMarcel Holtmann cp.tx_phys = 0; 804de2ba303SMarcel Holtmann cp.rx_phys = 0; 805de2ba303SMarcel Holtmann 806de2ba303SMarcel Holtmann hci_req_add(req, HCI_OP_LE_SET_DEFAULT_PHY, sizeof(cp), &cp); 807de2ba303SMarcel Holtmann } 808de2ba303SMarcel Holtmann 809a1d01db1SJohan Hedberg return 0; 8105d4e7e8dSJohan Hedberg } 8115d4e7e8dSJohan Hedberg 8122177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8132177bab5SJohan Hedberg { 8142177bab5SJohan Hedberg int err; 8152177bab5SJohan Hedberg 8164ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT, NULL); 8172177bab5SJohan Hedberg if (err < 0) 8182177bab5SJohan Hedberg return err; 8192177bab5SJohan Hedberg 820f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 821f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 8224b4148e9SMarcel Holtmann 8234ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT, NULL); 8242177bab5SJohan Hedberg if (err < 0) 8252177bab5SJohan Hedberg return err; 8262177bab5SJohan Hedberg 827ca8bee5dSMarcel Holtmann /* HCI_PRIMARY covers both single-mode LE, BR/EDR and dual-mode 8280af801b9SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8290af801b9SJohan Hedberg * first two stages of init. 8300af801b9SJohan Hedberg */ 831ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) 8320af801b9SJohan Hedberg return 0; 8330af801b9SJohan Hedberg 8344ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT, NULL); 8355d4e7e8dSJohan Hedberg if (err < 0) 8365d4e7e8dSJohan Hedberg return err; 8375d4e7e8dSJohan Hedberg 8384ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT, NULL); 839baf27f6eSMarcel Holtmann if (err < 0) 840baf27f6eSMarcel Holtmann return err; 841baf27f6eSMarcel Holtmann 842ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 843ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 844ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 845ec6cef9cSMarcel Holtmann * 846ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 847ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 848ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 849ec6cef9cSMarcel Holtmann * be called during the config phase. 850ec6cef9cSMarcel Holtmann * 851ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 852ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 853baf27f6eSMarcel Holtmann */ 854d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 855d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 856baf27f6eSMarcel Holtmann return 0; 857baf27f6eSMarcel Holtmann 85860c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 85960c5f5fbSMarcel Holtmann 86071c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 86160c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 8622bfa3531SMarcel Holtmann 863162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 86460c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 865e7b8fc92SMarcel Holtmann 866baf27f6eSMarcel Holtmann return 0; 8672177bab5SJohan Hedberg } 8682177bab5SJohan Hedberg 869a1d01db1SJohan Hedberg static int hci_init0_req(struct hci_request *req, unsigned long opt) 8700ebca7d6SMarcel Holtmann { 8710ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 8720ebca7d6SMarcel Holtmann 8730ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 8740ebca7d6SMarcel Holtmann 8750ebca7d6SMarcel Holtmann /* Reset */ 8760ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 8770ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 8780ebca7d6SMarcel Holtmann 8790ebca7d6SMarcel Holtmann /* Read Local Version */ 8800ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 8810ebca7d6SMarcel Holtmann 8820ebca7d6SMarcel Holtmann /* Read BD Address */ 8830ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 8840ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 885a1d01db1SJohan Hedberg 886a1d01db1SJohan Hedberg return 0; 8870ebca7d6SMarcel Holtmann } 8880ebca7d6SMarcel Holtmann 8890ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 8900ebca7d6SMarcel Holtmann { 8910ebca7d6SMarcel Holtmann int err; 8920ebca7d6SMarcel Holtmann 893cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 894cc78b44bSMarcel Holtmann return 0; 895cc78b44bSMarcel Holtmann 8964ebeee2dSJohan Hedberg err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT, NULL); 8970ebca7d6SMarcel Holtmann if (err < 0) 8980ebca7d6SMarcel Holtmann return err; 8990ebca7d6SMarcel Holtmann 900f640ee98SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) 901f640ee98SMarcel Holtmann hci_debugfs_create_basic(hdev); 902f640ee98SMarcel Holtmann 9030ebca7d6SMarcel Holtmann return 0; 9040ebca7d6SMarcel Holtmann } 9050ebca7d6SMarcel Holtmann 906a1d01db1SJohan Hedberg static int hci_scan_req(struct hci_request *req, unsigned long opt) 9071da177e4SLinus Torvalds { 9081da177e4SLinus Torvalds __u8 scan = opt; 9091da177e4SLinus Torvalds 91042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds /* Inquiry and Page scans */ 91342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 914a1d01db1SJohan Hedberg return 0; 9151da177e4SLinus Torvalds } 9161da177e4SLinus Torvalds 917a1d01db1SJohan Hedberg static int hci_auth_req(struct hci_request *req, unsigned long opt) 9181da177e4SLinus Torvalds { 9191da177e4SLinus Torvalds __u8 auth = opt; 9201da177e4SLinus Torvalds 92142c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9221da177e4SLinus Torvalds 9231da177e4SLinus Torvalds /* Authentication */ 92442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 925a1d01db1SJohan Hedberg return 0; 9261da177e4SLinus Torvalds } 9271da177e4SLinus Torvalds 928a1d01db1SJohan Hedberg static int hci_encrypt_req(struct hci_request *req, unsigned long opt) 9291da177e4SLinus Torvalds { 9301da177e4SLinus Torvalds __u8 encrypt = opt; 9311da177e4SLinus Torvalds 93242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 9331da177e4SLinus Torvalds 934e4e8e37cSMarcel Holtmann /* Encryption */ 93542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 936a1d01db1SJohan Hedberg return 0; 9371da177e4SLinus Torvalds } 9381da177e4SLinus Torvalds 939a1d01db1SJohan Hedberg static int hci_linkpol_req(struct hci_request *req, unsigned long opt) 940e4e8e37cSMarcel Holtmann { 941e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 942e4e8e37cSMarcel Holtmann 94342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 944e4e8e37cSMarcel Holtmann 945e4e8e37cSMarcel Holtmann /* Default link policy */ 94642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 947a1d01db1SJohan Hedberg return 0; 948e4e8e37cSMarcel Holtmann } 949e4e8e37cSMarcel Holtmann 9501da177e4SLinus Torvalds /* Get HCI device by index. 9511da177e4SLinus Torvalds * Device is held on return. */ 9521da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 9531da177e4SLinus Torvalds { 9548035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 9551da177e4SLinus Torvalds 9561da177e4SLinus Torvalds BT_DBG("%d", index); 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds if (index < 0) 9591da177e4SLinus Torvalds return NULL; 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 9628035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 9631da177e4SLinus Torvalds if (d->id == index) { 9641da177e4SLinus Torvalds hdev = hci_dev_hold(d); 9651da177e4SLinus Torvalds break; 9661da177e4SLinus Torvalds } 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 9691da177e4SLinus Torvalds return hdev; 9701da177e4SLinus Torvalds } 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 973ff9ef578SJohan Hedberg 97430dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 97530dc78e1SJohan Hedberg { 97630dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 97730dc78e1SJohan Hedberg 9786fbe195dSAndre Guedes switch (discov->state) { 979343f935bSAndre Guedes case DISCOVERY_FINDING: 9806fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 98130dc78e1SJohan Hedberg return true; 98230dc78e1SJohan Hedberg 9836fbe195dSAndre Guedes default: 98430dc78e1SJohan Hedberg return false; 98530dc78e1SJohan Hedberg } 9866fbe195dSAndre Guedes } 98730dc78e1SJohan Hedberg 988ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 989ff9ef578SJohan Hedberg { 990bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 991bb3e0a33SJohan Hedberg 992ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 993ff9ef578SJohan Hedberg 994bb3e0a33SJohan Hedberg if (old_state == state) 995ff9ef578SJohan Hedberg return; 996ff9ef578SJohan Hedberg 997bb3e0a33SJohan Hedberg hdev->discovery.state = state; 998bb3e0a33SJohan Hedberg 999ff9ef578SJohan Hedberg switch (state) { 1000ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1001c54c3860SAndre Guedes hci_update_background_scan(hdev); 1002c54c3860SAndre Guedes 1003bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1004ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1005ff9ef578SJohan Hedberg break; 1006ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1007ff9ef578SJohan Hedberg break; 1008343f935bSAndre Guedes case DISCOVERY_FINDING: 1009ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1010ff9ef578SJohan Hedberg break; 101130dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 101230dc78e1SJohan Hedberg break; 1013ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1014ff9ef578SJohan Hedberg break; 1015ff9ef578SJohan Hedberg } 1016ff9ef578SJohan Hedberg } 1017ff9ef578SJohan Hedberg 10181f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 10191da177e4SLinus Torvalds { 102030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1021b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10221da177e4SLinus Torvalds 1023561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1024561aafbcSJohan Hedberg list_del(&p->all); 1025b57c1a56SJohan Hedberg kfree(p); 10261da177e4SLinus Torvalds } 1027561aafbcSJohan Hedberg 1028561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1029561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10301da177e4SLinus Torvalds } 10311da177e4SLinus Torvalds 1032a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1033a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 10341da177e4SLinus Torvalds { 103530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 10361da177e4SLinus Torvalds struct inquiry_entry *e; 10371da177e4SLinus Torvalds 10386ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 10391da177e4SLinus Torvalds 1040561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 10411da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 10421da177e4SLinus Torvalds return e; 10431da177e4SLinus Torvalds } 10441da177e4SLinus Torvalds 1045b57c1a56SJohan Hedberg return NULL; 1046b57c1a56SJohan Hedberg } 1047b57c1a56SJohan Hedberg 1048561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1049561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1050561aafbcSJohan Hedberg { 105130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1052561aafbcSJohan Hedberg struct inquiry_entry *e; 1053561aafbcSJohan Hedberg 10546ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1055561aafbcSJohan Hedberg 1056561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1057561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1058561aafbcSJohan Hedberg return e; 1059561aafbcSJohan Hedberg } 1060561aafbcSJohan Hedberg 1061561aafbcSJohan Hedberg return NULL; 1062561aafbcSJohan Hedberg } 1063561aafbcSJohan Hedberg 106430dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 106530dc78e1SJohan Hedberg bdaddr_t *bdaddr, 106630dc78e1SJohan Hedberg int state) 106730dc78e1SJohan Hedberg { 106830dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 106930dc78e1SJohan Hedberg struct inquiry_entry *e; 107030dc78e1SJohan Hedberg 10716ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 107230dc78e1SJohan Hedberg 107330dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 107430dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 107530dc78e1SJohan Hedberg return e; 107630dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 107730dc78e1SJohan Hedberg return e; 107830dc78e1SJohan Hedberg } 107930dc78e1SJohan Hedberg 108030dc78e1SJohan Hedberg return NULL; 108130dc78e1SJohan Hedberg } 108230dc78e1SJohan Hedberg 1083a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1084a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1085a3d4e20aSJohan Hedberg { 1086a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1087a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1088a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1089a3d4e20aSJohan Hedberg 1090a3d4e20aSJohan Hedberg list_del(&ie->list); 1091a3d4e20aSJohan Hedberg 1092a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1093a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1094a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1095a3d4e20aSJohan Hedberg break; 1096a3d4e20aSJohan Hedberg pos = &p->list; 1097a3d4e20aSJohan Hedberg } 1098a3d4e20aSJohan Hedberg 1099a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1100a3d4e20aSJohan Hedberg } 1101a3d4e20aSJohan Hedberg 1102af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1103af58925cSMarcel Holtmann bool name_known) 11041da177e4SLinus Torvalds { 110530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 110670f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1107af58925cSMarcel Holtmann u32 flags = 0; 11081da177e4SLinus Torvalds 11096ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11101da177e4SLinus Torvalds 11116928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11122b2fec4dSSzymon Janc 1113af58925cSMarcel Holtmann if (!data->ssp_mode) 1114af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1115388fc8faSJohan Hedberg 111670f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1117a3d4e20aSJohan Hedberg if (ie) { 1118af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1119af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1120388fc8faSJohan Hedberg 1121a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1122a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1123a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1124a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1125a3d4e20aSJohan Hedberg } 1126a3d4e20aSJohan Hedberg 1127561aafbcSJohan Hedberg goto update; 1128a3d4e20aSJohan Hedberg } 1129561aafbcSJohan Hedberg 11301da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 113127f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1132af58925cSMarcel Holtmann if (!ie) { 1133af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1134af58925cSMarcel Holtmann goto done; 1135af58925cSMarcel Holtmann } 113670f23020SAndrei Emeltchenko 1137561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1138561aafbcSJohan Hedberg 1139561aafbcSJohan Hedberg if (name_known) { 1140561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1141561aafbcSJohan Hedberg } else { 1142561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1143561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1144561aafbcSJohan Hedberg } 1145561aafbcSJohan Hedberg 1146561aafbcSJohan Hedberg update: 1147561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1148561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1149561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1150561aafbcSJohan Hedberg list_del(&ie->list); 11511da177e4SLinus Torvalds } 11521da177e4SLinus Torvalds 115370f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 115470f23020SAndrei Emeltchenko ie->timestamp = jiffies; 11551da177e4SLinus Torvalds cache->timestamp = jiffies; 11563175405bSJohan Hedberg 11573175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1158af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 11593175405bSJohan Hedberg 1160af58925cSMarcel Holtmann done: 1161af58925cSMarcel Holtmann return flags; 11621da177e4SLinus Torvalds } 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 11651da177e4SLinus Torvalds { 116630883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11671da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 11681da177e4SLinus Torvalds struct inquiry_entry *e; 11691da177e4SLinus Torvalds int copied = 0; 11701da177e4SLinus Torvalds 1171561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11721da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1173b57c1a56SJohan Hedberg 1174b57c1a56SJohan Hedberg if (copied >= num) 1175b57c1a56SJohan Hedberg break; 1176b57c1a56SJohan Hedberg 11771da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 11781da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 11791da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 11801da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 11811da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 11821da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1183b57c1a56SJohan Hedberg 11841da177e4SLinus Torvalds info++; 1185b57c1a56SJohan Hedberg copied++; 11861da177e4SLinus Torvalds } 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 11891da177e4SLinus Torvalds return copied; 11901da177e4SLinus Torvalds } 11911da177e4SLinus Torvalds 1192a1d01db1SJohan Hedberg static int hci_inq_req(struct hci_request *req, unsigned long opt) 11931da177e4SLinus Torvalds { 11941da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 119542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 11961da177e4SLinus Torvalds struct hci_cp_inquiry cp; 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 11991da177e4SLinus Torvalds 12001da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 1201a1d01db1SJohan Hedberg return 0; 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds /* Start Inquiry */ 12041da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12051da177e4SLinus Torvalds cp.length = ir->length; 12061da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 120742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 1208a1d01db1SJohan Hedberg 1209a1d01db1SJohan Hedberg return 0; 12101da177e4SLinus Torvalds } 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12131da177e4SLinus Torvalds { 12141da177e4SLinus Torvalds __u8 __user *ptr = arg; 12151da177e4SLinus Torvalds struct hci_inquiry_req ir; 12161da177e4SLinus Torvalds struct hci_dev *hdev; 12171da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 12181da177e4SLinus Torvalds long timeo; 12191da177e4SLinus Torvalds __u8 *buf; 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12221da177e4SLinus Torvalds return -EFAULT; 12231da177e4SLinus Torvalds 12245a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12255a08ecceSAndrei Emeltchenko if (!hdev) 12261da177e4SLinus Torvalds return -ENODEV; 12271da177e4SLinus Torvalds 1228d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 12290736cfa8SMarcel Holtmann err = -EBUSY; 12300736cfa8SMarcel Holtmann goto done; 12310736cfa8SMarcel Holtmann } 12320736cfa8SMarcel Holtmann 1233d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1234fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1235fee746b0SMarcel Holtmann goto done; 1236fee746b0SMarcel Holtmann } 1237fee746b0SMarcel Holtmann 1238ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 12395b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 12405b69bef5SMarcel Holtmann goto done; 12415b69bef5SMarcel Holtmann } 12425b69bef5SMarcel Holtmann 1243d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 124456f87901SJohan Hedberg err = -EOPNOTSUPP; 124556f87901SJohan Hedberg goto done; 124656f87901SJohan Hedberg } 124756f87901SJohan Hedberg 124809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12491da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1250a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 12511f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 12521da177e4SLinus Torvalds do_inquiry = 1; 12531da177e4SLinus Torvalds } 125409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12551da177e4SLinus Torvalds 125604837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 125770f23020SAndrei Emeltchenko 125870f23020SAndrei Emeltchenko if (do_inquiry) { 125901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 12604ebeee2dSJohan Hedberg timeo, NULL); 126170f23020SAndrei Emeltchenko if (err < 0) 12621da177e4SLinus Torvalds goto done; 12633e13fa1eSAndre Guedes 12643e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 12653e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 12663e13fa1eSAndre Guedes */ 126774316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 12683e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 12693e13fa1eSAndre Guedes return -EINTR; 127070f23020SAndrei Emeltchenko } 12711da177e4SLinus Torvalds 12728fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 12738fc9ced3SGustavo Padovan * 255 entries 12748fc9ced3SGustavo Padovan */ 12751da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 12781da177e4SLinus Torvalds * copy it to the user space. 12791da177e4SLinus Torvalds */ 128070f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 128170f23020SAndrei Emeltchenko if (!buf) { 12821da177e4SLinus Torvalds err = -ENOMEM; 12831da177e4SLinus Torvalds goto done; 12841da177e4SLinus Torvalds } 12851da177e4SLinus Torvalds 128609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12871da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 128809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12891da177e4SLinus Torvalds 12901da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 12911da177e4SLinus Torvalds 12921da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 12931da177e4SLinus Torvalds ptr += sizeof(ir); 12941da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 12951da177e4SLinus Torvalds ir.num_rsp)) 12961da177e4SLinus Torvalds err = -EFAULT; 12971da177e4SLinus Torvalds } else 12981da177e4SLinus Torvalds err = -EFAULT; 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds kfree(buf); 13011da177e4SLinus Torvalds 13021da177e4SLinus Torvalds done: 13031da177e4SLinus Torvalds hci_dev_put(hdev); 13041da177e4SLinus Torvalds return err; 13051da177e4SLinus Torvalds } 13061da177e4SLinus Torvalds 1307cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13081da177e4SLinus Torvalds { 13091da177e4SLinus Torvalds int ret = 0; 13101da177e4SLinus Torvalds 13111da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13121da177e4SLinus Torvalds 1313b504430cSJohan Hedberg hci_req_sync_lock(hdev); 13141da177e4SLinus Torvalds 1315d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNREGISTER)) { 131694324962SJohan Hovold ret = -ENODEV; 131794324962SJohan Hovold goto done; 131894324962SJohan Hovold } 131994324962SJohan Hovold 1320d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1321d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 1322a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1323a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1324bf543036SJohan Hedberg */ 1325d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED)) { 1326611b30f7SMarcel Holtmann ret = -ERFKILL; 1327611b30f7SMarcel Holtmann goto done; 1328611b30f7SMarcel Holtmann } 1329611b30f7SMarcel Holtmann 1330a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1331a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1332a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1333a5c8f270SMarcel Holtmann * or not. 1334a5c8f270SMarcel Holtmann * 1335c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1336c6beca0eSMarcel Holtmann * if a public address or static random address is 1337c6beca0eSMarcel Holtmann * available. 1338c6beca0eSMarcel Holtmann * 1339a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1340a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1341a5c8f270SMarcel Holtmann */ 1342d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1343ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY && 1344a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1345a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1346a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1347a5c8f270SMarcel Holtmann goto done; 1348a5c8f270SMarcel Holtmann } 1349a5c8f270SMarcel Holtmann } 1350a5c8f270SMarcel Holtmann 13511da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 13521da177e4SLinus Torvalds ret = -EALREADY; 13531da177e4SLinus Torvalds goto done; 13541da177e4SLinus Torvalds } 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds if (hdev->open(hdev)) { 13571da177e4SLinus Torvalds ret = -EIO; 13581da177e4SLinus Torvalds goto done; 13591da177e4SLinus Torvalds } 13601da177e4SLinus Torvalds 1361e9ca8bf1SMarcel Holtmann set_bit(HCI_RUNNING, &hdev->flags); 136205fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_OPEN); 13634a3f95b7SMarcel Holtmann 13641da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 13651da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1366f41c70c4SMarcel Holtmann 1367d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_SETUP)) { 1368e131d74aSMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SETUP); 1369e131d74aSMarcel Holtmann 1370af202f84SMarcel Holtmann if (hdev->setup) 1371f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1372f41c70c4SMarcel Holtmann 1373af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1374af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1375af202f84SMarcel Holtmann * 1376af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1377af202f84SMarcel Holtmann * start up as unconfigured. 1378af202f84SMarcel Holtmann */ 1379eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1380eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 1381a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 1382f41c70c4SMarcel Holtmann 13830ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 13840ebca7d6SMarcel Holtmann * read at least the version information provided by 13850ebca7d6SMarcel Holtmann * the Read Local Version Information command. 13860ebca7d6SMarcel Holtmann * 13870ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 13880ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 13890ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 13900ebca7d6SMarcel Holtmann */ 1391d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 13920ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 139389bc22d2SMarcel Holtmann } 139489bc22d2SMarcel Holtmann 1395d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_CONFIG)) { 13969713c17bSMarcel Holtmann /* If public address change is configured, ensure that 13979713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 13989713c17bSMarcel Holtmann * support changing the public address, fail the power 13999713c17bSMarcel Holtmann * on procedure. 140024c457e2SMarcel Holtmann */ 14019713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14029713c17bSMarcel Holtmann hdev->set_bdaddr) 140324c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 140424c457e2SMarcel Holtmann else 140524c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 140624c457e2SMarcel Holtmann } 140724c457e2SMarcel Holtmann 1408f41c70c4SMarcel Holtmann if (!ret) { 1409d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 141098a63aafSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 14112177bab5SJohan Hedberg ret = __hci_init(hdev); 141298a63aafSMarcel Holtmann if (!ret && hdev->post_init) 141398a63aafSMarcel Holtmann ret = hdev->post_init(hdev); 141498a63aafSMarcel Holtmann } 14151da177e4SLinus Torvalds } 14161da177e4SLinus Torvalds 14177e995b9eSMarcel Holtmann /* If the HCI Reset command is clearing all diagnostic settings, 14187e995b9eSMarcel Holtmann * then they need to be reprogrammed after the init procedure 14197e995b9eSMarcel Holtmann * completed. 14207e995b9eSMarcel Holtmann */ 14217e995b9eSMarcel Holtmann if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) && 1422b56c7b25SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 14237e995b9eSMarcel Holtmann hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) && hdev->set_diag) 14247e995b9eSMarcel Holtmann ret = hdev->set_diag(hdev, true); 14257e995b9eSMarcel Holtmann 1426f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1427f41c70c4SMarcel Holtmann 14281da177e4SLinus Torvalds if (!ret) { 14291da177e4SLinus Torvalds hci_dev_hold(hdev); 1430a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RPA_EXPIRED); 14311da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 143205fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UP); 14336d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, true); 1434d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 1435d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG) && 1436d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1437d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 14382ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 1439ca8bee5dSMarcel Holtmann hdev->dev_type == HCI_PRIMARY) { 14402ff13894SJohan Hedberg ret = __hci_req_hci_power_on(hdev); 14412ff13894SJohan Hedberg mgmt_power_on(hdev, ret); 144256e5cb86SJohan Hedberg } 14431da177e4SLinus Torvalds } else { 14441da177e4SLinus Torvalds /* Init failed, cleanup */ 14453eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1446c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1447b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14481da177e4SLinus Torvalds 14491da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14501da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds if (hdev->flush) 14531da177e4SLinus Torvalds hdev->flush(hdev); 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds if (hdev->sent_cmd) { 14561da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 14571da177e4SLinus Torvalds hdev->sent_cmd = NULL; 14581da177e4SLinus Torvalds } 14591da177e4SLinus Torvalds 1460e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 146105fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 14624a3f95b7SMarcel Holtmann 14631da177e4SLinus Torvalds hdev->close(hdev); 1464fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 14651da177e4SLinus Torvalds } 14661da177e4SLinus Torvalds 14671da177e4SLinus Torvalds done: 1468b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 14691da177e4SLinus Torvalds return ret; 14701da177e4SLinus Torvalds } 14711da177e4SLinus Torvalds 1472cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1473cbed0ca1SJohan Hedberg 1474cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1475cbed0ca1SJohan Hedberg { 1476cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1477cbed0ca1SJohan Hedberg int err; 1478cbed0ca1SJohan Hedberg 1479cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1480cbed0ca1SJohan Hedberg if (!hdev) 1481cbed0ca1SJohan Hedberg return -ENODEV; 1482cbed0ca1SJohan Hedberg 14834a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1484fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1485fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1486fee746b0SMarcel Holtmann * possible. 1487fee746b0SMarcel Holtmann * 1488fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1489fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1490fee746b0SMarcel Holtmann * open the device. 1491fee746b0SMarcel Holtmann */ 1492d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) && 1493d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 1494fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1495fee746b0SMarcel Holtmann goto done; 1496fee746b0SMarcel Holtmann } 1497fee746b0SMarcel Holtmann 1498e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1499e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1500e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1501e1d08f40SJohan Hedberg * completed. 1502e1d08f40SJohan Hedberg */ 1503a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 1504e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1505e1d08f40SJohan Hedberg 1506a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1507a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1508a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1509a5c8f270SMarcel Holtmann */ 1510e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1511e1d08f40SJohan Hedberg 151212aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1513b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 151412aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 151512aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 151612aa4f0aSMarcel Holtmann * to explicitly enable it. 151712aa4f0aSMarcel Holtmann */ 1518d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1519d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_MGMT)) 1520a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BONDABLE); 152112aa4f0aSMarcel Holtmann 1522cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1523cbed0ca1SJohan Hedberg 1524fee746b0SMarcel Holtmann done: 1525cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1526cbed0ca1SJohan Hedberg return err; 1527cbed0ca1SJohan Hedberg } 1528cbed0ca1SJohan Hedberg 1529d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1530d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1531d7347f3cSJohan Hedberg { 1532d7347f3cSJohan Hedberg struct hci_conn_params *p; 1533d7347f3cSJohan Hedberg 1534f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1535f161dd41SJohan Hedberg if (p->conn) { 1536f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1537f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1538f161dd41SJohan Hedberg p->conn = NULL; 1539f161dd41SJohan Hedberg } 1540d7347f3cSJohan Hedberg list_del_init(&p->action); 1541f161dd41SJohan Hedberg } 1542d7347f3cSJohan Hedberg 1543d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1544d7347f3cSJohan Hedberg } 1545d7347f3cSJohan Hedberg 15466b3cc1dbSSimon Fels int hci_dev_do_close(struct hci_dev *hdev) 15471da177e4SLinus Torvalds { 1548acc649c6SMarcel Holtmann bool auto_off; 1549acc649c6SMarcel Holtmann 15501da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 15511da177e4SLinus Torvalds 1552d24d8144SGabriele Mazzotta if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && 1553867146a0SLoic Poulain !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 1554d24d8144SGabriele Mazzotta test_bit(HCI_UP, &hdev->flags)) { 1555a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1556a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1557a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1558a44fecbdSTedd Ho-Jeong An } 1559a44fecbdSTedd Ho-Jeong An 156078c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 156178c04c0bSVinicius Costa Gomes 15627df0f73eSJohan Hedberg hci_request_cancel_all(hdev); 1563b504430cSJohan Hedberg hci_req_sync_lock(hdev); 15641da177e4SLinus Torvalds 15651da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 156665cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 1567b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 15681da177e4SLinus Torvalds return 0; 15691da177e4SLinus Torvalds } 15701da177e4SLinus Torvalds 15716d5d2ee6SHeiner Kallweit hci_leds_update_powered(hdev, false); 15726d5d2ee6SHeiner Kallweit 15733eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 15743eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1575b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15761da177e4SLinus Torvalds 157716ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 157816ab91abSJohan Hedberg hdev->discov_timeout = 0; 1579a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_DISCOVERABLE); 1580a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 158116ab91abSJohan Hedberg } 158216ab91abSJohan Hedberg 1583a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) 15847d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 15857d78525dSJohan Hedberg 1586d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_MGMT)) 1587d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 15887ba8b4beSAndre Guedes 158976727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 159076727c02SJohan Hedberg * ensuring the workqueue is empty up front. 159176727c02SJohan Hedberg */ 159276727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 159376727c02SJohan Hedberg 159409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 15951aeb9c65SJohan Hedberg 15968f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 15978f502f84SJohan Hedberg 1598acc649c6SMarcel Holtmann auto_off = hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF); 1599acc649c6SMarcel Holtmann 1600ca8bee5dSMarcel Holtmann if (!auto_off && hdev->dev_type == HCI_PRIMARY && 1601baab7932SMarcel Holtmann !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 16022ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT)) 16032ff13894SJohan Hedberg __mgmt_power_off(hdev); 16041aeb9c65SJohan Hedberg 16051f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1606d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1607f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 160809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16091da177e4SLinus Torvalds 161064dae967SMarcel Holtmann smp_unregister(hdev); 161164dae967SMarcel Holtmann 161205fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_DOWN); 16131da177e4SLinus Torvalds 16141da177e4SLinus Torvalds if (hdev->flush) 16151da177e4SLinus Torvalds hdev->flush(hdev); 16161da177e4SLinus Torvalds 16171da177e4SLinus Torvalds /* Reset device */ 16181da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16191da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 1620acc649c6SMarcel Holtmann if (test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks) && 1621acc649c6SMarcel Holtmann !auto_off && !hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 16221da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 16234ebeee2dSJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT, NULL); 16241da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 16251da177e4SLinus Torvalds } 16261da177e4SLinus Torvalds 1627c347b765SGustavo F. Padovan /* flush cmd work */ 1628c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 16291da177e4SLinus Torvalds 16301da177e4SLinus Torvalds /* Drop queues */ 16311da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16321da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16331da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 16341da177e4SLinus Torvalds 16351da177e4SLinus Torvalds /* Drop last sent command */ 16361da177e4SLinus Torvalds if (hdev->sent_cmd) { 163765cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16381da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16391da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16401da177e4SLinus Torvalds } 16411da177e4SLinus Torvalds 1642e9ca8bf1SMarcel Holtmann clear_bit(HCI_RUNNING, &hdev->flags); 164305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_CLOSE); 16444a3f95b7SMarcel Holtmann 16451da177e4SLinus Torvalds /* After this point our queues are empty 16461da177e4SLinus Torvalds * and no tasks are scheduled. */ 16471da177e4SLinus Torvalds hdev->close(hdev); 16481da177e4SLinus Torvalds 164935b973c9SJohan Hedberg /* Clear flags */ 1650fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 1651eacb44dfSMarcel Holtmann hci_dev_clear_volatile_flags(hdev); 165235b973c9SJohan Hedberg 1653ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1654536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1655ced5c338SAndrei Emeltchenko 1656e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 165709b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 16587a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1659e59fda8dSJohan Hedberg 1660b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 16611da177e4SLinus Torvalds 16621da177e4SLinus Torvalds hci_dev_put(hdev); 16631da177e4SLinus Torvalds return 0; 16641da177e4SLinus Torvalds } 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 16671da177e4SLinus Torvalds { 16681da177e4SLinus Torvalds struct hci_dev *hdev; 16691da177e4SLinus Torvalds int err; 16701da177e4SLinus Torvalds 167170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 167270f23020SAndrei Emeltchenko if (!hdev) 16731da177e4SLinus Torvalds return -ENODEV; 16748ee56540SMarcel Holtmann 1675d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 16760736cfa8SMarcel Holtmann err = -EBUSY; 16770736cfa8SMarcel Holtmann goto done; 16780736cfa8SMarcel Holtmann } 16790736cfa8SMarcel Holtmann 1680a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) 16818ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 16828ee56540SMarcel Holtmann 16831da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 16848ee56540SMarcel Holtmann 16850736cfa8SMarcel Holtmann done: 16861da177e4SLinus Torvalds hci_dev_put(hdev); 16871da177e4SLinus Torvalds return err; 16881da177e4SLinus Torvalds } 16891da177e4SLinus Torvalds 16905c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 16911da177e4SLinus Torvalds { 16925c912495SMarcel Holtmann int ret; 16931da177e4SLinus Torvalds 16945c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 16951da177e4SLinus Torvalds 1696b504430cSJohan Hedberg hci_req_sync_lock(hdev); 16971da177e4SLinus Torvalds 16981da177e4SLinus Torvalds /* Drop queues */ 16991da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17001da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17011da177e4SLinus Torvalds 170276727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 170376727c02SJohan Hedberg * ensuring the workqueue is empty up front. 170476727c02SJohan Hedberg */ 170576727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 170676727c02SJohan Hedberg 170709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17081f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17091da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 171009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17111da177e4SLinus Torvalds 17121da177e4SLinus Torvalds if (hdev->flush) 17131da177e4SLinus Torvalds hdev->flush(hdev); 17141da177e4SLinus Torvalds 17151da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17166ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 17171da177e4SLinus Torvalds 17184ebeee2dSJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT, NULL); 17191da177e4SLinus Torvalds 1720b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 17211da177e4SLinus Torvalds return ret; 17221da177e4SLinus Torvalds } 17231da177e4SLinus Torvalds 17245c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 17255c912495SMarcel Holtmann { 17265c912495SMarcel Holtmann struct hci_dev *hdev; 17275c912495SMarcel Holtmann int err; 17285c912495SMarcel Holtmann 17295c912495SMarcel Holtmann hdev = hci_dev_get(dev); 17305c912495SMarcel Holtmann if (!hdev) 17315c912495SMarcel Holtmann return -ENODEV; 17325c912495SMarcel Holtmann 17335c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 17345c912495SMarcel Holtmann err = -ENETDOWN; 17355c912495SMarcel Holtmann goto done; 17365c912495SMarcel Holtmann } 17375c912495SMarcel Holtmann 1738d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17395c912495SMarcel Holtmann err = -EBUSY; 17405c912495SMarcel Holtmann goto done; 17415c912495SMarcel Holtmann } 17425c912495SMarcel Holtmann 1743d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 17445c912495SMarcel Holtmann err = -EOPNOTSUPP; 17455c912495SMarcel Holtmann goto done; 17465c912495SMarcel Holtmann } 17475c912495SMarcel Holtmann 17485c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 17495c912495SMarcel Holtmann 17505c912495SMarcel Holtmann done: 17515c912495SMarcel Holtmann hci_dev_put(hdev); 17525c912495SMarcel Holtmann return err; 17535c912495SMarcel Holtmann } 17545c912495SMarcel Holtmann 17551da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 17561da177e4SLinus Torvalds { 17571da177e4SLinus Torvalds struct hci_dev *hdev; 17581da177e4SLinus Torvalds int ret = 0; 17591da177e4SLinus Torvalds 176070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 176170f23020SAndrei Emeltchenko if (!hdev) 17621da177e4SLinus Torvalds return -ENODEV; 17631da177e4SLinus Torvalds 1764d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 17650736cfa8SMarcel Holtmann ret = -EBUSY; 17660736cfa8SMarcel Holtmann goto done; 17670736cfa8SMarcel Holtmann } 17680736cfa8SMarcel Holtmann 1769d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1770fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1771fee746b0SMarcel Holtmann goto done; 1772fee746b0SMarcel Holtmann } 1773fee746b0SMarcel Holtmann 17741da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 17751da177e4SLinus Torvalds 17760736cfa8SMarcel Holtmann done: 17771da177e4SLinus Torvalds hci_dev_put(hdev); 17781da177e4SLinus Torvalds return ret; 17791da177e4SLinus Torvalds } 17801da177e4SLinus Torvalds 1781123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1782123abc08SJohan Hedberg { 1783bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1784123abc08SJohan Hedberg 1785123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1786123abc08SJohan Hedberg 1787123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1788238be788SMarcel Holtmann conn_changed = !hci_dev_test_and_set_flag(hdev, 1789238be788SMarcel Holtmann HCI_CONNECTABLE); 1790123abc08SJohan Hedberg else 1791a69d8927SMarcel Holtmann conn_changed = hci_dev_test_and_clear_flag(hdev, 1792a69d8927SMarcel Holtmann HCI_CONNECTABLE); 1793123abc08SJohan Hedberg 1794bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1795238be788SMarcel Holtmann discov_changed = !hci_dev_test_and_set_flag(hdev, 1796238be788SMarcel Holtmann HCI_DISCOVERABLE); 1797bc6d2d04SJohan Hedberg } else { 1798a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE); 1799a69d8927SMarcel Holtmann discov_changed = hci_dev_test_and_clear_flag(hdev, 1800a69d8927SMarcel Holtmann HCI_DISCOVERABLE); 1801bc6d2d04SJohan Hedberg } 1802bc6d2d04SJohan Hedberg 1803d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_MGMT)) 1804123abc08SJohan Hedberg return; 1805123abc08SJohan Hedberg 1806bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1807bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1808a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 1809bc6d2d04SJohan Hedberg 1810d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_LE_ENABLED)) 1811cab054abSJohan Hedberg hci_req_update_adv_data(hdev, hdev->cur_adv_instance); 1812bc6d2d04SJohan Hedberg 1813123abc08SJohan Hedberg mgmt_new_settings(hdev); 1814123abc08SJohan Hedberg } 1815bc6d2d04SJohan Hedberg } 1816123abc08SJohan Hedberg 18171da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 18181da177e4SLinus Torvalds { 18191da177e4SLinus Torvalds struct hci_dev *hdev; 18201da177e4SLinus Torvalds struct hci_dev_req dr; 18211da177e4SLinus Torvalds int err = 0; 18221da177e4SLinus Torvalds 18231da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 18241da177e4SLinus Torvalds return -EFAULT; 18251da177e4SLinus Torvalds 182670f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 182770f23020SAndrei Emeltchenko if (!hdev) 18281da177e4SLinus Torvalds return -ENODEV; 18291da177e4SLinus Torvalds 1830d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 18310736cfa8SMarcel Holtmann err = -EBUSY; 18320736cfa8SMarcel Holtmann goto done; 18330736cfa8SMarcel Holtmann } 18340736cfa8SMarcel Holtmann 1835d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 1836fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1837fee746b0SMarcel Holtmann goto done; 1838fee746b0SMarcel Holtmann } 1839fee746b0SMarcel Holtmann 1840ca8bee5dSMarcel Holtmann if (hdev->dev_type != HCI_PRIMARY) { 18415b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 18425b69bef5SMarcel Holtmann goto done; 18435b69bef5SMarcel Holtmann } 18445b69bef5SMarcel Holtmann 1845d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) { 184656f87901SJohan Hedberg err = -EOPNOTSUPP; 184756f87901SJohan Hedberg goto done; 184856f87901SJohan Hedberg } 184956f87901SJohan Hedberg 18501da177e4SLinus Torvalds switch (cmd) { 18511da177e4SLinus Torvalds case HCISETAUTH: 185201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18534ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18541da177e4SLinus Torvalds break; 18551da177e4SLinus Torvalds 18561da177e4SLinus Torvalds case HCISETENCRYPT: 18571da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 18581da177e4SLinus Torvalds err = -EOPNOTSUPP; 18591da177e4SLinus Torvalds break; 18601da177e4SLinus Torvalds } 18611da177e4SLinus Torvalds 18621da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 18631da177e4SLinus Torvalds /* Auth must be enabled first */ 186401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18654ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18661da177e4SLinus Torvalds if (err) 18671da177e4SLinus Torvalds break; 18681da177e4SLinus Torvalds } 18691da177e4SLinus Torvalds 187001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 18714ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18721da177e4SLinus Torvalds break; 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds case HCISETSCAN: 187501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 18764ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 187791a668b0SJohan Hedberg 1878bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1879bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 188091a668b0SJohan Hedberg */ 1881123abc08SJohan Hedberg if (!err) 1882123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 18831da177e4SLinus Torvalds break; 18841da177e4SLinus Torvalds 18851da177e4SLinus Torvalds case HCISETLINKPOL: 188601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 18874ebeee2dSJohan Hedberg HCI_INIT_TIMEOUT, NULL); 18881da177e4SLinus Torvalds break; 18891da177e4SLinus Torvalds 18901da177e4SLinus Torvalds case HCISETLINKMODE: 1891e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1892e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1893e4e8e37cSMarcel Holtmann break; 1894e4e8e37cSMarcel Holtmann 1895e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1896e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 18971da177e4SLinus Torvalds break; 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds case HCISETACLMTU: 19001da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 19011da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 19021da177e4SLinus Torvalds break; 19031da177e4SLinus Torvalds 19041da177e4SLinus Torvalds case HCISETSCOMTU: 19051da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 19061da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 19071da177e4SLinus Torvalds break; 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds default: 19101da177e4SLinus Torvalds err = -EINVAL; 19111da177e4SLinus Torvalds break; 19121da177e4SLinus Torvalds } 1913e4e8e37cSMarcel Holtmann 19140736cfa8SMarcel Holtmann done: 19151da177e4SLinus Torvalds hci_dev_put(hdev); 19161da177e4SLinus Torvalds return err; 19171da177e4SLinus Torvalds } 19181da177e4SLinus Torvalds 19191da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 19201da177e4SLinus Torvalds { 19218035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 19221da177e4SLinus Torvalds struct hci_dev_list_req *dl; 19231da177e4SLinus Torvalds struct hci_dev_req *dr; 19241da177e4SLinus Torvalds int n = 0, size, err; 19251da177e4SLinus Torvalds __u16 dev_num; 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 19281da177e4SLinus Torvalds return -EFAULT; 19291da177e4SLinus Torvalds 19301da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 19311da177e4SLinus Torvalds return -EINVAL; 19321da177e4SLinus Torvalds 19331da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 19341da177e4SLinus Torvalds 193570f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 193670f23020SAndrei Emeltchenko if (!dl) 19371da177e4SLinus Torvalds return -ENOMEM; 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds dr = dl->dev_req; 19401da177e4SLinus Torvalds 1941f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 19428035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 19432e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 1944c542a06cSJohan Hedberg 19452e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19462e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19472e84d8dbSMarcel Holtmann * device is actually down. 19482e84d8dbSMarcel Holtmann */ 1949d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 19502e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 1951c542a06cSJohan Hedberg 19521da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 19532e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 1954c542a06cSJohan Hedberg 19551da177e4SLinus Torvalds if (++n >= dev_num) 19561da177e4SLinus Torvalds break; 19571da177e4SLinus Torvalds } 1958f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 19591da177e4SLinus Torvalds 19601da177e4SLinus Torvalds dl->dev_num = n; 19611da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 19621da177e4SLinus Torvalds 19631da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 19641da177e4SLinus Torvalds kfree(dl); 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds return err ? -EFAULT : 0; 19671da177e4SLinus Torvalds } 19681da177e4SLinus Torvalds 19691da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 19701da177e4SLinus Torvalds { 19711da177e4SLinus Torvalds struct hci_dev *hdev; 19721da177e4SLinus Torvalds struct hci_dev_info di; 19732e84d8dbSMarcel Holtmann unsigned long flags; 19741da177e4SLinus Torvalds int err = 0; 19751da177e4SLinus Torvalds 19761da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 19771da177e4SLinus Torvalds return -EFAULT; 19781da177e4SLinus Torvalds 197970f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 198070f23020SAndrei Emeltchenko if (!hdev) 19811da177e4SLinus Torvalds return -ENODEV; 19821da177e4SLinus Torvalds 19832e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19842e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19852e84d8dbSMarcel Holtmann * device is actually down. 19862e84d8dbSMarcel Holtmann */ 1987d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) 19882e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 19892e84d8dbSMarcel Holtmann else 19902e84d8dbSMarcel Holtmann flags = hdev->flags; 1991c542a06cSJohan Hedberg 19921da177e4SLinus Torvalds strcpy(di.name, hdev->name); 19931da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 199460f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 19952e84d8dbSMarcel Holtmann di.flags = flags; 19961da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 1997572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 19981da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 19991da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 20001da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 20011da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2002572c7f84SJohan Hedberg } else { 2003572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2004572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2005572c7f84SJohan Hedberg di.sco_mtu = 0; 2006572c7f84SJohan Hedberg di.sco_pkts = 0; 2007572c7f84SJohan Hedberg } 20081da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 20091da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 20121da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 20131da177e4SLinus Torvalds 20141da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 20151da177e4SLinus Torvalds err = -EFAULT; 20161da177e4SLinus Torvalds 20171da177e4SLinus Torvalds hci_dev_put(hdev); 20181da177e4SLinus Torvalds 20191da177e4SLinus Torvalds return err; 20201da177e4SLinus Torvalds } 20211da177e4SLinus Torvalds 20221da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 20231da177e4SLinus Torvalds 2024611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2025611b30f7SMarcel Holtmann { 2026611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2027611b30f7SMarcel Holtmann 2028611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2029611b30f7SMarcel Holtmann 2030d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) 20310736cfa8SMarcel Holtmann return -EBUSY; 20320736cfa8SMarcel Holtmann 20335e130367SJohan Hedberg if (blocked) { 2034a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 2035d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_SETUP) && 2036d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) 2037611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 20385e130367SJohan Hedberg } else { 2039a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_RFKILLED); 20405e130367SJohan Hedberg } 2041611b30f7SMarcel Holtmann 2042611b30f7SMarcel Holtmann return 0; 2043611b30f7SMarcel Holtmann } 2044611b30f7SMarcel Holtmann 2045611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2046611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2047611b30f7SMarcel Holtmann }; 2048611b30f7SMarcel Holtmann 2049ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2050ab81cbf9SJohan Hedberg { 2051ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 205296570ffcSJohan Hedberg int err; 2053ab81cbf9SJohan Hedberg 2054ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2055ab81cbf9SJohan Hedberg 20562ff13894SJohan Hedberg if (test_bit(HCI_UP, &hdev->flags) && 20572ff13894SJohan Hedberg hci_dev_test_flag(hdev, HCI_MGMT) && 20582ff13894SJohan Hedberg hci_dev_test_and_clear_flag(hdev, HCI_AUTO_OFF)) { 2059d82142a8SWei-Ning Huang cancel_delayed_work(&hdev->power_off); 20602ff13894SJohan Hedberg hci_req_sync_lock(hdev); 20612ff13894SJohan Hedberg err = __hci_req_hci_power_on(hdev); 20622ff13894SJohan Hedberg hci_req_sync_unlock(hdev); 20632ff13894SJohan Hedberg mgmt_power_on(hdev, err); 20642ff13894SJohan Hedberg return; 20652ff13894SJohan Hedberg } 20662ff13894SJohan Hedberg 2067cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 206896570ffcSJohan Hedberg if (err < 0) { 20693ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 207096570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 20713ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2072ab81cbf9SJohan Hedberg return; 207396570ffcSJohan Hedberg } 2074ab81cbf9SJohan Hedberg 2075a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2076a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2077a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2078a5c8f270SMarcel Holtmann */ 2079d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_RFKILLED) || 2080d7a5a11dSMarcel Holtmann hci_dev_test_flag(hdev, HCI_UNCONFIGURED) || 2081ca8bee5dSMarcel Holtmann (hdev->dev_type == HCI_PRIMARY && 2082a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2083a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2084a358dc11SMarcel Holtmann hci_dev_clear_flag(hdev, HCI_AUTO_OFF); 2085bf543036SJohan Hedberg hci_dev_do_close(hdev); 2086d7a5a11dSMarcel Holtmann } else if (hci_dev_test_flag(hdev, HCI_AUTO_OFF)) { 208719202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 208819202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2089bf543036SJohan Hedberg } 2090ab81cbf9SJohan Hedberg 2091a69d8927SMarcel Holtmann if (hci_dev_test_and_clear_flag(hdev, HCI_SETUP)) { 20924a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 20934a964404SMarcel Holtmann * so that userspace can easily identify them. 20944a964404SMarcel Holtmann */ 2095d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 20964a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 20970602a8adSMarcel Holtmann 20980602a8adSMarcel Holtmann /* For fully configured devices, this will send 20990602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 21000602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 21010602a8adSMarcel Holtmann * 21020602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 21030602a8adSMarcel Holtmann * and no event will be send. 21040602a8adSMarcel Holtmann */ 2105744cf19eSJohan Hedberg mgmt_index_added(hdev); 2106a69d8927SMarcel Holtmann } else if (hci_dev_test_and_clear_flag(hdev, HCI_CONFIG)) { 21075ea234d3SMarcel Holtmann /* When the controller is now configured, then it 21085ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 21095ea234d3SMarcel Holtmann */ 2110d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) 21115ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 21125ea234d3SMarcel Holtmann 2113d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2114d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2115d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2116d603b76bSMarcel Holtmann */ 2117d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2118ab81cbf9SJohan Hedberg } 2119ab81cbf9SJohan Hedberg } 2120ab81cbf9SJohan Hedberg 2121ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2122ab81cbf9SJohan Hedberg { 21233243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 21243243553fSJohan Hedberg power_off.work); 2125ab81cbf9SJohan Hedberg 2126ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2127ab81cbf9SJohan Hedberg 21288ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2129ab81cbf9SJohan Hedberg } 2130ab81cbf9SJohan Hedberg 2131c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2132c7741d16SMarcel Holtmann { 2133c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2134c7741d16SMarcel Holtmann 2135c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2136c7741d16SMarcel Holtmann 2137c7741d16SMarcel Holtmann if (hdev->hw_error) 2138c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2139c7741d16SMarcel Holtmann else 2140c7741d16SMarcel Holtmann BT_ERR("%s hardware error 0x%2.2x", hdev->name, 2141c7741d16SMarcel Holtmann hdev->hw_error_code); 2142c7741d16SMarcel Holtmann 2143c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2144c7741d16SMarcel Holtmann return; 2145c7741d16SMarcel Holtmann 2146c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2147c7741d16SMarcel Holtmann } 2148c7741d16SMarcel Holtmann 214935f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 21502aeb9a1aSJohan Hedberg { 21514821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 21522aeb9a1aSJohan Hedberg 21534821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 21544821002cSJohan Hedberg list_del(&uuid->list); 21552aeb9a1aSJohan Hedberg kfree(uuid); 21562aeb9a1aSJohan Hedberg } 21572aeb9a1aSJohan Hedberg } 21582aeb9a1aSJohan Hedberg 215935f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 216055ed8ca1SJohan Hedberg { 216155ed8ca1SJohan Hedberg struct link_key *key; 216255ed8ca1SJohan Hedberg 21630378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 21640378b597SJohan Hedberg list_del_rcu(&key->list); 21650378b597SJohan Hedberg kfree_rcu(key, rcu); 216655ed8ca1SJohan Hedberg } 216755ed8ca1SJohan Hedberg } 216855ed8ca1SJohan Hedberg 216935f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2170b899efafSVinicius Costa Gomes { 2171970d0f1bSJohan Hedberg struct smp_ltk *k; 2172b899efafSVinicius Costa Gomes 2173970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2174970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2175970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2176b899efafSVinicius Costa Gomes } 2177b899efafSVinicius Costa Gomes } 2178b899efafSVinicius Costa Gomes 2179970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2180970c4e46SJohan Hedberg { 2181adae20cbSJohan Hedberg struct smp_irk *k; 2182970c4e46SJohan Hedberg 2183adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2184adae20cbSJohan Hedberg list_del_rcu(&k->list); 2185adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2186970c4e46SJohan Hedberg } 2187970c4e46SJohan Hedberg } 2188970c4e46SJohan Hedberg 218955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 219055ed8ca1SJohan Hedberg { 219155ed8ca1SJohan Hedberg struct link_key *k; 219255ed8ca1SJohan Hedberg 21930378b597SJohan Hedberg rcu_read_lock(); 21940378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 21950378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 21960378b597SJohan Hedberg rcu_read_unlock(); 219755ed8ca1SJohan Hedberg return k; 21980378b597SJohan Hedberg } 21990378b597SJohan Hedberg } 22000378b597SJohan Hedberg rcu_read_unlock(); 220155ed8ca1SJohan Hedberg 220255ed8ca1SJohan Hedberg return NULL; 220355ed8ca1SJohan Hedberg } 220455ed8ca1SJohan Hedberg 2205745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2206d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2207d25e28abSJohan Hedberg { 2208d25e28abSJohan Hedberg /* Legacy key */ 2209d25e28abSJohan Hedberg if (key_type < 0x03) 2210745c0ce3SVishal Agarwal return true; 2211d25e28abSJohan Hedberg 2212d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2213d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2214745c0ce3SVishal Agarwal return false; 2215d25e28abSJohan Hedberg 2216d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2217d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2218745c0ce3SVishal Agarwal return false; 2219d25e28abSJohan Hedberg 2220d25e28abSJohan Hedberg /* Security mode 3 case */ 2221d25e28abSJohan Hedberg if (!conn) 2222745c0ce3SVishal Agarwal return true; 2223d25e28abSJohan Hedberg 2224e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2225e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2226e3befab9SJohan Hedberg return true; 2227e3befab9SJohan Hedberg 2228d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2229d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2230745c0ce3SVishal Agarwal return true; 2231d25e28abSJohan Hedberg 2232d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2233d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2234745c0ce3SVishal Agarwal return true; 2235d25e28abSJohan Hedberg 2236d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2237d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2238745c0ce3SVishal Agarwal return true; 2239d25e28abSJohan Hedberg 2240d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2241d25e28abSJohan Hedberg * persistently */ 2242745c0ce3SVishal Agarwal return false; 2243d25e28abSJohan Hedberg } 2244d25e28abSJohan Hedberg 2245e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 224698a0b845SJohan Hedberg { 2247e804d25dSJohan Hedberg if (type == SMP_LTK) 2248e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 224998a0b845SJohan Hedberg 2250e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 225198a0b845SJohan Hedberg } 225298a0b845SJohan Hedberg 2253f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2254e804d25dSJohan Hedberg u8 addr_type, u8 role) 225575d262c2SVinicius Costa Gomes { 2256c9839a11SVinicius Costa Gomes struct smp_ltk *k; 225775d262c2SVinicius Costa Gomes 2258970d0f1bSJohan Hedberg rcu_read_lock(); 2259970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 22605378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 22615378bc56SJohan Hedberg continue; 22625378bc56SJohan Hedberg 2263923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2264970d0f1bSJohan Hedberg rcu_read_unlock(); 226575d262c2SVinicius Costa Gomes return k; 2266970d0f1bSJohan Hedberg } 2267970d0f1bSJohan Hedberg } 2268970d0f1bSJohan Hedberg rcu_read_unlock(); 226975d262c2SVinicius Costa Gomes 227075d262c2SVinicius Costa Gomes return NULL; 227175d262c2SVinicius Costa Gomes } 227275d262c2SVinicius Costa Gomes 2273970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2274970c4e46SJohan Hedberg { 2275970c4e46SJohan Hedberg struct smp_irk *irk; 2276970c4e46SJohan Hedberg 2277adae20cbSJohan Hedberg rcu_read_lock(); 2278adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2279adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2280adae20cbSJohan Hedberg rcu_read_unlock(); 2281970c4e46SJohan Hedberg return irk; 2282970c4e46SJohan Hedberg } 2283adae20cbSJohan Hedberg } 2284970c4e46SJohan Hedberg 2285adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2286defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2287970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2288adae20cbSJohan Hedberg rcu_read_unlock(); 2289970c4e46SJohan Hedberg return irk; 2290970c4e46SJohan Hedberg } 2291970c4e46SJohan Hedberg } 2292adae20cbSJohan Hedberg rcu_read_unlock(); 2293970c4e46SJohan Hedberg 2294970c4e46SJohan Hedberg return NULL; 2295970c4e46SJohan Hedberg } 2296970c4e46SJohan Hedberg 2297970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2298970c4e46SJohan Hedberg u8 addr_type) 2299970c4e46SJohan Hedberg { 2300970c4e46SJohan Hedberg struct smp_irk *irk; 2301970c4e46SJohan Hedberg 23026cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 23036cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 23046cfc9988SJohan Hedberg return NULL; 23056cfc9988SJohan Hedberg 2306adae20cbSJohan Hedberg rcu_read_lock(); 2307adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2308970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2309adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2310adae20cbSJohan Hedberg rcu_read_unlock(); 2311970c4e46SJohan Hedberg return irk; 2312970c4e46SJohan Hedberg } 2313adae20cbSJohan Hedberg } 2314adae20cbSJohan Hedberg rcu_read_unlock(); 2315970c4e46SJohan Hedberg 2316970c4e46SJohan Hedberg return NULL; 2317970c4e46SJohan Hedberg } 2318970c4e46SJohan Hedberg 2319567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 23207652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 23217652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 232255ed8ca1SJohan Hedberg { 232355ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2324745c0ce3SVishal Agarwal u8 old_key_type; 232555ed8ca1SJohan Hedberg 232655ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 232755ed8ca1SJohan Hedberg if (old_key) { 232855ed8ca1SJohan Hedberg old_key_type = old_key->type; 232955ed8ca1SJohan Hedberg key = old_key; 233055ed8ca1SJohan Hedberg } else { 233112adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 23320a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 233355ed8ca1SJohan Hedberg if (!key) 2334567fa2aaSJohan Hedberg return NULL; 23350378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 233655ed8ca1SJohan Hedberg } 233755ed8ca1SJohan Hedberg 23386ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 233955ed8ca1SJohan Hedberg 2340d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2341d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2342d25e28abSJohan Hedberg * previous key */ 2343d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2344a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2345d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2346655fe6ecSJohan Hedberg if (conn) 2347655fe6ecSJohan Hedberg conn->key_type = type; 2348655fe6ecSJohan Hedberg } 2349d25e28abSJohan Hedberg 235055ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 23519b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 235255ed8ca1SJohan Hedberg key->pin_len = pin_len; 235355ed8ca1SJohan Hedberg 2354b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 235555ed8ca1SJohan Hedberg key->type = old_key_type; 23564748fed2SJohan Hedberg else 23574748fed2SJohan Hedberg key->type = type; 23584748fed2SJohan Hedberg 23597652ff6aSJohan Hedberg if (persistent) 23607652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 23617652ff6aSJohan Hedberg old_key_type); 23624df378a1SJohan Hedberg 2363567fa2aaSJohan Hedberg return key; 236455ed8ca1SJohan Hedberg } 236555ed8ca1SJohan Hedberg 2366ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 236735d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2368fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 236975d262c2SVinicius Costa Gomes { 2370c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2371e804d25dSJohan Hedberg u8 role = ltk_role(type); 237275d262c2SVinicius Costa Gomes 2373f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2374c9839a11SVinicius Costa Gomes if (old_key) 237575d262c2SVinicius Costa Gomes key = old_key; 2376c9839a11SVinicius Costa Gomes else { 23770a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 237875d262c2SVinicius Costa Gomes if (!key) 2379ca9142b8SJohan Hedberg return NULL; 2380970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 238175d262c2SVinicius Costa Gomes } 238275d262c2SVinicius Costa Gomes 238375d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2384c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2385c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2386c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2387c9839a11SVinicius Costa Gomes key->ediv = ediv; 2388fe39c7b2SMarcel Holtmann key->rand = rand; 2389c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2390c9839a11SVinicius Costa Gomes key->type = type; 239175d262c2SVinicius Costa Gomes 2392ca9142b8SJohan Hedberg return key; 239375d262c2SVinicius Costa Gomes } 239475d262c2SVinicius Costa Gomes 2395ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2396ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2397970c4e46SJohan Hedberg { 2398970c4e46SJohan Hedberg struct smp_irk *irk; 2399970c4e46SJohan Hedberg 2400970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2401970c4e46SJohan Hedberg if (!irk) { 2402970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2403970c4e46SJohan Hedberg if (!irk) 2404ca9142b8SJohan Hedberg return NULL; 2405970c4e46SJohan Hedberg 2406970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2407970c4e46SJohan Hedberg irk->addr_type = addr_type; 2408970c4e46SJohan Hedberg 2409adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2410970c4e46SJohan Hedberg } 2411970c4e46SJohan Hedberg 2412970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2413970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2414970c4e46SJohan Hedberg 2415ca9142b8SJohan Hedberg return irk; 2416970c4e46SJohan Hedberg } 2417970c4e46SJohan Hedberg 241855ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 241955ed8ca1SJohan Hedberg { 242055ed8ca1SJohan Hedberg struct link_key *key; 242155ed8ca1SJohan Hedberg 242255ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 242355ed8ca1SJohan Hedberg if (!key) 242455ed8ca1SJohan Hedberg return -ENOENT; 242555ed8ca1SJohan Hedberg 24266ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 242755ed8ca1SJohan Hedberg 24280378b597SJohan Hedberg list_del_rcu(&key->list); 24290378b597SJohan Hedberg kfree_rcu(key, rcu); 243055ed8ca1SJohan Hedberg 243155ed8ca1SJohan Hedberg return 0; 243255ed8ca1SJohan Hedberg } 243355ed8ca1SJohan Hedberg 2434e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2435b899efafSVinicius Costa Gomes { 2436970d0f1bSJohan Hedberg struct smp_ltk *k; 2437c51ffa0bSJohan Hedberg int removed = 0; 2438b899efafSVinicius Costa Gomes 2439970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2440e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2441b899efafSVinicius Costa Gomes continue; 2442b899efafSVinicius Costa Gomes 24436ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2444b899efafSVinicius Costa Gomes 2445970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2446970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2447c51ffa0bSJohan Hedberg removed++; 2448b899efafSVinicius Costa Gomes } 2449b899efafSVinicius Costa Gomes 2450c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2451b899efafSVinicius Costa Gomes } 2452b899efafSVinicius Costa Gomes 2453a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2454a7ec7338SJohan Hedberg { 2455adae20cbSJohan Hedberg struct smp_irk *k; 2456a7ec7338SJohan Hedberg 2457adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2458a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2459a7ec7338SJohan Hedberg continue; 2460a7ec7338SJohan Hedberg 2461a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2462a7ec7338SJohan Hedberg 2463adae20cbSJohan Hedberg list_del_rcu(&k->list); 2464adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2465a7ec7338SJohan Hedberg } 2466a7ec7338SJohan Hedberg } 2467a7ec7338SJohan Hedberg 246855e76b38SJohan Hedberg bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 246955e76b38SJohan Hedberg { 247055e76b38SJohan Hedberg struct smp_ltk *k; 24714ba9faf3SJohan Hedberg struct smp_irk *irk; 247255e76b38SJohan Hedberg u8 addr_type; 247355e76b38SJohan Hedberg 247455e76b38SJohan Hedberg if (type == BDADDR_BREDR) { 247555e76b38SJohan Hedberg if (hci_find_link_key(hdev, bdaddr)) 247655e76b38SJohan Hedberg return true; 247755e76b38SJohan Hedberg return false; 247855e76b38SJohan Hedberg } 247955e76b38SJohan Hedberg 248055e76b38SJohan Hedberg /* Convert to HCI addr type which struct smp_ltk uses */ 248155e76b38SJohan Hedberg if (type == BDADDR_LE_PUBLIC) 248255e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_PUBLIC; 248355e76b38SJohan Hedberg else 248455e76b38SJohan Hedberg addr_type = ADDR_LE_DEV_RANDOM; 248555e76b38SJohan Hedberg 24864ba9faf3SJohan Hedberg irk = hci_get_irk(hdev, bdaddr, addr_type); 24874ba9faf3SJohan Hedberg if (irk) { 24884ba9faf3SJohan Hedberg bdaddr = &irk->bdaddr; 24894ba9faf3SJohan Hedberg addr_type = irk->addr_type; 24904ba9faf3SJohan Hedberg } 24914ba9faf3SJohan Hedberg 249255e76b38SJohan Hedberg rcu_read_lock(); 249355e76b38SJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 249487c8b28dSJohan Hedberg if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) { 249587c8b28dSJohan Hedberg rcu_read_unlock(); 249655e76b38SJohan Hedberg return true; 249755e76b38SJohan Hedberg } 249887c8b28dSJohan Hedberg } 249955e76b38SJohan Hedberg rcu_read_unlock(); 250055e76b38SJohan Hedberg 250155e76b38SJohan Hedberg return false; 250255e76b38SJohan Hedberg } 250355e76b38SJohan Hedberg 25046bd32326SVille Tervo /* HCI command timer function */ 250565cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 25066bd32326SVille Tervo { 250765cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 250865cc2b49SMarcel Holtmann cmd_timer.work); 25096bd32326SVille Tervo 2510bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2511bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2512bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2513bda4f23aSAndrei Emeltchenko 2514bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2515bda4f23aSAndrei Emeltchenko } else { 25166bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2517bda4f23aSAndrei Emeltchenko } 2518bda4f23aSAndrei Emeltchenko 25196bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2520c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 25216bd32326SVille Tervo } 25226bd32326SVille Tervo 25232763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 25246928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 25252763eda6SSzymon Janc { 25262763eda6SSzymon Janc struct oob_data *data; 25272763eda6SSzymon Janc 25286928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 25296928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 25306928a924SJohan Hedberg continue; 25316928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 25326928a924SJohan Hedberg continue; 25332763eda6SSzymon Janc return data; 25346928a924SJohan Hedberg } 25352763eda6SSzymon Janc 25362763eda6SSzymon Janc return NULL; 25372763eda6SSzymon Janc } 25382763eda6SSzymon Janc 25396928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25406928a924SJohan Hedberg u8 bdaddr_type) 25412763eda6SSzymon Janc { 25422763eda6SSzymon Janc struct oob_data *data; 25432763eda6SSzymon Janc 25446928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25452763eda6SSzymon Janc if (!data) 25462763eda6SSzymon Janc return -ENOENT; 25472763eda6SSzymon Janc 25486928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 25492763eda6SSzymon Janc 25502763eda6SSzymon Janc list_del(&data->list); 25512763eda6SSzymon Janc kfree(data); 25522763eda6SSzymon Janc 25532763eda6SSzymon Janc return 0; 25542763eda6SSzymon Janc } 25552763eda6SSzymon Janc 255635f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 25572763eda6SSzymon Janc { 25582763eda6SSzymon Janc struct oob_data *data, *n; 25592763eda6SSzymon Janc 25602763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 25612763eda6SSzymon Janc list_del(&data->list); 25622763eda6SSzymon Janc kfree(data); 25632763eda6SSzymon Janc } 25642763eda6SSzymon Janc } 25652763eda6SSzymon Janc 25660798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25676928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 256838da1703SJohan Hedberg u8 *hash256, u8 *rand256) 25690798872eSMarcel Holtmann { 25700798872eSMarcel Holtmann struct oob_data *data; 25710798872eSMarcel Holtmann 25726928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25730798872eSMarcel Holtmann if (!data) { 25740a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 25750798872eSMarcel Holtmann if (!data) 25760798872eSMarcel Holtmann return -ENOMEM; 25770798872eSMarcel Holtmann 25780798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 25796928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 25800798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 25810798872eSMarcel Holtmann } 25820798872eSMarcel Holtmann 258381328d5cSJohan Hedberg if (hash192 && rand192) { 25840798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 258538da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2586f7697b16SMarcel Holtmann if (hash256 && rand256) 2587f7697b16SMarcel Holtmann data->present = 0x03; 258881328d5cSJohan Hedberg } else { 258981328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 259081328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2591f7697b16SMarcel Holtmann if (hash256 && rand256) 2592f7697b16SMarcel Holtmann data->present = 0x02; 2593f7697b16SMarcel Holtmann else 2594f7697b16SMarcel Holtmann data->present = 0x00; 259581328d5cSJohan Hedberg } 25960798872eSMarcel Holtmann 259781328d5cSJohan Hedberg if (hash256 && rand256) { 25980798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 259938da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 260081328d5cSJohan Hedberg } else { 260181328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 260281328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2603f7697b16SMarcel Holtmann if (hash192 && rand192) 2604f7697b16SMarcel Holtmann data->present = 0x01; 260581328d5cSJohan Hedberg } 26060798872eSMarcel Holtmann 26076ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 26082763eda6SSzymon Janc 26092763eda6SSzymon Janc return 0; 26102763eda6SSzymon Janc } 26112763eda6SSzymon Janc 2612d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2613d2609b34SFlorian Grandel struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance) 2614d2609b34SFlorian Grandel { 2615d2609b34SFlorian Grandel struct adv_info *adv_instance; 2616d2609b34SFlorian Grandel 2617d2609b34SFlorian Grandel list_for_each_entry(adv_instance, &hdev->adv_instances, list) { 2618d2609b34SFlorian Grandel if (adv_instance->instance == instance) 2619d2609b34SFlorian Grandel return adv_instance; 2620d2609b34SFlorian Grandel } 2621d2609b34SFlorian Grandel 2622d2609b34SFlorian Grandel return NULL; 2623d2609b34SFlorian Grandel } 2624d2609b34SFlorian Grandel 2625d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 262674b93e9fSPrasanna Karthik struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance) 262774b93e9fSPrasanna Karthik { 2628d2609b34SFlorian Grandel struct adv_info *cur_instance; 2629d2609b34SFlorian Grandel 2630d2609b34SFlorian Grandel cur_instance = hci_find_adv_instance(hdev, instance); 2631d2609b34SFlorian Grandel if (!cur_instance) 2632d2609b34SFlorian Grandel return NULL; 2633d2609b34SFlorian Grandel 2634d2609b34SFlorian Grandel if (cur_instance == list_last_entry(&hdev->adv_instances, 2635d2609b34SFlorian Grandel struct adv_info, list)) 2636d2609b34SFlorian Grandel return list_first_entry(&hdev->adv_instances, 2637d2609b34SFlorian Grandel struct adv_info, list); 2638d2609b34SFlorian Grandel else 2639d2609b34SFlorian Grandel return list_next_entry(cur_instance, list); 2640d2609b34SFlorian Grandel } 2641d2609b34SFlorian Grandel 2642d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2643d2609b34SFlorian Grandel int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance) 2644d2609b34SFlorian Grandel { 2645d2609b34SFlorian Grandel struct adv_info *adv_instance; 2646d2609b34SFlorian Grandel 2647d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2648d2609b34SFlorian Grandel if (!adv_instance) 2649d2609b34SFlorian Grandel return -ENOENT; 2650d2609b34SFlorian Grandel 2651d2609b34SFlorian Grandel BT_DBG("%s removing %dMR", hdev->name, instance); 2652d2609b34SFlorian Grandel 2653cab054abSJohan Hedberg if (hdev->cur_adv_instance == instance) { 2654cab054abSJohan Hedberg if (hdev->adv_instance_timeout) { 26555d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 26565d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 26575d900e46SFlorian Grandel } 2658cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2659cab054abSJohan Hedberg } 26605d900e46SFlorian Grandel 2661d2609b34SFlorian Grandel list_del(&adv_instance->list); 2662d2609b34SFlorian Grandel kfree(adv_instance); 2663d2609b34SFlorian Grandel 2664d2609b34SFlorian Grandel hdev->adv_instance_cnt--; 2665d2609b34SFlorian Grandel 2666d2609b34SFlorian Grandel return 0; 2667d2609b34SFlorian Grandel } 2668d2609b34SFlorian Grandel 2669d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2670d2609b34SFlorian Grandel void hci_adv_instances_clear(struct hci_dev *hdev) 2671d2609b34SFlorian Grandel { 2672d2609b34SFlorian Grandel struct adv_info *adv_instance, *n; 2673d2609b34SFlorian Grandel 26745d900e46SFlorian Grandel if (hdev->adv_instance_timeout) { 26755d900e46SFlorian Grandel cancel_delayed_work(&hdev->adv_instance_expire); 26765d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 26775d900e46SFlorian Grandel } 26785d900e46SFlorian Grandel 2679d2609b34SFlorian Grandel list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) { 2680d2609b34SFlorian Grandel list_del(&adv_instance->list); 2681d2609b34SFlorian Grandel kfree(adv_instance); 2682d2609b34SFlorian Grandel } 2683d2609b34SFlorian Grandel 2684d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2685cab054abSJohan Hedberg hdev->cur_adv_instance = 0x00; 2686d2609b34SFlorian Grandel } 2687d2609b34SFlorian Grandel 2688d2609b34SFlorian Grandel /* This function requires the caller holds hdev->lock */ 2689d2609b34SFlorian Grandel int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags, 2690d2609b34SFlorian Grandel u16 adv_data_len, u8 *adv_data, 2691d2609b34SFlorian Grandel u16 scan_rsp_len, u8 *scan_rsp_data, 2692d2609b34SFlorian Grandel u16 timeout, u16 duration) 2693d2609b34SFlorian Grandel { 2694d2609b34SFlorian Grandel struct adv_info *adv_instance; 2695d2609b34SFlorian Grandel 2696d2609b34SFlorian Grandel adv_instance = hci_find_adv_instance(hdev, instance); 2697d2609b34SFlorian Grandel if (adv_instance) { 2698d2609b34SFlorian Grandel memset(adv_instance->adv_data, 0, 2699d2609b34SFlorian Grandel sizeof(adv_instance->adv_data)); 2700d2609b34SFlorian Grandel memset(adv_instance->scan_rsp_data, 0, 2701d2609b34SFlorian Grandel sizeof(adv_instance->scan_rsp_data)); 2702d2609b34SFlorian Grandel } else { 2703d2609b34SFlorian Grandel if (hdev->adv_instance_cnt >= HCI_MAX_ADV_INSTANCES || 2704d2609b34SFlorian Grandel instance < 1 || instance > HCI_MAX_ADV_INSTANCES) 2705d2609b34SFlorian Grandel return -EOVERFLOW; 2706d2609b34SFlorian Grandel 270739ecfad6SJohan Hedberg adv_instance = kzalloc(sizeof(*adv_instance), GFP_KERNEL); 2708d2609b34SFlorian Grandel if (!adv_instance) 2709d2609b34SFlorian Grandel return -ENOMEM; 2710d2609b34SFlorian Grandel 2711fffd38bcSFlorian Grandel adv_instance->pending = true; 2712d2609b34SFlorian Grandel adv_instance->instance = instance; 2713d2609b34SFlorian Grandel list_add(&adv_instance->list, &hdev->adv_instances); 2714d2609b34SFlorian Grandel hdev->adv_instance_cnt++; 2715d2609b34SFlorian Grandel } 2716d2609b34SFlorian Grandel 2717d2609b34SFlorian Grandel adv_instance->flags = flags; 2718d2609b34SFlorian Grandel adv_instance->adv_data_len = adv_data_len; 2719d2609b34SFlorian Grandel adv_instance->scan_rsp_len = scan_rsp_len; 2720d2609b34SFlorian Grandel 2721d2609b34SFlorian Grandel if (adv_data_len) 2722d2609b34SFlorian Grandel memcpy(adv_instance->adv_data, adv_data, adv_data_len); 2723d2609b34SFlorian Grandel 2724d2609b34SFlorian Grandel if (scan_rsp_len) 2725d2609b34SFlorian Grandel memcpy(adv_instance->scan_rsp_data, 2726d2609b34SFlorian Grandel scan_rsp_data, scan_rsp_len); 2727d2609b34SFlorian Grandel 2728d2609b34SFlorian Grandel adv_instance->timeout = timeout; 27295d900e46SFlorian Grandel adv_instance->remaining_time = timeout; 2730d2609b34SFlorian Grandel 2731d2609b34SFlorian Grandel if (duration == 0) 2732d2609b34SFlorian Grandel adv_instance->duration = HCI_DEFAULT_ADV_DURATION; 2733d2609b34SFlorian Grandel else 2734d2609b34SFlorian Grandel adv_instance->duration = duration; 2735d2609b34SFlorian Grandel 2736d2609b34SFlorian Grandel BT_DBG("%s for %dMR", hdev->name, instance); 2737d2609b34SFlorian Grandel 2738d2609b34SFlorian Grandel return 0; 2739d2609b34SFlorian Grandel } 2740d2609b34SFlorian Grandel 2741dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2742b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2743b2a66aadSAntti Julku { 2744b2a66aadSAntti Julku struct bdaddr_list *b; 2745b2a66aadSAntti Julku 2746dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2747b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2748b2a66aadSAntti Julku return b; 2749b9ee0a78SMarcel Holtmann } 2750b2a66aadSAntti Julku 2751b2a66aadSAntti Julku return NULL; 2752b2a66aadSAntti Julku } 2753b2a66aadSAntti Julku 2754dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2755b2a66aadSAntti Julku { 27567eb7404fSGeliang Tang struct bdaddr_list *b, *n; 2757b2a66aadSAntti Julku 27587eb7404fSGeliang Tang list_for_each_entry_safe(b, n, bdaddr_list, list) { 27597eb7404fSGeliang Tang list_del(&b->list); 2760b2a66aadSAntti Julku kfree(b); 2761b2a66aadSAntti Julku } 2762b2a66aadSAntti Julku } 2763b2a66aadSAntti Julku 2764dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2765b2a66aadSAntti Julku { 2766b2a66aadSAntti Julku struct bdaddr_list *entry; 2767b2a66aadSAntti Julku 2768b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2769b2a66aadSAntti Julku return -EBADF; 2770b2a66aadSAntti Julku 2771dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 27725e762444SAntti Julku return -EEXIST; 2773b2a66aadSAntti Julku 277427f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 27755e762444SAntti Julku if (!entry) 27765e762444SAntti Julku return -ENOMEM; 2777b2a66aadSAntti Julku 2778b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2779b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2780b2a66aadSAntti Julku 2781dcc36c16SJohan Hedberg list_add(&entry->list, list); 2782b2a66aadSAntti Julku 27832a8357f2SJohan Hedberg return 0; 2784b2a66aadSAntti Julku } 2785b2a66aadSAntti Julku 2786dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2787b2a66aadSAntti Julku { 2788b2a66aadSAntti Julku struct bdaddr_list *entry; 2789b2a66aadSAntti Julku 279035f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2791dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 279235f7498aSJohan Hedberg return 0; 279335f7498aSJohan Hedberg } 2794b2a66aadSAntti Julku 2795dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2796d2ab0ac1SMarcel Holtmann if (!entry) 2797d2ab0ac1SMarcel Holtmann return -ENOENT; 2798d2ab0ac1SMarcel Holtmann 2799d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2800d2ab0ac1SMarcel Holtmann kfree(entry); 2801d2ab0ac1SMarcel Holtmann 2802d2ab0ac1SMarcel Holtmann return 0; 2803d2ab0ac1SMarcel Holtmann } 2804d2ab0ac1SMarcel Holtmann 280515819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 280615819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 280715819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 280815819a70SAndre Guedes { 280915819a70SAndre Guedes struct hci_conn_params *params; 281015819a70SAndre Guedes 281115819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 281215819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 281315819a70SAndre Guedes params->addr_type == addr_type) { 281415819a70SAndre Guedes return params; 281515819a70SAndre Guedes } 281615819a70SAndre Guedes } 281715819a70SAndre Guedes 281815819a70SAndre Guedes return NULL; 281915819a70SAndre Guedes } 282015819a70SAndre Guedes 282115819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2822501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 28234b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 282415819a70SAndre Guedes { 2825912b42efSJohan Hedberg struct hci_conn_params *param; 282615819a70SAndre Guedes 2827501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2828912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2829912b42efSJohan Hedberg param->addr_type == addr_type) 2830912b42efSJohan Hedberg return param; 28314b10966fSMarcel Holtmann } 28324b10966fSMarcel Holtmann 28334b10966fSMarcel Holtmann return NULL; 283415819a70SAndre Guedes } 283515819a70SAndre Guedes 283615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 283751d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 283851d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 283915819a70SAndre Guedes { 284015819a70SAndre Guedes struct hci_conn_params *params; 284115819a70SAndre Guedes 284215819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2843cef952ceSAndre Guedes if (params) 284451d167c0SMarcel Holtmann return params; 284515819a70SAndre Guedes 284615819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 284715819a70SAndre Guedes if (!params) { 284815819a70SAndre Guedes BT_ERR("Out of memory"); 284951d167c0SMarcel Holtmann return NULL; 285015819a70SAndre Guedes } 285115819a70SAndre Guedes 285215819a70SAndre Guedes bacpy(¶ms->addr, addr); 285315819a70SAndre Guedes params->addr_type = addr_type; 2854cef952ceSAndre Guedes 2855cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 285693450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2857cef952ceSAndre Guedes 2858bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2859bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2860bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2861bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2862bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2863bf5b3c8bSMarcel Holtmann 2864bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2865bf5b3c8bSMarcel Holtmann 286651d167c0SMarcel Holtmann return params; 2867bf5b3c8bSMarcel Holtmann } 2868bf5b3c8bSMarcel Holtmann 2869f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2870f6c63249SJohan Hedberg { 2871f6c63249SJohan Hedberg if (params->conn) { 2872f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2873f6c63249SJohan Hedberg hci_conn_put(params->conn); 2874f6c63249SJohan Hedberg } 2875f6c63249SJohan Hedberg 2876f6c63249SJohan Hedberg list_del(¶ms->action); 2877f6c63249SJohan Hedberg list_del(¶ms->list); 2878f6c63249SJohan Hedberg kfree(params); 2879f6c63249SJohan Hedberg } 2880f6c63249SJohan Hedberg 288115819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 288215819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 288315819a70SAndre Guedes { 288415819a70SAndre Guedes struct hci_conn_params *params; 288515819a70SAndre Guedes 288615819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 288715819a70SAndre Guedes if (!params) 288815819a70SAndre Guedes return; 288915819a70SAndre Guedes 2890f6c63249SJohan Hedberg hci_conn_params_free(params); 289115819a70SAndre Guedes 289295305baaSJohan Hedberg hci_update_background_scan(hdev); 289395305baaSJohan Hedberg 289415819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 289515819a70SAndre Guedes } 289615819a70SAndre Guedes 289715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 289855af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 289915819a70SAndre Guedes { 290015819a70SAndre Guedes struct hci_conn_params *params, *tmp; 290115819a70SAndre Guedes 290215819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 290355af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 290455af49a8SJohan Hedberg continue; 2905f75113a2SJakub Pawlowski 2906f75113a2SJakub Pawlowski /* If trying to estabilish one time connection to disabled 2907f75113a2SJakub Pawlowski * device, leave the params, but mark them as just once. 2908f75113a2SJakub Pawlowski */ 2909f75113a2SJakub Pawlowski if (params->explicit_connect) { 2910f75113a2SJakub Pawlowski params->auto_connect = HCI_AUTO_CONN_EXPLICIT; 2911f75113a2SJakub Pawlowski continue; 2912f75113a2SJakub Pawlowski } 2913f75113a2SJakub Pawlowski 291415819a70SAndre Guedes list_del(¶ms->list); 291515819a70SAndre Guedes kfree(params); 291615819a70SAndre Guedes } 291715819a70SAndre Guedes 291855af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 291955af49a8SJohan Hedberg } 292055af49a8SJohan Hedberg 292155af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 2922030e7f81SJohan Hedberg static void hci_conn_params_clear_all(struct hci_dev *hdev) 292315819a70SAndre Guedes { 292415819a70SAndre Guedes struct hci_conn_params *params, *tmp; 292515819a70SAndre Guedes 2926f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 2927f6c63249SJohan Hedberg hci_conn_params_free(params); 292815819a70SAndre Guedes 292915819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 293015819a70SAndre Guedes } 293115819a70SAndre Guedes 2932a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 2933a1f4c318SJohan Hedberg * 2934a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 2935a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 2936a1f4c318SJohan Hedberg * the static random address. 2937a1f4c318SJohan Hedberg * 2938a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 2939a1f4c318SJohan Hedberg * public address to use the static random address instead. 294050b5b952SMarcel Holtmann * 294150b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 294250b5b952SMarcel Holtmann * userspace has configured a static address, then that address 294350b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 2944a1f4c318SJohan Hedberg */ 2945a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 2946a1f4c318SJohan Hedberg u8 *bdaddr_type) 2947a1f4c318SJohan Hedberg { 2948b7cb93e5SMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) || 294950b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 2950d7a5a11dSMarcel Holtmann (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) && 295150b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 2952a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 2953a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 2954a1f4c318SJohan Hedberg } else { 2955a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 2956a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 2957a1f4c318SJohan Hedberg } 2958a1f4c318SJohan Hedberg } 2959a1f4c318SJohan Hedberg 29609be0dab7SDavid Herrmann /* Alloc HCI device */ 29619be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 29629be0dab7SDavid Herrmann { 29639be0dab7SDavid Herrmann struct hci_dev *hdev; 29649be0dab7SDavid Herrmann 296527f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 29669be0dab7SDavid Herrmann if (!hdev) 29679be0dab7SDavid Herrmann return NULL; 29689be0dab7SDavid Herrmann 2969b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2970b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2971b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2972b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2973b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 297496c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 2975bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2976bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2977d2609b34SFlorian Grandel hdev->adv_instance_cnt = 0; 2978d2609b34SFlorian Grandel hdev->cur_adv_instance = 0x00; 29795d900e46SFlorian Grandel hdev->adv_instance_timeout = 0; 2980b1b813d4SDavid Herrmann 2981b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2982b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2983b1b813d4SDavid Herrmann 29843f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 2985628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 2986628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 2987bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2988bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 2989b48c3b59SJonas Holmberg hdev->le_conn_min_interval = 0x0018; 2990b48c3b59SJonas Holmberg hdev->le_conn_max_interval = 0x0028; 299104fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 299204fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 2993a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 2994a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 2995a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 2996a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 2997a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 2998a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 2999bef64738SMarcel Holtmann 3000d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3001b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 300231ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 300331ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3004d6bfd59cSJohan Hedberg 3005b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3006b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3007b1b813d4SDavid Herrmann 3008b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3009b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 30106659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3011b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3012b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3013b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3014970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3015b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3016d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 301715819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 301877a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 301966f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 30206b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3021d2609b34SFlorian Grandel INIT_LIST_HEAD(&hdev->adv_instances); 3022b1b813d4SDavid Herrmann 3023b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3024b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3025b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3026b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3027c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3028b1b813d4SDavid Herrmann 3029b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3030b1b813d4SDavid Herrmann 3031b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3032b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3033b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3034b1b813d4SDavid Herrmann 3035b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3036b1b813d4SDavid Herrmann 303765cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3038b1b813d4SDavid Herrmann 30395fc16cc4SJohan Hedberg hci_request_setup(hdev); 30405fc16cc4SJohan Hedberg 3041b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3042b1b813d4SDavid Herrmann discovery_init(hdev); 30439be0dab7SDavid Herrmann 30449be0dab7SDavid Herrmann return hdev; 30459be0dab7SDavid Herrmann } 30469be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 30479be0dab7SDavid Herrmann 30489be0dab7SDavid Herrmann /* Free HCI device */ 30499be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 30509be0dab7SDavid Herrmann { 30519be0dab7SDavid Herrmann /* will free via device release */ 30529be0dab7SDavid Herrmann put_device(&hdev->dev); 30539be0dab7SDavid Herrmann } 30549be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 30559be0dab7SDavid Herrmann 30561da177e4SLinus Torvalds /* Register HCI device */ 30571da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 30581da177e4SLinus Torvalds { 3059b1b813d4SDavid Herrmann int id, error; 30601da177e4SLinus Torvalds 306174292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 30621da177e4SLinus Torvalds return -EINVAL; 30631da177e4SLinus Torvalds 306408add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 306508add513SMat Martineau * so the index can be used as the AMP controller ID. 306608add513SMat Martineau */ 30673df92b31SSasha Levin switch (hdev->dev_type) { 3068ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 30693df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 30701da177e4SLinus Torvalds break; 30713df92b31SSasha Levin case HCI_AMP: 30723df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 30733df92b31SSasha Levin break; 30743df92b31SSasha Levin default: 30753df92b31SSasha Levin return -EINVAL; 30761da177e4SLinus Torvalds } 30771da177e4SLinus Torvalds 30783df92b31SSasha Levin if (id < 0) 30793df92b31SSasha Levin return id; 30803df92b31SSasha Levin 30811da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 30821da177e4SLinus Torvalds hdev->id = id; 30832d8b3a11SAndrei Emeltchenko 30842d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 30852d8b3a11SAndrei Emeltchenko 3086d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3087d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 308833ca954dSDavid Herrmann if (!hdev->workqueue) { 308933ca954dSDavid Herrmann error = -ENOMEM; 309033ca954dSDavid Herrmann goto err; 309133ca954dSDavid Herrmann } 3092f48fd9c8SMarcel Holtmann 3093d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3094d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 30956ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 30966ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 30976ead1bbcSJohan Hedberg error = -ENOMEM; 30986ead1bbcSJohan Hedberg goto err; 30996ead1bbcSJohan Hedberg } 31006ead1bbcSJohan Hedberg 31010153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 31020153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 31030153e2ecSMarcel Holtmann 3104bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3105bdc3e0f1SMarcel Holtmann 3106bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 310733ca954dSDavid Herrmann if (error < 0) 310854506918SJohan Hedberg goto err_wqueue; 31091da177e4SLinus Torvalds 31106d5d2ee6SHeiner Kallweit hci_leds_init(hdev); 31116d5d2ee6SHeiner Kallweit 3112611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3113a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3114a8c5fb1aSGustavo Padovan hdev); 3115611b30f7SMarcel Holtmann if (hdev->rfkill) { 3116611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3117611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3118611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3119611b30f7SMarcel Holtmann } 3120611b30f7SMarcel Holtmann } 3121611b30f7SMarcel Holtmann 31225e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 3123a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_RFKILLED); 31245e130367SJohan Hedberg 3125a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_SETUP); 3126a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_AUTO_OFF); 3127ce2be9acSAndrei Emeltchenko 3128ca8bee5dSMarcel Holtmann if (hdev->dev_type == HCI_PRIMARY) { 312956f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 313056f87901SJohan Hedberg * through reading supported features during init. 313156f87901SJohan Hedberg */ 3132a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_BREDR_ENABLED); 313356f87901SJohan Hedberg } 3134ce2be9acSAndrei Emeltchenko 3135fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3136fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3137fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3138fcee3377SGustavo Padovan 31394a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 31404a964404SMarcel Holtmann * and should not be included in normal operation. 3141fee746b0SMarcel Holtmann */ 3142fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3143a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNCONFIGURED); 3144fee746b0SMarcel Holtmann 314505fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_REG); 3146dc946bd8SDavid Herrmann hci_dev_hold(hdev); 31471da177e4SLinus Torvalds 314819202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3149fbe96d6fSMarcel Holtmann 31501da177e4SLinus Torvalds return id; 3151f48fd9c8SMarcel Holtmann 315233ca954dSDavid Herrmann err_wqueue: 315333ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 31546ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 315533ca954dSDavid Herrmann err: 31563df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3157f48fd9c8SMarcel Holtmann 315833ca954dSDavid Herrmann return error; 31591da177e4SLinus Torvalds } 31601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 31611da177e4SLinus Torvalds 31621da177e4SLinus Torvalds /* Unregister HCI device */ 316359735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 31641da177e4SLinus Torvalds { 31652d7cc19eSMarcel Holtmann int id; 3166ef222013SMarcel Holtmann 3167c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 31681da177e4SLinus Torvalds 3169a1536da2SMarcel Holtmann hci_dev_set_flag(hdev, HCI_UNREGISTER); 317094324962SJohan Hovold 31713df92b31SSasha Levin id = hdev->id; 31723df92b31SSasha Levin 3173f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 31741da177e4SLinus Torvalds list_del(&hdev->list); 3175f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 31761da177e4SLinus Torvalds 3177b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3178b9b5ef18SGustavo Padovan 3179bf389cabSJiri Slaby hci_dev_do_close(hdev); 3180bf389cabSJiri Slaby 3181ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3182d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_SETUP) && 3183d7a5a11dSMarcel Holtmann !hci_dev_test_flag(hdev, HCI_CONFIG)) { 318409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3185744cf19eSJohan Hedberg mgmt_index_removed(hdev); 318609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 318756e5cb86SJohan Hedberg } 3188ab81cbf9SJohan Hedberg 31892e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 31902e58ef3eSJohan Hedberg * pending list */ 31912e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 31922e58ef3eSJohan Hedberg 319305fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_UNREG); 31941da177e4SLinus Torvalds 3195611b30f7SMarcel Holtmann if (hdev->rfkill) { 3196611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3197611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3198611b30f7SMarcel Holtmann } 3199611b30f7SMarcel Holtmann 3200bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3201147e2d59SDave Young 32020153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 32035177a838SMarcel Holtmann kfree_const(hdev->hw_info); 32045177a838SMarcel Holtmann kfree_const(hdev->fw_info); 32050153e2ecSMarcel Holtmann 3206f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 32076ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3208f48fd9c8SMarcel Holtmann 320909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3210dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 32116659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 32122aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 321355ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3214b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3215970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 32162763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3217d2609b34SFlorian Grandel hci_adv_instances_clear(hdev); 3218dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3219373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 322022078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 322109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3222e2e0cacbSJohan Hedberg 3223dc946bd8SDavid Herrmann hci_dev_put(hdev); 32243df92b31SSasha Levin 32253df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 32261da177e4SLinus Torvalds } 32271da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 32281da177e4SLinus Torvalds 32291da177e4SLinus Torvalds /* Suspend HCI device */ 32301da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 32311da177e4SLinus Torvalds { 323205fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_SUSPEND); 32331da177e4SLinus Torvalds return 0; 32341da177e4SLinus Torvalds } 32351da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 32361da177e4SLinus Torvalds 32371da177e4SLinus Torvalds /* Resume HCI device */ 32381da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 32391da177e4SLinus Torvalds { 324005fcd4c4SMarcel Holtmann hci_sock_dev_event(hdev, HCI_DEV_RESUME); 32411da177e4SLinus Torvalds return 0; 32421da177e4SLinus Torvalds } 32431da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 32441da177e4SLinus Torvalds 324575e0569fSMarcel Holtmann /* Reset HCI device */ 324675e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 324775e0569fSMarcel Holtmann { 324875e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 324975e0569fSMarcel Holtmann struct sk_buff *skb; 325075e0569fSMarcel Holtmann 325175e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 325275e0569fSMarcel Holtmann if (!skb) 325375e0569fSMarcel Holtmann return -ENOMEM; 325475e0569fSMarcel Holtmann 3255d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 325675e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 325775e0569fSMarcel Holtmann 325875e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 325975e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 326075e0569fSMarcel Holtmann } 326175e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 326275e0569fSMarcel Holtmann 326376bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3264e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 326576bca880SMarcel Holtmann { 326676bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 326776bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 326876bca880SMarcel Holtmann kfree_skb(skb); 326976bca880SMarcel Holtmann return -ENXIO; 327076bca880SMarcel Holtmann } 327176bca880SMarcel Holtmann 3272d79f34e3SMarcel Holtmann if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT && 3273d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT && 3274d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) != HCI_SCODATA_PKT) { 3275fe806dceSMarcel Holtmann kfree_skb(skb); 3276fe806dceSMarcel Holtmann return -EINVAL; 3277fe806dceSMarcel Holtmann } 3278fe806dceSMarcel Holtmann 3279d82603c6SJorrit Schippers /* Incoming skb */ 328076bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 328176bca880SMarcel Holtmann 328276bca880SMarcel Holtmann /* Time stamp */ 328376bca880SMarcel Holtmann __net_timestamp(skb); 328476bca880SMarcel Holtmann 328576bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3286b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3287c78ae283SMarcel Holtmann 328876bca880SMarcel Holtmann return 0; 328976bca880SMarcel Holtmann } 329076bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 329176bca880SMarcel Holtmann 3292e875ff84SMarcel Holtmann /* Receive diagnostic message from HCI drivers */ 3293e875ff84SMarcel Holtmann int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb) 3294e875ff84SMarcel Holtmann { 3295581d6fd6SMarcel Holtmann /* Mark as diagnostic packet */ 3296d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_DIAG_PKT; 3297581d6fd6SMarcel Holtmann 3298e875ff84SMarcel Holtmann /* Time stamp */ 3299e875ff84SMarcel Holtmann __net_timestamp(skb); 3300e875ff84SMarcel Holtmann 3301581d6fd6SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3302581d6fd6SMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3303e875ff84SMarcel Holtmann 3304e875ff84SMarcel Holtmann return 0; 3305e875ff84SMarcel Holtmann } 3306e875ff84SMarcel Holtmann EXPORT_SYMBOL(hci_recv_diag); 3307e875ff84SMarcel Holtmann 33085177a838SMarcel Holtmann void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...) 33095177a838SMarcel Holtmann { 33105177a838SMarcel Holtmann va_list vargs; 33115177a838SMarcel Holtmann 33125177a838SMarcel Holtmann va_start(vargs, fmt); 33135177a838SMarcel Holtmann kfree_const(hdev->hw_info); 33145177a838SMarcel Holtmann hdev->hw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 33155177a838SMarcel Holtmann va_end(vargs); 33165177a838SMarcel Holtmann } 33175177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_hw_info); 33185177a838SMarcel Holtmann 33195177a838SMarcel Holtmann void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...) 33205177a838SMarcel Holtmann { 33215177a838SMarcel Holtmann va_list vargs; 33225177a838SMarcel Holtmann 33235177a838SMarcel Holtmann va_start(vargs, fmt); 33245177a838SMarcel Holtmann kfree_const(hdev->fw_info); 33255177a838SMarcel Holtmann hdev->fw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs); 33265177a838SMarcel Holtmann va_end(vargs); 33275177a838SMarcel Holtmann } 33285177a838SMarcel Holtmann EXPORT_SYMBOL(hci_set_fw_info); 33295177a838SMarcel Holtmann 33301da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 33311da177e4SLinus Torvalds 33321da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 33331da177e4SLinus Torvalds { 33341da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33351da177e4SLinus Torvalds 3336fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 333700629e0fSJohan Hedberg list_add_tail(&cb->list, &hci_cb_list); 3338fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 33391da177e4SLinus Torvalds 33401da177e4SLinus Torvalds return 0; 33411da177e4SLinus Torvalds } 33421da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 33431da177e4SLinus Torvalds 33441da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 33451da177e4SLinus Torvalds { 33461da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33471da177e4SLinus Torvalds 3348fba7ecf0SJohan Hedberg mutex_lock(&hci_cb_list_lock); 33491da177e4SLinus Torvalds list_del(&cb->list); 3350fba7ecf0SJohan Hedberg mutex_unlock(&hci_cb_list_lock); 33511da177e4SLinus Torvalds 33521da177e4SLinus Torvalds return 0; 33531da177e4SLinus Torvalds } 33541da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 33551da177e4SLinus Torvalds 335651086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 33571da177e4SLinus Torvalds { 3358cdc52faaSMarcel Holtmann int err; 3359cdc52faaSMarcel Holtmann 3360d79f34e3SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb), 3361d79f34e3SMarcel Holtmann skb->len); 33621da177e4SLinus Torvalds 33631da177e4SLinus Torvalds /* Time stamp */ 3364a61bbcf2SPatrick McHardy __net_timestamp(skb); 33651da177e4SLinus Torvalds 3366cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3367cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3368cd82e61cSMarcel Holtmann 3369cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3370cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3371470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 33721da177e4SLinus Torvalds } 33731da177e4SLinus Torvalds 33741da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 33751da177e4SLinus Torvalds skb_orphan(skb); 33761da177e4SLinus Torvalds 337773d0d3c8SMarcel Holtmann if (!test_bit(HCI_RUNNING, &hdev->flags)) { 337873d0d3c8SMarcel Holtmann kfree_skb(skb); 337973d0d3c8SMarcel Holtmann return; 338073d0d3c8SMarcel Holtmann } 338173d0d3c8SMarcel Holtmann 3382cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3383cdc52faaSMarcel Holtmann if (err < 0) { 3384cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3385cdc52faaSMarcel Holtmann kfree_skb(skb); 3386cdc52faaSMarcel Holtmann } 33871da177e4SLinus Torvalds } 33881da177e4SLinus Torvalds 33891ca3a9d0SJohan Hedberg /* Send HCI command */ 339007dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 339107dc93ddSJohan Hedberg const void *param) 33921ca3a9d0SJohan Hedberg { 33931ca3a9d0SJohan Hedberg struct sk_buff *skb; 33941ca3a9d0SJohan Hedberg 33951ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 33961ca3a9d0SJohan Hedberg 33971ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 33981ca3a9d0SJohan Hedberg if (!skb) { 33991ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 34001ca3a9d0SJohan Hedberg return -ENOMEM; 34011ca3a9d0SJohan Hedberg } 34021ca3a9d0SJohan Hedberg 340349c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 340411714b3dSJohan Hedberg * single-command requests. 340511714b3dSJohan Hedberg */ 340644d27137SJohan Hedberg bt_cb(skb)->hci.req_flags |= HCI_REQ_START; 340711714b3dSJohan Hedberg 34081da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3409c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 34101da177e4SLinus Torvalds 34111da177e4SLinus Torvalds return 0; 34121da177e4SLinus Torvalds } 34131da177e4SLinus Torvalds 34141da177e4SLinus Torvalds /* Get data from the previously sent command */ 3415a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 34161da177e4SLinus Torvalds { 34171da177e4SLinus Torvalds struct hci_command_hdr *hdr; 34181da177e4SLinus Torvalds 34191da177e4SLinus Torvalds if (!hdev->sent_cmd) 34201da177e4SLinus Torvalds return NULL; 34211da177e4SLinus Torvalds 34221da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 34231da177e4SLinus Torvalds 3424a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 34251da177e4SLinus Torvalds return NULL; 34261da177e4SLinus Torvalds 3427f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 34281da177e4SLinus Torvalds 34291da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 34301da177e4SLinus Torvalds } 34311da177e4SLinus Torvalds 3432fbef168fSLoic Poulain /* Send HCI command and wait for command commplete event */ 3433fbef168fSLoic Poulain struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 3434fbef168fSLoic Poulain const void *param, u32 timeout) 3435fbef168fSLoic Poulain { 3436fbef168fSLoic Poulain struct sk_buff *skb; 3437fbef168fSLoic Poulain 3438fbef168fSLoic Poulain if (!test_bit(HCI_UP, &hdev->flags)) 3439fbef168fSLoic Poulain return ERR_PTR(-ENETDOWN); 3440fbef168fSLoic Poulain 3441fbef168fSLoic Poulain bt_dev_dbg(hdev, "opcode 0x%4.4x plen %d", opcode, plen); 3442fbef168fSLoic Poulain 3443b504430cSJohan Hedberg hci_req_sync_lock(hdev); 3444fbef168fSLoic Poulain skb = __hci_cmd_sync(hdev, opcode, plen, param, timeout); 3445b504430cSJohan Hedberg hci_req_sync_unlock(hdev); 3446fbef168fSLoic Poulain 3447fbef168fSLoic Poulain return skb; 3448fbef168fSLoic Poulain } 3449fbef168fSLoic Poulain EXPORT_SYMBOL(hci_cmd_sync); 3450fbef168fSLoic Poulain 34511da177e4SLinus Torvalds /* Send ACL data */ 34521da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 34531da177e4SLinus Torvalds { 34541da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 34551da177e4SLinus Torvalds int len = skb->len; 34561da177e4SLinus Torvalds 3457badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3458badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 34599c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3460aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3461aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 34621da177e4SLinus Torvalds } 34631da177e4SLinus Torvalds 3464ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 346573d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 34661da177e4SLinus Torvalds { 3467ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 34681da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 34691da177e4SLinus Torvalds struct sk_buff *list; 34701da177e4SLinus Torvalds 3471087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3472087bfd99SGustavo Padovan skb->data_len = 0; 3473087bfd99SGustavo Padovan 3474d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3475204a6e54SAndrei Emeltchenko 3476204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3477ca8bee5dSMarcel Holtmann case HCI_PRIMARY: 3478087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3479204a6e54SAndrei Emeltchenko break; 3480204a6e54SAndrei Emeltchenko case HCI_AMP: 3481204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3482204a6e54SAndrei Emeltchenko break; 3483204a6e54SAndrei Emeltchenko default: 3484204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3485204a6e54SAndrei Emeltchenko return; 3486204a6e54SAndrei Emeltchenko } 3487087bfd99SGustavo Padovan 348870f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 348970f23020SAndrei Emeltchenko if (!list) { 34901da177e4SLinus Torvalds /* Non fragmented */ 34911da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 34921da177e4SLinus Torvalds 349373d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 34941da177e4SLinus Torvalds } else { 34951da177e4SLinus Torvalds /* Fragmented */ 34961da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 34971da177e4SLinus Torvalds 34981da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 34991da177e4SLinus Torvalds 35009cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 35019cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 35029cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 35039cfd5a23SJukka Rissanen * deadlocks. 35049cfd5a23SJukka Rissanen */ 35059cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 35061da177e4SLinus Torvalds 350773d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3508e702112fSAndrei Emeltchenko 3509e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3510e702112fSAndrei Emeltchenko flags |= ACL_CONT; 35111da177e4SLinus Torvalds do { 35121da177e4SLinus Torvalds skb = list; list = list->next; 35131da177e4SLinus Torvalds 3514d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT; 3515e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 35161da177e4SLinus Torvalds 35171da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 35181da177e4SLinus Torvalds 351973d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 35201da177e4SLinus Torvalds } while (list); 35211da177e4SLinus Torvalds 35229cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 35231da177e4SLinus Torvalds } 352473d80debSLuiz Augusto von Dentz } 352573d80debSLuiz Augusto von Dentz 352673d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 352773d80debSLuiz Augusto von Dentz { 3528ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 352973d80debSLuiz Augusto von Dentz 3530f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 353173d80debSLuiz Augusto von Dentz 3532ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 35331da177e4SLinus Torvalds 35343eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35351da177e4SLinus Torvalds } 35361da177e4SLinus Torvalds 35371da177e4SLinus Torvalds /* Send SCO data */ 35380d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 35391da177e4SLinus Torvalds { 35401da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 35411da177e4SLinus Torvalds struct hci_sco_hdr hdr; 35421da177e4SLinus Torvalds 35431da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 35441da177e4SLinus Torvalds 3545aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 35461da177e4SLinus Torvalds hdr.dlen = skb->len; 35471da177e4SLinus Torvalds 3548badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3549badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 35509c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 35511da177e4SLinus Torvalds 3552d79f34e3SMarcel Holtmann hci_skb_pkt_type(skb) = HCI_SCODATA_PKT; 3553c78ae283SMarcel Holtmann 35541da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 35553eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35561da177e4SLinus Torvalds } 35571da177e4SLinus Torvalds 35581da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 35591da177e4SLinus Torvalds 35601da177e4SLinus Torvalds /* HCI Connection scheduler */ 35616039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3562a8c5fb1aSGustavo Padovan int *quote) 35631da177e4SLinus Torvalds { 35641da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 35658035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3566abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 35671da177e4SLinus Torvalds 35681da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 35691da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3570bf4c6325SGustavo F. Padovan 3571bf4c6325SGustavo F. Padovan rcu_read_lock(); 3572bf4c6325SGustavo F. Padovan 3573bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3574769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 35751da177e4SLinus Torvalds continue; 3576769be974SMarcel Holtmann 3577769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3578769be974SMarcel Holtmann continue; 3579769be974SMarcel Holtmann 35801da177e4SLinus Torvalds num++; 35811da177e4SLinus Torvalds 35821da177e4SLinus Torvalds if (c->sent < min) { 35831da177e4SLinus Torvalds min = c->sent; 35841da177e4SLinus Torvalds conn = c; 35851da177e4SLinus Torvalds } 358652087a79SLuiz Augusto von Dentz 358752087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 358852087a79SLuiz Augusto von Dentz break; 35891da177e4SLinus Torvalds } 35901da177e4SLinus Torvalds 3591bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3592bf4c6325SGustavo F. Padovan 35931da177e4SLinus Torvalds if (conn) { 35946ed58ec5SVille Tervo int cnt, q; 35956ed58ec5SVille Tervo 35966ed58ec5SVille Tervo switch (conn->type) { 35976ed58ec5SVille Tervo case ACL_LINK: 35986ed58ec5SVille Tervo cnt = hdev->acl_cnt; 35996ed58ec5SVille Tervo break; 36006ed58ec5SVille Tervo case SCO_LINK: 36016ed58ec5SVille Tervo case ESCO_LINK: 36026ed58ec5SVille Tervo cnt = hdev->sco_cnt; 36036ed58ec5SVille Tervo break; 36046ed58ec5SVille Tervo case LE_LINK: 36056ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 36066ed58ec5SVille Tervo break; 36076ed58ec5SVille Tervo default: 36086ed58ec5SVille Tervo cnt = 0; 36096ed58ec5SVille Tervo BT_ERR("Unknown link type"); 36106ed58ec5SVille Tervo } 36116ed58ec5SVille Tervo 36126ed58ec5SVille Tervo q = cnt / num; 36131da177e4SLinus Torvalds *quote = q ? q : 1; 36141da177e4SLinus Torvalds } else 36151da177e4SLinus Torvalds *quote = 0; 36161da177e4SLinus Torvalds 36171da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 36181da177e4SLinus Torvalds return conn; 36191da177e4SLinus Torvalds } 36201da177e4SLinus Torvalds 36216039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 36221da177e4SLinus Torvalds { 36231da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 36241da177e4SLinus Torvalds struct hci_conn *c; 36251da177e4SLinus Torvalds 3626bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 36271da177e4SLinus Torvalds 3628bf4c6325SGustavo F. Padovan rcu_read_lock(); 3629bf4c6325SGustavo F. Padovan 36301da177e4SLinus Torvalds /* Kill stalled connections */ 3631bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3632bae1f5d9SVille Tervo if (c->type == type && c->sent) { 36336ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 36346ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3635bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 36361da177e4SLinus Torvalds } 36371da177e4SLinus Torvalds } 3638bf4c6325SGustavo F. Padovan 3639bf4c6325SGustavo F. Padovan rcu_read_unlock(); 36401da177e4SLinus Torvalds } 36411da177e4SLinus Torvalds 36426039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 364373d80debSLuiz Augusto von Dentz int *quote) 364473d80debSLuiz Augusto von Dentz { 364573d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 364673d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3647abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 364873d80debSLuiz Augusto von Dentz struct hci_conn *conn; 364973d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 365073d80debSLuiz Augusto von Dentz 365173d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 365273d80debSLuiz Augusto von Dentz 3653bf4c6325SGustavo F. Padovan rcu_read_lock(); 3654bf4c6325SGustavo F. Padovan 3655bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 365673d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 365773d80debSLuiz Augusto von Dentz 365873d80debSLuiz Augusto von Dentz if (conn->type != type) 365973d80debSLuiz Augusto von Dentz continue; 366073d80debSLuiz Augusto von Dentz 366173d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 366273d80debSLuiz Augusto von Dentz continue; 366373d80debSLuiz Augusto von Dentz 366473d80debSLuiz Augusto von Dentz conn_num++; 366573d80debSLuiz Augusto von Dentz 36668192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 366773d80debSLuiz Augusto von Dentz struct sk_buff *skb; 366873d80debSLuiz Augusto von Dentz 366973d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 367073d80debSLuiz Augusto von Dentz continue; 367173d80debSLuiz Augusto von Dentz 367273d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 367373d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 367473d80debSLuiz Augusto von Dentz continue; 367573d80debSLuiz Augusto von Dentz 367673d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 367773d80debSLuiz Augusto von Dentz num = 0; 367873d80debSLuiz Augusto von Dentz min = ~0; 367973d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 368073d80debSLuiz Augusto von Dentz } 368173d80debSLuiz Augusto von Dentz 368273d80debSLuiz Augusto von Dentz num++; 368373d80debSLuiz Augusto von Dentz 368473d80debSLuiz Augusto von Dentz if (conn->sent < min) { 368573d80debSLuiz Augusto von Dentz min = conn->sent; 368673d80debSLuiz Augusto von Dentz chan = tmp; 368773d80debSLuiz Augusto von Dentz } 368873d80debSLuiz Augusto von Dentz } 368973d80debSLuiz Augusto von Dentz 369073d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 369173d80debSLuiz Augusto von Dentz break; 369273d80debSLuiz Augusto von Dentz } 369373d80debSLuiz Augusto von Dentz 3694bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3695bf4c6325SGustavo F. Padovan 369673d80debSLuiz Augusto von Dentz if (!chan) 369773d80debSLuiz Augusto von Dentz return NULL; 369873d80debSLuiz Augusto von Dentz 369973d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 370073d80debSLuiz Augusto von Dentz case ACL_LINK: 370173d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 370273d80debSLuiz Augusto von Dentz break; 3703bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3704bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3705bd1eb66bSAndrei Emeltchenko break; 370673d80debSLuiz Augusto von Dentz case SCO_LINK: 370773d80debSLuiz Augusto von Dentz case ESCO_LINK: 370873d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 370973d80debSLuiz Augusto von Dentz break; 371073d80debSLuiz Augusto von Dentz case LE_LINK: 371173d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 371273d80debSLuiz Augusto von Dentz break; 371373d80debSLuiz Augusto von Dentz default: 371473d80debSLuiz Augusto von Dentz cnt = 0; 371573d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 371673d80debSLuiz Augusto von Dentz } 371773d80debSLuiz Augusto von Dentz 371873d80debSLuiz Augusto von Dentz q = cnt / num; 371973d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 372073d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 372173d80debSLuiz Augusto von Dentz return chan; 372273d80debSLuiz Augusto von Dentz } 372373d80debSLuiz Augusto von Dentz 372402b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 372502b20f0bSLuiz Augusto von Dentz { 372602b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 372702b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 372802b20f0bSLuiz Augusto von Dentz int num = 0; 372902b20f0bSLuiz Augusto von Dentz 373002b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 373102b20f0bSLuiz Augusto von Dentz 3732bf4c6325SGustavo F. Padovan rcu_read_lock(); 3733bf4c6325SGustavo F. Padovan 3734bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 373502b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 373602b20f0bSLuiz Augusto von Dentz 373702b20f0bSLuiz Augusto von Dentz if (conn->type != type) 373802b20f0bSLuiz Augusto von Dentz continue; 373902b20f0bSLuiz Augusto von Dentz 374002b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 374102b20f0bSLuiz Augusto von Dentz continue; 374202b20f0bSLuiz Augusto von Dentz 374302b20f0bSLuiz Augusto von Dentz num++; 374402b20f0bSLuiz Augusto von Dentz 37458192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 374602b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 374702b20f0bSLuiz Augusto von Dentz 374802b20f0bSLuiz Augusto von Dentz if (chan->sent) { 374902b20f0bSLuiz Augusto von Dentz chan->sent = 0; 375002b20f0bSLuiz Augusto von Dentz continue; 375102b20f0bSLuiz Augusto von Dentz } 375202b20f0bSLuiz Augusto von Dentz 375302b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 375402b20f0bSLuiz Augusto von Dentz continue; 375502b20f0bSLuiz Augusto von Dentz 375602b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 375702b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 375802b20f0bSLuiz Augusto von Dentz continue; 375902b20f0bSLuiz Augusto von Dentz 376002b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 376102b20f0bSLuiz Augusto von Dentz 376202b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 376302b20f0bSLuiz Augusto von Dentz skb->priority); 376402b20f0bSLuiz Augusto von Dentz } 376502b20f0bSLuiz Augusto von Dentz 376602b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 376702b20f0bSLuiz Augusto von Dentz break; 376802b20f0bSLuiz Augusto von Dentz } 3769bf4c6325SGustavo F. Padovan 3770bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3771bf4c6325SGustavo F. Padovan 377202b20f0bSLuiz Augusto von Dentz } 377302b20f0bSLuiz Augusto von Dentz 3774b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3775b71d385aSAndrei Emeltchenko { 3776b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3777b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3778b71d385aSAndrei Emeltchenko } 3779b71d385aSAndrei Emeltchenko 37806039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 37811da177e4SLinus Torvalds { 3782d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 37831da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 37841da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 378563d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 37865f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3787bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 37881da177e4SLinus Torvalds } 378963d2bc1bSAndrei Emeltchenko } 37901da177e4SLinus Torvalds 37916039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 379263d2bc1bSAndrei Emeltchenko { 379363d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 379463d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 379563d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 379663d2bc1bSAndrei Emeltchenko int quote; 379763d2bc1bSAndrei Emeltchenko 379863d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 379904837f64SMarcel Holtmann 380073d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 380173d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3802ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3803ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 380473d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 380573d80debSLuiz Augusto von Dentz skb->len, skb->priority); 380673d80debSLuiz Augusto von Dentz 3807ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3808ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3809ec1cce24SLuiz Augusto von Dentz break; 3810ec1cce24SLuiz Augusto von Dentz 3811ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3812ec1cce24SLuiz Augusto von Dentz 381373d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 381473d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 381504837f64SMarcel Holtmann 381657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38171da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 38181da177e4SLinus Torvalds 38191da177e4SLinus Torvalds hdev->acl_cnt--; 382073d80debSLuiz Augusto von Dentz chan->sent++; 382173d80debSLuiz Augusto von Dentz chan->conn->sent++; 38221da177e4SLinus Torvalds } 38231da177e4SLinus Torvalds } 382402b20f0bSLuiz Augusto von Dentz 382502b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 382602b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 38271da177e4SLinus Torvalds } 38281da177e4SLinus Torvalds 38296039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3830b71d385aSAndrei Emeltchenko { 383163d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3832b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3833b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3834b71d385aSAndrei Emeltchenko int quote; 3835bd1eb66bSAndrei Emeltchenko u8 type; 3836b71d385aSAndrei Emeltchenko 383763d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3838b71d385aSAndrei Emeltchenko 3839bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3840bd1eb66bSAndrei Emeltchenko 3841bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3842bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3843bd1eb66bSAndrei Emeltchenko else 3844bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3845bd1eb66bSAndrei Emeltchenko 3846b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3847bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3848b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3849b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3850b71d385aSAndrei Emeltchenko int blocks; 3851b71d385aSAndrei Emeltchenko 3852b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3853b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3854b71d385aSAndrei Emeltchenko 3855b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3856b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3857b71d385aSAndrei Emeltchenko break; 3858b71d385aSAndrei Emeltchenko 3859b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3860b71d385aSAndrei Emeltchenko 3861b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3862b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3863b71d385aSAndrei Emeltchenko return; 3864b71d385aSAndrei Emeltchenko 3865b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3866b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3867b71d385aSAndrei Emeltchenko 386857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3869b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3870b71d385aSAndrei Emeltchenko 3871b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3872b71d385aSAndrei Emeltchenko quote -= blocks; 3873b71d385aSAndrei Emeltchenko 3874b71d385aSAndrei Emeltchenko chan->sent += blocks; 3875b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3876b71d385aSAndrei Emeltchenko } 3877b71d385aSAndrei Emeltchenko } 3878b71d385aSAndrei Emeltchenko 3879b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3880bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3881b71d385aSAndrei Emeltchenko } 3882b71d385aSAndrei Emeltchenko 38836039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3884b71d385aSAndrei Emeltchenko { 3885b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3886b71d385aSAndrei Emeltchenko 3887bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3888ca8bee5dSMarcel Holtmann if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_PRIMARY) 3889bd1eb66bSAndrei Emeltchenko return; 3890bd1eb66bSAndrei Emeltchenko 3891bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3892bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3893b71d385aSAndrei Emeltchenko return; 3894b71d385aSAndrei Emeltchenko 3895b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3896b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3897b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3898b71d385aSAndrei Emeltchenko break; 3899b71d385aSAndrei Emeltchenko 3900b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3901b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3902b71d385aSAndrei Emeltchenko break; 3903b71d385aSAndrei Emeltchenko } 3904b71d385aSAndrei Emeltchenko } 3905b71d385aSAndrei Emeltchenko 39061da177e4SLinus Torvalds /* Schedule SCO */ 39076039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 39081da177e4SLinus Torvalds { 39091da177e4SLinus Torvalds struct hci_conn *conn; 39101da177e4SLinus Torvalds struct sk_buff *skb; 39111da177e4SLinus Torvalds int quote; 39121da177e4SLinus Torvalds 39131da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 39141da177e4SLinus Torvalds 391552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 391652087a79SLuiz Augusto von Dentz return; 391752087a79SLuiz Augusto von Dentz 39181da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 39191da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 39201da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 392157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39221da177e4SLinus Torvalds 39231da177e4SLinus Torvalds conn->sent++; 39241da177e4SLinus Torvalds if (conn->sent == ~0) 39251da177e4SLinus Torvalds conn->sent = 0; 39261da177e4SLinus Torvalds } 39271da177e4SLinus Torvalds } 39281da177e4SLinus Torvalds } 39291da177e4SLinus Torvalds 39306039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3931b6a0dc82SMarcel Holtmann { 3932b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3933b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3934b6a0dc82SMarcel Holtmann int quote; 3935b6a0dc82SMarcel Holtmann 3936b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3937b6a0dc82SMarcel Holtmann 393852087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 393952087a79SLuiz Augusto von Dentz return; 394052087a79SLuiz Augusto von Dentz 39418fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 39428fc9ced3SGustavo Padovan "e))) { 3943b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3944b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 394557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3946b6a0dc82SMarcel Holtmann 3947b6a0dc82SMarcel Holtmann conn->sent++; 3948b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3949b6a0dc82SMarcel Holtmann conn->sent = 0; 3950b6a0dc82SMarcel Holtmann } 3951b6a0dc82SMarcel Holtmann } 3952b6a0dc82SMarcel Holtmann } 3953b6a0dc82SMarcel Holtmann 39546039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 39556ed58ec5SVille Tervo { 395673d80debSLuiz Augusto von Dentz struct hci_chan *chan; 39576ed58ec5SVille Tervo struct sk_buff *skb; 395802b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 39596ed58ec5SVille Tervo 39606ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 39616ed58ec5SVille Tervo 396252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 396352087a79SLuiz Augusto von Dentz return; 396452087a79SLuiz Augusto von Dentz 3965d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) { 39666ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 39676ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3968bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 39696ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3970bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 39716ed58ec5SVille Tervo } 39726ed58ec5SVille Tervo 39736ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 397402b20f0bSLuiz Augusto von Dentz tmp = cnt; 397573d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3976ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3977ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 397873d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 397973d80debSLuiz Augusto von Dentz skb->len, skb->priority); 39806ed58ec5SVille Tervo 3981ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3982ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3983ec1cce24SLuiz Augusto von Dentz break; 3984ec1cce24SLuiz Augusto von Dentz 3985ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3986ec1cce24SLuiz Augusto von Dentz 398757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39886ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 39896ed58ec5SVille Tervo 39906ed58ec5SVille Tervo cnt--; 399173d80debSLuiz Augusto von Dentz chan->sent++; 399273d80debSLuiz Augusto von Dentz chan->conn->sent++; 39936ed58ec5SVille Tervo } 39946ed58ec5SVille Tervo } 399573d80debSLuiz Augusto von Dentz 39966ed58ec5SVille Tervo if (hdev->le_pkts) 39976ed58ec5SVille Tervo hdev->le_cnt = cnt; 39986ed58ec5SVille Tervo else 39996ed58ec5SVille Tervo hdev->acl_cnt = cnt; 400002b20f0bSLuiz Augusto von Dentz 400102b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 400202b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 40036ed58ec5SVille Tervo } 40046ed58ec5SVille Tervo 40053eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 40061da177e4SLinus Torvalds { 40073eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 40081da177e4SLinus Torvalds struct sk_buff *skb; 40091da177e4SLinus Torvalds 40106ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 40116ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 40121da177e4SLinus Torvalds 4013d7a5a11dSMarcel Holtmann if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 40141da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 40151da177e4SLinus Torvalds hci_sched_acl(hdev); 40161da177e4SLinus Torvalds hci_sched_sco(hdev); 4017b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 40186ed58ec5SVille Tervo hci_sched_le(hdev); 401952de599eSMarcel Holtmann } 40206ed58ec5SVille Tervo 40211da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 40221da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 402357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40241da177e4SLinus Torvalds } 40251da177e4SLinus Torvalds 402625985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 40271da177e4SLinus Torvalds 40281da177e4SLinus Torvalds /* ACL data packet */ 40296039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40301da177e4SLinus Torvalds { 40311da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 40321da177e4SLinus Torvalds struct hci_conn *conn; 40331da177e4SLinus Torvalds __u16 handle, flags; 40341da177e4SLinus Torvalds 40351da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 40361da177e4SLinus Torvalds 40371da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40381da177e4SLinus Torvalds flags = hci_flags(handle); 40391da177e4SLinus Torvalds handle = hci_handle(handle); 40401da177e4SLinus Torvalds 4041f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4042a8c5fb1aSGustavo Padovan handle, flags); 40431da177e4SLinus Torvalds 40441da177e4SLinus Torvalds hdev->stat.acl_rx++; 40451da177e4SLinus Torvalds 40461da177e4SLinus Torvalds hci_dev_lock(hdev); 40471da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40481da177e4SLinus Torvalds hci_dev_unlock(hdev); 40491da177e4SLinus Torvalds 40501da177e4SLinus Torvalds if (conn) { 405165983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 405204837f64SMarcel Holtmann 40531da177e4SLinus Torvalds /* Send to upper protocol */ 4054686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 40551da177e4SLinus Torvalds return; 40561da177e4SLinus Torvalds } else { 40571da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 40581da177e4SLinus Torvalds hdev->name, handle); 40591da177e4SLinus Torvalds } 40601da177e4SLinus Torvalds 40611da177e4SLinus Torvalds kfree_skb(skb); 40621da177e4SLinus Torvalds } 40631da177e4SLinus Torvalds 40641da177e4SLinus Torvalds /* SCO data packet */ 40656039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40661da177e4SLinus Torvalds { 40671da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 40681da177e4SLinus Torvalds struct hci_conn *conn; 40691da177e4SLinus Torvalds __u16 handle; 40701da177e4SLinus Torvalds 40711da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 40721da177e4SLinus Torvalds 40731da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40741da177e4SLinus Torvalds 4075f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 40761da177e4SLinus Torvalds 40771da177e4SLinus Torvalds hdev->stat.sco_rx++; 40781da177e4SLinus Torvalds 40791da177e4SLinus Torvalds hci_dev_lock(hdev); 40801da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40811da177e4SLinus Torvalds hci_dev_unlock(hdev); 40821da177e4SLinus Torvalds 40831da177e4SLinus Torvalds if (conn) { 40841da177e4SLinus Torvalds /* Send to upper protocol */ 4085686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 40861da177e4SLinus Torvalds return; 40871da177e4SLinus Torvalds } else { 40881da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 40891da177e4SLinus Torvalds hdev->name, handle); 40901da177e4SLinus Torvalds } 40911da177e4SLinus Torvalds 40921da177e4SLinus Torvalds kfree_skb(skb); 40931da177e4SLinus Torvalds } 40941da177e4SLinus Torvalds 40959238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 40969238f36aSJohan Hedberg { 40979238f36aSJohan Hedberg struct sk_buff *skb; 40989238f36aSJohan Hedberg 40999238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 41009238f36aSJohan Hedberg if (!skb) 41019238f36aSJohan Hedberg return true; 41029238f36aSJohan Hedberg 410344d27137SJohan Hedberg return (bt_cb(skb)->hci.req_flags & HCI_REQ_START); 41049238f36aSJohan Hedberg } 41059238f36aSJohan Hedberg 410642c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 410742c6b129SJohan Hedberg { 410842c6b129SJohan Hedberg struct hci_command_hdr *sent; 410942c6b129SJohan Hedberg struct sk_buff *skb; 411042c6b129SJohan Hedberg u16 opcode; 411142c6b129SJohan Hedberg 411242c6b129SJohan Hedberg if (!hdev->sent_cmd) 411342c6b129SJohan Hedberg return; 411442c6b129SJohan Hedberg 411542c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 411642c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 411742c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 411842c6b129SJohan Hedberg return; 411942c6b129SJohan Hedberg 412042c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 412142c6b129SJohan Hedberg if (!skb) 412242c6b129SJohan Hedberg return; 412342c6b129SJohan Hedberg 412442c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 412542c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 412642c6b129SJohan Hedberg } 412742c6b129SJohan Hedberg 4128e6214487SJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status, 4129e6214487SJohan Hedberg hci_req_complete_t *req_complete, 4130e6214487SJohan Hedberg hci_req_complete_skb_t *req_complete_skb) 41319238f36aSJohan Hedberg { 41329238f36aSJohan Hedberg struct sk_buff *skb; 41339238f36aSJohan Hedberg unsigned long flags; 41349238f36aSJohan Hedberg 41359238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 41369238f36aSJohan Hedberg 413742c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 413842c6b129SJohan Hedberg * sent we need to do special handling of it. 41399238f36aSJohan Hedberg */ 414042c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 414142c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 414242c6b129SJohan Hedberg * reset complete event during init and any pending 414342c6b129SJohan Hedberg * command will never be completed. In such a case we 414442c6b129SJohan Hedberg * need to resend whatever was the last sent 414542c6b129SJohan Hedberg * command. 414642c6b129SJohan Hedberg */ 414742c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 414842c6b129SJohan Hedberg hci_resend_last(hdev); 414942c6b129SJohan Hedberg 41509238f36aSJohan Hedberg return; 415142c6b129SJohan Hedberg } 41529238f36aSJohan Hedberg 41539238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 41549238f36aSJohan Hedberg * this request the request is not yet complete. 41559238f36aSJohan Hedberg */ 41569238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 41579238f36aSJohan Hedberg return; 41589238f36aSJohan Hedberg 41599238f36aSJohan Hedberg /* If this was the last command in a request the complete 41609238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 41619238f36aSJohan Hedberg * command queue (hdev->cmd_q). 41629238f36aSJohan Hedberg */ 416344d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_flags & HCI_REQ_SKB) { 416444d27137SJohan Hedberg *req_complete_skb = bt_cb(hdev->sent_cmd)->hci.req_complete_skb; 4165e6214487SJohan Hedberg return; 41669238f36aSJohan Hedberg } 4167e6214487SJohan Hedberg 416844d27137SJohan Hedberg if (bt_cb(hdev->sent_cmd)->hci.req_complete) { 416944d27137SJohan Hedberg *req_complete = bt_cb(hdev->sent_cmd)->hci.req_complete; 4170e6214487SJohan Hedberg return; 417153e21fbcSJohan Hedberg } 41729238f36aSJohan Hedberg 41739238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 41749238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 41759238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 417644d27137SJohan Hedberg if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) { 41779238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 41789238f36aSJohan Hedberg break; 41799238f36aSJohan Hedberg } 41809238f36aSJohan Hedberg 41813bd7594eSDouglas Anderson if (bt_cb(skb)->hci.req_flags & HCI_REQ_SKB) 4182242c0ebdSMarcel Holtmann *req_complete_skb = bt_cb(skb)->hci.req_complete_skb; 41833bd7594eSDouglas Anderson else 41843bd7594eSDouglas Anderson *req_complete = bt_cb(skb)->hci.req_complete; 41859238f36aSJohan Hedberg kfree_skb(skb); 41869238f36aSJohan Hedberg } 41879238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 41889238f36aSJohan Hedberg } 41899238f36aSJohan Hedberg 4190b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 41911da177e4SLinus Torvalds { 4192b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 41931da177e4SLinus Torvalds struct sk_buff *skb; 41941da177e4SLinus Torvalds 41951da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 41961da177e4SLinus Torvalds 41971da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4198cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4199cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4200cd82e61cSMarcel Holtmann 42011da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 42021da177e4SLinus Torvalds /* Send copy to the sockets */ 4203470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 42041da177e4SLinus Torvalds } 42051da177e4SLinus Torvalds 4206d7a5a11dSMarcel Holtmann if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) { 42071da177e4SLinus Torvalds kfree_skb(skb); 42081da177e4SLinus Torvalds continue; 42091da177e4SLinus Torvalds } 42101da177e4SLinus Torvalds 42111da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 42121da177e4SLinus Torvalds /* Don't process data packets in this states. */ 4213d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 42141da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 42151da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42161da177e4SLinus Torvalds kfree_skb(skb); 42171da177e4SLinus Torvalds continue; 42183ff50b79SStephen Hemminger } 42191da177e4SLinus Torvalds } 42201da177e4SLinus Torvalds 42211da177e4SLinus Torvalds /* Process frame */ 4222d79f34e3SMarcel Holtmann switch (hci_skb_pkt_type(skb)) { 42231da177e4SLinus Torvalds case HCI_EVENT_PKT: 4224b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 42251da177e4SLinus Torvalds hci_event_packet(hdev, skb); 42261da177e4SLinus Torvalds break; 42271da177e4SLinus Torvalds 42281da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 42291da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 42301da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 42311da177e4SLinus Torvalds break; 42321da177e4SLinus Torvalds 42331da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42341da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 42351da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 42361da177e4SLinus Torvalds break; 42371da177e4SLinus Torvalds 42381da177e4SLinus Torvalds default: 42391da177e4SLinus Torvalds kfree_skb(skb); 42401da177e4SLinus Torvalds break; 42411da177e4SLinus Torvalds } 42421da177e4SLinus Torvalds } 42431da177e4SLinus Torvalds } 42441da177e4SLinus Torvalds 4245c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 42461da177e4SLinus Torvalds { 4247c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 42481da177e4SLinus Torvalds struct sk_buff *skb; 42491da177e4SLinus Torvalds 42502104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 42512104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 42521da177e4SLinus Torvalds 42531da177e4SLinus Torvalds /* Send queued commands */ 42545a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 42555a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 42565a08ecceSAndrei Emeltchenko if (!skb) 42575a08ecceSAndrei Emeltchenko return; 42585a08ecceSAndrei Emeltchenko 42591da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 42601da177e4SLinus Torvalds 4261a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 426270f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 42631da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 426457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42657bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 426665cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 42677bdb8a5cSSzymon Janc else 426865cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 426965cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 42701da177e4SLinus Torvalds } else { 42711da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4272c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 42731da177e4SLinus Torvalds } 42741da177e4SLinus Torvalds } 42751da177e4SLinus Torvalds } 4276